@decocms/tanstack 8.0.0 → 8.1.0-next.0

package/src/vite/plugin.test.js

@@ -1,5 +1,8 @@
+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 } from "./plugin.js";
+import { decoVitePlugin, generateSchemaArgs } from "./plugin.js";
 
 /**
  * The Vite plugin's `resolveId` / `load` hooks are pure functions over their
@@ -53,6 +56,17 @@ describe("decoVitePlugin client stubs (regression guard)", () => {
   });
 });
 
+describe("generateSchemaArgs (regression: meta.gen.json must be composed)", () => {
+  // Both generate-schema.ts invocations in configureServer (watch regen + cold
+  // start) derive their args from this helper. generate-schema always composes
+  // before writing, so the manifest carries every framework website/* block
+  // (matchers/Page/Resolvable) that Studio — which reads meta.gen.json as-is —
+  // needs, e.g. the variant date matcher. See a production storefront regression.
+  it("targets the given site", () => {
+    expect(generateSchemaArgs("my-site")).toEqual(["--site", "my-site"]);
+  });
+});
+
 describe("decoVitePlugin __DECO_BUILD_HASH__ injection", () => {
   let originalEnv;
 
@@ -111,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",
+    );
+  });
+});

package/src/vite/plugin.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import { decoVitePlugin } from "./plugin.js";
 
 /**
@@ -50,3 +50,127 @@ describe("decoVitePlugin — loaders.gen client stub", () => {
     expect(plugin.load("/repo/src/actions/foo.ts", { ssr: false })).toBeUndefined();
   });
 });
+
+/**
+ * `fastDeploy: true` must stub blocks.gen out of the SERVER bundle — but only
+ * for production builds.
+ *
+ * Without the stub, a fast-deploy site holds the decofile twice: the bundled
+ * JSON.parse(...) graph stays reachable via the site's `import { blocks }`
+ * binding for the isolate's whole life, and ensureBlocksHydrated adds a second
+ * graph. Measured at 13.6 MB + 13.4 MB for a 9.2 MB decofile.
+ *
+ * In `vite dev` there is no KV to hydrate from, and the dev bootstrap relies on
+ * reading the `.json` sibling the stub bypasses — so stubbing there would blank
+ * the local site.
+ */
+describe("decoVitePlugin — fastDeploy server stub", () => {
+  const id = "/repo/.deco/blocks.gen.ts";
+  const STUB = "export const blocks = {};";
+
+  // The default is "auto", which reads DECO_SEEDED_DEPLOY. Pin it off so the
+  // "default does not stub" assertions below can't be silently satisfied (or
+  // broken) by an ambient env var.
+  vi.stubEnv("DECO_SEEDED_DEPLOY", "");
+  afterEach(() => vi.stubEnv("DECO_SEEDED_DEPLOY", ""));
+
+  /** @param {{fastDeploy?: boolean}} opts @param {"build"|"serve"} command */
+  const make = (opts, command) => {
+    const p = /** @type {any} */ (decoVitePlugin(opts));
+    p.config({}, { command }); // Vite always runs config() before load()
+    return p;
+  };
+
+  it("stubs blocks.gen on SSR for a production build", () => {
+    expect(make({ fastDeploy: true }, "build").load(id, { ssr: true })).toBe(STUB);
+  });
+
+  it("does NOT stub on SSR in dev, where there is no KV to hydrate from", () => {
+    expect(make({ fastDeploy: true }, "serve").load(id, { ssr: true })).not.toBe(STUB);
+  });
+
+  it("keeps stubbing the client bundle regardless", () => {
+    expect(make({ fastDeploy: true }, "build").load(id, { ssr: false })).toBe(STUB);
+    expect(make({ fastDeploy: true }, "serve").load(id, { ssr: false })).toBe(STUB);
+  });
+
+  it("does NOT stub blocks.gen on SSR by default (bundled fallback preserved)", () => {
+    // No .json sibling on disk for this synthetic path, so the hook falls
+    // through to Vite (undefined). The point is it never returns the stub.
+    expect(make({}, "build").load(id, { ssr: true })).not.toBe(STUB);
+  });
+
+  it("leaves unrelated modules alone", () => {
+    expect(make({ fastDeploy: true }, "build").load("/repo/src/x.tsx", { ssr: true })).toBeUndefined();
+  });
+
+  it("defines __DECO_BLOCKS_STUBBED__ so the runtime knows whether it has a fallback", () => {
+    const build = /** @type {any} */ (decoVitePlugin({ fastDeploy: true })).config({}, { command: "build" });
+    expect(build.define.__DECO_BLOCKS_STUBBED__).toBe("true");
+
+    // Dev and the default must both report "no, you still have a decofile",
+    // otherwise ensureBlocksHydrated would start failing requests.
+    const dev = /** @type {any} */ (decoVitePlugin({ fastDeploy: true })).config({}, { command: "serve" });
+    expect(dev.define.__DECO_BLOCKS_STUBBED__).toBe("false");
+    const def = /** @type {any} */ (decoVitePlugin()).config({}, { command: "build" });
+    expect(def.define.__DECO_BLOCKS_STUBBED__).toBe("false");
+  });
+});
+
+/**
+ * The `"auto"` default: stub only when the deploy pipeline declares it seeds
+ * `decofile:<deployment-id>` into KV BEFORE activating the new version.
+ *
+ * Stubbing without that guarantee is a hard outage, not a degraded mode — the
+ * bundle has no decofile, so `ensureBlocksHydrated` 5xxs on purpose rather than
+ * serving an empty site the edge would cache. Cloudflare Workers Builds and a
+ * manual `wrangler deploy` do not seed, and they never set the env.
+ */
+describe("decoVitePlugin — fastDeploy auto gate", () => {
+  const id = "/repo/.deco/blocks.gen.ts";
+  const STUB = "export const blocks = {};";
+
+  afterEach(() => vi.unstubAllEnvs());
+
+  /** @param {"build"|"serve"} command */
+  const makeDefault = (command) => {
+    const p = /** @type {any} */ (decoVitePlugin());
+    const cfg = p.config({}, { command });
+    return { plugin: p, cfg };
+  };
+
+  it("does not stub when the pipeline does not declare a seed step", () => {
+    vi.stubEnv("DECO_SEEDED_DEPLOY", "");
+    const { plugin, cfg } = makeDefault("build");
+    expect(plugin.load(id, { ssr: true })).not.toBe(STUB);
+    expect(cfg.define.__DECO_BLOCKS_STUBBED__).toBe("false");
+  });
+
+  it("stubs on a production build when the pipeline declares it seeds", () => {
+    vi.stubEnv("DECO_SEEDED_DEPLOY", "1");
+    const { plugin, cfg } = makeDefault("build");
+    expect(plugin.load(id, { ssr: true })).toBe(STUB);
+    expect(cfg.define.__DECO_BLOCKS_STUBBED__).toBe("true");
+  });
+
+  it("still never stubs SSR in dev, even inside a seeding pipeline", () => {
+    vi.stubEnv("DECO_SEEDED_DEPLOY", "1");
+    const { plugin, cfg } = makeDefault("serve");
+    expect(plugin.load(id, { ssr: true })).not.toBe(STUB);
+    expect(cfg.define.__DECO_BLOCKS_STUBBED__).toBe("false");
+  });
+
+  it("explicit false wins over a seeding pipeline", () => {
+    vi.stubEnv("DECO_SEEDED_DEPLOY", "1");
+    const p = /** @type {any} */ (decoVitePlugin({ fastDeploy: false }));
+    const cfg = p.config({}, { command: "build" });
+    expect(p.load(id, { ssr: true })).not.toBe(STUB);
+    expect(cfg.define.__DECO_BLOCKS_STUBBED__).toBe("false");
+  });
+
+  it("explicit true wins over a non-seeding pipeline", () => {
+    vi.stubEnv("DECO_SEEDED_DEPLOY", "");
+    const p = /** @type {any} */ (decoVitePlugin({ fastDeploy: true }));
+    expect(p.config({}, { command: "build" }).define.__DECO_BLOCKS_STUBBED__).toBe("true");
+  });
+});