@decocms/blocks-cli 7.7.0 → 7.8.0

package/package.json

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

package/scripts/generate-invoke.test.ts

@@ -190,3 +190,81 @@ describe("generate-invoke.ts — output shape", () => {
     expect(generatedOutput).toContain("const result = await simulateCart(data);");
   });
 });
+
+describe("generate-invoke.ts — default --apps-dir resolution", () => {
+  // Regression for the published-tarball layout: @decocms/apps-vtex 7.x
+  // ships its sources under src/ (`"files": ["src"]`), so invoke.ts lives
+  // at node_modules/@decocms/apps-vtex/src/invoke.ts — NOT at the package
+  // root. The old default only probed the root, never resolved on a site
+  // with npm-installed packages, and forced sites to pass
+  // `--apps-dir node_modules/@decocms/apps-vtex/src` by hand (granadobr's
+  // migration workaround). The default must probe <pkg>/invoke.ts first,
+  // then <pkg>/src/invoke.ts.
+
+  function makeSite(layout: "root" | "src"): { siteDir: string; cleanup: () => void } {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "gen-invoke-default-"));
+    const siteDir = path.join(tmp, "site");
+    const pkgDir = path.join(siteDir, "node_modules", "@decocms", "apps-vtex");
+    const appsDir = layout === "src" ? path.join(pkgDir, "src") : pkgDir;
+    fs.mkdirSync(path.join(appsDir, "actions"), { recursive: true });
+    fs.writeFileSync(path.join(appsDir, "invoke.ts"), FIXTURE_INVOKE_TS);
+    fs.writeFileSync(path.join(appsDir, "actions", "checkout.ts"), FIXTURE_ACTIONS_CHECKOUT_TS);
+    fs.writeFileSync(path.join(appsDir, "actions", "session.ts"), FIXTURE_ACTIONS_SESSION_TS);
+    fs.writeFileSync(path.join(appsDir, "types.ts"), FIXTURE_TYPES_TS);
+    return { siteDir, cleanup: () => fs.rmSync(tmp, { recursive: true, force: true }) };
+  }
+
+  it("resolves the published layout (node_modules/@decocms/apps-vtex/src/invoke.ts) without --apps-dir", () => {
+    const { siteDir, cleanup } = makeSite("src");
+    try {
+      const outFile = path.join(siteDir, "src", "server", "invoke.gen.ts");
+      const result = spawnSync("npx", ["tsx", GENERATOR, "--out-file", outFile], {
+        cwd: siteDir,
+        encoding: "utf8",
+      });
+      expect(result.status, result.stderr).toBe(0);
+      const generated = fs.readFileSync(outFile, "utf8");
+      // Relative `./actions/*` imports must still be rewritten to package
+      // subpaths — the exports map points them back into src/, so the src/
+      // nesting must not leak into the emitted specifiers.
+      expect(generated).toContain('from "@decocms/apps-vtex/actions/checkout"');
+      expect(generated).not.toContain("apps-vtex/src/");
+      expect(generated).toContain("export const vtexActions");
+    } finally {
+      cleanup();
+    }
+  }, 30_000);
+
+  it("still resolves invoke.ts at the package root (legacy dev-checkout layout) without --apps-dir", () => {
+    const { siteDir, cleanup } = makeSite("root");
+    try {
+      const outFile = path.join(siteDir, "src", "server", "invoke.gen.ts");
+      const result = spawnSync("npx", ["tsx", GENERATOR, "--out-file", outFile], {
+        cwd: siteDir,
+        encoding: "utf8",
+      });
+      expect(result.status, result.stderr).toBe(0);
+      const generated = fs.readFileSync(outFile, "utf8");
+      expect(generated).toContain('from "@decocms/apps-vtex/actions/checkout"');
+      expect(generated).toContain("export const vtexActions");
+    } finally {
+      cleanup();
+    }
+  }, 30_000);
+
+  it("fails with a clear error when @decocms/apps-vtex cannot be found", () => {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "gen-invoke-missing-"));
+    try {
+      const outFile = path.join(tmp, "src", "server", "invoke.gen.ts");
+      const result = spawnSync("npx", ["tsx", GENERATOR, "--out-file", outFile], {
+        cwd: tmp,
+        encoding: "utf8",
+      });
+      expect(result.status).not.toBe(0);
+      expect(result.stderr).toContain("Could not find @decocms/apps-vtex");
+      expect(result.stderr).toContain("--apps-dir");
+    } finally {
+      fs.rmSync(tmp, { recursive: true, force: true });
+    }
+  }, 30_000);
+});

package/scripts/generate-invoke.ts

@@ -55,17 +55,26 @@ function resolveAppsDir(): string {
   const explicit = arg("apps-dir", "");
   if (explicit) return path.resolve(cwd, explicit);
 
-  // Try common locations. Both point at the directory that contains
-  // invoke.ts directly at its root: the installed @decocms/apps-vtex
-  // package (no more vtex/ nesting — that directory IS the package root
-  // now), or a raw apps-start checkout's vtex/ subdirectory as a legacy
-  // fallback for anyone still developing against the pre-split monorepo.
-  const candidates = [
+  // Try common locations: the installed @decocms/apps-vtex package first,
+  // then a raw apps-start checkout's vtex/ subdirectory as a legacy fallback
+  // for anyone still developing against the pre-split monorepo.
+  //
+  // For each root, invoke.ts may sit directly at the root (legacy dev
+  // checkouts) or under src/ — the published @decocms/apps-vtex tarball
+  // ships its sources under src/ (`"files": ["src"]`, `"main":
+  // "./src/index.ts"`), so on any site with npm-installed 7.x packages the
+  // file lives at node_modules/@decocms/apps-vtex/src/invoke.ts. The src/
+  // nesting doesn't affect the emitted imports: relative `./actions/*`
+  // specifiers are rewritten to `@decocms/apps-vtex/actions/*`, which the
+  // package's exports map points back into src/.
+  const roots = [
     path.resolve(cwd, "node_modules/@decocms/apps-vtex"),
     path.resolve(cwd, "../apps-start/vtex"),
   ];
-  for (const c of candidates) {
-    if (fs.existsSync(path.join(c, "invoke.ts"))) return c;
+  for (const root of roots) {
+    for (const c of [root, path.join(root, "src")]) {
+      if (fs.existsSync(path.join(c, "invoke.ts"))) return c;
+    }
   }
   throw new Error("Could not find @decocms/apps-vtex. Use --apps-dir to specify its location.");
 }

package/scripts/generate-sections.test.ts

@@ -281,6 +281,75 @@ describe("generate-sections --registry", () => {
   }, 30_000);
 });
 
+describe("generate-sections neverDefer convention", () => {
+  // Regression: the scanner recognized `export const neverDefer = true` and
+  // emitted `neverDefer: true` on the section's sectionMeta entry, but the
+  // SectionMetaEntry interface the SAME file declares omitted the field —
+  // so every generated file containing a neverDefer section failed the
+  // site's typecheck (TS2353 excess property), and sites hand-patched the
+  // interface only to have the next regeneration wipe the patch (miess's
+  // .deco/sections.gen.ts carried exactly that TODO). The emitted interface
+  // must match SectionMetaEntry in @decocms/blocks/cms.
+  let tmpDir: string;
+  let sectionsDir: string;
+  let outFile: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "generate-sections-neverdefer-"));
+    sectionsDir = path.join(tmpDir, "sections");
+    outFile = path.join(tmpDir, "out", "sections.gen.ts");
+    fs.mkdirSync(sectionsDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("declares neverDefer on the emitted SectionMetaEntry interface and the generated file typechecks + imports", () => {
+    // Mirrors miess's src/sections/Product/SearchResult.tsx.
+    fs.writeFileSync(
+      path.join(sectionsDir, "SearchResult.tsx"),
+      "export const neverDefer = true;\nexport default function SearchResult() { return null; }\n",
+    );
+
+    const { code } = runGenerator(["--sections-dir", sectionsDir, "--out-file", outFile]);
+    expect(code).toBe(0);
+
+    const generated = fs.readFileSync(outFile, "utf-8");
+    // Entry carries the convention…
+    expect(generated).toMatch(/"site\/sections\/SearchResult\.tsx": \{ neverDefer: true \}/);
+    // …and the interface declares the field (optional boolean, matching
+    // SectionMetaEntry in @decocms/blocks/cms/applySectionConventions.ts).
+    expect(generated).toContain("neverDefer?: boolean;");
+
+    // The actual failure mode was a TYPECHECK error (excess property on the
+    // Record<string, SectionMetaEntry> literal), which a runtime import
+    // through tsx/esbuild would never catch — so run tsc on the output.
+    const tscResult = cp.spawnSync(
+      "npx",
+      ["tsc", "--noEmit", "--strict", "--skipLibCheck", outFile],
+      { encoding: "utf8" },
+    );
+    expect(tscResult.status, tscResult.stdout + tscResult.stderr).toBe(0);
+
+    // And keep the importability guarantee from the earlier template
+    // regression: the file must load as valid TS/ESM with the expected
+    // exports.
+    const checkerFile = path.join(tmpDir, "check-import.mjs");
+    fs.writeFileSync(
+      checkerFile,
+      [
+        `const m = await import(${JSON.stringify(pathToFileURL(outFile).href)});`,
+        `if (m.sectionMeta?.["site/sections/SearchResult.tsx"]?.neverDefer !== true) {`,
+        `  throw new Error("neverDefer entry missing from sectionMeta");`,
+        `}`,
+      ].join("\n"),
+    );
+    const importResult = cp.spawnSync("npx", ["tsx", checkerFile], { encoding: "utf8" });
+    expect(importResult.status, importResult.stderr).toBe(0);
+  }, 60_000);
+});
+
 describe("generate-sections output hygiene (non-registry)", () => {
   let tmpDir: string;
   let sectionsDir: string;

package/scripts/generate-sections.ts

@@ -194,8 +194,14 @@ for (let i = 0; i < nonSyncFallbacks.length; i++) {
 lines.push("");
 
 // Metadata map
+// Keep this emitted interface in sync with SectionMetaEntry in
+// @decocms/blocks/cms (applySectionConventions.ts) — every convention the
+// scanner can set on an entry must be declared here, or the generated file
+// fails the site's typecheck (excess-property error) and sites end up
+// hand-patching a file that the next regeneration wipes.
 lines.push("export interface SectionMetaEntry {");
 lines.push("  eager?: boolean;");
+lines.push("  neverDefer?: boolean;");
 lines.push("  cache?: string;");
 lines.push("  layout?: boolean;");
 lines.push("  sync?: boolean;");