@decocms/blocks-cli 7.16.6 → 7.16.8

package/package.json

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

package/scripts/generate-schema.test.ts

@@ -100,6 +100,63 @@ describe("typeToJsonSchema with an unresolvable widget alias import", () => {
   }, 30_000);
 });
 
+describe("typeToJsonSchema with intersection types", () => {
+  it("keeps a branded primitive (`string & { __brand }`) as a string", () => {
+    const project = new Project({
+      useInMemoryFileSystem: true,
+      compilerOptions: { skipLibCheck: true },
+    });
+    const sf = project.createSourceFile(
+      "props.ts",
+      `
+        type Slug = string & { readonly __brand: unique symbol };
+        export interface Props { slug?: Slug }
+      `,
+    );
+    const schema = typeToJsonSchema(sf.getInterfaceOrThrow("Props").getType());
+    expect(schema.properties.slug.type).toBe("string");
+  }, 30_000);
+
+  it("expands an object intersection into a merged field set (recursive menu shape)", () => {
+    const project = new Project({
+      useInMemoryFileSystem: true,
+      compilerOptions: { skipLibCheck: true },
+    });
+    // Mirrors the granado header `SiteNavigationElement` recursive workaround:
+    // nested children written as `Leaf & { children?: Array<…> }`. Before the
+    // intersection branch these collapsed to `children: { items: { type: "string" } }`.
+    const sf = project.createSourceFile(
+      "props.ts",
+      `
+        interface Leaf {
+          /** The name of the item. */
+          name?: string;
+          /** URL of the item. */
+          url?: string;
+        }
+        export interface Props {
+          navItems?: Array<
+            Leaf & {
+              children?: Array<Leaf & { children?: Leaf[] }>;
+            }
+          >;
+        }
+      `,
+    );
+    const schema = typeToJsonSchema(sf.getInterfaceOrThrow("Props").getType());
+
+    const item = schema.properties.navItems.items;
+    expect(item.type).toBe("object");
+    expect(Object.keys(item.properties).sort()).toEqual(["children", "name", "url"]);
+
+    const child = item.properties.children.items;
+    expect(child.type).toBe("object");
+    expect(child.properties.name.type).toBe("string");
+    expect(child.properties.url.type).toBe("string");
+    expect(child.properties.children.items.type).toBe("object");
+  }, 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

@@ -430,6 +430,37 @@ export function typeToJsonSchema(type: Type, visited = new Set<string>(), ctx?:
       return result;
     }
 
+    // Intersection (A & B). TypeScript merges the members, but ts-morph reports
+    // the type as neither object nor interface, so without this branch it falls
+    // through to the `{ type: "string" }` fallback — which is why recursive
+    // menu/navigation types written as `Leaf & { children?: Array<Leaf & …> }`
+    // lost every field and rendered as a bare string/block-ref in the CMS.
+    // Two shapes matter:
+    //   - Branded primitives (`string & { __brand }`) → keep the primitive.
+    //   - Object intersections → merge every member's properties into one object.
+    if (type.isIntersection()) {
+      const parts = type.getIntersectionTypes();
+      const primitive = parts.find((t) => t.isString() || t.isNumber() || t.isBoolean());
+      if (primitive) return typeToJsonSchema(primitive, new Set(visited), ctx);
+
+      const merged: any = { type: "object", properties: {} };
+      const required = new Set<string>();
+      for (const part of parts) {
+        const sub = typeToJsonSchema(part, new Set(visited), ctx);
+        if (sub?.type !== "object" || !sub.properties) continue;
+        Object.assign(merged.properties, sub.properties);
+        for (const r of sub.required ?? []) required.add(r);
+        // Carry object-level annotations (title, @titleBy, …) from members,
+        // first member wins so an earlier explicit value is never clobbered.
+        for (const [k, v] of Object.entries(sub)) {
+          if (k === "type" || k === "properties" || k === "required") continue;
+          if (!(k in merged)) merged[k] = v;
+        }
+      }
+      if (required.size > 0) merged.required = [...required];
+      return merged;
+    }
+
     if (type.isObject() || type.isInterface()) {
       // Runtime-injected platform types (loader `url: URL`, `req: Request`, …)
       // are not CMS-configurable — hide instead of expanding the whole DOM