Unverified Commit f57eecde authored by JJ Kasper's avatar JJ Kasper Committed by GitHub

Separate routing code from render servers (#52492)

This breaks out routing handling from `next-server`, `next-dev-server`,
and `base-server` so that these are only handling the "render" work and
eventually these will be deleted completely in favor of the bundling
work being done.

The `router` process and separate `render` processes are still
maintained here although will be investigated further in follow-up to
see if we can reduce the need for these.

We are also changing the `require-cache` IPC to a single call instead of
call per entry to reduce overhead and also de-dupes handling for
starting the server between the standalone server and normal server.

To maintain support for existing turbopack route resolving this
implements the new route resolving in place of the existing
`route-resolver` until the new nextturbo API is fully landed.

After these initial changes we should continue to eliminate non-render
related code from `next-server`, `base-server`, and `next-dev-server`.
parent 04ae5be8
...@@ -17,7 +17,6 @@ import os from 'os' ...@@ -17,7 +17,6 @@ import os from 'os'
import { Worker } from '../lib/worker' import { Worker } from '../lib/worker'
import { defaultConfig } from '../server/config-shared' import { defaultConfig } from '../server/config-shared'
import devalue from 'next/dist/compiled/devalue' import devalue from 'next/dist/compiled/devalue'
import { escapeStringRegexp } from '../shared/lib/escape-regexp'
import findUp from 'next/dist/compiled/find-up' import findUp from 'next/dist/compiled/find-up'
import { nanoid } from 'next/dist/compiled/nanoid/index.cjs' import { nanoid } from 'next/dist/compiled/nanoid/index.cjs'
import { pathToRegexp } from 'next/dist/compiled/path-to-regexp' import { pathToRegexp } from 'next/dist/compiled/path-to-regexp'
...@@ -141,7 +140,12 @@ import { createClientRouterFilter } from '../lib/create-client-router-filter' ...@@ -141,7 +140,12 @@ import { createClientRouterFilter } from '../lib/create-client-router-filter'
import { createValidFileMatcher } from '../server/lib/find-page-file' import { createValidFileMatcher } from '../server/lib/find-page-file'
import { startTypeChecking } from './type-check' import { startTypeChecking } from './type-check'
import { generateInterceptionRoutesRewrites } from '../lib/generate-interception-routes-rewrites' 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 = { export type SsgRoute = {
initialRevalidateSeconds: number | false initialRevalidateSeconds: number | false
...@@ -166,6 +170,66 @@ export type PrerenderManifest = { ...@@ -166,6 +170,66 @@ export type PrerenderManifest = {
preview: __ApiPreviewProps 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( async function generateClientSsgManifest(
prerenderManifest: PrerenderManifest, prerenderManifest: PrerenderManifest,
{ {
...@@ -684,55 +748,9 @@ export default async function build( ...@@ -684,55 +748,9 @@ export default async function build(
} }
const routesManifestPath = path.join(distDir, ROUTES_MANIFEST) const routesManifestPath = path.join(distDir, ROUTES_MANIFEST)
const routesManifest: { const routesManifest: RoutesManifest = nextBuildSpan
version: number .traceChild('generate-routes-manifest')
pages404: boolean .traceFn(() => {
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>>
}
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([ const sortedRoutes = getSortedRoutes([
...pageKeys.pages, ...pageKeys.pages,
...(pageKeys.app ?? []), ...(pageKeys.app ?? []),
...@@ -753,7 +771,9 @@ export default async function build( ...@@ -753,7 +771,9 @@ export default async function build(
pages404: true, pages404: true,
caseSensitive: !!config.experimental.caseSensitiveRoutes, caseSensitive: !!config.experimental.caseSensitiveRoutes,
basePath: config.basePath, basePath: config.basePath,
redirects: redirects.map((r: any) => buildCustomRoute(r, 'redirect')), redirects: redirects.map((r: any) =>
buildCustomRoute(r, 'redirect')
),
headers: headers.map((r: any) => buildCustomRoute(r, 'header')), headers: headers.map((r: any) => buildCustomRoute(r, 'header')),
dynamicRoutes, dynamicRoutes,
staticRoutes, staticRoutes,
...@@ -903,6 +923,7 @@ export default async function build( ...@@ -903,6 +923,7 @@ export default async function build(
] ]
: []), : []),
path.join(SERVER_DIRECTORY, APP_PATHS_MANIFEST), path.join(SERVER_DIRECTORY, APP_PATHS_MANIFEST),
path.join(APP_PATH_ROUTES_MANIFEST),
APP_BUILD_MANIFEST, APP_BUILD_MANIFEST,
path.join( path.join(
SERVER_DIRECTORY, SERVER_DIRECTORY,
...@@ -1962,6 +1983,11 @@ export default async function build( ...@@ -1962,6 +1983,11 @@ export default async function build(
...Object.values(experimentalOverrides).map((override) => ...Object.values(experimentalOverrides).map((override) =>
require.resolve(override) require.resolve(override)
), ),
...(config.experimental.turbotrace
? []
: Object.values(defaultOverrides).map((value) =>
require.resolve(value)
)),
] ]
// ensure we trace any dependencies needed for custom // ensure we trace any dependencies needed for custom
...@@ -1979,9 +2005,7 @@ export default async function build( ...@@ -1979,9 +2005,7 @@ export default async function build(
const vanillaServerEntries = [ const vanillaServerEntries = [
...sharedEntriesSet, ...sharedEntriesSet,
isStandalone isStandalone
? require.resolve( ? require.resolve('next/dist/server/lib/start-server')
'next/dist/server/lib/render-server-standalone'
)
: null, : null,
require.resolve('next/dist/server/next-server'), require.resolve('next/dist/server/next-server'),
].filter(Boolean) as string[] ].filter(Boolean) as string[]
...@@ -2158,49 +2182,7 @@ export default async function build( ...@@ -2158,49 +2182,7 @@ export default async function build(
...serverPropsPages, ...serverPropsPages,
...ssgPages, ...ssgPages,
]).map((page) => { ]).map((page) => {
const pagePath = normalizePagePath(page) return buildDataRoute(page, buildId)
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,
}
}) })
await fs.writeFile( await fs.writeFile(
......
...@@ -1928,12 +1928,12 @@ export async function copyTracedFiles( ...@@ -1928,12 +1928,12 @@ export async function copyTracedFiles(
import path from 'path' import path from 'path'
import { fileURLToPath } from 'url' import { fileURLToPath } from 'url'
const __dirname = fileURLToPath(new URL('.', import.meta.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 http = require('http')
const path = require('path') 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) const dir = path.join(__dirname)
...@@ -1950,11 +1950,7 @@ if (!process.env.NEXT_MANUAL_SIG_HANDLE) { ...@@ -1950,11 +1950,7 @@ if (!process.env.NEXT_MANUAL_SIG_HANDLE) {
const currentPort = parseInt(process.env.PORT, 10) || 3000 const currentPort = parseInt(process.env.PORT, 10) || 3000
const hostname = process.env.HOSTNAME || 'localhost' const hostname = process.env.HOSTNAME || 'localhost'
const keepAliveTimeout = parseInt(process.env.KEEP_ALIVE_TIMEOUT, 10); let keepAliveTimeout = parseInt(process.env.KEEP_ALIVE_TIMEOUT, 10);
const isValidKeepAliveTimeout =
!Number.isNaN(keepAliveTimeout) &&
Number.isFinite(keepAliveTimeout) &&
keepAliveTimeout >= 0;
const nextConfig = ${JSON.stringify({ const nextConfig = ${JSON.stringify({
...serverConfig, ...serverConfig,
distDir: `./${path.relative(dir, distDir)}`, distDir: `./${path.relative(dir, distDir)}`,
...@@ -1962,41 +1958,30 @@ const nextConfig = ${JSON.stringify({ ...@@ -1962,41 +1958,30 @@ const nextConfig = ${JSON.stringify({
process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(nextConfig) process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(nextConfig)
createServerHandler({ if (
port: currentPort, Number.isNaN(keepAliveTimeout) ||
hostname, !Number.isFinite(keepAliveTimeout) ||
dir, keepAliveTimeout < 0
conf: nextConfig, ) {
keepAliveTimeout: isValidKeepAliveTimeout ? keepAliveTimeout : undefined, 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)
}
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( console.log(
'Listening on port', 'Listening on port',
currentPort, currentPort,
'url: http://' + hostname + ':' + currentPort 'url: http://' + hostname + ':' + currentPort
) )
}); }).catch((err) => {
}).catch(err => {
console.error(err); console.error(err);
process.exit(1); process.exit(1);
});` });`
......
...@@ -35,10 +35,27 @@ function generateClientManifest( ...@@ -35,10 +35,27 @@ function generateClientManifest(
'NextJsBuildManifest-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(() => { return genClientManifestSpan?.traceFn(() => {
const clientManifest: ClientBuildManifest = { const clientManifest: ClientBuildManifest = {
// TODO: update manifest type to include rewrites __rewrites: {
__rewrites: rewrites as any, 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 appDependencies = new Set(assetMap.pages['/_app'])
const sortedPageKeys = getSortedRoutes(Object.keys(assetMap.pages)) const sortedPageKeys = getSortedRoutes(Object.keys(assetMap.pages))
......
...@@ -20,9 +20,15 @@ const originModules = [ ...@@ -20,9 +20,15 @@ const originModules = [
const RUNTIME_NAMES = ['webpack-runtime', 'webpack-api-runtime'] 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() { export function deleteAppClientCache() {
if ((global as any)._nextDeleteAppClientCache) { if ((global as any)._nextDeleteAppClientCache) {
;(global as any)._nextDeleteAppClientCache() return (global as any)._nextDeleteAppClientCache()
} }
// ensure we reset the cache for rsc components // ensure we reset the cache for rsc components
// loaded via react-server-dom-webpack // loaded via react-server-dom-webpack
...@@ -41,10 +47,6 @@ export function deleteAppClientCache() { ...@@ -41,10 +47,6 @@ export function deleteAppClientCache() {
} }
export function deleteCache(filePath: string) { export function deleteCache(filePath: string) {
if ((global as any)._nextDeleteCache) {
;(global as any)._nextDeleteCache(filePath)
}
// try to clear it from the fs cache // try to clear it from the fs cache
clearManifestCache(filePath) clearManifestCache(filePath)
...@@ -86,7 +88,7 @@ export class NextJsRequireCacheHotReloader implements WebpackPluginInstance { ...@@ -86,7 +88,7 @@ export class NextJsRequireCacheHotReloader implements WebpackPluginInstance {
apply(compiler: Compiler) { apply(compiler: Compiler) {
compiler.hooks.assetEmitted.tap(PLUGIN_NAME, (_file, { targetPath }) => { compiler.hooks.assetEmitted.tap(PLUGIN_NAME, (_file, { targetPath }) => {
deleteCache(targetPath) nextDeleteCacheRpc([targetPath])
// Clear module context in other processes // Clear module context in other processes
if ((global as any)._nextClearModuleContext) { if ((global as any)._nextClearModuleContext) {
...@@ -96,35 +98,33 @@ export class NextJsRequireCacheHotReloader implements WebpackPluginInstance { ...@@ -96,35 +98,33 @@ export class NextJsRequireCacheHotReloader implements WebpackPluginInstance {
clearModuleContext(targetPath) clearModuleContext(targetPath)
}) })
compiler.hooks.afterEmit.tap(PLUGIN_NAME, (compilation) => { compiler.hooks.afterEmit.tapPromise(PLUGIN_NAME, async (compilation) => {
RUNTIME_NAMES.forEach((name) => { const cacheEntriesToDelete = []
for (const name of RUNTIME_NAMES) {
const runtimeChunkPath = path.join( const runtimeChunkPath = path.join(
compilation.outputOptions.path!, compilation.outputOptions.path!,
`${name}.js` `${name}.js`
) )
deleteCache(runtimeChunkPath) cacheEntriesToDelete.push(runtimeChunkPath)
}) }
let hasAppPath = false
// we need to make sure to clear all server entries from cache // we need to make sure to clear all server entries from cache
// since they can have a stale webpack-runtime cache // since they can have a stale webpack-runtime cache
// which needs to always be in-sync // which needs to always be in-sync
const entries = [...compilation.entries.keys()].filter((entry) => { const entries = [...compilation.entries.keys()].filter((entry) => {
const isAppPath = entry.toString().startsWith('app/') const isAppPath = entry.toString().startsWith('app/')
hasAppPath = hasAppPath || isAppPath
return entry.toString().startsWith('pages/') || isAppPath return entry.toString().startsWith('pages/') || isAppPath
}) })
if (hasAppPath) { for (const page of entries) {
}
entries.forEach((page) => {
const outputPath = path.join( const outputPath = path.join(
compilation.outputOptions.path!, compilation.outputOptions.path!,
page + '.js' page + '.js'
) )
deleteCache(outputPath) cacheEntriesToDelete.push(outputPath)
}) }
await nextDeleteCacheRpc(cacheEntriesToDelete)
}) })
} }
} }
...@@ -8,11 +8,7 @@ import isError from '../lib/is-error' ...@@ -8,11 +8,7 @@ import isError from '../lib/is-error'
import { getProjectDir } from '../lib/get-project-dir' import { getProjectDir } from '../lib/get-project-dir'
import { CONFIG_FILES, PHASE_DEVELOPMENT_SERVER } from '../shared/lib/constants' import { CONFIG_FILES, PHASE_DEVELOPMENT_SERVER } from '../shared/lib/constants'
import path from 'path' import path from 'path'
import { import { defaultConfig, NextConfigComplete } from '../server/config-shared'
defaultConfig,
NextConfig,
NextConfigComplete,
} from '../server/config-shared'
import { traceGlobals } from '../trace/shared' import { traceGlobals } from '../trace/shared'
import { Telemetry } from '../telemetry/storage' import { Telemetry } from '../telemetry/storage'
import loadConfig from '../server/config' import loadConfig from '../server/config'
...@@ -26,6 +22,7 @@ import { getPossibleInstrumentationHookFilenames } from '../build/worker' ...@@ -26,6 +22,7 @@ import { getPossibleInstrumentationHookFilenames } from '../build/worker'
import { resetEnv } from '@next/env' import { resetEnv } from '@next/env'
let dir: string let dir: string
let config: NextConfigComplete
let isTurboSession = false let isTurboSession = false
let sessionStopHandled = false let sessionStopHandled = false
let sessionStarted = Date.now() let sessionStarted = Date.now()
...@@ -38,13 +35,15 @@ const handleSessionStop = async () => { ...@@ -38,13 +35,15 @@ const handleSessionStop = async () => {
const { eventCliSession } = const { eventCliSession } =
require('../telemetry/events/session-stopped') as typeof import('../telemetry/events/session-stopped') require('../telemetry/events/session-stopped') as typeof import('../telemetry/events/session-stopped')
const config = await loadConfig( config =
config ||
(await loadConfig(
PHASE_DEVELOPMENT_SERVER, PHASE_DEVELOPMENT_SERVER,
dir, dir,
undefined, undefined,
undefined, undefined,
true true
) ))
let telemetry = let telemetry =
(traceGlobals.get('telemetry') as InstanceType< (traceGlobals.get('telemetry') as InstanceType<
...@@ -211,12 +210,14 @@ const nextDev: CliCommand = async (argv) => { ...@@ -211,12 +210,14 @@ const nextDev: CliCommand = async (argv) => {
// We do not set a default host value here to prevent breaking // We do not set a default host value here to prevent breaking
// some set-ups that rely on listening on other interfaces // some set-ups that rely on listening on other interfaces
const host = args['--hostname'] const host = args['--hostname']
config = await loadConfig(PHASE_DEVELOPMENT_SERVER, dir)
const devServerOptions: StartServerOptions = { const devServerOptions: StartServerOptions = {
dir, dir,
port, port,
allowRetry, allowRetry,
isDev: true, isDev: true,
nextConfig: config,
hostname: host, hostname: host,
// This is required especially for app dir. // This is required especially for app dir.
useWorkers: true, useWorkers: true,
...@@ -237,14 +238,6 @@ const nextDev: CliCommand = async (argv) => { ...@@ -237,14 +238,6 @@ const nextDev: CliCommand = async (argv) => {
resetEnv() resetEnv()
let bindings = await loadBindings() let bindings = await loadBindings()
const config = await loadConfig(
PHASE_DEVELOPMENT_SERVER,
dir,
undefined,
undefined,
true
)
// Just testing code here: // Just testing code here:
const project = await bindings.turbo.createProject({ const project = await bindings.turbo.createProject({
...@@ -409,7 +402,6 @@ const nextDev: CliCommand = async (argv) => { ...@@ -409,7 +402,6 @@ const nextDev: CliCommand = async (argv) => {
try { try {
let shouldFilter = false let shouldFilter = false
let devServerTeardown: (() => Promise<void>) | undefined let devServerTeardown: (() => Promise<void>) | undefined
let config: NextConfig | undefined
watchConfigFiles(devServerOptions.dir, (filename) => { watchConfigFiles(devServerOptions.dir, (filename) => {
Log.warn( Log.warn(
...@@ -505,16 +497,6 @@ const nextDev: CliCommand = async (argv) => { ...@@ -505,16 +497,6 @@ const nextDev: CliCommand = async (argv) => {
// fallback to noop, if not provided // fallback to noop, if not provided
resolveCleanup(async () => {}) resolveCleanup(async () => {})
} }
if (!config) {
config = await loadConfig(
PHASE_DEVELOPMENT_SERVER,
dir,
undefined,
undefined,
true
)
}
} }
await setupFork() await setupFork()
......
...@@ -84,6 +84,7 @@ const nextStart: CliCommand = async (argv) => { ...@@ -84,6 +84,7 @@ const nextStart: CliCommand = async (argv) => {
await startServer({ await startServer({
dir, dir,
nextConfig: config,
isDev: false, isDev: false,
hostname: host, hostname: host,
port, port,
......
...@@ -36,6 +36,7 @@ const supportedTurbopackNextConfigOptions = [ ...@@ -36,6 +36,7 @@ const supportedTurbopackNextConfigOptions = [
'experimental.isrFlushToDisk', 'experimental.isrFlushToDisk',
'experimental.workerThreads', 'experimental.workerThreads',
'experimenatl.pageEnv', 'experimenatl.pageEnv',
'experimental.caseSensitiveRoutes',
] ]
// The following will need to be supported by `next build --turbo` // The following will need to be supported by `next build --turbo`
......
import type { IncomingMessage } from 'http' import type { IncomingMessage } from 'http'
import type { BaseNextRequest } from '../base-http' import type { BaseNextRequest } from '../base-http'
import type { CookieSerializeOptions } from 'next/dist/compiled/cookie' 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 { HeadersAdapter } from '../web/spec-extension/adapters/headers'
import { import {
...@@ -186,7 +186,7 @@ export function sendError( ...@@ -186,7 +186,7 @@ export function sendError(
} }
interface LazyProps { interface LazyProps {
req: NextApiRequest req: IncomingMessage
} }
/** /**
......
...@@ -475,16 +475,7 @@ async function revalidate( ...@@ -475,16 +475,7 @@ async function revalidate(
headers: {}, headers: {},
} }
) )
const result = await res.json()
const chunks = []
for await (const chunk of res) {
if (chunk) {
chunks.push(chunk)
}
}
const body = Buffer.concat(chunks).toString()
const result = JSON.parse(body)
if (result.err) { if (result.err) {
throw new Error(result.err.message) throw new Error(result.err.message)
......
This diff is collapsed.
let installed: boolean = false let installed: boolean = false
export function loadWebpackHook({ init }: { init: boolean }) { export function loadWebpackHook() {
if (init) {
const { init: initWebpack } = require('next/dist/compiled/webpack/webpack') const { init: initWebpack } = require('next/dist/compiled/webpack/webpack')
if (installed) { if (installed) {
return return
} }
installed = true installed = true
initWebpack() initWebpack()
}
// hook the Node.js require so that webpack requires are // hook the Node.js require so that webpack requires are
// routed to the bundled and now initialized webpack version // routed to the bundled and now initialized webpack version
......
...@@ -711,24 +711,21 @@ export default async function loadConfig( ...@@ -711,24 +711,21 @@ export default async function loadConfig(
rawConfig?: boolean, rawConfig?: boolean,
silent?: boolean silent?: boolean
): Promise<NextConfigComplete> { ): Promise<NextConfigComplete> {
if (process.env.__NEXT_PRIVATE_STANDALONE_CONFIG) { if (!process.env.__NEXT_PRIVATE_RENDER_WORKER) {
return JSON.parse(process.env.__NEXT_PRIVATE_STANDALONE_CONFIG) 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
}
} }
const curLog = silent
? {
warn: () => {},
info: () => {},
error: () => {},
} }
: Log
loadEnvConfig(dir, phase === PHASE_DEVELOPMENT_SERVER, curLog)
loadWebpackHook({ if (process.env.__NEXT_PRIVATE_STANDALONE_CONFIG) {
// For render workers, there's no need to init webpack eagerly return JSON.parse(process.env.__NEXT_PRIVATE_STANDALONE_CONFIG)
init: !process.env.__NEXT_PRIVATE_RENDER_WORKER, }
})
// For the render worker, we directly return the serialized config from the // For the render worker, we directly return the serialized config from the
// parent worker (router worker) to avoid loading it again. // parent worker (router worker) to avoid loading it again.
...@@ -740,6 +737,16 @@ export default async function loadConfig( ...@@ -740,6 +737,16 @@ export default async function loadConfig(
return JSON.parse(process.env.__NEXT_PRIVATE_RENDER_WORKER_CONFIG) 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' let configFileName = 'next.config.js'
if (customConfig) { if (customConfig) {
......
...@@ -279,7 +279,7 @@ export default class HotReloader { ...@@ -279,7 +279,7 @@ export default class HotReloader {
parsedPageBundleUrl: UrlObject parsedPageBundleUrl: UrlObject
): Promise<{ finished?: true }> => { ): Promise<{ finished?: true }> => {
const { pathname } = parsedPageBundleUrl const { pathname } = parsedPageBundleUrl
const params = matchNextPageBundleRequest<{ path: string[] }>(pathname) const params = matchNextPageBundleRequest(pathname)
if (!params) { if (!params) {
return {} return {}
} }
...@@ -288,7 +288,7 @@ export default class HotReloader { ...@@ -288,7 +288,7 @@ export default class HotReloader {
try { try {
decodedPagePath = `/${params.path decodedPagePath = `/${params.path
.map((param) => decodeURIComponent(param)) .map((param: string) => decodeURIComponent(param))
.join('/')}` .join('/')}`
} catch (_) { } catch (_) {
throw new DecodeError('failed to decode param') throw new DecodeError('failed to decode param')
...@@ -1411,10 +1411,12 @@ export default class HotReloader { ...@@ -1411,10 +1411,12 @@ export default class HotReloader {
clientOnly, clientOnly,
appPaths, appPaths,
match, match,
isApp,
}: { }: {
page: string page: string
clientOnly: boolean clientOnly: boolean
appPaths?: string[] | null appPaths?: string[] | null
isApp?: boolean
match?: RouteMatch match?: RouteMatch
}): Promise<void> { }): Promise<void> {
// Make sure we don't re-build or dispose prebuilt pages // Make sure we don't re-build or dispose prebuilt pages
...@@ -1432,6 +1434,7 @@ export default class HotReloader { ...@@ -1432,6 +1434,7 @@ export default class HotReloader {
clientOnly, clientOnly,
appPaths, appPaths,
match, match,
isApp,
}) as any }) as any
} }
} }
...@@ -689,11 +689,13 @@ export function onDemandEntryHandler({ ...@@ -689,11 +689,13 @@ export function onDemandEntryHandler({
clientOnly, clientOnly,
appPaths = null, appPaths = null,
match, match,
isApp,
}: { }: {
page: string page: string
clientOnly: boolean clientOnly: boolean
appPaths?: ReadonlyArray<string> | null appPaths?: ReadonlyArray<string> | null
match?: RouteMatch match?: RouteMatch
isApp?: boolean
}): Promise<void> { }): Promise<void> {
const stalledTime = 60 const stalledTime = 60
const stalledEnsureTimeout = setTimeout(() => { const stalledEnsureTimeout = setTimeout(() => {
...@@ -722,6 +724,12 @@ export function onDemandEntryHandler({ ...@@ -722,6 +724,12 @@ export function onDemandEntryHandler({
const isInsideAppDir = const isInsideAppDir =
!!appDir && pagePathData.absolutePagePath.startsWith(appDir) !!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 pageBundleType = getPageBundleType(pagePathData.bundlePath)
const addEntry = ( const addEntry = (
compilerType: CompilerNameValues compilerType: CompilerNameValues
...@@ -894,11 +902,13 @@ export function onDemandEntryHandler({ ...@@ -894,11 +902,13 @@ export function onDemandEntryHandler({
clientOnly, clientOnly,
appPaths = null, appPaths = null,
match, match,
isApp,
}: { }: {
page: string page: string
clientOnly: boolean clientOnly: boolean
appPaths?: ReadonlyArray<string> | null appPaths?: ReadonlyArray<string> | null
match?: RouteMatch match?: RouteMatch
isApp?: boolean
}) { }) {
if (curEnsurePage.has(page)) { if (curEnsurePage.has(page)) {
return curEnsurePage.get(page) return curEnsurePage.get(page)
...@@ -908,6 +918,7 @@ export function onDemandEntryHandler({ ...@@ -908,6 +918,7 @@ export function onDemandEntryHandler({
clientOnly, clientOnly,
appPaths, appPaths,
match, match,
isApp,
}).finally(() => { }).finally(() => {
curEnsurePage.delete(page) curEnsurePage.delete(page)
}) })
......
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 type { RequestHandler } from '../next'
import './cpu-profile' // this must come first as it includes require hooks
import v8 from 'v8' import { initializeServerWorker } from './setup-server-worker'
import http from 'http'
import { isIPv6 } from 'net'
// This is required before other imports to ensure the require hook is setup.
import '../require-hook'
import next from '../next' import next from '../next'
import { warn } from '../../build/output/log'
import { getFreePort } from '../lib/worker-utils'
export const WORKER_SELF_EXIT_CODE = 77 export const WORKER_SELF_EXIT_CODE = 77
const MAXIMUM_HEAP_SIZE_ALLOWED =
(v8.getHeapStatistics().heap_size_limit / 1024 / 1024) * 0.9
let result: let result:
| undefined | undefined
| { | {
...@@ -24,6 +13,8 @@ let result: ...@@ -24,6 +13,8 @@ let result:
hostname: string hostname: string
} }
let app: ReturnType<typeof next> | undefined
let sandboxContext: undefined | typeof import('../web/sandbox/context') let sandboxContext: undefined | typeof import('../web/sandbox/context')
let requireCacheHotReloader: let requireCacheHotReloader:
| undefined | undefined
...@@ -35,15 +26,46 @@ if (process.env.NODE_ENV !== 'production') { ...@@ -35,15 +26,46 @@ if (process.env.NODE_ENV !== 'production') {
} }
export function clearModuleContext(target: string) { export function clearModuleContext(target: string) {
sandboxContext?.clearModuleContext(target) return sandboxContext?.clearModuleContext(target)
} }
export function deleteAppClientCache() { export function deleteAppClientCache() {
requireCacheHotReloader?.deleteAppClientCache() return requireCacheHotReloader?.deleteAppClientCache()
} }
export function deleteCache(filePath: string) { export function deleteCache(filePaths: string[]) {
for (const filePath of filePaths) {
requireCacheHotReloader?.deleteCache(filePath) 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: { export async function initialize(opts: {
...@@ -55,6 +77,7 @@ export async function initialize(opts: { ...@@ -55,6 +77,7 @@ export async function initialize(opts: {
workerType: 'router' | 'render' workerType: 'router' | 'render'
isNodeDebugging: boolean isNodeDebugging: boolean
keepAliveTimeout?: number keepAliveTimeout?: number
serverFields?: any
}): Promise<NonNullable<typeof result>> { }): Promise<NonNullable<typeof result>> {
// if we already setup the server return as we only need to do // if we already setup the server return as we only need to do
// this on first worker boot // this on first worker boot
...@@ -62,83 +85,27 @@ export async function initialize(opts: { ...@@ -62,83 +85,27 @@ export async function initialize(opts: {
return result 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! const type = process.env.__NEXT_PRIVATE_RENDER_WORKER!
process.title = 'next-render-worker-' + type process.title = 'next-render-worker-' + type
}
let requestHandler: RequestHandler 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)
}
})
})
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)
})
let upgradeHandler: any let upgradeHandler: any
if (!opts.dev) { const { port, server, hostname } = await initializeServerWorker(
server.on('upgrade', (req, socket, upgrade) => { (...args) => {
upgradeHandler(req, socket, upgrade) return requestHandler(...args)
}) },
} (...args) => {
return upgradeHandler(...args)
server.on('listening', async () => { },
try { opts
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)) { app = next({
hostname = hostname === '::' ? '[::1]' : `[${hostname}]`
}
result = {
port,
hostname,
}
const app = next({
...opts, ...opts,
_routerWorker: isRouterWorker, _routerWorker: opts.workerType === 'router',
_renderWorker: isRenderWorker, _renderWorker: opts.workerType === 'render',
hostname, hostname: hostname === '0.0.0.0' ? 'localhost' : hostname,
customServer: false, customServer: false,
httpServer: server, httpServer: server,
port: opts.port, port: opts.port,
...@@ -147,12 +114,11 @@ export async function initialize(opts: { ...@@ -147,12 +114,11 @@ export async function initialize(opts: {
requestHandler = app.getRequestHandler() requestHandler = app.getRequestHandler()
upgradeHandler = app.getUpgradeHandler() upgradeHandler = app.getUpgradeHandler()
await app.prepare() await app.prepare(opts.serverFields)
resolve(result)
} catch (err) { result = {
return reject(err) port,
hostname: hostname === '0.0.0.0' ? '127.0.0.1' : hostname,
} }
}) return result
server.listen(await getFreePort(), '0.0.0.0')
})
} }
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 ( ...@@ -88,13 +88,14 @@ export const createWorker = async (
nextConfig: NextConfigComplete nextConfig: NextConfigComplete
) => { ) => {
const { initialEnv } = require('@next/env') as typeof import('@next/env') const { initialEnv } = require('@next/env') as typeof import('@next/env')
const { Worker } = require('next/dist/compiled/jest-worker')
const useServerActions = !!nextConfig.experimental.serverActions 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'), { const worker = new Worker(require.resolve('../render-server'), {
numWorkers: 1, numWorkers: 1,
// TODO: do we want to allow more than 10 OOM restarts? // TODO: do we want to allow more than 8 OOM restarts?
maxRetries: 10, maxRetries: 8,
forkOptions: { forkOptions: {
env: { env: {
FORCE_COLOR: '1', FORCE_COLOR: '1',
...@@ -129,11 +130,14 @@ export const createWorker = async ( ...@@ -129,11 +130,14 @@ export const createWorker = async (
'deleteCache', 'deleteCache',
'deleteAppClientCache', 'deleteAppClientCache',
'clearModuleContext', 'clearModuleContext',
'propagateServerField',
], ],
}) as any as InstanceType<typeof Worker> & { }) as any as InstanceType<typeof Worker> & {
initialize: typeof import('../render-server').initialize initialize: typeof import('../render-server').initialize
deleteCache: typeof import('../render-server').deleteCache deleteCache: typeof import('../render-server').deleteCache
deleteAppClientCache: typeof import('../render-server').deleteAppClientCache deleteAppClientCache: typeof import('../render-server').deleteAppClientCache
clearModuleContext: typeof import('../render-server').clearModuleContext
propagateServerField: typeof import('../render-server').propagateServerField
} }
worker.getStderr().pipe(process.stderr) 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' import { filterReqHeaders } from './utils'
export const invokeRequest = async ( export const invokeRequest = async (
...@@ -7,51 +10,62 @@ export const invokeRequest = async ( ...@@ -7,51 +10,62 @@ export const invokeRequest = async (
headers: IncomingMessage['headers'] headers: IncomingMessage['headers']
method: IncomingMessage['method'] method: IncomingMessage['method']
}, },
readableBody?: import('stream').Readable readableBody?: Readable | ReadableStream
) => { ) => {
const invokeHeaders = filterReqHeaders({
...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 // force to 127.0.0.1 as IPC always runs on this hostname
// to avoid localhost issues // to avoid localhost issues
const parsedTargetUrl = new URL(targetUrl) const parsedTargetUrl = new URL(targetUrl)
parsedTargetUrl.hostname = '127.0.0.1' parsedTargetUrl.hostname = '127.0.0.1'
const invokeReq = http.request( const invokeHeaders = filterReqHeaders({
parsedTargetUrl.toString(), 'cache-control': '',
{ ...requestInit.headers,
headers: invokeHeaders, }) as IncomingMessage['headers']
const invokeRes = await fetch(parsedTargetUrl.toString(), {
headers: invokeHeaders as any as Headers,
method: requestInit.method, method: requestInit.method,
}, redirect: 'manual',
(res) => {
resolveInvoke(res) ...(requestInit.method !== 'GET' &&
requestInit.method !== 'HEAD' &&
readableBody
? {
body: readableBody as BodyInit,
duplex: 'half',
} }
) : {}),
invokeReq.on('error', (err) => {
rejectInvoke(err)
})
if (requestInit.method !== 'GET' && requestInit.method !== 'HEAD') { next: {
if (readableBody) { // @ts-ignore
readableBody.pipe(invokeReq) internal: true,
readableBody.on('close', () => { },
invokeReq.end()
}) })
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()
} }
} else {
invokeReq.end()
} }
} catch (err) {
rejectInvoke(err) if (!item?.done) {
return doRead()
} }
} }
) await doRead()
writable.end()
return invokeRes
} }
export const forbiddenHeaders = [ export const forbiddenHeaders = [
'accept-encoding', 'accept-encoding',
'keepalive', 'keepalive',
'keep-alive',
'content-encoding', 'content-encoding',
'transfer-encoding', 'transfer-encoding',
// https://github.com/nodejs/undici/issues/1470 // https://github.com/nodejs/undici/issues/1470
...@@ -8,7 +9,7 @@ export const forbiddenHeaders = [ ...@@ -8,7 +9,7 @@ export const forbiddenHeaders = [
] ]
export const filterReqHeaders = ( export const filterReqHeaders = (
headers: Record<string, undefined | string | string[]> headers: Record<string, undefined | string | number | string[]>
) => { ) => {
for (const [key, value] of Object.entries(headers)) { for (const [key, value] of Object.entries(headers)) {
if ( if (
...@@ -18,5 +19,5 @@ export const filterReqHeaders = ( ...@@ -18,5 +19,5 @@ export const filterReqHeaders = (
delete headers[key] delete headers[key]
} }
} }
return headers return headers as Record<string, undefined | string | string[]>
} }
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
...@@ -10,10 +10,11 @@ send.mime.define({ ...@@ -10,10 +10,11 @@ send.mime.define({
export function serveStatic( export function serveStatic(
req: IncomingMessage, req: IncomingMessage,
res: ServerResponse, res: ServerResponse,
path: string path: string,
opts?: Parameters<typeof send>[2]
): Promise<void> { ): Promise<void> {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
send(req, path) send(req, path, opts)
.on('directory', () => { .on('directory', () => {
// We don't allow directories to be read. // We don't allow directories to be read.
const err: any = new Error('No directory access') const err: any = new Error('No directory access')
......
This diff is collapsed.
This diff is collapsed.
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