File size: 3,711 Bytes
1e92f2d |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 |
import type { NextServer, RequestHandler, UpgradeHandler } from '../next'
import type { DevBundlerService } from './dev-bundler-service'
import type { PropagateToWorkersField } from './router-utils/types'
import next from '../next'
import type { Span } from '../../trace'
export type ServerInitResult = {
requestHandler: RequestHandler
upgradeHandler: UpgradeHandler
server: NextServer
// Make an effort to close upgraded HTTP requests (e.g. Turbopack HMR websockets)
closeUpgraded: () => void
}
let initializations: Record<string, Promise<ServerInitResult> | undefined> = {}
let sandboxContext: undefined | typeof import('../web/sandbox/context')
if (process.env.NODE_ENV !== 'production') {
sandboxContext =
require('../web/sandbox/context') as typeof import('../web/sandbox/context')
}
export function clearAllModuleContexts() {
return sandboxContext?.clearAllModuleContexts()
}
export function clearModuleContext(target: string) {
return sandboxContext?.clearModuleContext(target)
}
export async function getServerField(
dir: string,
field: PropagateToWorkersField
) {
const initialization = await initializations[dir]
if (!initialization) {
throw new Error('Invariant cant propagate server field, no app initialized')
}
const { server } = initialization
let wrappedServer = server['server']! // NextServer.server is private
return wrappedServer[field as keyof typeof wrappedServer]
}
export async function propagateServerField(
dir: string,
field: PropagateToWorkersField,
value: any
) {
const initialization = await initializations[dir]
if (!initialization) {
throw new Error('Invariant cant propagate server field, no app initialized')
}
const { server } = initialization
let wrappedServer = server['server']
const _field = field as keyof NonNullable<typeof wrappedServer>
if (wrappedServer) {
if (typeof wrappedServer[_field] === 'function') {
// @ts-expect-error
await wrappedServer[_field].apply(
wrappedServer,
Array.isArray(value) ? value : []
)
} else {
// @ts-expect-error
wrappedServer[_field] = value
}
}
}
async function initializeImpl(opts: {
dir: string
port: number
dev: boolean
minimalMode?: boolean
hostname?: string
keepAliveTimeout?: number
serverFields?: any
server?: any
experimentalTestProxy: boolean
experimentalHttpsServer: boolean
_ipcPort?: string
_ipcKey?: string
bundlerService: DevBundlerService | undefined
startServerSpan: Span | undefined
quiet?: boolean
onDevServerCleanup: ((listener: () => Promise<void>) => void) | undefined
}): Promise<ServerInitResult> {
const type = process.env.__NEXT_PRIVATE_RENDER_WORKER
if (type) {
process.title = 'next-render-worker-' + type
}
let requestHandler: RequestHandler
let upgradeHandler: UpgradeHandler
const server = next({
...opts,
hostname: opts.hostname || 'localhost',
customServer: false,
httpServer: opts.server,
port: opts.port,
}) as NextServer // should return a NextServer when `customServer: false`
requestHandler = server.getRequestHandler()
upgradeHandler = server.getUpgradeHandler()
await server.prepare(opts.serverFields)
return {
requestHandler,
upgradeHandler,
server,
closeUpgraded() {
opts.bundlerService?.close()
},
}
}
export async function initialize(
opts: Parameters<typeof initializeImpl>[0]
): Promise<ServerInitResult> {
// if we already setup the server return as we only need to do
// this on first worker boot
if (initializations[opts.dir]) {
return initializations[opts.dir]!
}
return (initializations[opts.dir] = initializeImpl(opts))
}
|