@wular/pnext 0.0.1

package/src/compat/adapter/build-complete.ts

@@ -0,0 +1,257 @@
+import { existsSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileHref } from '../../config';
+import type { ResolvedConfig } from '../../config';
+import type { BuildManifest, RouteManifestEntry } from '../../types';
+import { getNextConfig } from '../next/config-loader';
+
+/**
+ * `adapterPath` support (Next's `onBuildComplete` hook).
+ *
+ * A deployment adapter is a module with `{ name, onBuildComplete(ctx) }`. Next
+ * calls it at the very end of `next build` with the build's routing table and a
+ * classified list of OUTPUTS; adapters turn those into their own deployment
+ * artifacts. pnext reports the same classification off its build manifest.
+ */
+interface SharedRouteFields {
+  id: string;
+  filePath: string;
+  pathname: string;
+  sourcePage: string;
+  runtime: 'nodejs' | 'edge';
+  assets: Record<string, string>;
+  assetsHashes: Record<string, string>;
+  config: { maxDuration?: number };
+  type: string;
+}
+
+interface AdapterOutputs {
+  pages: SharedRouteFields[];
+  appPages: SharedRouteFields[];
+  pagesApi: SharedRouteFields[];
+  appRoutes: SharedRouteFields[];
+  prerenders: { id: string; pathname: string; type: string; parentOutputId: string }[];
+  staticFiles: { id: string; filePath: string; pathname: string; type: string }[];
+}
+
+/** One entry of `routing.*` — Next's routes-manifest rewrite shape. */
+interface AdapterRoute {
+  source?: string;
+  sourceRegex: string;
+  destination?: string;
+}
+
+/** Adapter module shape — only the hook pnext can honour is typed. */
+interface NextAdapter {
+  name?: string;
+  onBuildComplete?: (ctx: unknown) => unknown;
+}
+
+/** The URL pathname a built `public/` file is served at. */
+function staticPathname(relative: string): string {
+  const url = `/${relative.replace(/\\/g, '/')}`;
+  if (url.endsWith('/index.html')) return url.slice(0, -'index.html'.length) || '/';
+  return url.endsWith('.html') ? url.slice(0, -'.html'.length) : url;
+}
+
+/** Where the per-route server entry for `route` is written. */
+function serverEntryPath(config: ResolvedConfig, route: RouteManifestEntry): string {
+  return path.join(config.outPath, 'server', `${route.id}.js`);
+}
+
+/**
+ * Write one server entry per route. An adapter keys its deployment artifacts by output `filePath`, so
+ * every output has to name a file that exists. pnext serves every route from a single server process -
+ * there is no per-route bundle to point at - so the entry is a descriptor module naming the route and
+ * the source module the server renders for it. Only written when an adapter is configured.
+ */
+async function writeServerEntries(
+  config: ResolvedConfig,
+  manifest: BuildManifest,
+): Promise<void> {
+  await mkdir(path.join(config.outPath, 'server'), { recursive: true });
+  await Promise.all(
+    manifest.routes.map((route) =>
+      writeFile(
+        serverEntryPath(config, route),
+        [
+          '// Generated by `pnext build` for the configured deployment adapter.',
+          '// pnext serves every route from one server process (`pnext start`);',
+          '// this entry identifies the route rather than bundling it standalone.',
+          `export const id = ${JSON.stringify(route.id)};`,
+          `export const pathname = ${JSON.stringify(route.route)};`,
+          `export const sourcePage = ${JSON.stringify(sourcePage(config, route))};`,
+          `export const kind = ${JSON.stringify(route.kind)};`,
+          "export const runtime = 'nodejs';",
+          'export default { id, pathname, sourcePage, kind, runtime };',
+          '',
+        ].join('\n'),
+      ),
+    ),
+  );
+}
+
+function sourcePage(config: ResolvedConfig, route: RouteManifestEntry): string {
+  return `/${path.relative(config.root, route.file).replace(/\\/g, '/')}`;
+}
+
+function sharedFields(
+  config: ResolvedConfig,
+  route: RouteManifestEntry,
+): Omit<SharedRouteFields, 'type'> {
+  return {
+    id: route.id,
+    filePath: serverEntryPath(config, route),
+    pathname: route.route,
+    sourcePage: sourcePage(config, route),
+    // pnext has one runtime: the server process. `edge` is never emitted.
+    runtime: 'nodejs',
+    assets: {},
+    assetsHashes: {},
+    config: {
+      ...(route.maxDuration !== undefined ? { maxDuration: route.maxDuration } : {}),
+    },
+  };
+}
+
+/**
+ * Classify the build into adapter outputs. A route that produced a file in `public/` was prerendered:
+ * a STATIC_FILE when it is frozen for the life of the deployment, a PRERENDER when it carries a
+ * revalidate (ISR seeds a cache entry the server refreshes). Everything else is a server entrypoint -
+ * `page` routes are APP_PAGE, `handler` routes (API routes and code-based metadata routes) are APP_ROUTE.
+ */
+function collectOutputs(config: ResolvedConfig, manifest: BuildManifest): AdapterOutputs {
+  const outputs: AdapterOutputs = {
+    pages: [],
+    appPages: [],
+    pagesApi: [],
+    appRoutes: [],
+    prerenders: [],
+    staticFiles: [],
+  };
+  const prerenderedRoutes = new Set<string>();
+
+  for (const [relative, metadata] of Object.entries(manifest.staticFiles ?? {})) {
+    const filePath = path.join(config.outPath, 'public', relative);
+    // The manifest also records prerenders that produced no body on disk
+    // (an empty response, `_not-found` / `_global-error`). Those are not
+    // deployable artifacts: leave them out, and leave the owning route as a
+    // server entrypoint rather than treating it as prerendered.
+    if (!existsSync(filePath)) continue;
+    if (metadata.routeId) prerenderedRoutes.add(metadata.routeId);
+    const entry = { id: relative, filePath, pathname: staticPathname(relative) };
+    if (metadata.revalidateSeconds !== undefined) {
+      outputs.prerenders.push({
+        ...entry,
+        type: 'PRERENDER',
+        parentOutputId: metadata.routeId ?? relative,
+      });
+    } else {
+      outputs.staticFiles.push({ ...entry, type: 'STATIC_FILE' });
+    }
+  }
+
+  for (const route of manifest.routes) {
+    if (prerenderedRoutes.has(route.id) && route.mode === 'static' && !route.ppr) continue;
+    const fields = sharedFields(config, route);
+    if (route.kind === 'handler') {
+      outputs.appRoutes.push({ ...fields, type: 'APP_ROUTE' });
+    } else {
+      outputs.appPages.push({ ...fields, type: 'APP_PAGE' });
+      // Every app page is reachable both as HTML and as its RSC payload; Next
+      // reports the pair as two outputs sharing one entrypoint.
+      outputs.appPages.push({
+        ...fields,
+        type: 'APP_PAGE',
+        id: `${route.id}.rsc`,
+        pathname: `${fields.pathname}.rsc`,
+      });
+    }
+  }
+
+  return outputs;
+}
+
+/**
+ * Name the capture groups of a route's match pattern after its params, giving
+ * the `namedRegex` form Next's routes-manifest uses (`$name` in destinations).
+ */
+function namedSourceRegex(route: RouteManifestEntry): string {
+  let index = 0;
+  const named = route.pattern.replace(/\((\[\^\/\]\+|\.\*)\)/g, (whole, body: string) => {
+    const param = route.params[index++];
+    return param ? `(?<${param.replace(/\W/g, '')}>${body})` : whole;
+  });
+  return `^${named}(?:/)?$`;
+}
+
+/**
+ * The dynamic (param-carrying) routes, in match order. App pages get a second entry ahead of the plain
+ * one matching their RSC suffixes - `/x.rsc` and the per-segment prefetch URLs - mirroring how Next
+ * emits them.
+ */
+function collectDynamicRoutes(manifest: BuildManifest): AdapterRoute[] {
+  const routes: AdapterRoute[] = [];
+  for (const route of manifest.routes) {
+    if (route.params.length === 0) continue;
+    const sourceRegex = namedSourceRegex(route);
+    if (route.kind === 'page') {
+      routes.push({
+        source: `${route.route}.rsc`,
+        sourceRegex: sourceRegex.replace(
+          /\(\?:\/\)\?\$$/,
+          String.raw`(?<rscSuffix>\.rsc|\.segments/.+\.segment\.rsc)(?:/)?$`,
+        ),
+        destination: `${route.route}$rscSuffix`,
+      });
+    }
+    routes.push({ source: route.route, sourceRegex, destination: route.route });
+  }
+  return routes;
+}
+
+/**
+ * Resolve the configured adapter and run its `onBuildComplete`.
+ *
+ * `NEXT_ADAPTER_PATH` wins over the config value (Next reads it the same way, so
+ * a deployment platform can inject its adapter into an unmodified app).
+ */
+export async function runBuildCompleteAdapter(
+  config: ResolvedConfig,
+  manifest: BuildManifest,
+): Promise<void> {
+  const configured = getNextConfig().adapterPath;
+  const adapterPath =
+    // eslint-disable-next-line turbo/no-undeclared-env-vars -- Next's own env override
+    process.env.NEXT_ADAPTER_PATH || (typeof configured === 'string' ? configured : undefined);
+  if (!adapterPath) return;
+  const resolved = path.isAbsolute(adapterPath)
+    ? adapterPath
+    : path.resolve(config.root, adapterPath);
+  const module = (await import(pathToFileHref(resolved))) as {
+    default?: NextAdapter;
+  } & NextAdapter;
+  const adapter = module.default ?? module;
+  if (typeof adapter?.onBuildComplete !== 'function') return;
+
+  await writeServerEntries(config, manifest);
+
+  await adapter.onBuildComplete({
+    routing: {
+      beforeMiddleware: [],
+      middlewareMatchers: [],
+      beforeFiles: [],
+      afterFiles: [],
+      dynamicRoutes: collectDynamicRoutes(manifest),
+      onMatch: [],
+      fallback: [],
+      shouldNormalizeNextData: false,
+      rsc: undefined,
+    },
+    outputs: collectOutputs(config, manifest),
+    projectDir: config.root,
+    repoRoot: config.root,
+    distDir: config.outPath,
+  });
+}

package/src/compat/bundler/bun-externals.ts

@@ -0,0 +1,53 @@
+import { uniqueIdentifier } from '../../utils/source';
+
+// A quoted `'bun'`/`'bun:x'` specifier anywhere in the source. Deliberately not
+// the module record's edges: a route handler looping
+// `require(name)` over a table of module names has NO static edge, and Next
+// still externalizes those. Matching the quoted specifier keeps that reach while
+// staying far tighter than the old bare-word `bun` regex.
+const QUOTED_BUN_SPECIFIER = /(['"])bun(?::[^'"]+)?\1/;
+
+/**
+ * Guard `bun`/`bun:*` builtins behind a runtime throw so a module importing one can still be compiled
+ * for a non-Bun target. The call-site rewrite is textual - the guard has to reach non-literal
+ * require/import calls too, which no record can name.
+ */
+export function rewriteBunBuiltinExternals(source: string, _file = 'module.tsx'): string {
+  if (!source.includes('bun')) return source;
+  if (!QUOTED_BUN_SPECIFIER.test(source)) return source;
+
+  const requireName = uniqueIdentifier(source, '__pnext_require_external');
+  const importName = uniqueIdentifier(source, '__pnext_import_external', requireName);
+  const literalRequires: string[] = [];
+  let next = source.replace(
+    /\brequire\s*\(\s*(['"])(bun(?::[^'"]+)?)\1\s*\)/g,
+    (_match, _quote: string, specifier: string) => {
+      literalRequires.push(specifier);
+      return `__pnext_bun_external_${literalRequires.length - 1}__`;
+    },
+  );
+  next = next.replace(/\brequire\s*\(/g, `${requireName}(`);
+  next = next.replace(/__pnext_bun_external_(\d+)__/g, (_match, index: string) => {
+    const specifier = literalRequires[Number(index)];
+    return `${requireName}(${JSON.stringify(specifier)}, () => require(${JSON.stringify(specifier)}))`;
+  });
+  next = next.replace(/\bimport\s*\(/g, `${importName}(`);
+
+  const directive = /^(?:\s*['"][^'"]+['"];?\s*)*/.exec(next)?.[0] ?? '';
+  const helpers = [
+    `const ${requireName} = (specifier, load) => {`,
+    `  if (specifier === 'bun' || specifier.startsWith('bun:')) {`,
+    "    throw new Error(`Cannot find module '${specifier}'`);",
+    '  }',
+    '  return load ? load() : require(specifier);',
+    '};',
+    `const ${importName} = (specifier) => {`,
+    `  if (specifier === 'bun' || specifier.startsWith('bun:')) {`,
+    "    return Promise.reject(new Error(`Cannot find module '${specifier}'`));",
+    '  }',
+    '  return import(specifier);',
+    '};',
+    '',
+  ].join('\n');
+  return `${directive}${helpers}${next.slice(directive.length)}`;
+}