allow using the nodejs runtime for route handlers when using turbop…

…ack (#48791)

### What?
We previously ran all route handlers with the edge runtime, which means
you can't use built in node.js modules

With this PR, the runtime can be selected as documented in the next.js
docs

Fixes WEB-873

packages/next-swc/crates/next-core/js/src/entry/app/route-bootstrap.ts → packages/next-swc/crates/next-core/js/src/entry/app/edge-route-bootstrap.ts

@@ -1,10 +1,8 @@
-// PAGE and PATHNAME is set from rust code
-declare const PAGE: string, PATHNAME: string
-
 import { EdgeRouteModuleWrapper } from 'next/dist/server/web/edge-route-module-wrapper'
 
 import RouteModule from 'ROUTE_MODULE'
 import * as userland from 'ENTRY'
+import { PAGE, PATHNAME } from 'BOOTSTRAP_CONFIG'
 
 // TODO: (wyattjoh) - perform the option construction in Rust to allow other modules to accept different options
 const routeModule = new RouteModule({

packages/next-swc/crates/next-core/js/src/entry/app/edge-route.ts

@@ -0,0 +1,49 @@
+// IPC need to be the first import to allow it to catch errors happening during
+// the other imports
+import startHandler from '../../internal/api-server-handler'
+
+import 'next/dist/server/node-polyfill-fetch.js'
+
+import { join } from 'path'
+import { parse as parseUrl } from 'node:url'
+
+import {
+  NodeNextRequest,
+  NodeNextResponse,
+} from 'next/dist/server/base-http/node'
+
+import { runEdgeFunction } from '../../internal/edge'
+import { attachRequestMeta } from '../../internal/next-request-helpers'
+
+import chunkGroup from 'ROUTE_CHUNK_GROUP'
+
+startHandler(async ({ request, response, query, params, path }) => {
+  const req = new NodeNextRequest(request)
+  const res = new NodeNextResponse(response)
+
+  const parsedUrl = parseUrl(req.url!, true)
+  attachRequestMeta(req, parsedUrl, request.headers.host!)
+
+  const edgeInfo = {
+    name: 'edge',
+    paths: chunkGroup.map((chunk) =>
+      join(process.cwd(), '.next/server/app', chunk)
+    ),
+    wasm: [],
+    env: Object.keys(process.env),
+    assets: [],
+  }
+
+  await runEdgeFunction({
+    edgeInfo,
+    outputDir: 'app',
+    req,
+    res,
+    query,
+    params,
+    path,
+    onWarning(warning) {
+      console.warn(warning)
+    },
+  })
+})

packages/next-swc/crates/next-core/js/src/entry/app/route.ts

@@ -1,39 +1,50 @@
 // IPC need to be the first import to allow it to catch errors happening during
 // the other imports
 import startHandler from '../../internal/api-server-handler'
-import { runEdgeFunction } from '../../internal/edge'
 
-import { join } from 'path'
+import '../../polyfill/app-polyfills'
 
-import 'next/dist/server/node-polyfill-fetch.js'
-
-import chunkGroup from 'ROUTE_CHUNK_GROUP'
+import { parse as parseUrl } from 'node:url'
 
 import {
   NodeNextRequest,
   NodeNextResponse,
 } from 'next/dist/server/base-http/node'
+import { sendResponse } from 'next/dist/server/send-response'
+import { NextRequestAdapter } from 'next/dist/server/web/spec-extension/adapters/next-request'
+import { RouteHandlerManagerContext } from 'next/dist/server/future/route-handler-managers/route-handler-manager'
+
+import { attachRequestMeta } from '../../internal/next-request-helpers'
+
+import RouteModule from 'ROUTE_MODULE'
+import * as userland from 'ENTRY'
+import { PAGE, PATHNAME } from 'BOOTSTRAP_CONFIG'
+
+const routeModule = new RouteModule({
+  userland,
+  pathname: PATHNAME,
+  resolvedPagePath: `app/${PAGE}`,
+  nextConfigOutput: undefined,
+})
 
 startHandler(async ({ request, response, query, params, path }) => {
-  const edgeInfo = {
-    name: 'edge',
-    paths: chunkGroup.map((chunk) =>
-      join(process.cwd(), '.next/server/app', chunk)
-    ),
-    wasm: [],
-    env: Object.keys(process.env),
-    assets: [],
-  }
-  await runEdgeFunction({
-    edgeInfo,
-    outputDir: 'app',
-    req: new NodeNextRequest(request),
-    res: new NodeNextResponse(response),
-    query,
+  const req = new NodeNextRequest(request)
+  const res = new NodeNextResponse(response)
+
+  const parsedUrl = parseUrl(req.url!, true)
+  attachRequestMeta(req, parsedUrl, request.headers.host!)
+
+  const context: RouteHandlerManagerContext = {
     params,
-    path,
-    onWarning(warning) {
-      console.warn(warning)
+    staticGenerationContext: {
+      supportsDynamicHTML: true,
     },
-  })
+  }
+
+  const routeResponse = await routeModule.handle(
+    NextRequestAdapter.fromNodeNextRequest(req),
+    context
+  )
+
+  await sendResponse(req, res, routeResponse)
 })

packages/next-swc/crates/next-core/js/src/entry/edge-bootstrap.ts

@@ -1,7 +1,5 @@
-declare const NAME: string
-declare const PAGE: string
-
 import { adapter, enhanceGlobals } from 'next/dist/server/web/adapter'
+import { NAME, PAGE } from 'BOOTSTRAP_CONFIG'
 
 enhanceGlobals()
 

packages/next-swc/crates/next-core/js/src/entry/server-api.tsx

@@ -4,23 +4,31 @@ import startHandler from '../internal/api-server-handler'
 
 import 'next/dist/server/node-polyfill-fetch.js'
 
-import * as allExports from 'INNER'
+import { parse as parseQuery } from 'node:querystring'
+import { parse as parseUrl } from 'node:url'
+
 import { apiResolver } from 'next/dist/server/api-utils/node'
 import {
   NodeNextRequest,
   NodeNextResponse,
 } from 'next/dist/server/base-http/node'
-import { parse } from 'node:querystring'
+
+import { attachRequestMeta } from '../internal/next-request-helpers'
+
+import * as allExports from 'INNER'
 
 startHandler(({ request, response, query, params, path }) => {
-  const parsedQuery = parse(query)
+  const parsedQuery = parseQuery(query)
 
   const mergedQuery = { ...parsedQuery, ...params }
 
   // This enables `req.cookies` in API routes.
   const req = new NodeNextRequest(request)
   const res = new NodeNextResponse(response)
 
+  const parsedUrl = parseUrl(req.url!, true)
+  attachRequestMeta(req, parsedUrl, request.headers.host!)
+
   return apiResolver(
     req.originalRequest,
     res.originalResponse,

packages/next-swc/crates/next-core/js/src/entry/server-edge-api.tsx

@@ -1,20 +1,29 @@
 // IPC need to be the first import to allow it to catch errors happening during
 // the other imports
 import startHandler from '../internal/api-server-handler'
-import { runEdgeFunction } from '../internal/edge'
-
-import { join } from 'path'
 
 import 'next/dist/server/node-polyfill-fetch.js'
 
-import chunkGroup from 'INNER_EDGE_CHUNK_GROUP'
+import { join } from 'node:path'
+import { parse as parseUrl } from 'node:url'
 
 import {
   NodeNextRequest,
   NodeNextResponse,
 } from 'next/dist/server/base-http/node'
 
+import { attachRequestMeta } from '../internal/next-request-helpers'
+import { runEdgeFunction } from '../internal/edge'
+
+import chunkGroup from 'INNER_EDGE_CHUNK_GROUP'
+
 startHandler(async ({ request, response, query, params, path }) => {
+  const req = new NodeNextRequest(request)
+  const res = new NodeNextResponse(response)
+
+  const parsedUrl = parseUrl(req.url!, true)
+  attachRequestMeta(req, parsedUrl, request.headers.host!)
+
   const edgeInfo = {
     name: 'edge',
     paths: chunkGroup.map((chunk: string) =>
@@ -24,11 +33,12 @@ startHandler(async ({ request, response, query, params, path }) => {
     env: Object.keys(process.env),
     assets: [],
   }
+
   await runEdgeFunction({
     edgeInfo,
     outputDir: 'pages',
-    req: new NodeNextRequest(request),
-    res: new NodeNextResponse(response),
+    req,
+    res,
     query,
     params,
     path,

packages/next-swc/crates/next-core/js/src/internal/api-server-handler.ts

@@ -2,13 +2,15 @@
 // the other imports
 import { IPC } from '@vercel/turbopack-node/ipc/index'
 
-import type { RenderData } from 'types/turbopack'
-import type { Ipc } from '@vercel/turbopack-node/ipc/index'
 import type { ClientRequest, IncomingMessage, Server } from 'node:http'
 import type { ServerResponse } from 'node:http'
+import { Buffer } from 'node:buffer'
+
+import type { Ipc } from '@vercel/turbopack-node/ipc/index'
+
+import type { RenderData } from 'types/turbopack'
 import { createServer, makeRequest } from '../internal/server'
 import { toPairs } from '../internal/headers'
-import { Buffer } from 'node:buffer'
 
 const ipc = IPC as Ipc<IpcIncomingMessage, IpcOutgoingMessage>
 

packages/next-swc/crates/next-core/js/src/internal/next-request-helpers.ts

@@ -0,0 +1,27 @@
+import { TLSSocket } from 'tls'
+import {
+  addRequestMeta,
+  NextUrlWithParsedQuery,
+} from 'next/dist/server/request-meta'
+import { NodeNextRequest } from 'next/dist/server/base-http/node'
+import { BaseNextRequest } from 'next/dist/server/base-http'
+import { getCloneableBody } from 'next/dist/server/body-streams'
+
+export function attachRequestMeta(
+  req: BaseNextRequest,
+  parsedUrl: NextUrlWithParsedQuery,
+  host: string
+) {
+  const protocol = (
+    (req as NodeNextRequest).originalRequest?.socket as TLSSocket
+  )?.encrypted
+    ? 'https'
+    : 'http'
+
+  const initUrl = `${protocol}://${host}${req.url}`
+
+  addRequestMeta(req, '__NEXT_INIT_URL', initUrl)
+  addRequestMeta(req, '__NEXT_INIT_QUERY', { ...parsedUrl.query })
+  addRequestMeta(req, '_protocol', protocol)
+  addRequestMeta(req, '__NEXT_CLONABLE_BODY', getCloneableBody(req.body))
+}

packages/next-swc/crates/next-core/js/types/rust.d.ts

@@ -71,6 +71,12 @@ declare module 'ROUTE_MODULE' {
   }
 }
 
+declare module 'BOOTSTRAP_CONFIG' {
+  export const NAME: string
+  export const PAGE: string
+  export const PATHNAME: string
+}
+
 declare module 'CLIENT_MODULE' {
   export const __turbopack_module_id__: string
 }