@decocms/blocks-cli 7.16.8 → 7.17.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/blocks-cli",
-  "version": "7.16.8",
+  "version": "7.17.1",
   "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.16.8",
+    "@decocms/blocks": "7.17.1",
     "ts-morph": "^27.0.0",
     "tsx": "^4.22.5"
   },

package/scripts/generate-schema.test.ts

@@ -157,6 +157,66 @@ describe("typeToJsonSchema with intersection types", () => {
   }, 30_000);
 });
 
+describe("typeToJsonSchema loader block-ref matching", () => {
+  // Regression: a loader that returns an array whose element type has no
+  // resolvable name (`VNode[]`, `string[]`, …) used to be bucketed under the
+  // generic key "Array". Because an array type's OWN symbol name is also
+  // "Array", EVERY array-of-objects section prop (`Collection[]`, `Tab[]`)
+  // matched that bucket and collapsed into a block-ref picker — so the array
+  // was no longer editable and its item fields (label, nested loaders) all
+  // disappeared from the CMS form. The two guards (drop the "Array" bucket at
+  // registration; never look it up from an array prop's symbol name) keep the
+  // array inline and editable.
+  it("does not collapse an array-of-objects prop into a block-ref via the generic 'Array' bucket", () => {
+    const project = new Project({
+      useInMemoryFileSystem: true,
+      compilerOptions: { skipLibCheck: true },
+    });
+    const sf = project.createSourceFile(
+      "props.ts",
+      `
+        interface Product { productID: string; name: string; }
+        interface Collection { label: string; products: Product[] | null; }
+        export interface Props {
+          collections: Collection[];
+          topLevelProducts?: Product[] | null;
+        }
+      `,
+    );
+    const ctx = {
+      // Mimics a site where List/Sections (VNode[]) and skuList (string[])
+      // would otherwise land in an "Array" bucket, plus a real Product[] loader.
+      outputTypeToLoaderKeys: new Map<string, string[]>([
+        ["Product[]", ["site/loaders/algolia/products/list.ts"]],
+        ["Array", ["site/loaders/List/Sections.tsx", "site/loaders/skuList.ts"]],
+      ]),
+    };
+
+    const schema = typeToJsonSchema(sf.getInterfaceOrThrow("Props").getType(), new Set(), ctx);
+    const collections = schema.properties.collections;
+
+    // Stays an editable array of objects — NOT a block-ref anyOf.
+    expect(collections.type).toBe("array");
+    expect(collections.anyOf).toBeUndefined();
+
+    const item = collections.items;
+    expect(item.type).toBe("object");
+    expect(item.properties.label).toMatchObject({ type: "string" });
+    // The nested Product[] field still resolves to a loader picker (its type
+    // name matches a registered loader output).
+    expect(item.properties.products.anyOf).toEqual([
+      { $ref: "#/definitions/Resolvable" },
+      { $ref: "#/definitions/c2l0ZS9sb2FkZXJzL2FsZ29saWEvcHJvZHVjdHMvbGlzdC50cw==" },
+    ]);
+
+    // Control: a top-level Product[] prop still resolves to a loader picker.
+    expect(schema.properties.topLevelProducts.anyOf).toEqual([
+      { $ref: "#/definitions/Resolvable" },
+      { $ref: "#/definitions/c2l0ZS9sb2FkZXJzL2FsZ29saWEvcHJvZHVjdHMvbGlzdC50cw==" },
+    ]);
+  }, 30_000);
+});
+
 // ---------------------------------------------------------------------------
 // Default output path (.deco/) + legacy warning — subprocess, mirrors the
 // pattern in generate-sections.test.ts. generate-schema.ts IS guarded by

package/scripts/generate-schema.ts

@@ -27,6 +27,12 @@ import { fileURLToPath } from "node:url";
  *   --skip-apps   Skip app schema generation
  *   --out         Output file        (default: ".deco/meta.gen.json")
  *   --platform    Platform name      (default: "cloudflare")
+ *   --compose     Run composeMeta() before writing so the output is
+ *                 SELF-CONTAINED (bakes in Page, matchers, __SECTION_REF__,
+ *                 Resolvable). For consumers that read meta.gen.json straight
+ *                 from disk with no runtime (FS-based Studio / Eitri stack).
+ *   --framework   With --compose, the value written to the `framework` field
+ *                 (default: "tanstack-start").
  *
  * If no `--out` is passed and the OLD default (src/server/admin/meta.gen.json)
  * still exists on disk, a one-line legacy warning is printed to stderr and the
@@ -75,6 +81,15 @@ let APPS_REL = "src/apps";
 let SKIP_APPS = false;
 let OUT_REL = NEW_DEFAULT_OUT_REL;
 let PLATFORM = "cloudflare";
+// When true, run composeMeta() over the generated site meta before writing, so
+// the output file is SELF-CONTAINED — it carries the framework block types
+// (Page, matchers, __SECTION_REF__, Resolvable) that composeMeta otherwise
+// injects at runtime. Required by consumers that read meta.gen.json straight
+// from the filesystem with no runtime (e.g. the FS-based Studio / Eitri stack).
+let COMPOSE = false;
+// Value written to the composed meta's `framework` field (only used with
+// --compose). Defaults to composeMeta's historical "tanstack-start".
+let FRAMEWORK = "tanstack-start";
 
 if (isMainModule()) {
   SITE_NAMESPACE = arg("namespace", SITE_NAMESPACE);
@@ -87,6 +102,8 @@ if (isMainModule()) {
   const outFileExplicit = argv.includes("--out");
   OUT_REL = arg("out", NEW_DEFAULT_OUT_REL);
   PLATFORM = arg("platform", PLATFORM);
+  COMPOSE = argv.includes("--compose");
+  FRAMEWORK = arg("framework", FRAMEWORK);
   if (!outFileExplicit && fs.existsSync(path.resolve(process.cwd(), OLD_DEFAULT_OUT_REL))) {
     warnLegacyArtifact(OLD_DEFAULT_OUT_REL, NEW_DEFAULT_OUT_REL);
   }
@@ -328,15 +345,21 @@ function extractLoaderOutputTypeName(sourceFile: SourceFile): string | null {
     const nonNull = ret.getUnionTypes().filter((t) => !t.isNull() && !t.isUndefined());
     if (nonNull.length === 1) ret = nonNull[0];
   }
-  // Unwrap array element type — Product[] → "Product[]" (keyed as array)
+  // Unwrap array element type — Product[] → "Product[]" (keyed as array).
+  // When the element type has no resolvable name (primitives like `string[]`,
+  // or opaque types like `VNode[]`), there is NO meaningful output-type key.
+  // Returning the generic `Array` symbol here would bucket the loader under
+  // "Array", which then collides with EVERY array-typed section prop
+  // (`Collection[]`, `Tab[]`, …) and wrongly turns them into loader pickers.
   if (ret.isArray()) {
     const elType = ret.getArrayElementType();
-    if (elType) {
-      const elName = elType.getSymbol()?.getName() ?? elType.getAliasSymbol()?.getName() ?? null;
-      if (elName) return `${elName}[]`;
-    }
+    const elName = elType?.getSymbol()?.getName() ?? elType?.getAliasSymbol()?.getName() ?? null;
+    return elName ? `${elName}[]` : null;
   }
-  return ret.getSymbol()?.getName() ?? ret.getAliasSymbol()?.getName() ?? null;
+  // Reject anonymous object returns (`{ … }` → symbol name "__type"): they are
+  // not a nameable output type and would over-match anonymous-object props.
+  const name = ret.getSymbol()?.getName() ?? ret.getAliasSymbol()?.getName() ?? null;
+  return name && name !== "__type" ? name : null;
 }
 
 export function typeToJsonSchema(type: Type, visited = new Set<string>(), ctx?: GenerationContext): any {
@@ -548,7 +571,12 @@ export function typeToJsonSchema(type: Type, visited = new Set<string>(), ctx?:
         // baseHint strips "| null | undefined" so "ProductListingPage | null" → "ProductListingPage"
         if (ctx?.outputTypeToLoaderKeys) {
           const typeSym = propType.getSymbol() ?? propType.getAliasSymbol();
-          const outputTypeName = typeSym?.getName() ?? baseHint;
+          // An array type's symbol name is always the generic "Array", which is
+          // never a meaningful loader output key — fall back to the AST type
+          // text (`baseHint`, e.g. "Collection[]") instead. The element-based
+          // `${elName}[]` lookup below handles arrays precisely.
+          const symName = typeSym?.getName();
+          const outputTypeName = symName && symName !== "Array" ? symName : baseHint;
           let matchingLoaders =
             ctx.outputTypeToLoaderKeys.get(outputTypeName) ??
             (outputTypeName !== baseHint ? ctx.outputTypeToLoaderKeys.get(baseHint) : undefined);
@@ -1441,16 +1469,28 @@ function isMainModule(): boolean {
 }
 
 if (isMainModule()) {
-  const meta = generateMeta();
-  const outPath = path.resolve(process.cwd(), OUT_REL);
-  fs.mkdirSync(path.dirname(outPath), { recursive: true });
-  fs.writeFileSync(outPath, JSON.stringify(meta, null, 2));
-
-  const defCount = Object.keys(meta.schema.definitions).length;
-  const secCount = Object.keys(meta.manifest.blocks.sections || {}).length;
-  const ldrCount = Object.keys(meta.manifest.blocks.loaders || {}).length;
-  const appCount = Object.keys(meta.manifest.blocks.apps || {}).length;
-  console.log(
-    `\nGenerated schema: ${defCount} definitions, ${secCount} sections, ${ldrCount} loaders, ${appCount} apps → ${path.relative(process.cwd(), outPath)}`,
-  );
+  // Wrapped in an async IIFE so --compose can dynamically import composeMeta
+  // ONLY when requested — the default path (and any test importing this
+  // module's pure exports) never pulls in the @decocms/blocks/cms barrel.
+  void (async () => {
+    let meta = generateMeta();
+    if (COMPOSE) {
+      const { composeMeta } = await import("@decocms/blocks/cms");
+      // composeMeta returns @decocms/blocks' MetaResponse (platform optional);
+      // this file's local MetaResponse requires platform. It's always present
+      // (composeMeta spreads siteMeta, which set it), so the cast is safe.
+      meta = composeMeta(meta, { framework: FRAMEWORK }) as MetaResponse;
+    }
+    const outPath = path.resolve(process.cwd(), OUT_REL);
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    fs.writeFileSync(outPath, JSON.stringify(meta, null, 2));
+
+    const defCount = Object.keys(meta.schema.definitions).length;
+    const secCount = Object.keys(meta.manifest.blocks.sections || {}).length;
+    const ldrCount = Object.keys(meta.manifest.blocks.loaders || {}).length;
+    const appCount = Object.keys(meta.manifest.blocks.apps || {}).length;
+    console.log(
+      `\nGenerated schema${COMPOSE ? " (self-contained)" : ""}: ${defCount} definitions, ${secCount} sections, ${ldrCount} loaders, ${appCount} apps → ${path.relative(process.cwd(), outPath)}`,
+    );
+  })();
 }