|
|
import type { Socket } from 'net' |
|
|
import { mkdir, writeFile } from 'fs/promises' |
|
|
import { join, extname, relative } from 'path' |
|
|
import { pathToFileURL } from 'url' |
|
|
|
|
|
import ws from 'next/dist/compiled/ws' |
|
|
|
|
|
import type { OutputState } from '../../build/output/store' |
|
|
import { store as consoleStore } from '../../build/output/store' |
|
|
import type { |
|
|
CompilationError, |
|
|
HMR_ACTION_TYPES, |
|
|
NextJsHotReloaderInterface, |
|
|
ReloadPageAction, |
|
|
SyncAction, |
|
|
TurbopackConnectedAction, |
|
|
} from './hot-reloader-types' |
|
|
import { HMR_ACTIONS_SENT_TO_BROWSER } from './hot-reloader-types' |
|
|
import type { |
|
|
Update as TurbopackUpdate, |
|
|
Endpoint, |
|
|
WrittenEndpoint, |
|
|
TurbopackResult, |
|
|
Project, |
|
|
Entrypoints, |
|
|
} from '../../build/swc/types' |
|
|
import { createDefineEnv } from '../../build/swc' |
|
|
import * as Log from '../../build/output/log' |
|
|
import { |
|
|
getVersionInfo, |
|
|
matchNextPageBundleRequest, |
|
|
} from './hot-reloader-webpack' |
|
|
import { BLOCKED_PAGES } from '../../shared/lib/constants' |
|
|
import { |
|
|
getOverlayMiddleware, |
|
|
getSourceMapMiddleware, |
|
|
} from './middleware-turbopack' |
|
|
import { PageNotFoundError } from '../../shared/lib/utils' |
|
|
import { debounce } from '../utils' |
|
|
import { deleteCache } from './require-cache' |
|
|
import { |
|
|
clearAllModuleContexts, |
|
|
clearModuleContext, |
|
|
} from '../lib/render-server' |
|
|
import { denormalizePagePath } from '../../shared/lib/page-path/denormalize-page-path' |
|
|
import { trace } from '../../trace' |
|
|
import { |
|
|
AssetMapper, |
|
|
type ChangeSubscriptions, |
|
|
type ClientState, |
|
|
handleEntrypoints, |
|
|
handlePagesErrorRoute, |
|
|
handleRouteType, |
|
|
hasEntrypointForKey, |
|
|
msToNs, |
|
|
type ReadyIds, |
|
|
type SendHmr, |
|
|
type StartBuilding, |
|
|
processTopLevelIssues, |
|
|
printNonFatalIssue, |
|
|
normalizedPageToTurbopackStructureRoute, |
|
|
} from './turbopack-utils' |
|
|
import { |
|
|
propagateServerField, |
|
|
type ServerFields, |
|
|
type SetupOpts, |
|
|
} from '../lib/router-utils/setup-dev-bundler' |
|
|
import { TurbopackManifestLoader } from '../../shared/lib/turbopack/manifest-loader' |
|
|
import { findPagePathData } from './on-demand-entry-handler' |
|
|
import type { RouteDefinition } from '../route-definitions/route-definition' |
|
|
import { |
|
|
type EntryKey, |
|
|
getEntryKey, |
|
|
splitEntryKey, |
|
|
} from '../../shared/lib/turbopack/entry-key' |
|
|
import { FAST_REFRESH_RUNTIME_RELOAD } from './messages' |
|
|
import { generateEncryptionKeyBase64 } from '../app-render/encryption-utils-server' |
|
|
import { isAppPageRouteDefinition } from '../route-definitions/app-page-route-definition' |
|
|
import { normalizeAppPath } from '../../shared/lib/router/utils/app-paths' |
|
|
import type { ModernSourceMapPayload } from '../lib/source-maps' |
|
|
import { getNodeDebugType } from '../lib/utils' |
|
|
import { isMetadataRouteFile } from '../../lib/metadata/is-metadata-route' |
|
|
import { setBundlerFindSourceMapImplementation } from '../patch-error-inspect' |
|
|
import { getNextErrorFeedbackMiddleware } from '../../next-devtools/server/get-next-error-feedback-middleware' |
|
|
import { |
|
|
formatIssue, |
|
|
getTurbopackJsConfig, |
|
|
isPersistentCachingEnabled, |
|
|
isWellKnownError, |
|
|
processIssues, |
|
|
renderStyledStringToErrorAnsi, |
|
|
type EntryIssuesMap, |
|
|
type TopLevelIssuesMap, |
|
|
} from '../../shared/lib/turbopack/utils' |
|
|
import { getDevOverlayFontMiddleware } from '../../next-devtools/server/font/get-dev-overlay-font-middleware' |
|
|
import { devIndicatorServerState } from './dev-indicator-server-state' |
|
|
import { getDisableDevIndicatorMiddleware } from '../../next-devtools/server/dev-indicator-middleware' |
|
|
import { getRestartDevServerMiddleware } from '../../next-devtools/server/restart-dev-server-middleware' |
|
|
import { backgroundLogCompilationEvents } from '../../shared/lib/turbopack/compilation-events' |
|
|
import { getSupportedBrowsers } from '../../build/utils' |
|
|
import { receiveBrowserLogsTurbopack } from './browser-logs/receive-logs' |
|
|
import { normalizePath } from '../../lib/normalize-path' |
|
|
import { |
|
|
devToolsConfigMiddleware, |
|
|
getDevToolsConfig, |
|
|
} from '../../next-devtools/server/devtools-config-middleware' |
|
|
|
|
|
const wsServer = new ws.Server({ noServer: true }) |
|
|
const isTestMode = !!( |
|
|
process.env.NEXT_TEST_MODE || |
|
|
process.env.__NEXT_TEST_MODE || |
|
|
process.env.DEBUG |
|
|
) |
|
|
|
|
|
const sessionId = Math.floor(Number.MAX_SAFE_INTEGER * Math.random()) |
|
|
|
|
|
declare const __next__clear_chunk_cache__: (() => void) | null | undefined |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function rewriteTurbopackSources( |
|
|
projectRoot: string, |
|
|
sourceMap: ModernSourceMapPayload |
|
|
): void { |
|
|
if ('sections' in sourceMap) { |
|
|
for (const section of sourceMap.sections) { |
|
|
rewriteTurbopackSources(projectRoot, section.map) |
|
|
} |
|
|
} else { |
|
|
for (let i = 0; i < sourceMap.sources.length; i++) { |
|
|
sourceMap.sources[i] = pathToFileURL( |
|
|
join( |
|
|
projectRoot, |
|
|
sourceMap.sources[i].replace(/turbopack:\/\/\/\[project\]/, '') |
|
|
) |
|
|
).toString() |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
function getSourceMapFromTurbopack( |
|
|
project: Project, |
|
|
projectRoot: string, |
|
|
sourceURL: string |
|
|
): ModernSourceMapPayload | undefined { |
|
|
let sourceMapJson: string | null = null |
|
|
|
|
|
try { |
|
|
sourceMapJson = project.getSourceMapSync(sourceURL) |
|
|
} catch (err) {} |
|
|
|
|
|
if (sourceMapJson === null) { |
|
|
return undefined |
|
|
} else { |
|
|
const payload: ModernSourceMapPayload = JSON.parse(sourceMapJson) |
|
|
|
|
|
|
|
|
rewriteTurbopackSources(projectRoot, payload) |
|
|
return payload |
|
|
} |
|
|
} |
|
|
|
|
|
export async function createHotReloaderTurbopack( |
|
|
opts: SetupOpts & { isSrcDir: boolean }, |
|
|
serverFields: ServerFields, |
|
|
distDir: string, |
|
|
resetFetch: () => void |
|
|
): Promise<NextJsHotReloaderInterface> { |
|
|
const dev = true |
|
|
const buildId = 'development' |
|
|
const { nextConfig, dir: projectPath } = opts |
|
|
|
|
|
const { loadBindings } = |
|
|
require('../../build/swc') as typeof import('../../build/swc') |
|
|
|
|
|
let bindings = await loadBindings() |
|
|
|
|
|
|
|
|
|
|
|
if (isTestMode) { |
|
|
;(require('console') as typeof import('console')).log( |
|
|
'Creating turbopack project', |
|
|
{ |
|
|
dir: projectPath, |
|
|
testMode: isTestMode, |
|
|
} |
|
|
) |
|
|
} |
|
|
|
|
|
const hasRewrites = |
|
|
opts.fsChecker.rewrites.afterFiles.length > 0 || |
|
|
opts.fsChecker.rewrites.beforeFiles.length > 0 || |
|
|
opts.fsChecker.rewrites.fallback.length > 0 |
|
|
|
|
|
const hotReloaderSpan = trace('hot-reloader', undefined, { |
|
|
version: process.env.__NEXT_VERSION as string, |
|
|
}) |
|
|
|
|
|
|
|
|
hotReloaderSpan.stop() |
|
|
|
|
|
const encryptionKey = await generateEncryptionKeyBase64({ |
|
|
isBuild: false, |
|
|
distDir, |
|
|
}) |
|
|
|
|
|
|
|
|
let clientRouterFilters: any |
|
|
if (nextConfig.experimental.clientRouterFilter) { |
|
|
|
|
|
} |
|
|
|
|
|
const supportedBrowsers = getSupportedBrowsers(projectPath, dev) |
|
|
const currentNodeJsVersion = process.versions.node |
|
|
|
|
|
const rootPath = |
|
|
opts.nextConfig.turbopack?.root || |
|
|
opts.nextConfig.outputFileTracingRoot || |
|
|
projectPath |
|
|
const project = await bindings.turbo.createProject( |
|
|
{ |
|
|
rootPath, |
|
|
projectPath: normalizePath(relative(rootPath, projectPath) || '.'), |
|
|
distDir, |
|
|
nextConfig: opts.nextConfig, |
|
|
jsConfig: await getTurbopackJsConfig(projectPath, nextConfig), |
|
|
watch: { |
|
|
enable: dev, |
|
|
pollIntervalMs: nextConfig.watchOptions?.pollIntervalMs, |
|
|
}, |
|
|
dev, |
|
|
env: process.env as Record<string, string>, |
|
|
defineEnv: createDefineEnv({ |
|
|
isTurbopack: true, |
|
|
clientRouterFilters, |
|
|
config: nextConfig, |
|
|
dev, |
|
|
distDir, |
|
|
projectPath, |
|
|
fetchCacheKeyPrefix: opts.nextConfig.experimental.fetchCacheKeyPrefix, |
|
|
hasRewrites, |
|
|
|
|
|
middlewareMatchers: undefined, |
|
|
rewrites: opts.fsChecker.rewrites, |
|
|
}), |
|
|
buildId, |
|
|
encryptionKey, |
|
|
previewProps: opts.fsChecker.prerenderManifest.preview, |
|
|
browserslistQuery: supportedBrowsers.join(', '), |
|
|
noMangling: false, |
|
|
currentNodeJsVersion, |
|
|
}, |
|
|
{ |
|
|
persistentCaching: isPersistentCachingEnabled(opts.nextConfig), |
|
|
memoryLimit: opts.nextConfig.experimental?.turbopackMemoryLimit, |
|
|
} |
|
|
) |
|
|
backgroundLogCompilationEvents(project, { |
|
|
eventTypes: ['StartupCacheInvalidationEvent'], |
|
|
}) |
|
|
setBundlerFindSourceMapImplementation( |
|
|
getSourceMapFromTurbopack.bind(null, project, projectPath) |
|
|
) |
|
|
opts.onDevServerCleanup?.(async () => { |
|
|
setBundlerFindSourceMapImplementation(() => undefined) |
|
|
await project.onExit() |
|
|
}) |
|
|
const entrypointsSubscription = project.entrypointsSubscribe() |
|
|
|
|
|
const currentWrittenEntrypoints: Map<EntryKey, WrittenEndpoint> = new Map() |
|
|
const currentEntrypoints: Entrypoints = { |
|
|
global: { |
|
|
app: undefined, |
|
|
document: undefined, |
|
|
error: undefined, |
|
|
|
|
|
middleware: undefined, |
|
|
instrumentation: undefined, |
|
|
}, |
|
|
|
|
|
page: new Map(), |
|
|
app: new Map(), |
|
|
} |
|
|
|
|
|
const currentTopLevelIssues: TopLevelIssuesMap = new Map() |
|
|
const currentEntryIssues: EntryIssuesMap = new Map() |
|
|
|
|
|
const manifestLoader = new TurbopackManifestLoader({ |
|
|
buildId, |
|
|
distDir, |
|
|
encryptionKey, |
|
|
}) |
|
|
|
|
|
|
|
|
const changeSubscriptions: ChangeSubscriptions = new Map() |
|
|
const serverPathState = new Map<string, string>() |
|
|
const readyIds: ReadyIds = new Set() |
|
|
let currentEntriesHandlingResolve: ((value?: unknown) => void) | undefined |
|
|
let currentEntriesHandling = new Promise( |
|
|
(resolve) => (currentEntriesHandlingResolve = resolve) |
|
|
) |
|
|
|
|
|
const assetMapper = new AssetMapper() |
|
|
|
|
|
function clearRequireCache( |
|
|
key: EntryKey, |
|
|
writtenEndpoint: WrittenEndpoint, |
|
|
{ |
|
|
force, |
|
|
}: { |
|
|
// Always clear the cache, don't check if files have changed |
|
|
force?: boolean |
|
|
} = {} |
|
|
): boolean { |
|
|
if (force) { |
|
|
for (const { path, contentHash } of writtenEndpoint.serverPaths) { |
|
|
serverPathState.set(path, contentHash) |
|
|
} |
|
|
} else { |
|
|
// Figure out if the server files have changed |
|
|
let hasChange = false |
|
|
for (const { path, contentHash } of writtenEndpoint.serverPaths) { |
|
|
// We ignore source maps |
|
|
if (path.endsWith('.map')) continue |
|
|
const localKey = `${key}:${path}` |
|
|
const localHash = serverPathState.get(localKey) |
|
|
const globalHash = serverPathState.get(path) |
|
|
if ( |
|
|
(localHash && localHash !== contentHash) || |
|
|
(globalHash && globalHash !== contentHash) |
|
|
) { |
|
|
hasChange = true |
|
|
serverPathState.set(key, contentHash) |
|
|
serverPathState.set(path, contentHash) |
|
|
} else { |
|
|
if (!localHash) { |
|
|
serverPathState.set(key, contentHash) |
|
|
} |
|
|
if (!globalHash) { |
|
|
serverPathState.set(path, contentHash) |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
if (!hasChange) { |
|
|
return false |
|
|
} |
|
|
} |
|
|
|
|
|
resetFetch() |
|
|
|
|
|
// Not available in: |
|
|
// - Pages Router (no server-side HMR) |
|
|
// - Edge Runtime (uses browser runtime which already disposes chunks individually) |
|
|
if (typeof __next__clear_chunk_cache__ === 'function') { |
|
|
__next__clear_chunk_cache__() |
|
|
} |
|
|
|
|
|
const serverPaths = writtenEndpoint.serverPaths.map(({ path: p }) => |
|
|
join(distDir, p) |
|
|
) |
|
|
|
|
|
for (const file of serverPaths) { |
|
|
clearModuleContext(file) |
|
|
deleteCache(file) |
|
|
} |
|
|
|
|
|
return true |
|
|
} |
|
|
|
|
|
const buildingIds = new Set() |
|
|
|
|
|
const startBuilding: StartBuilding = (id, requestUrl, forceRebuild) => { |
|
|
if (!forceRebuild && readyIds.has(id)) { |
|
|
return () => {} |
|
|
} |
|
|
if (buildingIds.size === 0) { |
|
|
consoleStore.setState( |
|
|
{ |
|
|
loading: true, |
|
|
trigger: id, |
|
|
url: requestUrl, |
|
|
} as OutputState, |
|
|
true |
|
|
) |
|
|
} |
|
|
buildingIds.add(id) |
|
|
return function finishBuilding() { |
|
|
if (buildingIds.size === 0) { |
|
|
return |
|
|
} |
|
|
readyIds.add(id) |
|
|
buildingIds.delete(id) |
|
|
if (buildingIds.size === 0) { |
|
|
hmrEventHappened = false |
|
|
consoleStore.setState( |
|
|
{ |
|
|
loading: false, |
|
|
} as OutputState, |
|
|
true |
|
|
) |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
let hmrEventHappened = false |
|
|
let hmrHash = 0 |
|
|
|
|
|
const clients = new Set<ws>() |
|
|
const clientStates = new WeakMap<ws, ClientState>() |
|
|
|
|
|
function sendToClient(client: ws, payload: HMR_ACTION_TYPES) { |
|
|
client.send(JSON.stringify(payload)) |
|
|
} |
|
|
|
|
|
function sendEnqueuedMessages() { |
|
|
for (const [, issueMap] of currentEntryIssues) { |
|
|
if ( |
|
|
[...issueMap.values()].filter((i) => i.severity !== 'warning').length > |
|
|
0 |
|
|
) { |
|
|
// During compilation errors we want to delay the HMR events until errors are fixed |
|
|
return |
|
|
} |
|
|
} |
|
|
|
|
|
for (const client of clients) { |
|
|
const state = clientStates.get(client) |
|
|
if (!state) { |
|
|
continue |
|
|
} |
|
|
|
|
|
for (const [, issueMap] of state.clientIssues) { |
|
|
if ( |
|
|
[...issueMap.values()].filter((i) => i.severity !== 'warning') |
|
|
.length > 0 |
|
|
) { |
|
|
// During compilation errors we want to delay the HMR events until errors are fixed |
|
|
return |
|
|
} |
|
|
} |
|
|
|
|
|
for (const payload of state.hmrPayloads.values()) { |
|
|
sendToClient(client, payload) |
|
|
} |
|
|
state.hmrPayloads.clear() |
|
|
|
|
|
if (state.turbopackUpdates.length > 0) { |
|
|
sendToClient(client, { |
|
|
action: HMR_ACTIONS_SENT_TO_BROWSER.TURBOPACK_MESSAGE, |
|
|
data: state.turbopackUpdates, |
|
|
}) |
|
|
state.turbopackUpdates.length = 0 |
|
|
} |
|
|
} |
|
|
} |
|
|
const sendEnqueuedMessagesDebounce = debounce(sendEnqueuedMessages, 2) |
|
|
|
|
|
const sendHmr: SendHmr = (id: string, payload: HMR_ACTION_TYPES) => { |
|
|
for (const client of clients) { |
|
|
clientStates.get(client)?.hmrPayloads.set(id, payload) |
|
|
} |
|
|
|
|
|
hmrEventHappened = true |
|
|
sendEnqueuedMessagesDebounce() |
|
|
} |
|
|
|
|
|
function sendTurbopackMessage(payload: TurbopackUpdate) { |
|
|
// TODO(PACK-2049): For some reason we end up emitting hundreds of issues messages on bigger apps, |
|
|
// a lot of which are duplicates. |
|
|
// They are currently not handled on the client at all, so might as well not send them for now. |
|
|
payload.diagnostics = [] |
|
|
payload.issues = [] |
|
|
|
|
|
for (const client of clients) { |
|
|
clientStates.get(client)?.turbopackUpdates.push(payload) |
|
|
} |
|
|
|
|
|
hmrEventHappened = true |
|
|
sendEnqueuedMessagesDebounce() |
|
|
} |
|
|
|
|
|
async function subscribeToChanges( |
|
|
key: EntryKey, |
|
|
includeIssues: boolean, |
|
|
endpoint: Endpoint, |
|
|
makePayload: ( |
|
|
change: TurbopackResult, |
|
|
hash: string |
|
|
) => Promise<HMR_ACTION_TYPES> | HMR_ACTION_TYPES | void, |
|
|
onError?: ( |
|
|
error: Error |
|
|
) => Promise<HMR_ACTION_TYPES> | HMR_ACTION_TYPES | void |
|
|
) { |
|
|
if (changeSubscriptions.has(key)) { |
|
|
return |
|
|
} |
|
|
|
|
|
const { side } = splitEntryKey(key) |
|
|
|
|
|
const changedPromise = endpoint[`${side}Changed`](includeIssues) |
|
|
changeSubscriptions.set(key, changedPromise) |
|
|
try { |
|
|
const changed = await changedPromise |
|
|
|
|
|
for await (const change of changed) { |
|
|
processIssues(currentEntryIssues, key, change, false, true) |
|
|
// TODO: Get an actual content hash from Turbopack. |
|
|
const payload = await makePayload(change, String(++hmrHash)) |
|
|
if (payload) { |
|
|
sendHmr(key, payload) |
|
|
} |
|
|
} |
|
|
} catch (e) { |
|
|
changeSubscriptions.delete(key) |
|
|
const payload = await onError?.(e as Error) |
|
|
if (payload) { |
|
|
sendHmr(key, payload) |
|
|
} |
|
|
return |
|
|
} |
|
|
changeSubscriptions.delete(key) |
|
|
} |
|
|
|
|
|
async function unsubscribeFromChanges(key: EntryKey) { |
|
|
const subscription = await changeSubscriptions.get(key) |
|
|
if (subscription) { |
|
|
await subscription.return?.() |
|
|
changeSubscriptions.delete(key) |
|
|
} |
|
|
currentEntryIssues.delete(key) |
|
|
} |
|
|
|
|
|
async function subscribeToHmrEvents(client: ws, id: string) { |
|
|
const key = getEntryKey('assets', 'client', id) |
|
|
if (!hasEntrypointForKey(currentEntrypoints, key, assetMapper)) { |
|
|
// maybe throw an error / force the client to reload? |
|
|
return |
|
|
} |
|
|
|
|
|
const state = clientStates.get(client) |
|
|
if (!state || state.subscriptions.has(id)) { |
|
|
return |
|
|
} |
|
|
|
|
|
const subscription = project!.hmrEvents(id) |
|
|
state.subscriptions.set(id, subscription) |
|
|
|
|
|
// The subscription will always emit once, which is the initial |
|
|
// computation. This is not a change, so swallow it. |
|
|
try { |
|
|
await subscription.next() |
|
|
|
|
|
for await (const data of subscription) { |
|
|
processIssues(state.clientIssues, key, data, false, true) |
|
|
if (data.type !== 'issues') { |
|
|
sendTurbopackMessage(data) |
|
|
} |
|
|
} |
|
|
} catch (e) { |
|
|
// The client might be using an HMR session from a previous server, tell them |
|
|
// to fully reload the page to resolve the issue. We can't use |
|
|
// `hotReloader.send` since that would force every connected client to |
|
|
// reload, only this client is out of date. |
|
|
const reloadAction: ReloadPageAction = { |
|
|
action: HMR_ACTIONS_SENT_TO_BROWSER.RELOAD_PAGE, |
|
|
data: `error in HMR event subscription for ${id}: ${e}`, |
|
|
} |
|
|
sendToClient(client, reloadAction) |
|
|
client.close() |
|
|
return |
|
|
} |
|
|
} |
|
|
|
|
|
function unsubscribeFromHmrEvents(client: ws, id: string) { |
|
|
const state = clientStates.get(client) |
|
|
if (!state) { |
|
|
return |
|
|
} |
|
|
|
|
|
const subscription = state.subscriptions.get(id) |
|
|
subscription?.return!() |
|
|
|
|
|
const key = getEntryKey('assets', 'client', id) |
|
|
state.clientIssues.delete(key) |
|
|
} |
|
|
|
|
|
async function handleEntrypointsSubscription() { |
|
|
for await (const entrypoints of entrypointsSubscription) { |
|
|
if (!currentEntriesHandlingResolve) { |
|
|
currentEntriesHandling = new Promise( |
|
|
// eslint-disable-next-line no-loop-func |
|
|
(resolve) => (currentEntriesHandlingResolve = resolve) |
|
|
) |
|
|
} |
|
|
|
|
|
processTopLevelIssues(currentTopLevelIssues, entrypoints) |
|
|
|
|
|
await handleEntrypoints({ |
|
|
entrypoints, |
|
|
|
|
|
currentEntrypoints, |
|
|
|
|
|
currentEntryIssues, |
|
|
manifestLoader, |
|
|
devRewrites: opts.fsChecker.rewrites, |
|
|
productionRewrites: undefined, |
|
|
logErrors: true, |
|
|
|
|
|
dev: { |
|
|
assetMapper, |
|
|
changeSubscriptions, |
|
|
clients, |
|
|
clientStates, |
|
|
serverFields, |
|
|
|
|
|
hooks: { |
|
|
handleWrittenEndpoint: (id, result, forceDeleteCache) => { |
|
|
currentWrittenEntrypoints.set(id, result) |
|
|
return clearRequireCache(id, result, { force: forceDeleteCache }) |
|
|
}, |
|
|
propagateServerField: propagateServerField.bind(null, opts), |
|
|
sendHmr, |
|
|
startBuilding, |
|
|
subscribeToChanges, |
|
|
unsubscribeFromChanges, |
|
|
unsubscribeFromHmrEvents, |
|
|
}, |
|
|
}, |
|
|
}) |
|
|
|
|
|
currentEntriesHandlingResolve!() |
|
|
currentEntriesHandlingResolve = undefined |
|
|
} |
|
|
} |
|
|
|
|
|
await mkdir(join(distDir, 'server'), { recursive: true }) |
|
|
await mkdir(join(distDir, 'static', buildId), { recursive: true }) |
|
|
await writeFile( |
|
|
join(distDir, 'package.json'), |
|
|
JSON.stringify( |
|
|
{ |
|
|
type: 'commonjs', |
|
|
}, |
|
|
null, |
|
|
2 |
|
|
) |
|
|
) |
|
|
|
|
|
const middlewares = [ |
|
|
getOverlayMiddleware({ |
|
|
project, |
|
|
projectPath, |
|
|
isSrcDir: opts.isSrcDir, |
|
|
}), |
|
|
getSourceMapMiddleware(project), |
|
|
getNextErrorFeedbackMiddleware(opts.telemetry), |
|
|
getDevOverlayFontMiddleware(), |
|
|
getDisableDevIndicatorMiddleware(), |
|
|
getRestartDevServerMiddleware({ |
|
|
telemetry: opts.telemetry, |
|
|
turbopackProject: project, |
|
|
}), |
|
|
devToolsConfigMiddleware({ |
|
|
distDir, |
|
|
sendUpdateSignal: (data) => { |
|
|
hotReloader.send({ |
|
|
action: HMR_ACTIONS_SENT_TO_BROWSER.DEVTOOLS_CONFIG, |
|
|
data, |
|
|
}) |
|
|
}, |
|
|
}), |
|
|
] |
|
|
|
|
|
const versionInfoPromise = getVersionInfo() |
|
|
|
|
|
let devtoolsFrontendUrl: string | undefined |
|
|
const nodeDebugType = getNodeDebugType() |
|
|
if (nodeDebugType) { |
|
|
const debugPort = process.debugPort |
|
|
let debugInfo |
|
|
try { |
|
|
// It requires to use 127.0.0.1 instead of localhost for server-side fetching. |
|
|
const debugInfoList = await fetch( |
|
|
`http://127.0.0.1:${debugPort}/json/list` |
|
|
).then((res) => res.json()) |
|
|
debugInfo = debugInfoList[0] |
|
|
} catch {} |
|
|
if (debugInfo) { |
|
|
devtoolsFrontendUrl = debugInfo.devtoolsFrontendUrl |
|
|
} |
|
|
} |
|
|
|
|
|
const hotReloader: NextJsHotReloaderInterface = { |
|
|
turbopackProject: project, |
|
|
activeWebpackConfigs: undefined, |
|
|
serverStats: null, |
|
|
edgeServerStats: null, |
|
|
async run(req, res, _parsedUrl) { |
|
|
// intercept page chunks request and ensure them with turbopack |
|
|
if (req.url?.startsWith('/_next/static/chunks/pages/')) { |
|
|
const params = matchNextPageBundleRequest(req.url) |
|
|
|
|
|
if (params) { |
|
|
const decodedPagePath = `/${params.path |
|
|
.map((param: string) => decodeURIComponent(param)) |
|
|
.join('/')}` |
|
|
|
|
|
const denormalizedPagePath = denormalizePagePath(decodedPagePath) |
|
|
|
|
|
await hotReloader |
|
|
.ensurePage({ |
|
|
page: denormalizedPagePath, |
|
|
clientOnly: false, |
|
|
definition: undefined, |
|
|
url: req.url, |
|
|
}) |
|
|
.catch(console.error) |
|
|
} |
|
|
} |
|
|
|
|
|
for (const middleware of middlewares) { |
|
|
let calledNext = false |
|
|
|
|
|
await middleware(req, res, () => { |
|
|
calledNext = true |
|
|
}) |
|
|
|
|
|
if (!calledNext) { |
|
|
return { finished: true } |
|
|
} |
|
|
} |
|
|
|
|
|
// Request was not finished. |
|
|
return { finished: undefined } |
|
|
}, |
|
|
|
|
|
// TODO: Figure out if socket type can match the NextJsHotReloaderInterface |
|
|
onHMR(req, socket: Socket, head, onUpgrade) { |
|
|
wsServer.handleUpgrade(req, socket, head, (client) => { |
|
|
onUpgrade(client) |
|
|
const clientIssues: EntryIssuesMap = new Map() |
|
|
const subscriptions: Map<string, AsyncIterator<any>> = new Map() |
|
|
|
|
|
clients.add(client) |
|
|
clientStates.set(client, { |
|
|
clientIssues, |
|
|
hmrPayloads: new Map(), |
|
|
turbopackUpdates: [], |
|
|
subscriptions, |
|
|
}) |
|
|
|
|
|
client.on('close', () => { |
|
|
// Remove active subscriptions |
|
|
for (const subscription of subscriptions.values()) { |
|
|
subscription.return?.() |
|
|
} |
|
|
clientStates.delete(client) |
|
|
clients.delete(client) |
|
|
}) |
|
|
|
|
|
client.addEventListener('message', async ({ data }) => { |
|
|
const parsedData = JSON.parse( |
|
|
typeof data !== 'string' ? data.toString() : data |
|
|
) |
|
|
|
|
|
// Next.js messages |
|
|
switch (parsedData.event) { |
|
|
case 'span-end': { |
|
|
hotReloaderSpan.manualTraceChild( |
|
|
parsedData.spanName, |
|
|
msToNs(parsedData.startTime), |
|
|
msToNs(parsedData.endTime), |
|
|
parsedData.attributes |
|
|
) |
|
|
break |
|
|
} |
|
|
case 'client-hmr-latency': // { id, startTime, endTime, page, updatedModules, isPageHidden } |
|
|
hotReloaderSpan.manualTraceChild( |
|
|
parsedData.event, |
|
|
msToNs(parsedData.startTime), |
|
|
msToNs(parsedData.endTime), |
|
|
{ |
|
|
updatedModules: parsedData.updatedModules, |
|
|
page: parsedData.page, |
|
|
isPageHidden: parsedData.isPageHidden, |
|
|
} |
|
|
) |
|
|
break |
|
|
|
|
|
case 'client-error': // { errorCount, clientId } |
|
|
case 'client-warning': // { warningCount, clientId } |
|
|
case 'client-success': // { clientId } |
|
|
case 'server-component-reload-page': // { clientId } |
|
|
case 'client-reload-page': // { clientId } |
|
|
case 'client-removed-page': // { page } |
|
|
case 'client-full-reload': // { stackTrace, hadRuntimeError } |
|
|
const { hadRuntimeError, dependencyChain } = parsedData |
|
|
if (hadRuntimeError) { |
|
|
Log.warn(FAST_REFRESH_RUNTIME_RELOAD) |
|
|
} |
|
|
if ( |
|
|
Array.isArray(dependencyChain) && |
|
|
typeof dependencyChain[0] === 'string' |
|
|
) { |
|
|
const cleanedModulePath = dependencyChain[0] |
|
|
.replace(/^\[project\]/, '.') |
|
|
.replace(/ \[.*\] \(.*\)$/, '') |
|
|
Log.warn( |
|
|
`Fast Refresh had to perform a full reload when ${cleanedModulePath} changed. Read more: https://nextjs.org/docs/messages/fast-refresh-reload` |
|
|
) |
|
|
} |
|
|
break |
|
|
case 'client-added-page': |
|
|
// TODO |
|
|
break |
|
|
case 'browser-logs': { |
|
|
if (nextConfig.experimental.browserDebugInfoInTerminal) { |
|
|
await receiveBrowserLogsTurbopack({ |
|
|
entries: parsedData.entries, |
|
|
router: parsedData.router, |
|
|
sourceType: parsedData.sourceType, |
|
|
project, |
|
|
projectPath, |
|
|
distDir, |
|
|
config: nextConfig.experimental.browserDebugInfoInTerminal, |
|
|
}) |
|
|
} |
|
|
break |
|
|
} |
|
|
|
|
|
default: |
|
|
// Might be a Turbopack message... |
|
|
if (!parsedData.type) { |
|
|
throw new Error(`unrecognized HMR message "${data}"`) |
|
|
} |
|
|
} |
|
|
|
|
|
// Turbopack messages |
|
|
switch (parsedData.type) { |
|
|
case 'turbopack-subscribe': |
|
|
subscribeToHmrEvents(client, parsedData.path) |
|
|
break |
|
|
|
|
|
case 'turbopack-unsubscribe': |
|
|
unsubscribeFromHmrEvents(client, parsedData.path) |
|
|
break |
|
|
|
|
|
default: |
|
|
if (!parsedData.event) { |
|
|
throw new Error(`unrecognized Turbopack HMR message "${data}"`) |
|
|
} |
|
|
} |
|
|
}) |
|
|
|
|
|
const turbopackConnected: TurbopackConnectedAction = { |
|
|
action: HMR_ACTIONS_SENT_TO_BROWSER.TURBOPACK_CONNECTED, |
|
|
data: { sessionId }, |
|
|
} |
|
|
sendToClient(client, turbopackConnected) |
|
|
|
|
|
const errors: CompilationError[] = [] |
|
|
|
|
|
for (const entryIssues of currentEntryIssues.values()) { |
|
|
for (const issue of entryIssues.values()) { |
|
|
if (issue.severity !== 'warning') { |
|
|
errors.push({ |
|
|
message: formatIssue(issue), |
|
|
}) |
|
|
} else { |
|
|
printNonFatalIssue(issue) |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
if (devIndicatorServerState.disabledUntil < Date.now()) { |
|
|
devIndicatorServerState.disabledUntil = 0 |
|
|
} |
|
|
|
|
|
;(async function () { |
|
|
const versionInfo = await versionInfoPromise |
|
|
const devToolsConfig = await getDevToolsConfig(distDir) |
|
|
|
|
|
const sync: SyncAction = { |
|
|
action: HMR_ACTIONS_SENT_TO_BROWSER.SYNC, |
|
|
errors, |
|
|
warnings: [], |
|
|
hash: '', |
|
|
versionInfo, |
|
|
debug: { |
|
|
devtoolsFrontendUrl, |
|
|
}, |
|
|
devIndicator: devIndicatorServerState, |
|
|
devToolsConfig, |
|
|
} |
|
|
|
|
|
sendToClient(client, sync) |
|
|
})() |
|
|
}) |
|
|
}, |
|
|
|
|
|
send(action) { |
|
|
const payload = JSON.stringify(action) |
|
|
for (const client of clients) { |
|
|
client.send(payload) |
|
|
} |
|
|
}, |
|
|
|
|
|
setHmrServerError(_error) { |
|
|
// Not implemented yet. |
|
|
}, |
|
|
clearHmrServerError() { |
|
|
// Not implemented yet. |
|
|
}, |
|
|
async start() {}, |
|
|
async getCompilationErrors(page) { |
|
|
const appEntryKey = getEntryKey('app', 'server', page) |
|
|
const pagesEntryKey = getEntryKey('pages', 'server', page) |
|
|
|
|
|
const topLevelIssues = currentTopLevelIssues.values() |
|
|
|
|
|
const thisEntryIssues = |
|
|
currentEntryIssues.get(appEntryKey) ?? |
|
|
currentEntryIssues.get(pagesEntryKey) |
|
|
|
|
|
if (thisEntryIssues !== undefined && thisEntryIssues.size > 0) { |
|
|
// If there is an error related to the requesting page we display it instead of the first error |
|
|
return [...topLevelIssues, ...thisEntryIssues.values()] |
|
|
.map((issue) => { |
|
|
const formattedIssue = formatIssue(issue) |
|
|
if (issue.severity === 'warning') { |
|
|
printNonFatalIssue(issue) |
|
|
return null |
|
|
} else if (isWellKnownError(issue)) { |
|
|
Log.error(formattedIssue) |
|
|
} |
|
|
|
|
|
return new Error(formattedIssue) |
|
|
}) |
|
|
.filter((error) => error !== null) |
|
|
} |
|
|
|
|
|
// Otherwise, return all errors across pages |
|
|
const errors = [] |
|
|
for (const issue of topLevelIssues) { |
|
|
if (issue.severity !== 'warning') { |
|
|
errors.push(new Error(formatIssue(issue))) |
|
|
} |
|
|
} |
|
|
for (const entryIssues of currentEntryIssues.values()) { |
|
|
for (const issue of entryIssues.values()) { |
|
|
if (issue.severity !== 'warning') { |
|
|
const message = formatIssue(issue) |
|
|
errors.push(new Error(message)) |
|
|
} else { |
|
|
printNonFatalIssue(issue) |
|
|
} |
|
|
} |
|
|
} |
|
|
return errors |
|
|
}, |
|
|
async invalidate({ |
|
|
// .env files or tsconfig/jsconfig change |
|
|
reloadAfterInvalidation, |
|
|
}) { |
|
|
if (reloadAfterInvalidation) { |
|
|
for (const [key, entrypoint] of currentWrittenEntrypoints) { |
|
|
clearRequireCache(key, entrypoint, { force: true }) |
|
|
} |
|
|
|
|
|
await clearAllModuleContexts() |
|
|
this.send({ |
|
|
action: HMR_ACTIONS_SENT_TO_BROWSER.SERVER_COMPONENT_CHANGES, |
|
|
hash: String(++hmrHash), |
|
|
}) |
|
|
} |
|
|
}, |
|
|
async buildFallbackError() { |
|
|
// Not implemented yet. |
|
|
}, |
|
|
async ensurePage({ |
|
|
page: inputPage, |
|
|
// Unused parameters |
|
|
// clientOnly, |
|
|
appPaths, |
|
|
definition, |
|
|
isApp, |
|
|
url: requestUrl, |
|
|
}) { |
|
|
// When there is no route definition this is an internal file not a route the user added. |
|
|
// Middleware and instrumentation are handled in turbpack-utils.ts handleEntrypoints instead. |
|
|
if (!definition) { |
|
|
if (inputPage === '/middleware') return |
|
|
if (inputPage === '/src/middleware') return |
|
|
if (inputPage === '/instrumentation') return |
|
|
if (inputPage === '/src/instrumentation') return |
|
|
} |
|
|
|
|
|
return hotReloaderSpan |
|
|
.traceChild('ensure-page', { |
|
|
inputPage, |
|
|
}) |
|
|
.traceAsyncFn(async () => { |
|
|
if (BLOCKED_PAGES.includes(inputPage) && inputPage !== '/_error') { |
|
|
return |
|
|
} |
|
|
|
|
|
await currentEntriesHandling |
|
|
|
|
|
// TODO We shouldn't look into the filesystem again. This should use the information from entrypoints |
|
|
let routeDef: Pick< |
|
|
RouteDefinition, |
|
|
'filename' | 'bundlePath' | 'page' |
|
|
> = |
|
|
definition ?? |
|
|
(await findPagePathData( |
|
|
projectPath, |
|
|
inputPage, |
|
|
nextConfig.pageExtensions, |
|
|
opts.pagesDir, |
|
|
opts.appDir, |
|
|
!!nextConfig.experimental.globalNotFound |
|
|
)) |
|
|
|
|
|
// If the route is actually an app page route, then we should have access |
|
|
// to the app route definition, and therefore, the appPaths from it. |
|
|
if (!appPaths && definition && isAppPageRouteDefinition(definition)) { |
|
|
appPaths = definition.appPaths |
|
|
} |
|
|
|
|
|
let page = routeDef.page |
|
|
if (appPaths) { |
|
|
const normalizedPage = normalizeAppPath(page) |
|
|
|
|
|
// filter out paths that are not exact matches (e.g. catchall) |
|
|
const matchingAppPaths = appPaths.filter( |
|
|
(path) => normalizeAppPath(path) === normalizedPage |
|
|
) |
|
|
|
|
|
// the last item in the array is the root page, if there are parallel routes |
|
|
page = matchingAppPaths[matchingAppPaths.length - 1] |
|
|
} |
|
|
|
|
|
const pathname = definition?.pathname ?? inputPage |
|
|
|
|
|
if (page === '/_error') { |
|
|
let finishBuilding = startBuilding(pathname, requestUrl, false) |
|
|
try { |
|
|
await handlePagesErrorRoute({ |
|
|
currentEntryIssues, |
|
|
entrypoints: currentEntrypoints, |
|
|
manifestLoader, |
|
|
devRewrites: opts.fsChecker.rewrites, |
|
|
productionRewrites: undefined, |
|
|
logErrors: true, |
|
|
hooks: { |
|
|
subscribeToChanges, |
|
|
handleWrittenEndpoint: (id, result, forceDeleteCache) => { |
|
|
currentWrittenEntrypoints.set(id, result) |
|
|
assetMapper.setPathsForKey(id, result.clientPaths) |
|
|
return clearRequireCache(id, result, { |
|
|
force: forceDeleteCache, |
|
|
}) |
|
|
}, |
|
|
}, |
|
|
}) |
|
|
} finally { |
|
|
finishBuilding() |
|
|
} |
|
|
return |
|
|
} |
|
|
|
|
|
const isInsideAppDir = routeDef.bundlePath.startsWith('app/') |
|
|
const isEntryMetadataRouteFile = isMetadataRouteFile( |
|
|
routeDef.filename.replace(opts.appDir || '', ''), |
|
|
nextConfig.pageExtensions, |
|
|
true |
|
|
) |
|
|
const normalizedAppPage = isEntryMetadataRouteFile |
|
|
? normalizedPageToTurbopackStructureRoute( |
|
|
page, |
|
|
extname(routeDef.filename) |
|
|
) |
|
|
: page |
|
|
|
|
|
const route = isInsideAppDir |
|
|
? currentEntrypoints.app.get(normalizedAppPage) |
|
|
: currentEntrypoints.page.get(page) |
|
|
|
|
|
if (!route) { |
|
|
// TODO: why is this entry missing in turbopack? |
|
|
if (page === '/middleware') return |
|
|
if (page === '/src/middleware') return |
|
|
if (page === '/instrumentation') return |
|
|
if (page === '/src/instrumentation') return |
|
|
|
|
|
throw new PageNotFoundError(`route not found ${page}`) |
|
|
} |
|
|
|
|
|
// We don't throw on ensureOpts.isApp === true for page-api |
|
|
// since this can happen when app pages make |
|
|
// api requests to page API routes. |
|
|
if (isApp && route.type === 'page') { |
|
|
throw new Error(`mis-matched route type: isApp && page for ${page}`) |
|
|
} |
|
|
|
|
|
const finishBuilding = startBuilding(pathname, requestUrl, false) |
|
|
try { |
|
|
await handleRouteType({ |
|
|
dev, |
|
|
page, |
|
|
pathname, |
|
|
route, |
|
|
currentEntryIssues, |
|
|
entrypoints: currentEntrypoints, |
|
|
manifestLoader, |
|
|
readyIds, |
|
|
devRewrites: opts.fsChecker.rewrites, |
|
|
productionRewrites: undefined, |
|
|
logErrors: true, |
|
|
|
|
|
hooks: { |
|
|
subscribeToChanges, |
|
|
handleWrittenEndpoint: (id, result, forceDeleteCache) => { |
|
|
currentWrittenEntrypoints.set(id, result) |
|
|
assetMapper.setPathsForKey(id, result.clientPaths) |
|
|
return clearRequireCache(id, result, { |
|
|
force: forceDeleteCache, |
|
|
}) |
|
|
}, |
|
|
}, |
|
|
}) |
|
|
} finally { |
|
|
finishBuilding() |
|
|
} |
|
|
}) |
|
|
}, |
|
|
close() { |
|
|
for (const wsClient of clients) { |
|
|
// it's okay to not cleanly close these websocket connections, this is dev |
|
|
wsClient.terminate() |
|
|
} |
|
|
clients.clear() |
|
|
}, |
|
|
} |
|
|
|
|
|
handleEntrypointsSubscription().catch((err) => { |
|
|
console.error(err) |
|
|
process.exit(1) |
|
|
}) |
|
|
|
|
|
// Write empty manifests |
|
|
await currentEntriesHandling |
|
|
await manifestLoader.writeManifests({ |
|
|
devRewrites: opts.fsChecker.rewrites, |
|
|
productionRewrites: undefined, |
|
|
entrypoints: currentEntrypoints, |
|
|
}) |
|
|
|
|
|
async function handleProjectUpdates() { |
|
|
for await (const updateMessage of project.updateInfoSubscribe(30)) { |
|
|
switch (updateMessage.updateType) { |
|
|
case 'start': { |
|
|
hotReloader.send({ action: HMR_ACTIONS_SENT_TO_BROWSER.BUILDING }) |
|
|
break |
|
|
} |
|
|
case 'end': { |
|
|
sendEnqueuedMessages() |
|
|
|
|
|
function addErrors( |
|
|
errorsMap: Map<string, CompilationError>, |
|
|
issues: EntryIssuesMap |
|
|
) { |
|
|
for (const issueMap of issues.values()) { |
|
|
for (const [key, issue] of issueMap) { |
|
|
if (issue.severity === 'warning') continue |
|
|
if (errorsMap.has(key)) continue |
|
|
|
|
|
const message = formatIssue(issue) |
|
|
|
|
|
errorsMap.set(key, { |
|
|
message, |
|
|
details: issue.detail |
|
|
? renderStyledStringToErrorAnsi(issue.detail) |
|
|
: undefined, |
|
|
}) |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
const errors = new Map<string, CompilationError>() |
|
|
addErrors(errors, currentEntryIssues) |
|
|
|
|
|
for (const client of clients) { |
|
|
const state = clientStates.get(client) |
|
|
if (!state) { |
|
|
continue |
|
|
} |
|
|
|
|
|
const clientErrors = new Map(errors) |
|
|
addErrors(clientErrors, state.clientIssues) |
|
|
|
|
|
sendToClient(client, { |
|
|
action: HMR_ACTIONS_SENT_TO_BROWSER.BUILT, |
|
|
hash: String(++hmrHash), |
|
|
errors: [...clientErrors.values()], |
|
|
warnings: [], |
|
|
}) |
|
|
} |
|
|
|
|
|
if (hmrEventHappened) { |
|
|
const time = updateMessage.value.duration |
|
|
const timeMessage = |
|
|
time > 2000 ? `${Math.round(time / 100) / 10}s` : `${time}ms` |
|
|
Log.event(`Compiled in ${timeMessage}`) |
|
|
hmrEventHappened = false |
|
|
} |
|
|
break |
|
|
} |
|
|
default: |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
handleProjectUpdates().catch((err) => { |
|
|
console.error(err) |
|
|
process.exit(1) |
|
|
}) |
|
|
|
|
|
return hotReloader |
|
|
} |
|
|
|
