@wular/pnext 0.1.5 → 0.1.7

package/src/routing/match.ts

@@ -0,0 +1,287 @@
+/**
+ * Request-time routing: matching a pathname against the built route table and finding an app
+ * directory's convention files. The route scan that builds the table lives in `./routes`.
+ */
+import path from 'node:path'
+import { readDirListing, toPosixPath } from '../utils/fs'
+import { safeDecode } from '../utils/decode'
+import { extraPageExtensions } from '../extensions'
+import type { NavState, RouteManifestEntry, RouteParamValue } from '../types'
+
+const BASE_PAGE_EXTENSIONS = ['tsx', 'ts', 'jsx', 'js', 'mjs'] as const
+
+/** Base + compat-registered page extensions, de-duplicated in order. */
+export function pageExtensions(): string[] {
+  return [...new Set([...BASE_PAGE_EXTENSIONS, ...extraPageExtensions()])]
+}
+
+const globalErrorBase = 'global-error'
+
+/** Nearest existing file named `<base>.<ext>` for the convention extensions. */
+export function conventionFileName(dir: string, base: string) {
+  const { files } = readDirListing(dir)
+  for (const extension of pageExtensions()) {
+    if (files.has(`${base}.${extension}`)) return path.join(dir, `${base}.${extension}`)
+  }
+  return undefined
+}
+
+export function findLayouts(appPath: string, routeFilePath: string) {
+  return findConventionFiles(appPath, routeFilePath, 'layout')
+}
+
+/**
+ * Walk from the route's directory up to `appPath`, returning one convention file per segment ordered
+ * root-to-leaf. `name` may be a bare base (`'layout'`) or carry an extension - a known extension is stripped
+ * so the full extension list is tried. Each segment resolves to the first existing `<base>.<ext>`; when none
+ * exists the `.tsx` candidate is returned so existing callers that filter by `existsSync` keep
+ * byte-identical behavior.
+ */
+export function findConventionFiles(appPath: string, routeFilePath: string, name: string) {
+  const base = conventionBase(name)
+  const files: string[] = []
+  let dir = path.dirname(routeFilePath)
+
+  while (dir.startsWith(appPath)) {
+    files.push(conventionFileName(dir, base) ?? path.join(dir, `${base}.tsx`))
+    if (dir === appPath) break
+    dir = path.dirname(dir)
+  }
+
+  return files.reverse()
+}
+
+function conventionBase(name: string) {
+  const match = new RegExp(`\\.(${pageExtensions().join('|')})$`).exec(name)
+  return match ? name.slice(0, -match[0].length) : name
+}
+
+/** App-root `global-error.*` file, if present (BuildManifest.globalErrorFile). */
+export function findGlobalError(appPath: string) {
+  return conventionFileName(appPath, globalErrorBase)
+}
+
+export function matchRoute(routes: RouteManifestEntry[], pathname: string) {
+  // Trailing-slash tolerance: '/route/' matches the same entry as '/route'
+  // (Next redirects these away; static file serving already accepts both).
+  const normalized = normalizePathname(pathname)
+  for (const route of routes) {
+    // Interception entries never match a plain (hard) request; they apply
+    // only through matchInterception on soft navigations.
+    if (route.interception) continue
+    const match = routeRegex(route).exec(normalized)
+    if (!match) continue
+    return { route, params: routeMatchParams(route, match) }
+  }
+  return null
+}
+
+export function normalizePathname(pathname: string) {
+  return pathname.length > 1 ? pathname.replace(/\/+$/, '') || '/' : pathname
+}
+
+function routeMatchParams(route: RouteManifestEntry, match: RegExpExecArray) {
+  const params: Record<string, RouteParamValue> = {}
+  route.params.forEach((name, index) => {
+    const decoded = safeDecode(match[index + 1] ?? '')
+    // A runtime request whose segment IS the dynamic placeholder for its own
+    // param (`[slug]`, whether sent raw or as `%5Bslug%5D`) is Next's "params
+    // placeholder": it must surface the ENCODED placeholder (`%5Bslug%5D`), not
+    // a decoded `[slug]`. A decoded `[slug]` reads as a fallback param and would
+    // trigger a fallback-shell render (failing without a parent Suspense
+    // boundary); Next keeps it URL-encoded to render at runtime instead.
+    // Fallback-shell generation injects its placeholder params through a
+    // separate build path, so this only affects live requests.
+    params[name] = decoded === `[${name}]` ? encodeURIComponent(decoded) : decoded
+  })
+  if (route.catchAll) {
+    params[route.catchAll] = (match[route.params.length + 1] ?? '')
+      .split('/')
+      .filter(Boolean)
+      .map(safeDecode)
+  }
+  return params
+}
+
+export interface InterceptionRouteMatch {
+  route: RouteManifestEntry
+  params: Record<string, RouteParamValue>
+}
+
+/**
+ * Match a soft navigation against interception entries: the entry's target
+ * pattern must match the destination and the navigation must originate at or
+ * below the interceptor's base (the children path the current document
+ * rendered from). The deepest base wins. A no-op when destination equals the
+ * origin (a refresh re-renders whatever produced the current document).
+ */
+export function matchInterception(
+  routes: RouteManifestEntry[],
+  pathname: string,
+  fromPath: string | undefined,
+): InterceptionRouteMatch | null {
+  if (!fromPath) return null
+  const target = normalizePathname(pathname)
+  const from = normalizePathname(fromPath)
+  if (target === from) return null
+  let best: InterceptionRouteMatch | null = null
+  let bestDepth = -1
+  for (const route of routes) {
+    const interception = route.interception
+    if (!interception) continue
+    const match = routeRegex(route).exec(target)
+    if (!match) continue
+    const basePattern = interception.basePattern ? `/${interception.basePattern}` : ''
+    if (!new RegExp(`^${basePattern}(?:/.*)?$`).test(from)) continue
+    const depth = interception.base.split('/').filter(Boolean).length
+    if (depth <= bestDepth) continue
+    bestDepth = depth
+    best = { route, params: routeMatchParams(route, match) }
+  }
+  return best
+}
+
+export interface RouteRenderSelection {
+  route: RouteManifestEntry
+  params: Record<string, RouteParamValue>
+  /** Pathname the children tree renders from (normalized). */
+  childrenPath: string
+  /** Internal pathname after rewrites, used to resolve interception slots. */
+  targetPath: string
+}
+
+/**
+ * Pick the entry a page request renders. Hard requests match plainly. Soft navigations first consult
+ * interception entries; a slot interception (and a synthetic slot URL reached with known origin) renders the
+ * ORIGIN's entry as host - the current page stays while the slot content changes - with the children tree
+ * anchored at `childrenPath`.
+ */
+export function selectRouteForRequest(
+  routes: RouteManifestEntry[],
+  pathname: string,
+  nav?: import('../types').NavState,
+): RouteRenderSelection | null {
+  const target = normalizePathname(pathname)
+  if (nav) {
+    const intercepted = matchInterception(routes, target, nav.children)
+    if (intercepted) {
+      if (!intercepted.route.interception?.slotDir) {
+        return {
+          route: intercepted.route,
+          params: intercepted.params,
+          childrenPath: target,
+          targetPath: target,
+        }
+      }
+      const host = hostMatch(routes, nav.children)
+      if (host) return { ...host, targetPath: target }
+    }
+  }
+  const matched = matchRoute(routes, target)
+  if (!matched) return null
+  if (nav && matched.route.synthetic && nav.children) {
+    const primary = matchRoute(
+      routes.filter(route => !route.synthetic),
+      target,
+    )
+    const syntheticOwner = matched.route.syntheticSlotDir
+      ? path.dirname(matched.route.syntheticSlotDir)
+      : undefined
+    const primaryFromOwner =
+      primary && syntheticOwner ? path.relative(syntheticOwner, primary.route.file) : undefined
+    if (
+      primary &&
+      primaryFromOwner !== undefined &&
+      primaryFromOwner !== '..' &&
+      !primaryFromOwner.startsWith(`..${path.sep}`)
+    ) {
+      return {
+        route: primary.route,
+        params: primary.params,
+        childrenPath: target,
+        targetPath: target,
+      }
+    }
+    const host = hostMatch(routes, nav.children)
+    if (
+      host &&
+      host.route !== matched.route &&
+      matched.route.syntheticSlotDir &&
+      host.route.slotDirs?.includes(matched.route.syntheticSlotDir)
+    ) {
+      return { ...host, targetPath: target }
+    }
+  }
+  return {
+    route: matched.route,
+    params: matched.params,
+    childrenPath: target,
+    targetPath: target,
+  }
+}
+
+/**
+ * Navigation headers from the client soft-nav runtime: `x-pnext-soft-nav`
+ * marks the fetch and `x-pnext-nav-state` carries the current document's
+ * parallel-route state (URI-encoded JSON).
+ */
+export function parseNavState(request: Request): NavState | undefined {
+  if (!request.headers.get('x-pnext-soft-nav')) return undefined
+  const raw = request.headers.get('x-pnext-nav-state')
+  if (!raw) return {}
+  try {
+    const parsed = JSON.parse(decodeURIComponent(raw)) as unknown
+    if (parsed && typeof parsed === 'object') return parsed
+  } catch {
+    // Malformed state degrades to a plain soft navigation.
+  }
+  return {}
+}
+
+function hostMatch(
+  routes: RouteManifestEntry[],
+  fromPath: string | undefined,
+): RouteRenderSelection | null {
+  if (!fromPath) return null
+  const from = normalizePathname(fromPath)
+  const host = matchRoute(routes, from)
+  if (host?.route.kind !== 'page') return null
+  return { route: host.route, params: host.params, childrenPath: from, targetPath: from }
+}
+
+const routeRegexCache = new WeakMap<RouteManifestEntry, RegExp>()
+
+function routeRegex(route: RouteManifestEntry) {
+  let regex = routeRegexCache.get(route)
+  if (!regex) {
+    regex = new RegExp(`^${route.pattern}$`)
+    routeRegexCache.set(route, regex)
+  }
+  return regex
+}
+
+export function serverActionsUnsupportedMessage(offender: {
+  file: string
+  route?: string
+  root?: string
+}) {
+  const file = offender.root
+    ? toPosixPath(path.relative(offender.root, offender.file))
+    : offender.file
+  const reach = offender.route ? `, reachable from the route ${offender.route}` : ''
+  return [
+    `Server actions need next compat, and this app is pure core.`,
+    ``,
+    `  ${file} has a 'use server' directive${reach}.`,
+    ``,
+    `pnext will not build this app: core has no server-action registry and no`,
+    `dispatch endpoint, so the action could only render as a form that submits`,
+    `nowhere.`,
+    ``,
+    `Fix it one of two ways:`,
+    `  1. Enable compat in pnext.config.ts:`,
+    `       export default { compat: { next: true } }`,
+    `  2. Or delete the 'use server' directive from ${file}, if those exports are`,
+    `     only ever called on the server (in core the directive does nothing).`,
+  ].join('\n')
+}

package/src/routing/metadata-files.ts

@@ -13,6 +13,7 @@ import type {
 } from '../types'
 import { escapeHtml, stringifyHtmlValue } from '../utils/html'
 import { toPosixPath } from '../utils/fs'
+import { servedAppFiles, servedRelease } from '../runtime/production'
 
 export type StaticMetadataKind =
   | 'favicon'
@@ -65,6 +66,8 @@ export function clearMetadataFileCaches() {
 }
 
 export function discoverStaticMetadataFiles(appPath: string): StaticMetadataFile[] {
+  const served = servedRelease()
+  if (served) return served.staticMetadataFiles ?? []
   const cached = staticMetadataFiles.get(appPath)
   if (cached) return cached
   const files = existsSync(appPath)
@@ -343,15 +346,26 @@ function metadataAppliesToRoute(file: StaticMetadataFile, routeDir: string) {
   return routeDir === dir || routeDir.startsWith(`${dir}/`)
 }
 
+// A release's tree is immutable: its inventory is derived once per release.
+const releasedDynamicMetadataFiles = new WeakMap<object, DynamicMetadataFile[]>()
+
 function discoverDynamicMetadataFiles(appPath: string): DynamicMetadataFile[] {
-  const cached = dynamicMetadataFiles.get(appPath)
+  const served = servedRelease()?.conventions
+  const cached = served
+    ? releasedDynamicMetadataFiles.get(served)
+    : dynamicMetadataFiles.get(appPath)
   if (cached) return cached
-  const files = existsSync(appPath)
-    ? listFilesSync(appPath)
+  const files = served
+    ? servedAppFiles(served)
         .flatMap(file => dynamicMetadataFile(appPath, file) ?? [])
         .sort((a, b) => a.relative.localeCompare(b.relative))
-    : []
-  dynamicMetadataFiles.set(appPath, files)
+    : existsSync(appPath)
+      ? listFilesSync(appPath)
+          .flatMap(file => dynamicMetadataFile(appPath, file) ?? [])
+          .sort((a, b) => a.relative.localeCompare(b.relative))
+      : []
+  if (served) releasedDynamicMetadataFiles.set(served, files)
+  else dynamicMetadataFiles.set(appPath, files)
   return files
 }
 

package/src/routing/proxy-config.ts

@@ -0,0 +1,137 @@
+/** The proxy's literal `config` read off its source: build and dev only, a release carries it. */
+import { readFileSync } from 'node:fs'
+import path from 'node:path'
+import type { ResolvedConfig } from '../config'
+import { loadNative } from '../utils/native-require'
+import { findProxyFile, type ProxyConfig } from './proxy'
+
+// Lazy: the oxc-parser native binding costs ~12.6 MB RSS; load it only when a parse happens.
+const parseSync: typeof import('oxc-parser').parseSync = (...args) =>
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  loadNative(() => require('oxc-parser') as typeof import('oxc-parser')).parseSync(...args)
+
+/** The proxy a production release serves: its source and, when wholly literal, its matcher config. */
+export function releasedProxy(config: ResolvedConfig) {
+  const file = findProxyFile(config)
+  if (!file) return undefined
+  try {
+    return { file, config: staticProxyConfig(file, readFileSync(file, 'utf8')) }
+  } catch {
+    return { file }
+  }
+}
+
+export function staticProxyConfig(file: string, source: string): ProxyConfig | undefined {
+  const result = parseSync(file, source, { lang: parserLang(file) })
+  // A recovered parse may have dropped the very declaration we are reading.
+  if (result.errors.length > 0) return undefined
+  for (const statement of result.program.body as StaticNode[]) {
+    if (statement.type !== 'ExportNamedDeclaration') continue
+    const declaration = statement.declaration
+    if (declaration?.type !== 'VariableDeclaration') continue
+    for (const declarator of declaration.declarations ?? []) {
+      if (declarator.id?.type !== 'Identifier' || declarator.id.name !== 'config') continue
+      const value = staticValue(declarator.init)
+      return isProxyConfigShape(value) ? (value as ProxyConfig) : undefined
+    }
+  }
+  return undefined
+}
+
+function parserLang(file: string) {
+  const ext = path.extname(file)
+  if (ext === '.tsx') return 'tsx'
+  if (ext === '.jsx') return 'jsx'
+  return ext === '.js' || ext === '.mjs' ? 'js' : 'ts'
+}
+
+/** Structural view of the oxc AST nodes this file reads — no full type import. */
+interface StaticNode {
+  type: string
+  name?: string
+  value?: unknown
+  computed?: boolean
+  shorthand?: boolean
+  key?: StaticNode
+  init?: StaticNode
+  id?: StaticNode
+  declaration?: StaticNode
+  declarations?: StaticNode[]
+  expression?: StaticNode
+  properties?: StaticNode[]
+  elements?: (StaticNode | null)[]
+  expressions?: StaticNode[]
+  quasis?: { value?: { cooked?: string } }[]
+}
+
+/** Literal-only evaluation; `undefined` marks "not statically known". */
+function staticValue(node: StaticNode | undefined | null): unknown {
+  if (!node) return undefined
+  switch (node.type) {
+    // `… as const` / `… satisfies ProxyConfig` wrap the literal, they never change it.
+    case 'TSAsExpression':
+    case 'TSSatisfiesExpression':
+    case 'TSNonNullExpression':
+      return staticValue(node.expression)
+    case 'Literal':
+    case 'StringLiteral':
+    case 'NumericLiteral':
+    case 'BooleanLiteral':
+      // A regex literal reports `value: null` here; it is not a matcher shape.
+      return node.value === null ? undefined : node.value
+    case 'TemplateLiteral':
+      return node.expressions?.length === 0
+        ? (node.quasis?.[0]?.value?.cooked ?? undefined)
+        : undefined
+    case 'ArrayExpression': {
+      const items: unknown[] = []
+      for (const element of node.elements ?? []) {
+        const value = staticValue(element)
+        if (value === undefined) return undefined
+        items.push(value)
+      }
+      return items
+    }
+    case 'ObjectExpression': {
+      const object: Record<string, unknown> = {}
+      for (const property of node.properties ?? []) {
+        if (property.type !== 'Property' && property.type !== 'ObjectProperty') return undefined
+        if (property.computed) return undefined
+        const key =
+          property.key?.type === 'Identifier' ? property.key.name : (property.key?.value as string)
+        if (typeof key !== 'string') return undefined
+        const value = staticValue(property.value as StaticNode | undefined)
+        if (value === undefined) return undefined
+        object[key] = value
+      }
+      return object
+    }
+    default:
+      return undefined
+  }
+}
+
+/** Only a config whose `matcher` is exactly the documented shape may gate. */
+function isProxyConfigShape(value: unknown): boolean {
+  if (typeof value !== 'object' || value === null) return false
+  const matcher = (value as { matcher?: unknown }).matcher
+  if (matcher === undefined) return true
+  const items = Array.isArray(matcher) ? matcher : [matcher]
+  return items.every(item => {
+    if (typeof item === 'string') return true
+    if (typeof item !== 'object' || item === null) return false
+    const { source, has, missing } = item as Record<string, unknown>
+    if (typeof source !== 'string') return false
+    return [has, missing].every(
+      list => list === undefined || (Array.isArray(list) && list.every(isConditionShape)),
+    )
+  })
+}
+
+function isConditionShape(value: unknown): boolean {
+  if (typeof value !== 'object' || value === null) return false
+  const { type, key, value: expected } = value as Record<string, unknown>
+  if (type !== 'header' && type !== 'query' && type !== 'cookie' && type !== 'host') return false
+  if (key !== undefined && typeof key !== 'string') return false
+  return expected === undefined || typeof expected === 'string'
+}