@decocms/blocks-cli 7.20.6 → 7.20.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/blocks-cli",
-  "version": "7.20.6",
+  "version": "7.20.8",
   "type": "module",
   "description": "Deco codegen (generate-blocks, generate-schema, generate-invoke) and Fresh-to-TanStack migration tooling",
   "repository": {
@@ -30,7 +30,7 @@
     "lint:unused": "knip"
   },
   "dependencies": {
-    "@decocms/blocks": "7.20.6",
+    "@decocms/blocks": "7.20.8",
     "ts-morph": "^27.0.0",
     "tsx": "^4.22.5"
   },

package/scripts/generate-blocks.ts

@@ -48,6 +48,7 @@ import {
   mergeCandidates,
   singleDecodeBlockName,
 } from "./lib/blocks-dedupe";
+import { buildCsvRedirectBlocks } from "./lib/csv-redirects";
 import { warnLegacyArtifact } from "./lib/legacyArtifact";
 
 const TS_STUB = [
@@ -175,11 +176,20 @@ export async function generateBlocks(
   // This matches the Deno runtime's `parseBlockId` (one decodeURIComponent)
   // so that studio's `encodeURIComponent(blockKey)` round-trips back to the
   // exact filename on disk.
-  const blocks: Record<string, unknown> = {};
+  const mergedBlocks: Record<string, unknown> = {};
   for (const [_name, c] of Object.entries(winners)) {
-    blocks[singleDecodeBlockName(c.file)] = c.parsed;
+    mergedBlocks[singleDecodeBlockName(c.file)] = c.parsed;
   }
 
+  // Read CSV-backed redirect loaders from public/ and emit synthetic top-level
+  // redirect blocks so `loadRedirects` can see them (it only scans top-level).
+  // Spread CSV blocks FIRST so a curated CMS redirect wins over a bulk CSV row
+  // for the same `from` (loadRedirects is last-write-wins over insertion order).
+  const csvRedirectBlocks = buildCsvRedirectBlocks(mergedBlocks, { blocksDir, silent });
+  const blocks: Record<string, unknown> = Object.keys(csvRedirectBlocks).length
+    ? { ...csvRedirectBlocks, ...mergedBlocks }
+    : mergedBlocks;
+
   await fs.promises.mkdir(path.dirname(outFile), { recursive: true });
 
   // 1. Compact JSON — the real data (no pretty-printing to save ~40% size)
@@ -277,7 +287,11 @@ export function readBlockDelta(options: ReadBlockDeltaOptions): Record<string, u
     delta[key] = parsed;
   }
 
-  return delta;
+  // If a changed block references a CSV redirect loader (e.g. site.json was
+  // edited), re-materialize the synthetic top-level redirect blocks into the
+  // delta so the live snapshot stays in sync. Curated blocks keep precedence.
+  const csvRedirectBlocks = buildCsvRedirectBlocks(delta, { blocksDir, silent });
+  return Object.keys(csvRedirectBlocks).length ? { ...csvRedirectBlocks, ...delta } : delta;
 }
 
 // ---------------------------------------------------------------------------

package/scripts/generate.ts

@@ -178,8 +178,13 @@ Selection:
 
 Platform:
   --platform <name>   Forwarded to schema. With "eitri": runs ONLY schema +
-                      blocks (skips manifest/sections/loaders/invoke) and makes
-                      the schema self-contained (composeMeta at gen time).
+                      blocks (skips manifest/sections/loaders/invoke) and tags
+                      the composed meta's framework field with "eitri".
+
+The generated meta.gen.json is always self-contained (composeMeta runs at gen
+time for every platform), so FS-only consumers (FS-based Studio, Eitri) and the
+committed artifact all carry the framework block types. The tanstack runtime
+re-composes on load idempotently, so it sees the same shape either way.
 
 Forwarded to the individual generators:
   --blocks-dir <dir>       blocks + manifest input        (default .deco/blocks)
@@ -653,9 +658,19 @@ export function buildPlan(cwd: string, opts: CliOptions): GeneratorPlan[] {
         ...(opts.namespace ? ["--namespace", opts.namespace] : []),
         ...(opts.platform ? ["--platform", opts.platform] : []),
         ...(opts.skipApps ? ["--skip-apps"] : []),
-        // Eitri (and any FS-only consumer) needs a self-contained meta.gen.json:
-        // bake composeMeta's framework block types in at generation time.
-        ...(opts.platform === "eitri" ? ["--compose", "--framework", "eitri"] : []),
+        // Always bake composeMeta's framework block types (Page, matchers,
+        // __SECTION_REF__, Resolvable) into meta.gen.json so the file is
+        // SELF-CONTAINED for every consumer that reads it straight from disk —
+        // the FS-based Studio and the Eitri stack, but also anyone diffing the
+        // committed artifact against /live/_meta. The tanstack runtime re-runs
+        // composeMeta on load, which is now idempotent (it returns an
+        // already-composed meta unchanged — see composeMeta's `framework`
+        // sentinel), so this is a no-op there rather than a double-compose.
+        "--compose",
+        // Non-React stacks (Eitri) tag the composed meta with their own
+        // framework name; everyone else gets composeMeta's default
+        // ("tanstack-start").
+        ...(opts.platform === "eitri" ? ["--framework", "eitri"] : []),
       ],
       stage: 2,
       ...enabledIf(

package/scripts/lib/csv-redirects.test.ts

@@ -0,0 +1,98 @@
+/**
+ * Unit test for `buildCsvRedirectBlocks` — the generate-time materialization of
+ * `website/loaders/redirectsFromCsv.ts` blocks into synthetic top-level redirect
+ * blocks. Drives it against a tmp `public/` fixture and asserts the emitted
+ * blocks are what `loadRedirects` (runtime) actually consumes.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { loadRedirects, matchRedirect } from "@decocms/blocks/sdk/redirects";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { buildCsvRedirectBlocks } from "./csv-redirects";
+
+describe("buildCsvRedirectBlocks", () => {
+  let tmpDir: string;
+  let blocksDir: string;
+  let publicDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "csv-redirects-"));
+    blocksDir = path.join(tmpDir, ".deco", "blocks");
+    publicDir = path.join(tmpDir, "public");
+    fs.mkdirSync(blocksDir, { recursive: true });
+    fs.mkdirSync(publicDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  const writeCsv = (name: string, body: string) =>
+    fs.writeFileSync(path.join(publicDir, name), body);
+
+  it("materializes a CSV nested in site.routes into a top-level redirect block", () => {
+    writeCsv("redirects.csv", "from,to,type\n/old,/new,permanent\n/tmp-old,/tmp-new,temporary\n");
+    const blocks: Record<string, unknown> = {
+      site: {
+        __resolveType: "site/apps/site.ts",
+        routes: [
+          {
+            __resolveType: "website/loaders/redirectsFromCsv.ts",
+            from: "static/redirects.csv",
+            redirects: [],
+          },
+        ],
+      },
+    };
+
+    const csvBlocks = buildCsvRedirectBlocks(blocks, { blocksDir, silent: true });
+    expect(Object.keys(csvBlocks)).toEqual(["__csv_redirects__redirects.csv"]);
+
+    // The synthetic block is what loadRedirects consumes at runtime.
+    const map = loadRedirects({ ...csvBlocks, ...blocks });
+    expect(matchRedirect("/old", map)).toMatchObject({ to: "/new", status: 301 });
+    expect(matchRedirect("/tmp-old", map)).toMatchObject({ to: "/tmp-new", status: 302 });
+  });
+
+  it("drops the header row instead of turning it into a redirect", () => {
+    writeCsv("h.csv", "from,to,type\n/a,/b,permanent\n");
+    const blocks = {
+      x: { __resolveType: "website/loaders/redirectsFromCsv.ts", from: "public/h.csv" },
+    };
+    const map = loadRedirects(buildCsvRedirectBlocks(blocks, { blocksDir, silent: true }));
+    expect(matchRedirect("/from", map)).toBeNull();
+    expect(matchRedirect("/a", map)).toMatchObject({ to: "/b", status: 301 });
+  });
+
+  it("lets a curated redirect block win over a CSV row for the same `from`", () => {
+    writeCsv("c.csv", "from,to,type\n/dup,/from-csv,permanent\n");
+    const blocks: Record<string, unknown> = {
+      "redirect-curated": {
+        __resolveType: "website/loaders/redirect.ts",
+        redirect: { from: "/dup", to: "/from-cms", type: "permanent" },
+      },
+      site: {
+        __resolveType: "site/apps/site.ts",
+        routes: [{ __resolveType: "website/loaders/redirectsFromCsv.ts", from: "c.csv" }],
+      },
+    };
+    const csvBlocks = buildCsvRedirectBlocks(blocks, { blocksDir, silent: true });
+    // Merge CSV FIRST so curated wins (documented precedence).
+    const map = loadRedirects({ ...csvBlocks, ...blocks });
+    expect(matchRedirect("/dup", map)).toMatchObject({ to: "/from-cms" });
+  });
+
+  it("returns {} when no CSV loader is referenced", () => {
+    const blocks = { a: { __resolveType: "website/loaders/redirect.ts" } };
+    expect(buildCsvRedirectBlocks(blocks, { blocksDir, silent: true })).toEqual({});
+  });
+
+  it("does not throw when the referenced CSV is missing", () => {
+    const blocks = {
+      x: { __resolveType: "website/loaders/redirectsFromCsv.ts", from: "static/missing.csv" },
+    };
+    expect(() => buildCsvRedirectBlocks(blocks, { blocksDir, silent: true })).not.toThrow();
+    expect(buildCsvRedirectBlocks(blocks, { blocksDir, silent: true })).toEqual({});
+  });
+});

package/scripts/lib/csv-redirects.ts

@@ -0,0 +1,108 @@
+/**
+ * Materialize CSV-backed redirects at generate time.
+ *
+ * A `website/loaders/redirectsFromCsv.ts` block only carries a `from` CSV path
+ * plus an empty `redirects: []` — the CSV was read by a Fresh/Deno loader at
+ * runtime that was never ported to TanStack. On top of that, these blocks are
+ * usually nested inside `site.routes[]`, and the runtime `loadRedirects` only
+ * scans TOP-LEVEL decofile entries, so nested CSV loaders are invisible twice
+ * over.
+ *
+ * `generate-blocks` runs in Node with fs access to the site's `public/` dir, so
+ * here we read each referenced CSV and emit synthetic TOP-LEVEL redirect blocks
+ * (`__csv_redirects__<name>`) with the parsed rules. `loadRedirects` picks those
+ * up with no runtime I/O — it stays synchronous and unchanged.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { parseRedirectsCsv } from "@decocms/blocks/sdk/redirects";
+
+const CSV_REDIRECT_RESOLVE_TYPE = "website/loaders/redirectsFromCsv.ts";
+const REDIRECTS_RESOLVE_TYPE = "website/loaders/redirects.ts";
+
+/** Recursively collect `from` CSV paths referenced by redirectsFromCsv nodes. */
+function collectCsvRefs(node: unknown, out: Set<string>): void {
+  if (!node || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const item of node) collectCsvRefs(item, out);
+    return;
+  }
+  const obj = node as Record<string, unknown>;
+  if (obj.__resolveType === CSV_REDIRECT_RESOLVE_TYPE && typeof obj.from === "string") {
+    out.add(obj.from);
+  }
+  for (const value of Object.values(obj)) collectCsvRefs(value, out);
+}
+
+/**
+ * Resolve a decofile CSV `from` to an absolute path under the site's `public/`.
+ * Accepts `static/foo.csv` (Fresh convention), `public/foo.csv`, or `foo.csv`.
+ */
+function resolveCsvPath(from: string, publicDir: string): string {
+  const rel = from.replace(/^\/?(?:static|public)\//i, "").replace(/^\//, "");
+  return path.resolve(publicDir, rel);
+}
+
+export interface MaterializeCsvRedirectsOptions {
+  /** The `.deco/blocks` directory; `public/` is resolved relative to its root. */
+  blocksDir: string;
+  /** Suppress info/warn logs. Defaults to false. */
+  silent?: boolean;
+}
+
+/**
+ * Scan `blocks` for CSV redirect loaders and return synthetic top-level redirect
+ * blocks (keyed `__csv_redirects__<name>`). Read-only over `blocks`; returns an
+ * empty object when no CSV loader is referenced. A missing CSV file warns but
+ * never throws, so it cannot break the build.
+ *
+ * Callers should merge the result with LOWER precedence than the real blocks
+ * (`{ ...csvBlocks, ...blocks }`) so a curated CMS redirect always wins over a
+ * bulk-migration CSV row for the same `from` (`loadRedirects` is last-write-wins
+ * over insertion order).
+ */
+export function buildCsvRedirectBlocks(
+  blocks: Record<string, unknown>,
+  options: MaterializeCsvRedirectsOptions,
+): Record<string, unknown> {
+  const silent = options.silent ?? false;
+  const publicDir = path.resolve(options.blocksDir, "../../public");
+
+  const refs = new Set<string>();
+  for (const value of Object.values(blocks)) collectCsvRefs(value, refs);
+  if (refs.size === 0) return {};
+
+  const csvBlocks: Record<string, unknown> = {};
+  for (const from of refs) {
+    const csvPath = resolveCsvPath(from, publicDir);
+    let csv: string;
+    try {
+      csv = fs.readFileSync(csvPath, "utf-8");
+    } catch {
+      if (!silent) {
+        console.warn(`[redirects] CSV not found for "${from}" (looked at ${csvPath}) — skipping.`);
+      }
+      continue;
+    }
+
+    // `loadRedirects` reads `entry.type` ("permanent" | "temporary"), while
+    // `parseRedirectsCsv` returns a numeric `status` — map it back so 301s stay
+    // 301s (a raw status field would be ignored and default to 302).
+    const entries = parseRedirectsCsv(csv).map((r) => ({
+      from: r.from,
+      to: r.to,
+      type: r.status === 301 ? "permanent" : "temporary",
+    }));
+
+    const key = `__csv_redirects__${path.basename(csvPath)}`;
+    csvBlocks[key] = { redirects: entries, __resolveType: REDIRECTS_RESOLVE_TYPE };
+
+    if (!silent) {
+      console.log(
+        `[redirects] Materialized ${entries.length} redirects from ${path.basename(csvPath)}.`,
+      );
+    }
+  }
+
+  return csvBlocks;
+}