@decocms/blocks-cli 7.2.2 → 7.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/blocks-cli",
-  "version": "7.2.2",
+  "version": "7.3.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.2.2",
+    "@decocms/blocks": "7.3.0",
     "ts-morph": "^27.0.0",
     "tsx": "^4.19.0"
   },

package/scripts/generate-blocks.ts

@@ -77,39 +77,65 @@ export async function generateBlocks(
     if (!silent) {
       console.warn(`Blocks directory not found: ${blocksDir} — generating empty barrel.`);
     }
-    fs.mkdirSync(path.dirname(outFile), { recursive: true });
-    fs.writeFileSync(jsonFile, "{}");
-    fs.writeFileSync(outFile, TS_STUB);
+    await fs.promises.mkdir(path.dirname(outFile), { recursive: true });
+    await fs.promises.writeFile(jsonFile, "{}");
+    await fs.promises.writeFile(outFile, TS_STUB);
     return { count: 0, collisions: 0, jsonFile, outFile, empty: true, blocks: {} };
   }
 
-  const files = fs.readdirSync(blocksDir).filter((f) => f.endsWith(".json"));
+  const files = (await fs.promises.readdir(blocksDir)).filter((f) => f.endsWith(".json"));
 
   // Read each file into a Candidate, then let the dedupe lib pick the winner
   // per decoded key and report any collisions. See `lib/blocks-dedupe.ts` for
   // the priority order and the rationale behind it (TL;DR: never use file size,
   // don't trust mtime alone in CI clones).
+  //
+  // Reads run as bounded-concurrency async I/O (not a synchronous
+  // readFileSync/statSync loop) so this whole-directory scan yields the event
+  // loop between batches. On dev cold-start the Vite plugin fires this
+  // fire-and-forget alongside Vite's own startup; a synchronous scan of a few
+  // hundred `.deco/blocks` files blocked the loop long enough to delay `ready`
+  // by ~1s (materially worse under a CPU quota, e.g. a sandbox pod). Batched to
+  // keep the open-fd count bounded (avoid EMFILE on large decofiles).
   const candidatesWithKeys: Array<{ candidate: Candidate; key: string }> = [];
-  for (const file of files) {
-    const { name, passes } = decodeBlockNameWithPasses(file);
-    const fp = path.join(blocksDir, file);
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(fs.readFileSync(fp, "utf-8"));
-    } catch (e) {
-      if (!silent) console.warn(`Failed to parse ${file}:`, e);
-      continue;
+  const READ_BATCH = 64;
+  for (let i = 0; i < files.length; i += READ_BATCH) {
+    const batch = await Promise.all(
+      files.slice(i, i + READ_BATCH).map(async (file) => {
+        const fp = path.join(blocksDir, file);
+        try {
+          const [raw, stat] = await Promise.all([
+            fs.promises.readFile(fp, "utf-8"),
+            fs.promises.stat(fp),
+          ]);
+          return { file, raw, mtimeMs: stat.mtimeMs };
+        } catch (e) {
+          if (!silent) console.warn(`Failed to read ${file}:`, e);
+          return null;
+        }
+      }),
+    );
+    for (const entry of batch) {
+      if (!entry) continue;
+      const { name, passes } = decodeBlockNameWithPasses(entry.file);
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(entry.raw);
+      } catch (e) {
+        if (!silent) console.warn(`Failed to parse ${entry.file}:`, e);
+        continue;
+      }
+      candidatesWithKeys.push({
+        key: name,
+        candidate: {
+          file: entry.file,
+          passes,
+          mtimeMs: entry.mtimeMs,
+          hasPath: blockHasPath(parsed),
+          parsed,
+        },
+      });
     }
-    candidatesWithKeys.push({
-      key: name,
-      candidate: {
-        file,
-        passes,
-        mtimeMs: fs.statSync(fp).mtimeMs,
-        hasPath: blockHasPath(parsed),
-        parsed,
-      },
-    });
   }
 
   const { winners, collisions } = mergeCandidates(candidatesWithKeys);
@@ -138,11 +164,11 @@ export async function generateBlocks(
     blocks[singleDecodeBlockName(c.file)] = c.parsed;
   }
 
-  fs.mkdirSync(path.dirname(outFile), { recursive: true });
+  await fs.promises.mkdir(path.dirname(outFile), { recursive: true });
 
   // 1. Compact JSON — the real data (no pretty-printing to save ~40% size)
   const jsonStr = JSON.stringify(blocks);
-  fs.writeFileSync(jsonFile, jsonStr);
+  await fs.promises.writeFile(jsonFile, jsonStr);
 
   // 2. Thin TS wrapper — just for TypeScript tooling and as a Vite load target.
   // Only write if content differs to avoid triggering Vite's file watcher,
@@ -150,10 +176,10 @@ export async function generateBlocks(
   // TanStack Router during dev hot-reload.
   let existingTs: string | undefined;
   try {
-    existingTs = fs.readFileSync(outFile, "utf-8");
+    existingTs = await fs.promises.readFile(outFile, "utf-8");
   } catch {}
   if (existingTs !== TS_STUB) {
-    fs.writeFileSync(outFile, TS_STUB);
+    await fs.promises.writeFile(outFile, TS_STUB);
   }
 
   if (!silent) {

package/scripts/generate-schema.test.ts

@@ -0,0 +1,74 @@
+import { Project } from "ts-morph";
+import { describe, expect, it } from "vitest";
+import { WIDGET_TYPE_FORMATS, applyWidgetFormat, typeToJsonSchema } from "./generate-schema";
+
+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
+    // resolve (remote/CDN), the type comes through as `any` and typeToJsonSchema
+    // returns {}. The intended widget must still be recovered.
+    const schema: any = {};
+    applyWidgetFormat(schema, "Color");
+    expect(schema).toEqual({ type: "string", format: "color" });
+  });
+
+  it.each(Object.entries(WIDGET_TYPE_FORMATS))(
+    "recovers the %s alias to { type: string, format: %s } from an empty schema",
+    (alias, format) => {
+      const schema: any = {};
+      applyWidgetFormat(schema, alias);
+      expect(schema).toEqual({ type: "string", format });
+    },
+  );
+
+  it("applies the format to a resolved string schema", () => {
+    const schema: any = { type: "string" };
+    applyWidgetFormat(schema, "Color");
+    expect(schema).toEqual({ type: "string", format: "color" });
+  });
+
+  it("does not overwrite a schema that resolved to a $ref", () => {
+    const schema: any = { $ref: "#/definitions/Foo" };
+    applyWidgetFormat(schema, "Color");
+    expect(schema).toEqual({ $ref: "#/definitions/Foo" });
+  });
+
+  it("does not touch a schema for a non-widget type hint", () => {
+    const schema: any = {};
+    applyWidgetFormat(schema, "SomeRandomType");
+    expect(schema).toEqual({});
+  });
+});
+
+describe("typeToJsonSchema with an unresolvable widget alias import", () => {
+  it("emits { type: string, format: color } for a Color field imported from a CDN", () => {
+    const project = new Project({
+      useInMemoryFileSystem: true,
+      compilerOptions: { skipLibCheck: true, noResolve: false },
+    });
+
+    // The import target is not resolvable, mirroring apps that import `Color`
+    // from a remote deco-cx/apps CDN URL — `Color` therefore resolves to `any`.
+    const sf = project.createSourceFile(
+      "props.ts",
+      `
+        import type { Color } from "https://cdn.example.com/admin/widgets.ts";
+
+        export interface Props {
+          /** @title Cor do Texto */
+          textLeftColor?: Color;
+        }
+      `,
+    );
+
+    const propsType = sf.getInterfaceOrThrow("Props").getType();
+    const schema = typeToJsonSchema(propsType);
+
+    expect(schema.type).toBe("object");
+    expect(schema.properties.textLeftColor).toEqual({
+      title: "Cor do Texto",
+      type: "string",
+      format: "color",
+    });
+  });
+});

package/scripts/generate-schema.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env tsx
 import fs from "node:fs";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 /**
  * Schema Generator for deco admin compatibility.
  *
@@ -153,7 +154,7 @@ function applyJsDocToSchema(schema: any, tags: Record<string, string>): void {
   }
 }
 
-const WIDGET_TYPE_FORMATS: Record<string, string> = {
+export const WIDGET_TYPE_FORMATS: Record<string, string> = {
   ImageWidget: "image-uri",
   VideoWidget: "video-uri",
   HTMLWidget: "html",
@@ -183,7 +184,7 @@ function applyWidgetDetection(schema: any, typeText: string): void {
  * Smart widget format application that handles arrays, nullable types,
  * and union types by applying the format to the correct inner schema.
  */
-function applyWidgetFormat(schema: any, typeHint: string): void {
+export function applyWidgetFormat(schema: any, typeHint: string): void {
   const matchedFormat = Object.entries(WIDGET_TYPE_FORMATS).find(
     ([wt]) => typeHint === wt || typeHint.includes(wt),
   )?.[1];
@@ -205,6 +206,12 @@ function applyWidgetFormat(schema: any, typeHint: string): void {
         variant.format = matchedFormat;
       }
     }
+  } else if (!schema.type && !schema.$ref) {
+    // Widget alias (e.g. `Color`) not resolvable by ts-morph (remote/CDN import)
+    // → it came through as `any`, so typeToJsonSchema returned an empty schema.
+    // Every widget alias is string-based, so recover the intended widget here.
+    schema.type = "string";
+    schema.format = matchedFormat;
   }
 }
 
@@ -262,7 +269,7 @@ function extractLoaderOutputTypeName(sourceFile: SourceFile): string | null {
   return ret.getSymbol()?.getName() ?? ret.getAliasSymbol()?.getName() ?? null;
 }
 
-function typeToJsonSchema(type: Type, visited = new Set<string>(), ctx?: GenerationContext): any {
+export function typeToJsonSchema(type: Type, visited = new Set<string>(), ctx?: GenerationContext): any {
   const typeText = type.getText();
   if (visited.has(typeText)) return { type: "object" };
   visited.add(typeText);
@@ -1283,15 +1290,38 @@ function generateMeta(): MetaResponse {
   };
 }
 
-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)}`,
-);
+function isMainModule(): boolean {
+  // True when this file is the process entrypoint (invoked directly), false when
+  // it's imported (e.g. from tests) — the guard keeps the module importable
+  // without triggering a full filesystem scan + write.
+  //
+  // Compare the *realpath* of both sides rather than the raw URL: under tsx /
+  // pnpm the entrypoint is reached through symlinks (pnpm's node_modules,
+  // macOS /tmp → /private/tmp), so argv[1] and import.meta.url spell the same
+  // file differently. A raw string compare would silently return false and skip
+  // generation. realpathSync collapses symlinks so both resolve identically.
+  const entry = process.argv[1];
+  if (!entry) return false;
+  try {
+    const entryPath = fs.realpathSync(path.resolve(entry));
+    const selfPath = fs.realpathSync(fileURLToPath(import.meta.url));
+    return entryPath === selfPath;
+  } catch {
+    return false;
+  }
+}
+
+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)}`,
+  );
+}