Unverified Commit 1398de99 authored by JJ Kasper's avatar JJ Kasper Committed by GitHub

Revert "Revert "Separate routing code from render servers (#52492)"" (#53029)

Reverts vercel/next.js#53016
parent 552bca46
use std::io::Write;
use anyhow::{bail, Result};
use indexmap::indexmap;
use indoc::writedoc;
use next_core::{
create_page_loader_entry_module, get_asset_path_from_pathname,
mode::NextMode,
......@@ -20,10 +24,15 @@ use next_core::{
};
use turbo_tasks::Vc;
use turbopack_binding::{
turbo::{tasks::Value, tasks_env::ProcessEnv, tasks_fs::FileSystemPath},
turbo::{
tasks::Value,
tasks_env::ProcessEnv,
tasks_fs::{rope::RopeBuilder, File, FileSystemPath},
},
turbopack::{
build::BuildChunkingContext,
core::{
asset::AssetContent,
chunk::{ChunkableModule, ChunkingContext, EvaluatableAssets},
compile_time_info::CompileTimeInfo,
context::AssetContext,
......@@ -31,6 +40,7 @@ use turbopack_binding::{
output::OutputAsset,
reference_type::{EntryReferenceSubType, ReferenceType},
source::Source,
virtual_source::VirtualSource,
},
ecmascript::{
chunk::{EcmascriptChunkPlaceable, EcmascriptChunkingContext},
......@@ -191,6 +201,8 @@ async fn get_page_entries_for_root_directory(
Vc::upcast(FileSource::new(app.project_path)),
next_router_root,
app.next_router_path,
app.original_path,
PathType::Page,
));
// This only makes sense on the server.
......@@ -201,6 +213,8 @@ async fn get_page_entries_for_root_directory(
Vc::upcast(FileSource::new(document.project_path)),
next_router_root,
document.next_router_path,
document.original_path,
PathType::Page,
));
// This only makes sense on both the client and the server, but they should map
......@@ -212,6 +226,8 @@ async fn get_page_entries_for_root_directory(
Vc::upcast(FileSource::new(error.project_path)),
next_router_root,
error.next_router_path,
error.original_path,
PathType::Page,
));
if let Some(api) = api {
......@@ -221,6 +237,7 @@ async fn get_page_entries_for_root_directory(
api,
next_router_root,
&mut entries,
PathType::PagesAPI,
)
.await?;
}
......@@ -232,6 +249,7 @@ async fn get_page_entries_for_root_directory(
pages,
next_router_root,
&mut entries,
PathType::Page,
)
.await?;
}
......@@ -246,6 +264,7 @@ async fn get_page_entries_for_directory(
pages_structure: Vc<PagesDirectoryStructure>,
next_router_root: Vc<FileSystemPath>,
entries: &mut Vec<Vc<PageEntry>>,
path_type: PathType,
) -> Result<()> {
let PagesDirectoryStructure {
ref items,
......@@ -257,7 +276,7 @@ async fn get_page_entries_for_directory(
let PagesStructureItem {
project_path,
next_router_path,
original_path: _,
original_path,
} = *item.await?;
entries.push(get_page_entry_for_file(
ssr_module_context,
......@@ -265,6 +284,8 @@ async fn get_page_entries_for_directory(
Vc::upcast(FileSource::new(project_path)),
next_router_root,
next_router_path,
original_path,
path_type,
));
}
......@@ -275,6 +296,7 @@ async fn get_page_entries_for_directory(
*child,
next_router_root,
entries,
path_type,
)
.await?;
}
......@@ -300,13 +322,129 @@ async fn get_page_entry_for_file(
source: Vc<Box<dyn Source>>,
next_router_root: Vc<FileSystemPath>,
next_router_path: Vc<FileSystemPath>,
next_original_path: Vc<FileSystemPath>,
path_type: PathType,
) -> Result<Vc<PageEntry>> {
let reference_type = Value::new(ReferenceType::Entry(EntryReferenceSubType::Page));
let reference_type = Value::new(ReferenceType::Entry(match path_type {
PathType::Page => EntryReferenceSubType::Page,
PathType::PagesAPI => EntryReferenceSubType::PagesApi,
_ => bail!("Invalid path type"),
}));
let pathname = pathname_for_path(next_router_root, next_router_path, path_type);
let pathname = pathname_for_path(next_router_root, next_router_path, PathType::Page);
let definition_page = format!("/{}", next_original_path.await?);
let definition_pathname = pathname.await?;
let ssr_module = ssr_module_context.process(source, reference_type.clone());
let mut result = RopeBuilder::default();
match path_type {
PathType::Page => {
// Sourced from https://github.com/vercel/next.js/blob/2848ce51d1552633119c89ab49ff7fe2e4e91c91/packages/next/src/build/webpack/loaders/next-route-loader/index.ts
writedoc!(
result,
r#"
import RouteModule from "next/dist/server/future/route-modules/pages/module"
import {{ hoist }} from "next/dist/build/webpack/loaders/next-route-loader/helpers"
import Document from "@vercel/turbopack-next/pages/_document"
import App from "@vercel/turbopack-next/pages/_app"
import * as userland from "INNER"
export default hoist(userland, "default")
export const getStaticProps = hoist(userland, "getStaticProps")
export const getStaticPaths = hoist(userland, "getStaticPaths")
export const getServerSideProps = hoist(userland, "getServerSideProps")
export const config = hoist(userland, "config")
export const reportWebVitals = hoist(userland, "reportWebVitals")
export const unstable_getStaticProps = hoist(userland, "unstable_getStaticProps")
export const unstable_getStaticPaths = hoist(userland, "unstable_getStaticPaths")
export const unstable_getStaticParams = hoist(userland, "unstable_getStaticParams")
export const unstable_getServerProps = hoist(userland, "unstable_getServerProps")
export const unstable_getServerSideProps = hoist(userland, "unstable_getServerSideProps")
export const routeModule = new RouteModule({{
definition: {{
kind: "PAGES",
page: "{definition_page}",
pathname: "{definition_pathname}",
// The following aren't used in production, but are
// required for the RouteModule constructor.
bundlePath: "",
filename: "",
}},
components: {{
App,
Document,
}},
userland,
}})
"#
)?;
// When we're building the instrumentation page (only when the
// instrumentation file conflicts with a page also labeled
// /instrumentation) hoist the `register` method.
if definition_page == "/instrumentation" || definition_page == "/src/instrumentation" {
writeln!(
result,
r#"export const register = hoist(userland, "register")"#
)?;
}
}
PathType::PagesAPI => {
// Sourced from https://github.com/vercel/next.js/blob/2848ce51d1552633119c89ab49ff7fe2e4e91c91/packages/next/src/build/webpack/loaders/next-route-loader/index.ts
writedoc!(
result,
r#"
import RouteModule from "next/dist/server/future/route-modules/pages-api/module"
import {{ hoist }} from "next/dist/build/webpack/loaders/next-route-loader/helpers"
import * as userland from "INNER"
export default hoist(userland, "default")
export const config = hoist(userland, "config")
export const routeModule = new RouteModule({{
definition: {{
kind: "PAGES_API",
page: "{definition_page}",
pathname: "{definition_pathname}",
// The following aren't used in production, but are
// required for the RouteModule constructor.
bundlePath: "",
filename: "",
}},
userland,
}})
"#
)?;
}
_ => bail!("Invalid path type"),
};
let file = File::from(result.build());
let asset = VirtualSource::new(
source.ident().path().join(match path_type {
PathType::Page => "pages-entry.tsx".to_string(),
PathType::PagesAPI => "pages-api-entry.tsx".to_string(),
_ => bail!("Invalid path type"),
}),
AssetContent::file(file.into()),
);
let ssr_module = ssr_module_context.process(
Vc::upcast(asset),
Value::new(ReferenceType::Internal(Vc::cell(indexmap! {
"INNER".to_string() => ssr_module,
}))),
);
let client_module = create_page_loader_entry_module(client_module_context, source, pathname);
let Some(client_module) =
......
......@@ -2,8 +2,8 @@
// the other imports
import startHandler from '../internal/page-server-handler'
import App from '@vercel/turbopack-next/pages/_app'
import Document from '@vercel/turbopack-next/pages/_document'
import App from '@vercel/turbopack-next/pages/_app'
import chunkGroup from 'INNER_CLIENT_CHUNK_GROUP'
......
......@@ -29,6 +29,7 @@ use crate::next_config::{NextConfig, OutputType};
#[derive(Debug, Clone, Copy, PartialEq, Eq, TaskInput)]
pub enum PathType {
Page,
PagesAPI,
Data,
}
......
......@@ -55,6 +55,8 @@ import { fileExists } from '../lib/file-exists'
import { getRouteLoaderEntry } from './webpack/loaders/next-route-loader'
import { isInternalComponent } from '../lib/is-internal-component'
import { isStaticMetadataRouteFile } from '../lib/metadata/is-metadata-route'
import { RouteKind } from '../server/future/route-kind'
import { encodeToBase64 } from './webpack/loaders/utils'
export async function getStaticInfoIncludingLayouts({
isInsideAppDir,
......@@ -589,9 +591,7 @@ export async function createEntrypoints(
assetPrefix: config.assetPrefix,
nextConfigOutput: config.output,
preferredRegion: staticInfo.preferredRegion,
middlewareConfig: Buffer.from(
JSON.stringify(staticInfo.middleware || {})
).toString('base64'),
middlewareConfig: encodeToBase64(staticInfo.middleware || {}),
})
} else if (isInstrumentationHookFile(page) && pagesType === 'root') {
server[serverBundlePath.replace('src/', '')] = {
......@@ -599,13 +599,23 @@ export async function createEntrypoints(
// the '../' is needed to make sure the file is not chunked
filename: `../${INSTRUMENTATION_HOOK_FILENAME}.js`,
}
} else if (isAPIRoute(page)) {
server[serverBundlePath] = [
getRouteLoaderEntry({
kind: RouteKind.PAGES_API,
page,
absolutePagePath,
preferredRegion: staticInfo.preferredRegion,
middlewareConfig: staticInfo.middleware || {},
}),
]
} else if (
!isAPIRoute(page) &&
!isMiddlewareFile(page) &&
!isInternalComponent(absolutePagePath)
) {
server[serverBundlePath] = [
getRouteLoaderEntry({
kind: RouteKind.PAGES,
page,
pages,
absolutePagePath,
......
......@@ -17,7 +17,6 @@ import os from 'os'
import { Worker } from '../lib/worker'
import { defaultConfig } from '../server/config-shared'
import devalue from 'next/dist/compiled/devalue'
import { escapeStringRegexp } from '../shared/lib/escape-regexp'
import findUp from 'next/dist/compiled/find-up'
import { nanoid } from 'next/dist/compiled/nanoid/index.cjs'
import { pathToRegexp } from 'next/dist/compiled/path-to-regexp'
......@@ -141,7 +140,12 @@ import { createClientRouterFilter } from '../lib/create-client-router-filter'
import { createValidFileMatcher } from '../server/lib/find-page-file'
import { startTypeChecking } from './type-check'
import { generateInterceptionRoutesRewrites } from '../lib/generate-interception-routes-rewrites'
import { baseOverrides, experimentalOverrides } from '../server/require-hook'
import { buildDataRoute } from '../server/lib/router-utils/build-data-route'
import {
baseOverrides,
defaultOverrides,
experimentalOverrides,
} from '../server/require-hook'
export type SsgRoute = {
initialRevalidateSeconds: number | false
......@@ -166,6 +170,66 @@ export type PrerenderManifest = {
preview: __ApiPreviewProps
}
type CustomRoute = {
regex: string
statusCode?: number | undefined
permanent?: undefined
source: string
locale?: false | undefined
basePath?: false | undefined
destination?: string | undefined
}
export type RoutesManifest = {
version: number
pages404: boolean
basePath: string
redirects: Array<CustomRoute>
rewrites?:
| Array<CustomRoute>
| {
beforeFiles: Array<CustomRoute>
afterFiles: Array<CustomRoute>
fallback: Array<CustomRoute>
}
headers: Array<CustomRoute>
staticRoutes: Array<{
page: string
regex: string
namedRegex?: string
routeKeys?: { [key: string]: string }
}>
dynamicRoutes: Array<{
page: string
regex: string
namedRegex?: string
routeKeys?: { [key: string]: string }
}>
dataRoutes: Array<{
page: string
routeKeys?: { [key: string]: string }
dataRouteRegex: string
namedDataRouteRegex?: string
}>
i18n?: {
domains?: Array<{
http?: true
domain: string
locales?: string[]
defaultLocale: string
}>
locales: string[]
defaultLocale: string
localeDetection?: false
}
rsc: {
header: typeof RSC
varyHeader: typeof RSC_VARY_HEADER
}
skipMiddlewareUrlNormalize?: boolean
caseSensitive?: boolean
}
async function generateClientSsgManifest(
prerenderManifest: PrerenderManifest,
{
......@@ -684,89 +748,45 @@ export default async function build(
}
const routesManifestPath = path.join(distDir, ROUTES_MANIFEST)
const routesManifest: {
version: number
pages404: boolean
basePath: string
redirects: Array<ReturnType<typeof buildCustomRoute>>
rewrites?:
| Array<ReturnType<typeof buildCustomRoute>>
| {
beforeFiles: Array<ReturnType<typeof buildCustomRoute>>
afterFiles: Array<ReturnType<typeof buildCustomRoute>>
fallback: Array<ReturnType<typeof buildCustomRoute>>
const routesManifest: RoutesManifest = nextBuildSpan
.traceChild('generate-routes-manifest')
.traceFn(() => {
const sortedRoutes = getSortedRoutes([
...pageKeys.pages,
...(pageKeys.app ?? []),
])
const dynamicRoutes: Array<ReturnType<typeof pageToRoute>> = []
const staticRoutes: typeof dynamicRoutes = []
for (const route of sortedRoutes) {
if (isDynamicRoute(route)) {
dynamicRoutes.push(pageToRoute(route))
} else if (!isReservedPage(route)) {
staticRoutes.push(pageToRoute(route))
}
headers: Array<ReturnType<typeof buildCustomRoute>>
staticRoutes: Array<{
page: string
regex: string
namedRegex?: string
routeKeys?: { [key: string]: string }
}>
dynamicRoutes: Array<{
page: string
regex: string
namedRegex?: string
routeKeys?: { [key: string]: string }
}>
dataRoutes: Array<{
page: string
routeKeys?: { [key: string]: string }
dataRouteRegex: string
namedDataRouteRegex?: string
}>
i18n?: {
domains?: Array<{
http?: true
domain: string
locales?: string[]
defaultLocale: string
}>
locales: string[]
defaultLocale: string
localeDetection?: false
}
rsc: {
header: typeof RSC
varyHeader: typeof RSC_VARY_HEADER
}
skipMiddlewareUrlNormalize?: boolean
caseSensitive?: boolean
} = nextBuildSpan.traceChild('generate-routes-manifest').traceFn(() => {
const sortedRoutes = getSortedRoutes([
...pageKeys.pages,
...(pageKeys.app ?? []),
])
const dynamicRoutes: Array<ReturnType<typeof pageToRoute>> = []
const staticRoutes: typeof dynamicRoutes = []
for (const route of sortedRoutes) {
if (isDynamicRoute(route)) {
dynamicRoutes.push(pageToRoute(route))
} else if (!isReservedPage(route)) {
staticRoutes.push(pageToRoute(route))
}
}
return {
version: 3,
pages404: true,
caseSensitive: !!config.experimental.caseSensitiveRoutes,
basePath: config.basePath,
redirects: redirects.map((r: any) => buildCustomRoute(r, 'redirect')),
headers: headers.map((r: any) => buildCustomRoute(r, 'header')),
dynamicRoutes,
staticRoutes,
dataRoutes: [],
i18n: config.i18n || undefined,
rsc: {
header: RSC,
varyHeader: RSC_VARY_HEADER,
contentTypeHeader: RSC_CONTENT_TYPE_HEADER,
},
skipMiddlewareUrlNormalize: config.skipMiddlewareUrlNormalize,
}
})
return {
version: 3,
pages404: true,
caseSensitive: !!config.experimental.caseSensitiveRoutes,
basePath: config.basePath,
redirects: redirects.map((r: any) =>
buildCustomRoute(r, 'redirect')
),
headers: headers.map((r: any) => buildCustomRoute(r, 'header')),
dynamicRoutes,
staticRoutes,
dataRoutes: [],
i18n: config.i18n || undefined,
rsc: {
header: RSC,
varyHeader: RSC_VARY_HEADER,
contentTypeHeader: RSC_CONTENT_TYPE_HEADER,
},
skipMiddlewareUrlNormalize: config.skipMiddlewareUrlNormalize,
}
})
if (rewrites.beforeFiles.length === 0 && rewrites.fallback.length === 0) {
routesManifest.rewrites = rewrites.afterFiles.map((r: any) =>
......@@ -903,6 +923,7 @@ export default async function build(
]
: []),
path.join(SERVER_DIRECTORY, APP_PATHS_MANIFEST),
path.join(APP_PATH_ROUTES_MANIFEST),
APP_BUILD_MANIFEST,
path.join(
SERVER_DIRECTORY,
......@@ -1962,6 +1983,11 @@ export default async function build(
...Object.values(experimentalOverrides).map((override) =>
require.resolve(override)
),
...(config.experimental.turbotrace
? []
: Object.values(defaultOverrides).map((value) =>
require.resolve(value)
)),
]
// ensure we trace any dependencies needed for custom
......@@ -1979,9 +2005,7 @@ export default async function build(
const vanillaServerEntries = [
...sharedEntriesSet,
isStandalone
? require.resolve(
'next/dist/server/lib/render-server-standalone'
)
? require.resolve('next/dist/server/lib/start-server')
: null,
require.resolve('next/dist/server/next-server'),
].filter(Boolean) as string[]
......@@ -2158,49 +2182,7 @@ export default async function build(
...serverPropsPages,
...ssgPages,
]).map((page) => {
const pagePath = normalizePagePath(page)
const dataRoute = path.posix.join(
'/_next/data',
buildId,
`${pagePath}.json`
)
let dataRouteRegex: string
let namedDataRouteRegex: string | undefined
let routeKeys: { [named: string]: string } | undefined
if (isDynamicRoute(page)) {
const routeRegex = getNamedRouteRegex(
dataRoute.replace(/\.json$/, ''),
true
)
dataRouteRegex = normalizeRouteRegex(
routeRegex.re.source.replace(/\(\?:\\\/\)\?\$$/, `\\.json$`)
)
namedDataRouteRegex = routeRegex.namedRegex!.replace(
/\(\?:\/\)\?\$$/,
`\\.json$`
)
routeKeys = routeRegex.routeKeys
} else {
dataRouteRegex = normalizeRouteRegex(
new RegExp(
`^${path.posix.join(
'/_next/data',
escapeStringRegexp(buildId),
`${pagePath}.json`
)}$`
).source
)
}
return {
page,
routeKeys,
dataRouteRegex,
namedDataRouteRegex,
}
return buildDataRoute(page, buildId)
})
await fs.writeFile(
......
......@@ -1928,12 +1928,12 @@ export async function copyTracedFiles(
import path from 'path'
import { fileURLToPath } from 'url'
const __dirname = fileURLToPath(new URL('.', import.meta.url))
import { createServerHandler } from 'next/dist/server/lib/render-server-standalone.js'
import { startServer } from 'next/dist/server/lib/start-server.js'
`
: `
const http = require('http')
const path = require('path')
const { createServerHandler } = require('next/dist/server/lib/render-server-standalone')`
const { startServer } = require('next/dist/server/lib/start-server')`
}
const dir = path.join(__dirname)
......@@ -1950,11 +1950,7 @@ if (!process.env.NEXT_MANUAL_SIG_HANDLE) {
const currentPort = parseInt(process.env.PORT, 10) || 3000
const hostname = process.env.HOSTNAME || 'localhost'
const keepAliveTimeout = parseInt(process.env.KEEP_ALIVE_TIMEOUT, 10);
const isValidKeepAliveTimeout =
!Number.isNaN(keepAliveTimeout) &&
Number.isFinite(keepAliveTimeout) &&
keepAliveTimeout >= 0;
let keepAliveTimeout = parseInt(process.env.KEEP_ALIVE_TIMEOUT, 10);
const nextConfig = ${JSON.stringify({
...serverConfig,
distDir: `./${path.relative(dir, distDir)}`,
......@@ -1962,41 +1958,30 @@ const nextConfig = ${JSON.stringify({
process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(nextConfig)
createServerHandler({
port: currentPort,
hostname,
dir,
conf: nextConfig,
keepAliveTimeout: isValidKeepAliveTimeout ? keepAliveTimeout : undefined,
}).then((nextHandler) => {
const server = http.createServer(async (req, res) => {
try {
await nextHandler(req, res)
} catch (err) {
console.error(err);
res.statusCode = 500
res.end('Internal Server Error')
}
})
if (isValidKeepAliveTimeout) {
server.keepAliveTimeout = keepAliveTimeout
}
server.listen(currentPort, async (err) => {
if (err) {
console.error("Failed to start server", err)
process.exit(1)
}
console.log(
'Listening on port',
currentPort,
'url: http://' + hostname + ':' + currentPort
)
});
if (
Number.isNaN(keepAliveTimeout) ||
!Number.isFinite(keepAliveTimeout) ||
keepAliveTimeout < 0
) {
keepAliveTimeout = undefined
}
}).catch(err => {
startServer({
dir,
isDev: false,
config: nextConfig,
hostname: hostname === 'localhost' ? '0.0.0.0' : hostname,
port: currentPort,
allowRetry: false,
keepAliveTimeout,
useWorkers: !!nextConfig.experimental?.appDir,
}).then(() => {
console.log(
'Listening on port',
currentPort,
'url: http://' + hostname + ':' + currentPort
)
}).catch((err) => {
console.error(err);
process.exit(1);
});`
......
......@@ -5,23 +5,25 @@ import type {
} from '../../analysis/get-page-static-info'
import { webpack } from 'next/dist/compiled/webpack/webpack'
export type ModuleBuildInfo = {
nextEdgeMiddleware?: EdgeMiddlewareMeta
nextEdgeApiFunction?: EdgeMiddlewareMeta
nextEdgeSSR?: EdgeSSRMeta
nextWasmMiddlewareBinding?: AssetBinding
nextAssetMiddlewareBinding?: AssetBinding
usingIndirectEval?: boolean | Set<string>
route?: RouteMeta
importLocByPath?: Map<string, any>
rootDir?: string
rsc?: RSCMeta
}
/**
* A getter for module build info that casts to the type it should have.
* We also expose here types to make easier to use it.
*/
export function getModuleBuildInfo(webpackModule: webpack.Module) {
return webpackModule.buildInfo as {
nextEdgeMiddleware?: EdgeMiddlewareMeta
nextEdgeApiFunction?: EdgeMiddlewareMeta
nextEdgeSSR?: EdgeSSRMeta
nextWasmMiddlewareBinding?: AssetBinding
nextAssetMiddlewareBinding?: AssetBinding
usingIndirectEval?: boolean | Set<string>
route?: RouteMeta
importLocByPath?: Map<string, any>
rootDir?: string
rsc?: RSCMeta
}
return webpackModule.buildInfo as ModuleBuildInfo
}
export interface RSCMeta {
......
......@@ -35,10 +35,27 @@ function generateClientManifest(
'NextJsBuildManifest-generateClientManifest'
)
const normalizeRewrite = (item: {
source: string
destination: string
has?: any
}) => {
return {
has: item.has,
source: item.source,
destination: item.destination,
}
}
return genClientManifestSpan?.traceFn(() => {
const clientManifest: ClientBuildManifest = {
// TODO: update manifest type to include rewrites
__rewrites: rewrites as any,
__rewrites: {
afterFiles: rewrites.afterFiles?.map((item) => normalizeRewrite(item)),
beforeFiles: rewrites.beforeFiles?.map((item) =>
normalizeRewrite(item)
),
fallback: rewrites.fallback?.map((item) => normalizeRewrite(item)),
} as any,
}
const appDependencies = new Set(assetMap.pages['/_app'])
const sortedPageKeys = getSortedRoutes(Object.keys(assetMap.pages))
......
......@@ -20,9 +20,15 @@ const originModules = [
const RUNTIME_NAMES = ['webpack-runtime', 'webpack-api-runtime']
const nextDeleteCacheRpc = async (filePaths: string[]) => {
if ((global as any)._nextDeleteCache) {
return (global as any)._nextDeleteCache(filePaths)
}
}
export function deleteAppClientCache() {
if ((global as any)._nextDeleteAppClientCache) {
;(global as any)._nextDeleteAppClientCache()
return (global as any)._nextDeleteAppClientCache()
}
// ensure we reset the cache for rsc components
// loaded via react-server-dom-webpack
......@@ -41,10 +47,6 @@ export function deleteAppClientCache() {
}
export function deleteCache(filePath: string) {
if ((global as any)._nextDeleteCache) {
;(global as any)._nextDeleteCache(filePath)
}
// try to clear it from the fs cache
clearManifestCache(filePath)
......@@ -86,7 +88,7 @@ export class NextJsRequireCacheHotReloader implements WebpackPluginInstance {
apply(compiler: Compiler) {
compiler.hooks.assetEmitted.tap(PLUGIN_NAME, (_file, { targetPath }) => {
deleteCache(targetPath)
nextDeleteCacheRpc([targetPath])
// Clear module context in other processes
if ((global as any)._nextClearModuleContext) {
......@@ -96,35 +98,33 @@ export class NextJsRequireCacheHotReloader implements WebpackPluginInstance {
clearModuleContext(targetPath)
})
compiler.hooks.afterEmit.tap(PLUGIN_NAME, (compilation) => {
RUNTIME_NAMES.forEach((name) => {
compiler.hooks.afterEmit.tapPromise(PLUGIN_NAME, async (compilation) => {
const cacheEntriesToDelete = []
for (const name of RUNTIME_NAMES) {
const runtimeChunkPath = path.join(
compilation.outputOptions.path!,
`${name}.js`
)
deleteCache(runtimeChunkPath)
})
let hasAppPath = false
cacheEntriesToDelete.push(runtimeChunkPath)
}
// we need to make sure to clear all server entries from cache
// since they can have a stale webpack-runtime cache
// which needs to always be in-sync
const entries = [...compilation.entries.keys()].filter((entry) => {
const isAppPath = entry.toString().startsWith('app/')
hasAppPath = hasAppPath || isAppPath
return entry.toString().startsWith('pages/') || isAppPath
})
if (hasAppPath) {
}
entries.forEach((page) => {
for (const page of entries) {
const outputPath = path.join(
compilation.outputOptions.path!,
page + '.js'
)
deleteCache(outputPath)
})
cacheEntriesToDelete.push(outputPath)
}
await nextDeleteCacheRpc(cacheEntriesToDelete)
})
}
}
......@@ -8,11 +8,7 @@ import isError from '../lib/is-error'
import { getProjectDir } from '../lib/get-project-dir'
import { CONFIG_FILES, PHASE_DEVELOPMENT_SERVER } from '../shared/lib/constants'
import path from 'path'
import {
defaultConfig,
NextConfig,
NextConfigComplete,
} from '../server/config-shared'
import { defaultConfig, NextConfigComplete } from '../server/config-shared'
import { traceGlobals } from '../trace/shared'
import { Telemetry } from '../telemetry/storage'
import loadConfig from '../server/config'
......@@ -26,6 +22,7 @@ import { getPossibleInstrumentationHookFilenames } from '../build/worker'
import { resetEnv } from '@next/env'
let dir: string
let config: NextConfigComplete
let isTurboSession = false
let sessionStopHandled = false
let sessionStarted = Date.now()
......@@ -38,13 +35,15 @@ const handleSessionStop = async () => {
const { eventCliSession } =
require('../telemetry/events/session-stopped') as typeof import('../telemetry/events/session-stopped')
const config = await loadConfig(
PHASE_DEVELOPMENT_SERVER,
dir,
undefined,
undefined,
true
)
config =
config ||
(await loadConfig(
PHASE_DEVELOPMENT_SERVER,
dir,
undefined,
undefined,
true
))
let telemetry =
(traceGlobals.get('telemetry') as InstanceType<
......@@ -211,12 +210,14 @@ const nextDev: CliCommand = async (argv) => {
// We do not set a default host value here to prevent breaking
// some set-ups that rely on listening on other interfaces
const host = args['--hostname']
config = await loadConfig(PHASE_DEVELOPMENT_SERVER, dir)
const devServerOptions: StartServerOptions = {
dir,
port,
allowRetry,
isDev: true,
nextConfig: config,
hostname: host,
// This is required especially for app dir.
useWorkers: true,
......@@ -237,14 +238,6 @@ const nextDev: CliCommand = async (argv) => {
resetEnv()
let bindings = await loadBindings()
const config = await loadConfig(
PHASE_DEVELOPMENT_SERVER,
dir,
undefined,
undefined,
true
)
// Just testing code here:
const project = await bindings.turbo.createProject({
......@@ -409,7 +402,6 @@ const nextDev: CliCommand = async (argv) => {
try {
let shouldFilter = false
let devServerTeardown: (() => Promise<void>) | undefined
let config: NextConfig | undefined
watchConfigFiles(devServerOptions.dir, (filename) => {
Log.warn(
......@@ -505,16 +497,6 @@ const nextDev: CliCommand = async (argv) => {
// fallback to noop, if not provided
resolveCleanup(async () => {})
}
if (!config) {
config = await loadConfig(
PHASE_DEVELOPMENT_SERVER,
dir,
undefined,
undefined,
true
)
}
}
await setupFork()
......
......@@ -84,6 +84,7 @@ const nextStart: CliCommand = async (argv) => {
await startServer({
dir,
nextConfig: config,
isDev: false,
hostname: host,
port,
......
......@@ -36,6 +36,7 @@ const supportedTurbopackNextConfigOptions = [
'experimental.isrFlushToDisk',
'experimental.workerThreads',
'experimenatl.pageEnv',
'experimental.caseSensitiveRoutes',
]
// The following will need to be supported by `next build --turbo`
......
import type { IncomingMessage } from 'http'
import type { BaseNextRequest } from '../base-http'
import type { CookieSerializeOptions } from 'next/dist/compiled/cookie'
import type { NextApiRequest, NextApiResponse } from '../../shared/lib/utils'
import type { NextApiResponse } from '../../shared/lib/utils'
import { HeadersAdapter } from '../web/spec-extension/adapters/headers'
import {
......@@ -186,7 +186,7 @@ export function sendError(
}
interface LazyProps {
req: NextApiRequest
req: IncomingMessage
}
/**
......
......@@ -191,17 +191,17 @@ export async function parseBody(
}
}
type RevalidateFn = (config: {
urlPath: string
revalidateHeaders: { [key: string]: string | string[] }
opts: { unstable_onlyGenerated?: boolean }
}) => Promise<void>
type ApiContext = __ApiPreviewProps & {
trustHostHeader?: boolean
allowedRevalidateHeaderKeys?: string[]
hostname?: string
revalidate?: (config: {
urlPath: string
revalidateHeaders: { [key: string]: string | string[] }
opts: { unstable_onlyGenerated?: boolean }
}) => Promise<any>
// (_req: IncomingMessage, _res: ServerResponse) => Promise<any>
revalidate?: RevalidateFn
}
function getMaxContentLength(responseLimit?: ResponseLimit) {
......@@ -475,16 +475,7 @@ async function revalidate(
headers: {},
}
)
const chunks = []
for await (const chunk of res) {
if (chunk) {
chunks.push(chunk)
}
}
const body = Buffer.concat(chunks).toString()
const result = JSON.parse(body)
const result = await res.json()
if (result.err) {
throw new Error(result.err.message)
......
This diff is collapsed.
......@@ -297,6 +297,11 @@ export interface ExperimentalConfig {
* Enables source maps generation for the server production bundle.
*/
serverSourceMaps?: boolean
/**
* @internal Used by the Next.js internals only.
*/
trustHostHeader?: boolean
}
export type ExportPathMap = {
......
let installed: boolean = false
export function loadWebpackHook({ init }: { init: boolean }) {
if (init) {
const { init: initWebpack } = require('next/dist/compiled/webpack/webpack')
if (installed) {
return
}
installed = true
initWebpack()
export function loadWebpackHook() {
const { init: initWebpack } = require('next/dist/compiled/webpack/webpack')
if (installed) {
return
}
installed = true
initWebpack()
// hook the Node.js require so that webpack requires are
// routed to the bundled and now initialized webpack version
......
......@@ -711,25 +711,22 @@ export default async function loadConfig(
rawConfig?: boolean,
silent?: boolean
): Promise<NextConfigComplete> {
if (!process.env.__NEXT_PRIVATE_RENDER_WORKER) {
try {
loadWebpackHook()
} catch (err) {
// this can fail in standalone mode as the files
// aren't traced/included
if (!process.env.__NEXT_PRIVATE_STANDALONE_CONFIG) {
throw err
}
}
}
if (process.env.__NEXT_PRIVATE_STANDALONE_CONFIG) {
return JSON.parse(process.env.__NEXT_PRIVATE_STANDALONE_CONFIG)
}
const curLog = silent
? {
warn: () => {},
info: () => {},
error: () => {},
}
: Log
loadEnvConfig(dir, phase === PHASE_DEVELOPMENT_SERVER, curLog)
loadWebpackHook({
// For render workers, there's no need to init webpack eagerly
init: !process.env.__NEXT_PRIVATE_RENDER_WORKER,
})
// For the render worker, we directly return the serialized config from the
// parent worker (router worker) to avoid loading it again.
// This is because loading the config might be expensive especiall when people
......@@ -740,6 +737,16 @@ export default async function loadConfig(
return JSON.parse(process.env.__NEXT_PRIVATE_RENDER_WORKER_CONFIG)
}
const curLog = silent
? {
warn: () => {},
info: () => {},
error: () => {},
}
: Log
loadEnvConfig(dir, phase === PHASE_DEVELOPMENT_SERVER, curLog)
let configFileName = 'next.config.js'
if (customConfig) {
......
......@@ -62,6 +62,7 @@ import { parseVersionInfo, VersionInfo } from './parse-version-info'
import { isAPIRoute } from '../../lib/is-api-route'
import { getRouteLoaderEntry } from '../../build/webpack/loaders/next-route-loader'
import { isInternalComponent } from '../../lib/is-internal-component'
import { RouteKind } from '../future/route-kind'
function diff(a: Set<any>, b: Set<any>) {
return new Set([...a].filter((v) => !b.has(v)))
......@@ -279,7 +280,7 @@ export default class HotReloader {
parsedPageBundleUrl: UrlObject
): Promise<{ finished?: true }> => {
const { pathname } = parsedPageBundleUrl
const params = matchNextPageBundleRequest<{ path: string[] }>(pathname)
const params = matchNextPageBundleRequest(pathname)
if (!params) {
return {}
}
......@@ -288,7 +289,7 @@ export default class HotReloader {
try {
decodedPagePath = `/${params.path
.map((param) => decodeURIComponent(param))
.map((param: string) => decodeURIComponent(param))
.join('/')}`
} catch (_) {
throw new DecodeError('failed to decode param')
......@@ -906,12 +907,20 @@ export default class HotReloader {
JSON.stringify(staticInfo.middleware || {})
).toString('base64'),
})
} else if (isAPIRoute(page)) {
value = getRouteLoaderEntry({
kind: RouteKind.PAGES_API,
page,
absolutePagePath: relativeRequest,
preferredRegion: staticInfo.preferredRegion,
middlewareConfig: staticInfo.middleware || {},
})
} else if (
!isAPIRoute(page) &&
!isMiddlewareFile(page) &&
!isInternalComponent(relativeRequest)
) {
value = getRouteLoaderEntry({
kind: RouteKind.PAGES,
page,
pages: this.pagesMapping,
absolutePagePath: relativeRequest,
......@@ -1411,10 +1420,12 @@ export default class HotReloader {
clientOnly,
appPaths,
match,
isApp,
}: {
page: string
clientOnly: boolean
appPaths?: string[] | null
isApp?: boolean
match?: RouteMatch
}): Promise<void> {
// Make sure we don't re-build or dispose prebuilt pages
......@@ -1432,6 +1443,7 @@ export default class HotReloader {
clientOnly,
appPaths,
match,
isApp,
}) as any
}
}
......@@ -689,11 +689,13 @@ export function onDemandEntryHandler({
clientOnly,
appPaths = null,
match,
isApp,
}: {
page: string
clientOnly: boolean
appPaths?: ReadonlyArray<string> | null
match?: RouteMatch
isApp?: boolean
}): Promise<void> {
const stalledTime = 60
const stalledEnsureTimeout = setTimeout(() => {
......@@ -722,6 +724,12 @@ export function onDemandEntryHandler({
const isInsideAppDir =
!!appDir && pagePathData.absolutePagePath.startsWith(appDir)
if (typeof isApp === 'boolean' && !(isApp === isInsideAppDir)) {
throw new Error(
'Ensure bailed, found path does not match ensure type (pages/app)'
)
}
const pageBundleType = getPageBundleType(pagePathData.bundlePath)
const addEntry = (
compilerType: CompilerNameValues
......@@ -894,11 +902,13 @@ export function onDemandEntryHandler({
clientOnly,
appPaths = null,
match,
isApp,
}: {
page: string
clientOnly: boolean
appPaths?: ReadonlyArray<string> | null
match?: RouteMatch
isApp?: boolean
}) {
if (curEnsurePage.has(page)) {
return curEnsurePage.get(page)
......@@ -908,6 +918,7 @@ export function onDemandEntryHandler({
clientOnly,
appPaths,
match,
isApp,
}).finally(() => {
curEnsurePage.delete(page)
})
......
......@@ -12,12 +12,11 @@ export class RouteModuleLoader {
id: string,
loader: ModuleLoader = new NodeModuleLoader()
): Promise<M> {
if (process.env.NEXT_RUNTIME !== 'edge') {
const { routeModule }: AppLoaderModule<M> = await loader.load(id)
return routeModule
const module: AppLoaderModule<M> = await loader.load(id)
if ('routeModule' in module) {
return module.routeModule
}
throw new Error('RouteModuleLoader is not supported in edge runtime.')
throw new Error(`Module "${id}" does not export a routeModule.`)
}
}
import type { IncomingMessage, ServerResponse } from 'http'
import type { PagesAPIRouteDefinition } from '../../route-definitions/pages-api-route-definition'
import type { PageConfig } from '../../../../../types'
import type { ParsedUrlQuery } from 'querystring'
import {
RouteModule,
RouteModuleOptions,
type RouteModuleHandleContext,
} from '../route-module'
import { apiResolver } from '../../../api-utils/node'
import { __ApiPreviewProps } from '../../../api-utils'
type PagesAPIHandleFn = (
req: IncomingMessage,
res: ServerResponse
) => Promise<void>
type PagesAPIUserlandModule = {
/**
* The exported handler method.
*/
readonly default: PagesAPIHandleFn
/**
* The exported page config.
*/
readonly config?: PageConfig
}
type PagesAPIRouteHandlerContext = RouteModuleHandleContext & {
/**
* The incoming server request in non-edge runtime.
*/
req?: IncomingMessage
/**
* The outgoing server response in non-edge runtime.
*/
res?: ServerResponse
/**
* The revalidate method used by the `revalidate` API.
*
* @param config the configuration for the revalidation
*/
revalidate: (config: {
urlPath: string
revalidateHeaders: { [key: string]: string | string[] }
opts: { unstable_onlyGenerated?: boolean }
}) => Promise<void>
/**
* The hostname for the request.
*/
hostname?: string
/**
* Keys allowed in the revalidate call.
*/
allowedRevalidateHeaderKeys?: string[]
/**
* Whether to trust the host header.
*/
trustHostHeader?: boolean
/**
* The query for the request.
*/
query: ParsedUrlQuery
/**
* The preview props used by the `preview` API.
*/
previewProps: __ApiPreviewProps
/**
* True if the server is in development mode.
*/
dev: boolean
/**
* True if the server is in minimal mode.
*/
minimalMode: boolean
/**
* The page that's being rendered.
*/
page: string
}
export type PagesAPIRouteModuleOptions = RouteModuleOptions<
PagesAPIRouteDefinition,
PagesAPIUserlandModule
>
export class PagesAPIRouteModule extends RouteModule<
PagesAPIRouteDefinition,
PagesAPIUserlandModule
> {
public handle(): Promise<Response> {
throw new Error('Method not implemented.')
}
/**
*
* @param req the incoming server request
* @param res the outgoing server response
* @param context the context for the render
*/
public async render(
req: IncomingMessage,
res: ServerResponse,
context: PagesAPIRouteHandlerContext
): Promise<void> {
await apiResolver(
req,
res,
context.query,
this.userland,
{
...context.previewProps,
revalidate: context.revalidate,
trustHostHeader: context.trustHostHeader,
allowedRevalidateHeaderKeys: context.allowedRevalidateHeaderKeys,
hostname: context.hostname,
},
context.minimalMode,
context.dev,
context.page
)
}
}
export default PagesAPIRouteModule
import type { IncomingMessage, ServerResponse } from 'http'
import type { ChildProcess } from 'child_process'
import httpProxy from 'next/dist/compiled/http-proxy'
import { Worker } from 'next/dist/compiled/jest-worker'
import { normalizeRepeatedSlashes } from '../../shared/lib/utils'
export const createServerHandler = async ({
port,
hostname,
dir,
dev = false,
minimalMode,
keepAliveTimeout,
}: {
port: number
hostname: string
dir: string
dev?: boolean
minimalMode: boolean
keepAliveTimeout?: number
}) => {
const routerWorker = new Worker(require.resolve('./render-server'), {
numWorkers: 1,
maxRetries: 10,
forkOptions: {
env: {
FORCE_COLOR: '1',
...process.env,
},
},
exposedMethods: ['initialize'],
}) as any as InstanceType<typeof Worker> & {
initialize: typeof import('./render-server').initialize
}
let didInitialize = false
for (const _worker of ((routerWorker as any)._workerPool?._workers || []) as {
_child: ChildProcess
}[]) {
// eslint-disable-next-line no-loop-func
_worker._child.on('exit', (code, signal) => {
// catch failed initializing without retry
if ((code || signal) && !didInitialize) {
routerWorker?.end()
process.exit(1)
}
})
}
const workerStdout = routerWorker.getStdout()
const workerStderr = routerWorker.getStderr()
workerStdout.on('data', (data) => {
process.stdout.write(data)
})
workerStderr.on('data', (data) => {
process.stderr.write(data)
})
const { port: routerPort } = await routerWorker.initialize({
dir,
port,
dev,
hostname,
minimalMode,
workerType: 'router',
isNodeDebugging: false,
keepAliveTimeout,
})
didInitialize = true
const getProxyServer = (pathname: string) => {
const targetUrl = `http://${
hostname === 'localhost' ? '127.0.0.1' : hostname
}:${routerPort}${pathname}`
const proxyServer = httpProxy.createProxy({
target: targetUrl,
changeOrigin: false,
ignorePath: true,
xfwd: true,
ws: true,
followRedirects: false,
})
return proxyServer
}
// proxy to router worker
return async (req: IncomingMessage, res: ServerResponse) => {
const urlParts = (req.url || '').split('?')
const urlNoQuery = urlParts[0]
// this normalizes repeated slashes in the path e.g. hello//world ->
// hello/world or backslashes to forward slashes, this does not
// handle trailing slash as that is handled the same as a next.config.js
// redirect
if (urlNoQuery?.match(/(\\|\/\/)/)) {
const cleanUrl = normalizeRepeatedSlashes(req.url!)
res.statusCode = 308
res.setHeader('Location', cleanUrl)
res.end(cleanUrl)
return
}
const proxyServer = getProxyServer(req.url || '/')
// http-proxy does not properly detect a client disconnect in newer
// versions of Node.js. This is caused because it only listens for the
// `aborted` event on the our request object, but it also fully reads and
// closes the request object. Node **will not** fire `aborted` when the
// request is already closed. Listening for `close` on our response object
// will detect the disconnect, and we can abort the proxy's connection.
proxyServer.on('proxyReq', (proxyReq) => {
res.on('close', () => proxyReq.destroy())
})
proxyServer.on('proxyRes', (proxyRes) => {
res.on('close', () => proxyRes.destroy())
})
proxyServer.web(req, res)
proxyServer.on('error', (err) => {
res.statusCode = 500
res.end('Internal Server Error')
console.error(err)
})
}
}
import type { RequestHandler } from '../next'
import './cpu-profile'
import v8 from 'v8'
import http from 'http'
import { isIPv6 } from 'net'
// This is required before other imports to ensure the require hook is setup.
import '../require-hook'
// this must come first as it includes require hooks
import { initializeServerWorker } from './setup-server-worker'
import next from '../next'
import { warn } from '../../build/output/log'
import { getFreePort } from '../lib/worker-utils'
export const WORKER_SELF_EXIT_CODE = 77
const MAXIMUM_HEAP_SIZE_ALLOWED =
(v8.getHeapStatistics().heap_size_limit / 1024 / 1024) * 0.9
let result:
| undefined
| {
......@@ -24,6 +13,8 @@ let result:
hostname: string
}
let app: ReturnType<typeof next> | undefined
let sandboxContext: undefined | typeof import('../web/sandbox/context')
let requireCacheHotReloader:
| undefined
......@@ -35,15 +26,46 @@ if (process.env.NODE_ENV !== 'production') {
}
export function clearModuleContext(target: string) {
sandboxContext?.clearModuleContext(target)
return sandboxContext?.clearModuleContext(target)
}
export function deleteAppClientCache() {
requireCacheHotReloader?.deleteAppClientCache()
return requireCacheHotReloader?.deleteAppClientCache()
}
export function deleteCache(filePaths: string[]) {
for (const filePath of filePaths) {
requireCacheHotReloader?.deleteCache(filePath)
}
}
export function deleteCache(filePath: string) {
requireCacheHotReloader?.deleteCache(filePath)
export async function propagateServerField(field: string, value: any) {
if (!app) {
throw new Error('Invariant cant propagate server field, no app initialized')
}
let appField = (app as any).server
if (field.includes('.')) {
const parts = field.split('.')
for (let i = 0; i < parts.length - 1; i++) {
if (appField) {
appField = appField[parts[i]]
}
}
field = parts[parts.length - 1]
}
if (appField) {
if (typeof appField[field] === 'function') {
appField[field].apply(
(app as any).server,
Array.isArray(value) ? value : []
)
} else {
appField[field] = value
}
}
}
export async function initialize(opts: {
......@@ -55,6 +77,7 @@ export async function initialize(opts: {
workerType: 'router' | 'render'
isNodeDebugging: boolean
keepAliveTimeout?: number
serverFields?: any
}): Promise<NonNullable<typeof result>> {
// if we already setup the server return as we only need to do
// this on first worker boot
......@@ -62,97 +85,40 @@ export async function initialize(opts: {
return result
}
const isRouterWorker = opts.workerType === 'router'
const isRenderWorker = opts.workerType === 'render'
if (isRouterWorker) {
process.title = 'next-router-worker'
} else if (isRenderWorker) {
const type = process.env.__NEXT_PRIVATE_RENDER_WORKER!
process.title = 'next-render-worker-' + type
}
const type = process.env.__NEXT_PRIVATE_RENDER_WORKER!
process.title = 'next-render-worker-' + type
let requestHandler: RequestHandler
const server = http.createServer((req, res) => {
return requestHandler(req, res)
.catch((err) => {
res.statusCode = 500
res.end('Internal Server Error')
console.error(err)
})
.finally(() => {
if (
process.memoryUsage().heapUsed / 1024 / 1024 >
MAXIMUM_HEAP_SIZE_ALLOWED
) {
warn(
'The server is running out of memory, restarting to free up memory.'
)
server.close()
process.exit(WORKER_SELF_EXIT_CODE)
}
})
let upgradeHandler: any
const { port, server, hostname } = await initializeServerWorker(
(...args) => {
return requestHandler(...args)
},
(...args) => {
return upgradeHandler(...args)
},
opts
)
app = next({
...opts,
_routerWorker: opts.workerType === 'router',
_renderWorker: opts.workerType === 'render',
hostname: hostname === '0.0.0.0' ? 'localhost' : hostname,
customServer: false,
httpServer: server,
port: opts.port,
isNodeDebugging: opts.isNodeDebugging,
})
if (opts.keepAliveTimeout) {
server.keepAliveTimeout = opts.keepAliveTimeout
}
return new Promise(async (resolve, reject) => {
server.on('error', (err: NodeJS.ErrnoException) => {
console.error(`Invariant: failed to start render worker`, err)
process.exit(1)
})
requestHandler = app.getRequestHandler()
upgradeHandler = app.getUpgradeHandler()
await app.prepare(opts.serverFields)
let upgradeHandler: any
if (!opts.dev) {
server.on('upgrade', (req, socket, upgrade) => {
upgradeHandler(req, socket, upgrade)
})
}
server.on('listening', async () => {
try {
const addr = server.address()
const port = addr && typeof addr === 'object' ? addr.port : 0
if (!port) {
console.error(`Invariant failed to detect render worker port`, addr)
process.exit(1)
}
let hostname =
!opts.hostname || opts.hostname === '0.0.0.0'
? 'localhost'
: opts.hostname
if (isIPv6(hostname)) {
hostname = hostname === '::' ? '[::1]' : `[${hostname}]`
}
result = {
port,
hostname,
}
const app = next({
...opts,
_routerWorker: isRouterWorker,
_renderWorker: isRenderWorker,
hostname,
customServer: false,
httpServer: server,
port: opts.port,
isNodeDebugging: opts.isNodeDebugging,
})
requestHandler = app.getRequestHandler()
upgradeHandler = app.getUpgradeHandler()
await app.prepare()
resolve(result)
} catch (err) {
return reject(err)
}
})
server.listen(await getFreePort(), '0.0.0.0')
})
result = {
port,
hostname: hostname === '0.0.0.0' ? '127.0.0.1' : hostname,
}
return result
}
This diff is collapsed.
import path from '../../../shared/lib/isomorphic/path'
import { normalizePagePath } from '../../../shared/lib/page-path/normalize-page-path'
import { isDynamicRoute } from '../../../shared/lib/router/utils/is-dynamic'
import { getNamedRouteRegex } from '../../../shared/lib/router/utils/route-regex'
import { normalizeRouteRegex } from '../../../lib/load-custom-routes'
import { escapeStringRegexp } from '../../../shared/lib/escape-regexp'
export function buildDataRoute(page: string, buildId: string) {
const pagePath = normalizePagePath(page)
const dataRoute = path.posix.join('/_next/data', buildId, `${pagePath}.json`)
let dataRouteRegex: string
let namedDataRouteRegex: string | undefined
let routeKeys: { [named: string]: string } | undefined
if (isDynamicRoute(page)) {
const routeRegex = getNamedRouteRegex(
dataRoute.replace(/\.json$/, ''),
true
)
dataRouteRegex = normalizeRouteRegex(
routeRegex.re.source.replace(/\(\?:\\\/\)\?\$$/, `\\.json$`)
)
namedDataRouteRegex = routeRegex.namedRegex!.replace(
/\(\?:\/\)\?\$$/,
`\\.json$`
)
routeKeys = routeRegex.routeKeys
} else {
dataRouteRegex = normalizeRouteRegex(
new RegExp(
`^${path.posix.join(
'/_next/data',
escapeStringRegexp(buildId),
`${pagePath}.json`
)}$`
).source
)
}
return {
page,
routeKeys,
dataRouteRegex,
namedDataRouteRegex,
}
}
This diff is collapsed.
import type { IncomingMessage, ServerResponse } from 'http'
import type { NextUrlWithParsedQuery } from '../../request-meta'
import url from 'url'
import { stringifyQuery } from '../../server-route-utils'
export async function proxyRequest(
req: IncomingMessage,
res: ServerResponse,
parsedUrl: NextUrlWithParsedQuery,
upgradeHead?: any,
reqBody?: any,
proxyTimeout?: number | null
) {
const { query } = parsedUrl
delete (parsedUrl as any).query
parsedUrl.search = stringifyQuery(req as any, query)
const target = url.format(parsedUrl)
const HttpProxy =
require('next/dist/compiled/http-proxy') as typeof import('next/dist/compiled/http-proxy')
const proxy = new HttpProxy({
target,
changeOrigin: true,
ignorePath: true,
xfwd: true,
ws: true,
// we limit proxy requests to 30s by default, in development
// we don't time out WebSocket requests to allow proxying
proxyTimeout: proxyTimeout === null ? undefined : proxyTimeout || 30_000,
})
await new Promise((proxyResolve, proxyReject) => {
let finished = false
proxy.on('proxyRes', (proxyRes, innerReq, innerRes) => {
const cleanup = (err: any) => {
// cleanup event listeners to allow clean garbage collection
proxyRes.removeListener('error', cleanup)
proxyRes.removeListener('close', cleanup)
innerRes.removeListener('error', cleanup)
innerRes.removeListener('close', cleanup)
// destroy all source streams to propagate the caught event backward
innerReq.destroy(err)
proxyRes.destroy(err)
}
proxyRes.once('error', cleanup)
proxyRes.once('close', cleanup)
innerRes.once('error', cleanup)
innerRes.once('close', cleanup)
})
proxy.on('error', (err) => {
console.error(`Failed to proxy ${target}`, err)
if (!finished) {
finished = true
proxyReject(err)
if (!res.closed) {
res.statusCode = 500
res.end('Internal Server Error')
}
}
})
// if upgrade head is present treat as WebSocket request
if (upgradeHead) {
proxy.on('proxyReqWs', (proxyReq) => {
proxyReq.on('close', () => {
if (!finished) {
finished = true
proxyResolve(true)
}
})
})
proxy.ws(req as any as IncomingMessage, res, upgradeHead)
proxyResolve(true)
} else {
proxy.on('proxyReq', (proxyReq) => {
proxyReq.on('close', () => {
if (!finished) {
finished = true
proxyResolve(true)
}
})
})
proxy.web(req, res, {
buffer: reqBody,
})
}
})
}
This diff is collapsed.
This diff is collapsed.
......@@ -88,13 +88,14 @@ export const createWorker = async (
nextConfig: NextConfigComplete
) => {
const { initialEnv } = require('@next/env') as typeof import('@next/env')
const { Worker } = require('next/dist/compiled/jest-worker')
const useServerActions = !!nextConfig.experimental.serverActions
const { Worker } =
require('next/dist/compiled/jest-worker') as typeof import('next/dist/compiled/jest-worker')
const worker = new Worker(require.resolve('../render-server'), {
numWorkers: 1,
// TODO: do we want to allow more than 10 OOM restarts?
maxRetries: 10,
// TODO: do we want to allow more than 8 OOM restarts?
maxRetries: 8,
forkOptions: {
env: {
FORCE_COLOR: '1',
......@@ -129,11 +130,14 @@ export const createWorker = async (
'deleteCache',
'deleteAppClientCache',
'clearModuleContext',
'propagateServerField',
],
}) as any as InstanceType<typeof Worker> & {
initialize: typeof import('../render-server').initialize
deleteCache: typeof import('../render-server').deleteCache
deleteAppClientCache: typeof import('../render-server').deleteAppClientCache
clearModuleContext: typeof import('../render-server').clearModuleContext
propagateServerField: typeof import('../render-server').propagateServerField
}
worker.getStderr().pipe(process.stderr)
......
import { IncomingMessage } from 'http'
import '../../node-polyfill-fetch'
import type { IncomingMessage } from 'http'
import type { Writable, Readable } from 'stream'
import { filterReqHeaders } from './utils'
export const invokeRequest = async (
......@@ -7,51 +10,62 @@ export const invokeRequest = async (
headers: IncomingMessage['headers']
method: IncomingMessage['method']
},
readableBody?: import('stream').Readable
readableBody?: Readable | ReadableStream
) => {
// force to 127.0.0.1 as IPC always runs on this hostname
// to avoid localhost issues
const parsedTargetUrl = new URL(targetUrl)
parsedTargetUrl.hostname = '127.0.0.1'
const invokeHeaders = filterReqHeaders({
'cache-control': '',
...requestInit.headers,
}) as IncomingMessage['headers']
const invokeRes = await new Promise<IncomingMessage>(
(resolveInvoke, rejectInvoke) => {
const http = require('http') as typeof import('http')
try {
// force to 127.0.0.1 as IPC always runs on this hostname
// to avoid localhost issues
const parsedTargetUrl = new URL(targetUrl)
parsedTargetUrl.hostname = '127.0.0.1'
const invokeReq = http.request(
parsedTargetUrl.toString(),
{
headers: invokeHeaders,
method: requestInit.method,
},
(res) => {
resolveInvoke(res)
}
)
invokeReq.on('error', (err) => {
rejectInvoke(err)
})
if (requestInit.method !== 'GET' && requestInit.method !== 'HEAD') {
if (readableBody) {
readableBody.pipe(invokeReq)
readableBody.on('close', () => {
invokeReq.end()
})
}
} else {
invokeReq.end()
const invokeRes = await fetch(parsedTargetUrl.toString(), {
headers: invokeHeaders as any as Headers,
method: requestInit.method,
redirect: 'manual',
...(requestInit.method !== 'GET' &&
requestInit.method !== 'HEAD' &&
readableBody
? {
body: readableBody as BodyInit,
duplex: 'half',
}
} catch (err) {
rejectInvoke(err)
: {}),
next: {
// @ts-ignore
internal: true,
},
})
return invokeRes
}
export async function pipeReadable(
readable: ReadableStream,
writable: Writable
) {
const reader = readable.getReader()
async function doRead() {
const item = await reader.read()
if (item?.value) {
writable.write(Buffer.from(item?.value))
if ('flush' in writable) {
;(writable as any).flush()
}
}
)
return invokeRes
if (!item?.done) {
return doRead()
}
}
await doRead()
writable.end()
}
export const forbiddenHeaders = [
'accept-encoding',
'keepalive',
'keep-alive',
'content-encoding',
'transfer-encoding',
// https://github.com/nodejs/undici/issues/1470
......@@ -8,7 +9,7 @@ export const forbiddenHeaders = [
]
export const filterReqHeaders = (
headers: Record<string, undefined | string | string[]>
headers: Record<string, undefined | string | number | string[]>
) => {
for (const [key, value] of Object.entries(headers)) {
if (
......@@ -18,5 +19,5 @@ export const filterReqHeaders = (
delete headers[key]
}
}
return headers
return headers as Record<string, undefined | string | string[]>
}
import './cpu-profile'
import v8 from 'v8'
import http, { IncomingMessage, ServerResponse } from 'http'
// This is required before other imports to ensure the require hook is setup.
import '../require-hook'
import '../node-polyfill-fetch'
import { warn } from '../../build/output/log'
import { Duplex } from 'stream'
process.on('unhandledRejection', (err) => {
console.error(err)
})
process.on('uncaughtException', (err) => {
console.error(err)
})
export const WORKER_SELF_EXIT_CODE = 77
const MAXIMUM_HEAP_SIZE_ALLOWED =
(v8.getHeapStatistics().heap_size_limit / 1024 / 1024) * 0.9
export async function initializeServerWorker(
requestHandler: (req: IncomingMessage, res: ServerResponse) => Promise<any>,
upgradeHandler: (req: IncomingMessage, socket: Duplex, head: Buffer) => any,
opts: {
dir: string
port: number
dev: boolean
minimalMode?: boolean
hostname?: string
workerType: 'router' | 'render'
isNodeDebugging: boolean
keepAliveTimeout?: number
}
): Promise<{
port: number
hostname: string
server: http.Server
}> {
const server = http.createServer((req, res) => {
return requestHandler(req, res)
.catch((err) => {
res.statusCode = 500
res.end('Internal Server Error')
console.error(err)
})
.finally(() => {
if (
process.memoryUsage().heapUsed / 1024 / 1024 >
MAXIMUM_HEAP_SIZE_ALLOWED
) {
warn(
'The server is running out of memory, restarting to free up memory.'
)
server.close()
process.exit(WORKER_SELF_EXIT_CODE)
}
})
})
if (opts.keepAliveTimeout) {
server.keepAliveTimeout = opts.keepAliveTimeout
}
return new Promise(async (resolve, reject) => {
server.on('error', (err: NodeJS.ErrnoException) => {
console.error(`Invariant: failed to start server worker`, err)
process.exit(1)
})
if (upgradeHandler) {
server.on('upgrade', (req, socket, upgrade) => {
upgradeHandler(req, socket, upgrade)
})
}
const hostname =
!opts.hostname || opts.hostname === 'localhost'
? '0.0.0.0'
: opts.hostname
server.on('listening', async () => {
try {
const addr = server.address()
const port = addr && typeof addr === 'object' ? addr.port : 0
if (!port) {
console.error(`Invariant failed to detect render worker port`, addr)
process.exit(1)
}
resolve({
server,
port,
hostname,
})
} catch (err) {
return reject(err)
}
})
server.listen(0, hostname)
})
}
This diff is collapsed.
This diff is collapsed.
......@@ -19,6 +19,11 @@ const resolve = process.env.NEXT_MINIMAL
const toResolveMap = (map: Record<string, string>): [string, string][] =>
Object.entries(map).map(([key, value]) => [key, resolve(value)])
export const defaultOverrides = {
'styled-jsx': dirname(resolve('styled-jsx/package.json')),
'styled-jsx/style': resolve('styled-jsx/style'),
}
export const baseOverrides = {
react: 'next/dist/compiled/react',
'react/package.json': 'next/dist/compiled/react/package.json',
......@@ -73,12 +78,7 @@ export function addHookAliases(aliases: [string, string][] = []) {
}
// Add default aliases
addHookAliases([
// Use `require.resolve` explicitly to make them statically analyzable
// styled-jsx needs to be resolved as the external dependency.
['styled-jsx', dirname(resolve('styled-jsx/package.json'))],
['styled-jsx/style', resolve('styled-jsx/style')],
])
addHookAliases(toResolveMap(defaultOverrides))
// Override built-in React packages if necessary
function overrideReact() {
......
This diff is collapsed.
......@@ -10,10 +10,11 @@ send.mime.define({
export function serveStatic(
req: IncomingMessage,
res: ServerResponse,
path: string
path: string,
opts?: Parameters<typeof send>[2]
): Promise<void> {
return new Promise((resolve, reject) => {
send(req, path)
send(req, path, opts)
.on('directory', () => {
// We don't allow directories to be read.
const err: any = new Error('No directory access')
......
This diff is collapsed.
......@@ -52,10 +52,10 @@ export function getPathMatch(path: string, options?: Options) {
* `false` but if it does it will return an object with the matched params
* merged with the params provided in the second argument.
*/
return <T extends { [key: string]: any }>(
return (
pathname?: string | null,
params?: any
): false | T => {
): false | { [key: string]: any } => {
const res = pathname == null ? false : matcher(pathname)
if (!res) {
return false
......
......@@ -38,17 +38,21 @@ createNextDescribe(
}, 'success')
})
it('should render the 404 page when the file is removed, and restore the page when re-added', async () => {
const browser = await next.browser('/')
await check(() => browser.elementByCss('h1').text(), 'My page')
await next.renameFile('./app/page.js', './app/foo.js')
await check(
() => browser.elementByCss('h1').text(),
'This Is The Not Found Page'
)
await next.renameFile('./app/foo.js', './app/page.js')
await check(() => browser.elementByCss('h1').text(), 'My page')
})
// TODO: investigate isEdge case
if (!isEdge) {
it('should render the 404 page when the file is removed, and restore the page when re-added', async () => {
const browser = await next.browser('/')
await check(() => browser.elementByCss('h1').text(), 'My page')
await next.renameFile('./app/page.js', './app/foo.js')
await check(
() => browser.elementByCss('h1').text(),
'This Is The Not Found Page'
)
// TODO: investigate flakey behavior
// await next.renameFile('./app/foo.js', './app/page.js')
// await check(() => browser.elementByCss('h1').text(), 'My page')
})
}
}
if (!isNextDev && !isEdge) {
......
......@@ -6,6 +6,9 @@ createNextDescribe(
files: __dirname,
skipDeployment: true,
startCommand: 'node server.js',
dependencies: {
'get-port': '5.1.1',
},
},
({ next }) => {
it.each(['/', '/render'])('should render %s', async (page) => {
......
const http = require('http')
const { parse } = require('url')
const next = require('next')
const getPort = require('get-port')
async function main() {
const dev = process.env.NEXT_TEST_MODE === 'dev'
process.env.NODE_ENV = dev ? 'development' : 'production'
const port = parseInt(process.env.PORT, 10) || 3000
const port = await getPort()
const app = next({ dev, port })
const handle = app.getRequestHandler()
......@@ -34,7 +34,7 @@ async function main() {
process.exit(1)
})
server.listen(port, () => {
server.listen(port, '0.0.0.0', () => {
console.log(
`> started server on url: http://localhost:${port} as ${
dev ? 'development' : process.env.NODE_ENV
......
......@@ -178,35 +178,6 @@ describe('Middleware fetches with body', () => {
})
describe('with custom bodyParser sizeLimit (5mb)', () => {
it('should return 413 for body equal to 10mb', async () => {
const bodySize = 10 * 1024 * 1024
const body = 't'.repeat(bodySize)
const res = await fetchViaHTTP(
next.url,
'/api/size_limit_5mb',
{},
{
body,
method: 'POST',
}
)
try {
expect(res.status).toBe(413)
if (!(global as any).isNextDeploy) {
expect(res.statusText).toBe('Body exceeded 5mb limit')
}
} catch (err) {
// TODO: investigate occasional EPIPE errors causing
// a 500 status instead of a 413
if (res.status !== 500) {
throw err
}
}
})
it('should return 413 for body greater than 5mb', async () => {
const bodySize = 5 * 1024 * 1024 + 1
const body = 'u'.repeat(bodySize)
......@@ -308,4 +279,33 @@ describe('Middleware fetches with body', () => {
).toBe(bodySize / 32 + 1)
})
})
it('should return 413 for body equal to 10mb', async () => {
const bodySize = 10 * 1024 * 1024
const body = 't'.repeat(bodySize)
const res = await fetchViaHTTP(
next.url,
'/api/size_limit_5mb',
{},
{
body,
method: 'POST',
}
)
try {
expect(res.status).toBe(413)
if (!(global as any).isNextDeploy) {
expect(res.statusText).toBe('Body exceeded 5mb limit')
}
} catch (err) {
// TODO: investigate occasional EPIPE errors causing
// a 500 status instead of a 413
if (res.status !== 500) {
throw err
}
}
})
})
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment