@decocms/blocks-cli 7.17.0 → 7.18.0

package/package.json

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

package/scripts/generate-schema.test.ts

@@ -5,9 +5,11 @@ import * as path from "node:path";
 import { Project } from "ts-morph";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import {
+  EITRI_FORMAT_ALIASES,
   WIDGET_TYPE_FORMATS,
   applyWidgetFormat,
   definitionIdForPath,
+  normalizeFormats,
   typeToJsonSchema,
 } from "./generate-schema";
 
@@ -29,6 +31,38 @@ describe("definitionIdForPath", () => {
   });
 });
 
+describe("normalizeFormats (Eitri @format aliases)", () => {
+  it("remaps a known alias in a nested prop schema", () => {
+    const defs = {
+      "abc@Props": {
+        type: "object",
+        properties: {
+          datetime: { type: "string", format: "datetime", title: "Publish date." },
+          post: { type: "string", format: "textarea" },
+        },
+      },
+    };
+    normalizeFormats(defs, EITRI_FORMAT_ALIASES);
+    expect(defs["abc@Props"].properties.datetime.format).toBe("date-time");
+    // textarea is already a valid widget format — left untouched.
+    expect(defs["abc@Props"].properties.post.format).toBe("textarea");
+  });
+
+  it("recurses through arrays and leaves unknown formats alone", () => {
+    const node = {
+      items: [{ format: "datetime" }, { format: "email" }],
+    };
+    normalizeFormats(node, EITRI_FORMAT_ALIASES);
+    expect(node.items[0].format).toBe("date-time");
+    expect(node.items[1].format).toBe("email");
+  });
+
+  it("is a no-op on primitives / null", () => {
+    expect(() => normalizeFormats(null, EITRI_FORMAT_ALIASES)).not.toThrow();
+    expect(() => normalizeFormats("datetime", EITRI_FORMAT_ALIASES)).not.toThrow();
+  });
+});
+
 describe("applyWidgetFormat", () => {
   it("recovers an unresolved widget alias (empty schema) as string + format", () => {
     // When a widget alias like `Color` is imported from a module ts-morph can't
@@ -157,6 +191,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

@@ -236,6 +236,35 @@ export const WIDGET_TYPE_FORMATS: Record<string, string> = {
   DateTimeWidget: "date-time",
 };
 
+/**
+ * Eitri authors annotate fields with JSDoc `@format` using Eitri's own vocab
+ * (e.g. `@format datetime`). Map those onto the JSON-Schema `format` values the
+ * Studio widget layer understands. `textarea` already matches, so only the
+ * divergent ones need remapping. Applied only for --platform eitri.
+ */
+export const EITRI_FORMAT_ALIASES: Record<string, string> = {
+  datetime: "date-time",
+};
+
+/**
+ * Recursively remap `format` string values in a JSON-Schema tree using the
+ * given alias map. Mutates in place; only touches `format` fields whose value
+ * is a known alias, so unrelated schema is untouched.
+ */
+export function normalizeFormats(node: unknown, aliases: Record<string, string>): void {
+  if (Array.isArray(node)) {
+    for (const item of node) normalizeFormats(item, aliases);
+    return;
+  }
+  if (node && typeof node === "object") {
+    const obj = node as Record<string, unknown>;
+    if (typeof obj.format === "string" && aliases[obj.format]) {
+      obj.format = aliases[obj.format];
+    }
+    for (const key of Object.keys(obj)) normalizeFormats(obj[key], aliases);
+  }
+}
+
 /**
  * Detect known widget types and set the appropriate format.
  */
@@ -345,15 +374,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 {
@@ -565,7 +600,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);
@@ -868,7 +908,13 @@ function resolvePropsViaReExport(
   return null;
 }
 
-function findTsxFiles(dir: string): string[] {
+// Default scan extensions. Sections may widen this to also include .jsx/.js
+// on stacks whose sections can be plain JavaScript (e.g. Eitri) — see
+// SECTION_EXTS. Loaders/apps stay TS-only (their input types come from real
+// TypeScript signatures, which JS files cannot express).
+const DEFAULT_EXTS = [".tsx", ".ts"] as const;
+
+function findTsxFiles(dir: string, exts: readonly string[] = DEFAULT_EXTS): string[] {
   const results: string[] = [];
   if (!fs.existsSync(dir)) return results;
   for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
@@ -876,10 +922,10 @@ function findTsxFiles(dir: string): string[] {
     if (entry.isDirectory()) {
       // The exclusion predicate targets generated/test *files* — a directory
       // named e.g. `foo.gen.ts` is a real path segment and must still be walked.
-      results.push(...findTsxFiles(full));
+      results.push(...findTsxFiles(full, exts));
     } else if (
       !isExcludedCodegenFile(entry.name) &&
-      (entry.name.endsWith(".tsx") || entry.name.endsWith(".ts"))
+      exts.some((e) => entry.name.endsWith(e))
     ) {
       results.push(full);
     }
@@ -1186,6 +1232,11 @@ function generateMeta(): MetaResponse {
   ];
   for (const wrapper of COMMERCE_EXTENSION_WRAPPERS) {
     const matchingLoaders = outputTypeToLoaderKeys.get(wrapper.outputType) ?? [];
+    // A wrapper whose base loader type has no matching loaders in the site is
+    // useless (its `data` picker would only offer Resolvable). Non-commerce
+    // sites (e.g. Eitri) have none, so skip it instead of injecting a phantom
+    // commerce loader into the picker.
+    if (matchingLoaders.length === 0) continue;
     const wrapperDefKey = toBase64(wrapper.key);
     definitions[wrapperDefKey] = {
       title: wrapper.key,
@@ -1227,7 +1278,13 @@ function generateMeta(): MetaResponse {
     process.exit(1);
   }
 
-  const sectionFiles = findTsxFiles(sectionsDir);
+  // Eitri sections can be plain JavaScript (.js/.jsx) as well as TS; other
+  // stacks stay TS-only so a stray .js helper in src/sections isn't mistaken
+  // for a section. A JS file with no extractable Props still registers as a
+  // (prop-less) section rather than being silently skipped.
+  const sectionExts =
+    PLATFORM === "eitri" ? [".tsx", ".ts", ".jsx", ".js"] : DEFAULT_EXTS;
+  const sectionFiles = findTsxFiles(sectionsDir, sectionExts);
   console.log(`Found ${sectionFiles.length} section files`);
   for (const filePath of sectionFiles) {
     getSourceFile(project, filePath, sourceFileCache);
@@ -1408,6 +1465,13 @@ function generateMeta(): MetaResponse {
     }
   }
 
+  // Eitri @format aliases → JSON-Schema formats (e.g. datetime → date-time).
+  // Done as a final pass over the generated definitions so every prop schema,
+  // however deeply nested, is normalized before it reaches Studio.
+  if (PLATFORM === "eitri") {
+    normalizeFormats(definitions, EITRI_FORMAT_ALIASES);
+  }
+
   // Pages, matchers, etc. are injected at runtime by composeMeta() in src/admin/schema.ts.
   // Site-level loaders are generated here (first pass above).
   const emptyAnyOf = { anyOf: [] as any[] };