@decocms/tanstack 7.71.3 → 7.71.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/tanstack",
-  "version": "7.71.3",
+  "version": "7.71.5",
   "type": "module",
   "description": "Deco framework binding for TanStack Start + Cloudflare Workers",
   "repository": {
@@ -27,9 +27,9 @@
     "lint:unused": "knip"
   },
   "dependencies": {
-    "@decocms/blocks": "7.71.3",
-    "@decocms/blocks-admin": "7.71.3",
-    "@decocms/blocks-cli": "7.71.3",
+    "@decocms/blocks": "7.71.5",
+    "@decocms/blocks-admin": "7.71.5",
+    "@decocms/blocks-cli": "7.71.5",
     "@deco-cx/warp-node": "^0.3.16",
     "fast-json-patch": "^3.1.0",
     "ws": "^8.18.0"

package/src/vite/plugin.js

@@ -84,6 +84,12 @@ function resolveBuildHash() {
   return Date.now().toString(36);
 }
 
+// Virtual id for meta.gen.json on the server: the real path wrapped so the id
+// does NOT end in `.json` (Vite's `vite:json` would re-parse our JS output).
+const META_GEN_PREFIX = "\0deco-meta:";
+const META_GEN_SUFFIX = ".deco-meta.js";
+const metaGenSsrId = (file) => META_GEN_PREFIX + file + META_GEN_SUFFIX;
+
 // Bare-specifier stubs resolved by ID before Vite touches them.
 /** @type {Record<string, string>} */
 const CLIENT_STUBS = {
@@ -235,6 +241,32 @@ export function decoVitePlugin({ fastDeploy = "auto" } = {}) {
       // SSR-only stubs — must be checked first since the client guard below
       // returns undefined for everything that hasn't matched yet on SSR.
       if (options?.ssr && SSR_STUBS[id]) return SSR_STUBS[id];
+      // meta.gen.json on the SERVER → a virtual id that does NOT end in
+      // `.json`. `load` below emits JS (`JSON.parse("...")`), and Vite's
+      // `vite:json` transform runs on every id matching `\.json$` regardless
+      // of who loaded it — it would try to JSON.parse that JS and fail the
+      // build ("Failed to parse JSON file").
+      if (options?.ssr && importer && id.endsWith("meta.gen.json")) {
+        if (id.startsWith(".") || path.isAbsolute(id)) {
+          const file = path.resolve(path.dirname(importer), id);
+          if (existsSync(file)) return metaGenSsrId(file);
+          // Absent (pre-generate-schema) — let Vite report it normally.
+          return undefined;
+        }
+        // Alias / bare specifier (`~/.deco/meta.gen.json`, tsconfig paths…):
+        // let the rest of the pipeline resolve it, then wrap — otherwise it
+        // falls through to vite:json and loses the JSON.parse optimization.
+        if (typeof this?.resolve === "function") {
+          return this.resolve(id, importer, { ...options, skipSelf: true }).then(
+            (r) =>
+              r && !r.external && r.id.endsWith("meta.gen.json") && existsSync(r.id)
+                ? metaGenSsrId(r.id)
+                : undefined,
+            // A resolver in the chain threw — let Vite's normal resolution report it.
+            () => undefined,
+          );
+        }
+      }
       // Server builds keep the real modules.
       if (options?.ssr) return undefined;
       // Bare-specifier exact-match stubs (react-dom/server, node:stream, etc.).
@@ -294,12 +326,12 @@ export function decoVitePlugin({ fastDeploy = "auto" } = {}) {
       // materializes the object graph at all.
       //
       // The client is stubbed in `resolveId` above and never reaches here.
-      if (id.endsWith("meta.gen.json") && options?.ssr) {
-        if (existsSync(id)) {
-          const raw = readFileSync(id, "utf-8");
-          return `export default JSON.parse(${JSON.stringify(raw)});`;
-        }
-        // Absent (pre-generate-schema) — let Vite report it normally.
+      if (id.startsWith(META_GEN_PREFIX) && id.endsWith(META_GEN_SUFFIX)) {
+        const file = id.slice(META_GEN_PREFIX.length, -META_GEN_SUFFIX.length);
+        // Virtual id → Vite won't watch the file on its own.
+        this.addWatchFile?.(file);
+        const raw = readFileSync(file, "utf-8");
+        return `export default JSON.parse(${JSON.stringify(raw)});`;
       }
 
       // loaders.gen.ts — the site's invoke registry (`export const siteLoaders`).
@@ -588,7 +620,7 @@ export function decoVitePlugin({ fastDeploy = "auto" } = {}) {
               console.log(`[deco] meta.gen.json updated (${Date.now() - start}ms)`);
               // Invalidate the meta.gen.json module so SSR picks up fresh schema
               const mod =
-                server.environments?.ssr?.moduleGraph?.getModuleById(schemaOutFile);
+                server.environments?.ssr?.moduleGraph?.getModuleById(metaGenSsrId(schemaOutFile));
               if (mod) {
                 server.environments.ssr.moduleGraph.invalidateModule(mod);
               }

package/src/vite/plugin.test.js

@@ -1,3 +1,6 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { decoVitePlugin, generateSchemaArgs } from "./plugin.js";
 
@@ -122,3 +125,114 @@ describe("decoVitePlugin __DECO_BUILD_HASH__ injection", () => {
     }
   });
 });
+
+describe("decoVitePlugin meta.gen.json on SSR (regression: vite:json double-parse)", () => {
+  // Vite's json plugin transforms every `.json` id — even when another plugin
+  // already loaded it as JS — so the virtual id must not end in `.json`.
+  let dir;
+
+  beforeEach(() => {
+    dir = mkdtempSync(path.join(tmpdir(), "deco-meta-"));
+    mkdirSync(path.join(dir, ".deco"));
+    mkdirSync(path.join(dir, "src"));
+    writeFileSync(path.join(dir, ".deco", "meta.gen.json"), '{"major":1,"schema":{}}');
+  });
+
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("resolves to a virtual id vite:json does not transform, and loads it as JSON.parse", () => {
+    const p = getPlugin();
+    const importer = path.join(dir, "src", "setup.ts");
+    const id = p.resolveId.call({}, "../.deco/meta.gen.json", importer, { ssr: true });
+    expect(id).toBeTypeOf("string");
+    expect(id.endsWith(".json")).toBe(false);
+
+    const watched = [];
+    const code = p.load.call({ addWatchFile: (f) => watched.push(f) }, id, { ssr: true });
+    expect(code).toBe(`export default JSON.parse(${JSON.stringify('{"major":1,"schema":{}}')});`);
+    expect(watched).toEqual([path.join(dir, ".deco", "meta.gen.json")]);
+  });
+
+  it("gives each meta.gen.json its own module id (no shared state)", () => {
+    const p = getPlugin();
+    const other = mkdtempSync(path.join(tmpdir(), "deco-meta-other-"));
+    try {
+      writeFileSync(path.join(other, "meta.gen.json"), '{"major":2}');
+      const a = p.resolveId.call({}, "../.deco/meta.gen.json", path.join(dir, "src", "setup.ts"), {
+        ssr: true,
+      });
+      const b = p.resolveId.call({}, path.join(other, "meta.gen.json"), path.join(dir, "x.ts"), {
+        ssr: true,
+      });
+      expect(a).not.toBe(b);
+      // Loading in reverse order still returns each file's own content.
+      expect(p.load.call({}, b, { ssr: true })).toContain('\\"major\\":2');
+      expect(p.load.call({}, a, { ssr: true })).toContain('\\"major\\":1');
+    } finally {
+      rmSync(other, { recursive: true, force: true });
+    }
+  });
+
+  it("wraps aliased imports after the rest of the pipeline resolves them", async () => {
+    const p = getPlugin();
+    const file = path.join(dir, ".deco", "meta.gen.json");
+    const seen = [];
+    const ctx = {
+      resolve: async (spec, imp, opts) => {
+        seen.push([spec, opts.skipSelf]);
+        return { id: file };
+      },
+    };
+    const id = await p.resolveId.call(
+      ctx,
+      "~/.deco/meta.gen.json",
+      path.join(dir, "src", "setup.ts"),
+      {
+        ssr: true,
+      },
+    );
+    expect(id.endsWith(".json")).toBe(false);
+    expect(seen).toEqual([["~/.deco/meta.gen.json", true]]);
+    expect(p.load.call({}, id, { ssr: true })).toContain("JSON.parse(");
+  });
+
+  it("leaves an aliased import alone when it doesn't resolve to an existing file", async () => {
+    const p = getPlugin();
+    const ctx = { resolve: async () => null };
+    const id = await p.resolveId.call(ctx, "~/missing/meta.gen.json", path.join(dir, "x.ts"), {
+      ssr: true,
+    });
+    expect(id).toBeUndefined();
+  });
+
+  it("falls through when a resolver in the chain throws for the alias", async () => {
+    const p = getPlugin();
+    const ctx = {
+      resolve: async () => {
+        throw new Error("exports map error");
+      },
+    };
+    const id = await p.resolveId.call(ctx, "~/x/meta.gen.json", path.join(dir, "x.ts"), {
+      ssr: true,
+    });
+    expect(id).toBeUndefined();
+  });
+
+  it("falls through to Vite when meta.gen.json does not exist yet", () => {
+    const p = getPlugin();
+    const importer = path.join(dir, "src", "setup.ts");
+    expect(
+      p.resolveId.call({}, "../missing/meta.gen.json", importer, { ssr: true }),
+    ).toBeUndefined();
+  });
+
+  it("still stubs meta.gen.json on the client", () => {
+    const p = getPlugin();
+    const importer = path.join(dir, "src", "setup.ts");
+    expect(p.resolveId.call({}, "../.deco/meta.gen.json", importer, { ssr: false })).toBe(
+      "\0stub:meta-gen",
+    );
+  });
+});