@nifrajs/cli 4.0.2 → 5.1.0

package/src/verification-plan.ts

@@ -37,6 +37,11 @@ const GATES = Object.freeze([
     "Run `bun run typecheck` and fix the reported TypeScript errors.",
   ),
   gate("tests", [["run", "test"]], "Run `bun run test` and fix the first failing test."),
+  gate(
+    "rest-tests",
+    [["run", "test:rest"]],
+    "Run `bun run test:rest` and fix the first failing test.",
+  ),
   gate(
     "docs",
     [["run", "check:docs"]],
@@ -178,12 +183,32 @@ const GATES = Object.freeze([
     [["run", "check:verification-parity"]],
     "Run `bun run check:verification-parity` and reconcile the release plan with CI.",
   ),
+  gate(
+    "server-components-contracts",
+    [["run", "check:server-components:contracts"]],
+    "Run `bun run check:server-components:contracts` and fix the component admission, transport or lifecycle regression.",
+  ),
+  gate(
+    "server-components",
+    [
+      ["run", "check:server-components"],
+      ["run", "check:server-components:consumers"],
+    ],
+    "Run the server-components matrix and packaged-consumer commands; every adapter and required row must pass.",
+  ),
+  gate(
+    "server-components-performance",
+    [["run", "check:server-components:performance"]],
+    "Run the five-run component performance comparison and investigate the measured regression.",
+    { workflowRequired: false },
+  ),
 ])
 
 const DEFAULT_PLAN = Object.freeze([
   "lint",
   "typecheck",
   "tests",
+  "server-components-contracts",
   "docs",
   "api-corpus",
   "cards-corpus",
@@ -196,14 +221,17 @@ const DEFAULT_PLAN = Object.freeze([
   "changesets",
 ] as const)
 
+// `coverage` fails on any failing test, so it is the release plan's run of the library suites;
+// `rest-tests` runs the suites it leaves out, and `tests` would only repeat the two.
 const RELEASE_PLAN = Object.freeze([
   "build",
   "lint",
   "typecheck",
-  "tests",
-  "cli-isolation",
   "coverage",
+  "rest-tests",
+  "cli-isolation",
   "corpus",
+  "sitemap",
   "docs",
   "public-boundary",
   "public-manifest",
@@ -222,6 +250,9 @@ const RELEASE_PLAN = Object.freeze([
   "pipeline-parity",
   "leak-matrix",
   "verification-parity",
+  "server-components",
+  "server-components-performance",
+  "server-components-contracts",
   "changesets",
 ] as const)
 

package/src/version-drift.ts

@@ -0,0 +1,118 @@
+import { readFileSync } from "node:fs"
+import { join, sep } from "node:path"
+import {
+  compareSemverSpec,
+  groupDeclaredNames,
+  groupPinVersions,
+  installedGroupPackages,
+  isFixedGroup,
+  type LinkedGroupInstall,
+} from "./upgrade.ts"
+
+/** The fixed-group packages the package installed at `dir` depends on. */
+function groupDependenciesAt(dir: string): string[] {
+  try {
+    const manifest: unknown = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"))
+    if (typeof manifest !== "object" || manifest === null) return []
+    return ["dependencies", "peerDependencies", "optionalDependencies"].flatMap((field) => {
+      const deps: unknown = Reflect.get(manifest, field)
+      return typeof deps === "object" && deps !== null ? Object.keys(deps).filter(isFixedGroup) : []
+    })
+  } catch {
+    return []
+  }
+}
+
+/** One version of the fixed release group, and where the workspace carries it. */
+export interface GroupVersion {
+  readonly version: string
+  readonly sources: readonly string[]
+}
+
+/**
+ * More than one version of the fixed release group (`@nifrajs/*`, `nifra`, `create-nifra`) in one
+ * workspace. Read only: package.json pins, installed packages (followed to their real location, so a
+ * linked repo reports its own version) and the running CLI. Nothing is spawned.
+ */
+export interface VersionDrift {
+  /** Oldest first. */
+  readonly versions: readonly GroupVersion[]
+  readonly highest: string
+  /** `nifra upgrade` edits the workspace only; these are listed, never edited. */
+  readonly linkedOutside: readonly LinkedGroupInstall[]
+}
+
+export function collectVersionDrift(cwd: string, cliVersion?: string): VersionDrift | undefined {
+  const sources = new Map<string, string[]>()
+  const add = (version: string, source: string): void => {
+    const list = sources.get(version) ?? []
+    list.push(source)
+    sources.set(version, list)
+  }
+  for (const [version, files] of groupPinVersions(cwd)) {
+    for (const file of files) add(version, `pinned in ${file}`)
+  }
+  const linkedOutside: LinkedGroupInstall[] = []
+  const installs = installedGroupPackages(cwd)
+  // An install nothing declares, such as one an older install left behind, loads nowhere, and no
+  // upgrade re-pins it: counting it would report drift that never clears.
+  const declared = new Set(groupDeclaredNames(cwd))
+  for (const { path } of installs) for (const name of groupDependenciesAt(path)) declared.add(name)
+  for (const { package: name, path, version, inside } of installs) {
+    if (!declared.has(name)) continue
+    add(version, `installed ${name}${inside ? "" : ` (linked from ${path})`}`)
+    if (!inside) linkedOutside.push({ package: name, path, version })
+  }
+  if (cliVersion !== undefined) add(cliVersion, "the running nifra CLI")
+  if (sources.size < 2) return undefined
+  const versions = [...sources]
+    .sort(([a], [b]) => compareSemverSpec(a, b))
+    .map(([version, list]) => ({ version, sources: list }))
+  return {
+    versions,
+    highest: versions[versions.length - 1]!.version,
+    linkedOutside,
+  }
+}
+
+/** The install a package belongs to: the folder above its last `node_modules`, or the package itself. */
+const installRoot = (path: string): string => {
+  const parts = path.split(sep)
+  const last = parts.lastIndexOf("node_modules")
+  return last <= 0 ? path : parts.slice(0, last).join(sep)
+}
+
+/** Linked installs, one phrase per install and version: a linked repository brings its whole group. */
+function linkedGroups(installs: readonly LinkedGroupInstall[]): string[] {
+  const groups = new Map<string, LinkedGroupInstall[]>()
+  for (const install of installs) {
+    const key = `${installRoot(install.path)}\0${install.version}`
+    groups.set(key, [...(groups.get(key) ?? []), install])
+  }
+  return [...groups.values()].map((group) => {
+    const [first] = group
+    if (first === undefined) return ""
+    if (group.length === 1) return `${first.package} ${first.version} at ${first.path}`
+    const names = group.map((install) => install.package).sort()
+    const listed =
+      names.length > 3
+        ? `${names.slice(0, 3).join(", ")} and ${names.length - 3} more`
+        : names.join(", ")
+    return `${group.length} packages at ${first.version} under ${installRoot(first.path)} (${listed})`
+  })
+}
+
+/** The advisory both `nifra doctor` and `nifra check` print. */
+export function versionDriftMessage(drift: VersionDrift): string {
+  const listed = drift.versions
+    .map(
+      ({ version, sources }) =>
+        `${version} (${sources.slice(0, 3).join("; ")}${sources.length > 3 ? `; and ${sources.length - 3} more` : ""})`,
+    )
+    .join(", ")
+  const linked =
+    drift.linkedOutside.length === 0
+      ? ""
+      : ` It does not edit ${linkedGroups(drift.linkedOutside).join(", ")}, linked from outside the workspace root; upgrade that repository on its own.`
+  return `mixed nifra versions in this workspace: ${listed}. Run \`nifra upgrade ${drift.highest}\` (it runs each release's migration steps, then re-pins).${linked}`
+}

package/src/web-app-options.ts

@@ -11,7 +11,7 @@ import { FRAMEWORK_WEB_OPTIONS, type FrameworkWebOption, type NifraFramework } f
 
 type FrameworkWebAppOptions = Pick<
   CreateWebAppOptions,
-  "use" | "api" | "apiPrefix" | "apiStrip" | "mounts" | "csp" | "nonce"
+  "use" | "api" | "apiPrefix" | "apiStrip" | "mounts" | "csp" | "nonce" | "serverComponents"
 >
 
 /** `use`, the backend as `api`, and every forwarded framework field the config sets. */
@@ -39,7 +39,7 @@ export function frameworkMountPaths(fw: NifraFramework, hasBackend: boolean): st
   for (const mount of fw.mounts ?? []) {
     if (typeof mount?.path === "string") paths.push(mount.path)
   }
-  const apiPrefix = fw.apiPrefix ?? "/api"
+  const apiPrefix = fw.apiPrefix ?? ""
   if (hasBackend && apiPrefix !== "") paths.push(apiPrefix)
   return paths
 }

package/src/work-graph.ts

@@ -251,16 +251,15 @@ export async function buildWorkGraph(input: WorkGraphBuildInput): Promise<WorkGr
   const files = input.files ?? []
   const nodes = new Map<string, WorkGraphNode>()
   const edges: WorkGraphEdge[] = []
+  const edgeKeys = new Set<string>()
   const addNode = (node: WorkGraphNode): void => {
     if (!nodes.has(node.id)) nodes.set(node.id, node)
   }
   const addEdge = (edge: WorkGraphEdge): void => {
-    if (
-      !edges.some(
-        (item) => item.from === edge.from && item.to === edge.to && item.relation === edge.relation,
-      )
-    )
-      edges.push(edge)
+    const key = `${edge.from}\n${edge.to}\n${edge.relation}`
+    if (edgeKeys.has(key)) return
+    edgeKeys.add(key)
+    edges.push(edge)
   }
   for (const file of files) {
     const kind =
@@ -381,14 +380,20 @@ export function queryImpact(graph: WorkGraph, changedFiles: readonly string[]):
   // Any backend or shared module can reach every handler through backend/app.ts.
   if (unmodeled.length > 0 || normalized.some((file) => BACKEND_SOURCE_DIR.test(file)))
     for (const node of graph.nodes) if (node.kind === "route") seeds.add(node.id)
+  const targets = new Map<string, string[]>()
+  for (const edge of graph.edges) {
+    const from = targets.get(edge.from)
+    if (from === undefined) targets.set(edge.from, [edge.to])
+    else from.push(edge.to)
+  }
   const impacted = new Set(seeds)
   const queue = [...seeds]
-  while (queue.length > 0) {
-    const current = queue.shift()!
-    for (const edge of graph.edges) {
-      if (edge.from !== current || impacted.has(edge.to)) continue
-      impacted.add(edge.to)
-      queue.push(edge.to)
+  // Iterating an array visits what is pushed onto it meanwhile, so this is the breadth-first walk.
+  for (const current of queue) {
+    for (const to of targets.get(current) ?? []) {
+      if (impacted.has(to)) continue
+      impacted.add(to)
+      queue.push(to)
     }
   }
   const impactedRoutes = graph.nodes