@nifrajs/cli 1.12.0 → 2.0.0

package/src/recipes/index.ts

@@ -5,6 +5,7 @@
  */
 
 import { recipe as v1_8_0 } from "./1.8.0.ts"
+import { recipe as v2_0_0 } from "./2.0.0.ts"
 
 /** A pin rule: every dependency whose name starts with `match` is set to version `to`. */
 export interface PinRule {
@@ -14,6 +15,13 @@ export interface PinRule {
   readonly to: string
 }
 
+/** Move a removed package dependency to its replacement, preserving the consumer's range style. */
+export interface DependencyMove {
+  readonly from: string
+  readonly to: string
+  readonly toVersion: string
+}
+
 /** An exact import-specifier rewrite (string-level, not AST): `from` → `to`. */
 export interface ImportMove {
   readonly from: string
@@ -23,6 +31,7 @@ export interface ImportMove {
 export interface UpgradeRecipe {
   readonly version: string
   readonly pins: readonly PinRule[]
+  readonly dependencyMoves?: readonly DependencyMove[]
   readonly importMoves: readonly ImportMove[]
   /** Human notes printed after the plan — e.g. structural changes the runner deliberately can't do. */
   readonly notes?: readonly string[]
@@ -30,6 +39,7 @@ export interface UpgradeRecipe {
 
 const RECIPES: Record<string, UpgradeRecipe> = {
   [v1_8_0.version]: v1_8_0,
+  [v2_0_0.version]: v2_0_0,
 }
 
 export function getRecipe(version: string): UpgradeRecipe | undefined {

package/src/sync-manifest.ts

@@ -0,0 +1,111 @@
+/**
+ * `nifra sync-manifest` - regenerate a committed web `server-manifest.ts` from the current `routes/` tree
+ * WITHOUT a full build. The manifest is a generated file that bakes the route table (+ client-asset hashes)
+ * for a disk-less edge worker; after adding/renaming/removing a route it drifts, and `nifra check` flags it.
+ * Regenerating it used to require the whole `build` (server + worker + migrate bundles). This re-scans
+ * `routes/` and rewrites just the manifest's route table, preserving the baked client-asset references.
+ *
+ * It does NOT rebuild the client bundle: a brand-new HYDRATING route still needs a full build so its client
+ * chunk exists. This clears route-table drift for the common case (a loader edit, an SSR-only route, a
+ * rename) in milliseconds, and prints that caveat for the case it can't cover.
+ */
+
+import { join } from "node:path"
+import { Glob } from "bun"
+
+// The marker `generateServerManifest` writes at the top of the file - so a user file merely named
+// `server-manifest.ts` is never mistaken for a generated one. Mirrors `nifra check`'s drift scan.
+const GENERATED_MARKER = "GENERATED by @nifrajs/web generateServerManifest"
+// The first route-import specifier's prefix up to `routes/` (`./`, `../`, `./src/`, …) - locates the
+// routes dir relative to the manifest and strips imports to route-relative keys.
+const ROUTES_PREFIX = /["'](\.{1,2}(?:\/[^"'/]+)*?\/routes\/)[^"']+["']/
+const IGNORED = /(^|\/)(node_modules|dist(-[a-z0-9]+)?|build|\.nifra|\.git|\.wrangler|coverage)\//
+
+export interface SyncManifestResult {
+  /** The committed server-manifest file (relative to cwd). */
+  readonly file: string
+  /** True when the file's route table changed and it was rewritten. */
+  readonly changed: boolean
+  /** Route files now imported that weren't before (added). */
+  readonly added: readonly string[]
+  /** Route files no longer imported (removed/renamed away). */
+  readonly removed: readonly string[]
+  /** Set when the sync was REFUSED because discovery found zero routes for a manifest that had some
+   * (`routes/` likely emptied by mistake) - the manifest was left untouched rather than wiped. */
+  readonly refusedEmpty?: boolean
+}
+
+/**
+ * Discover every generated `server-manifest.ts` under `cwd` and re-sync its route table from the live
+ * `routes/` tree, preserving baked client assets. Returns one result per generated manifest. Never throws
+ * on a per-manifest miss (an unreadable/absent routes dir is skipped).
+ */
+export async function syncServerManifests(cwd: string): Promise<SyncManifestResult[]> {
+  const { discoverRoutes } = await import("@nifrajs/web/fs")
+  const { parseManifestRouteFiles, diffManifestRoutes, resyncServerManifestSource } = await import(
+    "@nifrajs/web/build"
+  )
+  const results: SyncManifestResult[] = []
+  for await (const rel of new Glob("**/server-manifest.ts").scan({ cwd, dot: false })) {
+    if (IGNORED.test(rel)) continue
+    const abs = join(cwd, rel)
+    const source = await Bun.file(abs).text()
+    if (!source.includes(GENERATED_MARKER)) continue // not a generated manifest - skip
+    const routesPrefix = ROUTES_PREFIX.exec(source)?.[1]
+    if (routesPrefix === undefined) continue // no routes/ imports -> nothing to sync
+    const manifestDir = rel.includes("/") ? rel.slice(0, rel.lastIndexOf("/")) : ""
+    const routesDir = join(cwd, manifestDir, routesPrefix)
+    let next: string
+    try {
+      next = resyncServerManifestSource(source, discoverRoutes(routesDir), routesPrefix)
+    } catch {
+      continue // routes dir gone/unreadable - not a manifest we can sync
+    }
+    const before = parseManifestRouteFiles(source, routesPrefix)
+    const after = parseManifestRouteFiles(next, routesPrefix)
+    // Floor guard: refuse to overwrite a populated manifest with an empty one. Discovery yielding zero
+    // routes for a manifest that had some means `routes/` was likely emptied by mistake - writing the wipe
+    // would silently un-serve every route. Leave the file untouched and surface it instead.
+    if (after.length === 0 && before.length > 0) {
+      results.push({ file: rel, changed: false, added: [], removed: [], refusedEmpty: true })
+      continue
+    }
+    const changed = next !== source
+    if (changed) await Bun.write(abs, next)
+    // `diff(before, after)`: `missing` = files now present (added), `extra` = files gone (removed).
+    const drift = diffManifestRoutes(before, after)
+    results.push({ file: rel, changed, added: drift.missing, removed: drift.extra })
+  }
+  return results.sort((a, b) => a.file.localeCompare(b.file))
+}
+
+/** CLI entry: sync every generated manifest, print a per-file summary + the client-rebuild caveat. */
+export async function runSyncManifest(cwd: string): Promise<boolean> {
+  const results = await syncServerManifests(cwd)
+  if (results.length === 0) {
+    console.log("nifra sync-manifest: no generated server-manifest.ts found under this directory.")
+    return true
+  }
+  let anyChanged = false
+  for (const r of results) {
+    if (r.refusedEmpty) {
+      console.log(
+        `⚠ ${r.file}: refused - routes/ has zero routes but the manifest had some; left untouched (delete the manifest yourself if this is intentional).`,
+      )
+    } else if (r.changed) {
+      anyChanged = true
+      console.log(`✓ synced ${r.file}`)
+      if (r.added.length > 0) console.log(`    added:   ${r.added.join(", ")}`)
+      if (r.removed.length > 0) console.log(`    removed: ${r.removed.join(", ")}`)
+    } else {
+      console.log(`• ${r.file} already in sync`)
+    }
+  }
+  if (anyChanged) {
+    console.log(
+      "\nRe-synced the server manifest's route table. If you added or changed a HYDRATING route\n" +
+        "component (not just a loader / SSR-only route), also run a full build so the client bundle matches.",
+    )
+  }
+  return true
+}

package/src/upgrade.ts

@@ -5,8 +5,10 @@
  *
  *   1. **pin sweep** — set every matching dependency to the target version across the workspace's
  *      package.json files, preserving the caret/tilde/exact style and skipping `workspace:`/`link:` specs.
- *   2. **import moves** — rewrite exact import specifiers to their updated module paths.
- *   3. **verify** — reuse the existing `nifra check` gate; no new verification surface.
+ *   2. **dependency moves** — replace removed packages with their supported successor without
+ *      reserializing package.json or leaving duplicate dependency keys.
+ *   3. **import moves** — rewrite exact import specifiers to their updated module paths.
+ *   4. **verify** — reuse the existing `nifra check` gate; no new verification surface.
  *
  * Dry-run by default (prints the plan, writes nothing); `--write` applies. Fail-closed on an unknown
  * target version or a missing package.json, and deterministic (same repo + target → same edits).
@@ -48,9 +50,20 @@ export interface ImportChange {
   readonly count: number
 }
 
+export interface DependencyMoveChange {
+  readonly file: string
+  readonly field: string
+  readonly from: string
+  readonly to: string
+  readonly fromVersion: string
+  readonly toVersion: string
+  readonly action: "renamed" | "removed"
+}
+
 export interface UpgradePlan {
   readonly version: string
   readonly pins: readonly PinChange[]
+  readonly dependencyMoves: readonly DependencyMoveChange[]
   readonly importMoves: readonly ImportChange[]
   readonly notes: readonly string[]
 }
@@ -103,7 +116,9 @@ export function pinSweepText(
     if (typeof deps !== "object" || deps === null) continue
     for (const [name, rawSpec] of Object.entries(deps as Record<string, unknown>)) {
       if (typeof rawSpec !== "string") continue
-      const rule = rules.find((r) => name.startsWith(r.match))
+      const rule = rules.find(
+        (r) => name === r.match || (r.match.endsWith("/") && name.startsWith(r.match)),
+      )
       if (!rule) continue
       const next = rewriteVersionSpec(rawSpec, rule.to)
       if (next === null) continue
@@ -119,6 +134,120 @@ export function pinSweepText(
   return { text: out, changes }
 }
 
+function dependencyObjectRange(
+  text: string,
+  field: (typeof DEP_FIELDS)[number],
+): { start: number; end: number } | undefined {
+  const match = new RegExp(`"${field}"\\s*:\\s*\\{`).exec(text)
+  if (match === null) return undefined
+  const open = text.indexOf("{", match.index)
+  let depth = 0
+  let quoted = false
+  let escaped = false
+  for (let index = open; index < text.length; index++) {
+    const char = text[index]
+    if (quoted) {
+      if (escaped) escaped = false
+      else if (char === "\\") escaped = true
+      else if (char === '"') quoted = false
+      continue
+    }
+    if (char === '"') quoted = true
+    else if (char === "{") depth++
+    else if (char === "}" && --depth === 0) return { start: open + 1, end: index }
+  }
+  return undefined
+}
+
+function rewriteDependencyEntry(
+  text: string,
+  field: (typeof DEP_FIELDS)[number],
+  from: string,
+  fromVersion: string,
+  to: string | undefined,
+  toVersion: string | undefined,
+): string {
+  const range = dependencyObjectRange(text, field)
+  if (range === undefined) return text
+  const body = text.slice(range.start, range.end)
+  const key = escapeRegExp(from)
+  const version = escapeRegExp(fromVersion)
+  const entry = new RegExp(`"${key}"(\\s*:\\s*)"${version}"`)
+  const match = entry.exec(body)
+  if (match === null) return text
+
+  let nextBody: string
+  if (to !== undefined && toVersion !== undefined) {
+    nextBody =
+      body.slice(0, match.index) +
+      `"${to}"${match[1]}"${toVersion}"` +
+      body.slice(match.index + match[0].length)
+  } else {
+    let start = match.index
+    let end = match.index + match[0].length
+    let after = end
+    while (/\\s/.test(body[after] ?? "")) after++
+    if (body[after] === ",") {
+      end = after + 1
+    } else {
+      let before = start - 1
+      while (before >= 0 && /\\s/.test(body[before] ?? "")) before--
+      if (body[before] === ",") start = before
+    }
+    nextBody = body.slice(0, start) + body.slice(end)
+  }
+  return text.slice(0, range.start) + nextBody + text.slice(range.end)
+}
+
+/** Move removed package dependencies without reserializing or reordering package.json. */
+export function moveDependenciesText(
+  text: string,
+  moves: readonly { from: string; to: string; toVersion: string }[],
+): { text: string; changes: Array<Omit<DependencyMoveChange, "file">> } {
+  let out = text
+  const changes: Array<Omit<DependencyMoveChange, "file">> = []
+  for (const move of moves) {
+    let parsed: Record<string, unknown>
+    try {
+      parsed = JSON.parse(out) as Record<string, unknown>
+    } catch {
+      return { text, changes: [] }
+    }
+    for (const field of DEP_FIELDS) {
+      const deps = parsed[field]
+      if (typeof deps !== "object" || deps === null) continue
+      const dependencyMap = deps as Record<string, unknown>
+      if (!Object.hasOwn(dependencyMap, move.from)) continue
+      const fromVersion = dependencyMap[move.from]
+      if (typeof fromVersion !== "string") continue
+      const movedVersion = rewriteVersionSpec(fromVersion, move.toVersion) ?? fromVersion
+      // Dependency fields have different install semantics. A devDependency does not satisfy a runtime
+      // dependency, so only deduplicate the successor inside the same field.
+      const targetExists = Object.hasOwn(dependencyMap, move.to)
+      const action = targetExists ? "removed" : "renamed"
+      const next = rewriteDependencyEntry(
+        out,
+        field,
+        move.from,
+        fromVersion,
+        targetExists ? undefined : move.to,
+        targetExists ? undefined : movedVersion,
+      )
+      if (next === out) continue
+      out = next
+      changes.push({
+        field,
+        from: move.from,
+        to: move.to,
+        fromVersion,
+        toVersion: movedVersion,
+        action,
+      })
+    }
+  }
+  return { text: out, changes }
+}
+
 const IMPORT_SPEC = (from: string): RegExp =>
   new RegExp(
     `(\\bfrom\\s*|\\bimport\\s*\\(\\s*|\\brequire\\s*\\(\\s*|\\bimport\\s+)(['"])${escapeRegExp(from)}(['"])`,
@@ -162,16 +291,18 @@ function scan(cwd: string, pattern: string): string[] {
 /** Compute the plan (and, when `write`, apply it) for a target recipe against `cwd`. */
 export function computeUpgrade(cwd: string, recipe: UpgradeRecipe, write: boolean): UpgradePlan {
   const pins: PinChange[] = []
+  const dependencyMoves: DependencyMoveChange[] = []
   const importMoves: ImportChange[] = []
 
-  if (recipe.pins.length > 0) {
+  if ((recipe.dependencyMoves?.length ?? 0) > 0 || recipe.pins.length > 0) {
     for (const rel of scan(cwd, "**/package.json")) {
       const abs = join(cwd, rel)
-      const text = readFileSync(abs, "utf8")
-      const result = pinSweepText(text, recipe.pins)
-      if (result.changes.length === 0) continue
-      for (const change of result.changes) pins.push({ file: rel, ...change })
-      if (write) writeFileSync(abs, result.text)
+      const original = readFileSync(abs, "utf8")
+      const moved = moveDependenciesText(original, recipe.dependencyMoves ?? [])
+      for (const change of moved.changes) dependencyMoves.push({ file: rel, ...change })
+      const pinned = pinSweepText(moved.text, recipe.pins)
+      for (const change of pinned.changes) pins.push({ file: rel, ...change })
+      if (write && pinned.text !== original) writeFileSync(abs, pinned.text)
     }
   }
 
@@ -186,7 +317,13 @@ export function computeUpgrade(cwd: string, recipe: UpgradeRecipe, write: boolea
     }
   }
 
-  return { version: recipe.version, pins, importMoves, notes: recipe.notes ?? [] }
+  return {
+    version: recipe.version,
+    pins,
+    dependencyMoves,
+    importMoves,
+    notes: recipe.notes ?? [],
+  }
 }
 
 function renderPlan(plan: UpgradePlan, write: boolean): string {
@@ -194,10 +331,25 @@ function renderPlan(plan: UpgradePlan, write: boolean): string {
   const verb = write ? "Applied" : "Planned"
   lines.push(`nifra upgrade → ${plan.version}  (${write ? "write" : "dry-run"})`)
   lines.push("")
-  if (plan.pins.length === 0 && plan.importMoves.length === 0) {
+  if (
+    plan.pins.length === 0 &&
+    plan.dependencyMoves.length === 0 &&
+    plan.importMoves.length === 0
+  ) {
     lines.push("Already up to date — no changes.")
     return lines.join("\n")
   }
+  if (plan.dependencyMoves.length > 0) {
+    lines.push(`${verb} ${plan.dependencyMoves.length} dependency move(s):`)
+    for (const move of plan.dependencyMoves) {
+      const detail =
+        move.action === "renamed"
+          ? `${move.from}@${move.fromVersion} → ${move.to}@${move.toVersion}`
+          : `removed ${move.from}@${move.fromVersion}; ${move.to} is already declared`
+      lines.push(`  ${move.file}  ${detail}`)
+    }
+    lines.push("")
+  }
   if (plan.pins.length > 0) {
     lines.push(`${verb} ${plan.pins.length} dependency pin(s):`)
     for (const p of plan.pins) lines.push(`  ${p.file}  ${p.name}: ${p.from} → ${p.to}`)