@decocms/blocks-cli 8.0.0 → 8.1.0-next.0

package/scripts/generate-invoke.ts

@@ -46,6 +46,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { Project, type PropertyAssignment, SyntaxKind } from "ts-morph";
+import { resolveInvokeSource } from "./lib/invokeSource";
 
 const args = process.argv.slice(2);
 function arg(name: string, fallback: string): string {
@@ -77,28 +78,15 @@ const PRIVILEGED_ACTIONS = new Set([
 
 function resolveAppsDir(): string {
   const explicit = arg("apps-dir", "");
+  const source = resolveInvokeSource(cwd, explicit || null);
+  if (source) return path.dirname(source);
+  // Preserve explicit-path errors and the legacy raw-checkout fallback used
+  // only by direct invocation. Published packages can be local or hoisted,
+  // with invoke.ts at the package root or under src/.
   if (explicit) return path.resolve(cwd, explicit);
-
-  // 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 root of roots) {
-    for (const c of [root, path.join(root, "src")]) {
-      if (fs.existsSync(path.join(c, "invoke.ts"))) return c;
-    }
+  const legacy = resolveInvokeSource(cwd, "../apps-start/vtex");
+  if (legacy) {
+    return path.dirname(legacy);
   }
   throw new Error("Could not find @decocms/apps-vtex. Use --apps-dir to specify its location.");
 }

package/scripts/generate-loaders.test.ts

@@ -14,8 +14,8 @@ import { afterAll, beforeAll, describe, expect, it } from "vitest";
 
 const SCRIPT = path.resolve(__dirname, "generate-loaders.ts");
 
-function run(cwd: string): { stdout: string; stderr: string; code: number } {
-  const r = cp.spawnSync("npx", ["tsx", SCRIPT], { encoding: "utf8", cwd });
+function run(cwd: string, args: string[] = []): { stdout: string; stderr: string; code: number } {
+  const r = cp.spawnSync("npx", ["tsx", SCRIPT, ...args], { encoding: "utf8", cwd });
   return { stdout: r.stdout || "", stderr: r.stderr || "", code: r.status ?? -1 };
 }
 

package/scripts/generate-loaders.ts

@@ -43,14 +43,9 @@
  *   --exclude             comma-separated list of loader keys to skip (they have custom wiring)
  *   --prune-by-decofile   only emit entries whose key appears as `__resolveType` in any JSON
  *   --decofile-dir        @deprecated alias for --prune-by-decofile
- *
- * If no `--out-file` is passed and the OLD default (src/server/cms/loaders.gen.ts)
- * still exists on disk, a one-line legacy warning is printed to stderr and the
- * NEW default is written anyway — see lib/legacyArtifact.ts.
  */
 import fs from "node:fs";
 import path from "node:path";
-import { warnLegacyArtifact } from "./lib/legacyArtifact";
 
 const args = process.argv.slice(2);
 function arg(name: string, fallback: string): string {
@@ -60,13 +55,8 @@ function arg(name: string, fallback: string): string {
 
 const loadersDir = path.resolve(process.cwd(), arg("loaders-dir", "src/loaders"));
 const actionsDir = path.resolve(process.cwd(), arg("actions-dir", "src/actions"));
-const OUT_FILE_EXPLICIT = args.includes("--out-file");
 const NEW_DEFAULT_OUT_FILE = ".deco/loaders.gen.ts";
-const OLD_DEFAULT_OUT_FILE = "src/server/cms/loaders.gen.ts";
 const outFile = path.resolve(process.cwd(), arg("out-file", NEW_DEFAULT_OUT_FILE));
-if (!OUT_FILE_EXPLICIT && fs.existsSync(path.resolve(process.cwd(), OLD_DEFAULT_OUT_FILE))) {
-  warnLegacyArtifact(OLD_DEFAULT_OUT_FILE, NEW_DEFAULT_OUT_FILE);
-}
 const excludeRaw = arg("exclude", "");
 const excludeSet = new Set(excludeRaw.split(",").map((s) => s.trim()).filter(Boolean));
 

package/scripts/generate-schema-loader-aliases.test.ts

@@ -0,0 +1,186 @@
+import { spawnSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+
+interface Schema {
+  type?: string;
+  $ref?: string;
+  allOf?: Schema[];
+  anyOf?: Schema[];
+  properties?: Record<string, Schema>;
+  items?: Schema;
+  required?: string[];
+}
+
+// Exercise loader discovery AND prop matching through the real CLI. A context
+// pre-seeded with "Settings" would miss the bug in output-type registration.
+describe("generate-schema named loader aliases", () => {
+  let fixture: string;
+  let props: Schema;
+
+  beforeAll(() => {
+    fixture = mkdtempSync(path.join(tmpdir(), "schema-loader-aliases-"));
+    const write = (relative: string, contents: string) => {
+      const file = path.join(fixture, relative);
+      mkdirSync(path.dirname(file), { recursive: true });
+      writeFileSync(file, contents);
+    };
+    write(
+      "tsconfig.json",
+      JSON.stringify({
+        compilerOptions: {
+          target: "ES2022",
+          module: "ESNext",
+          moduleResolution: "Bundler",
+          strict: true,
+        },
+      }),
+    );
+    write(
+      "src/types.ts",
+      `export interface Config { title: string; modules: unknown; }
+       export type Settings = Omit<Config, "modules">;
+       export type Picked = Pick<Config, "title">;
+       export type Plain = { label: string };
+       export type Tree = { id: string; children?: Tree[] };
+       export type Generic<T> = { value: T };
+       export interface Product { productID: string; }
+       export interface Collection { label: string; settings: Settings; }
+       export type Unrelated = { title: string };`,
+    );
+    const loaders: Record<string, string> = {
+      settings: "Settings",
+      nullable: "Promise<Settings | null>",
+      picked: "Picked",
+      plain: "Plain",
+      list: "Promise<Settings[] | null>",
+      tree: "Tree",
+      products: "Product[]",
+      anonymous: "{ title: string }",
+      anonymousList: "{ label: string }[]",
+      strings: "string[]",
+      directOmit: 'Omit<Config, "title">',
+      generic: "Generic<string>",
+    };
+    for (const [name, output] of Object.entries(loaders)) {
+      write(
+        `src/loaders/${name}.ts`,
+        `import type { Config, Settings, Picked, Plain, Tree, Generic, Product } from "../types";
+         export default function load(): ${output} { throw new Error("fixture only"); }`,
+      );
+    }
+    write(
+      "src/sections/Example.tsx",
+      `import type { Config, Settings as SiteSettings, Picked, Plain, Tree,
+         Generic, Product, Collection, Unrelated } from "../types";
+       export interface Props {
+         settings: SiteSettings;
+         picked?: Picked | null;
+         plain: Plain;
+         list: SiteSettings[];
+         nullableList?: Array<SiteSettings> | null;
+         tree: Tree;
+         products: Product[];
+         collections: Collection[];
+         anonymous: { title: string };
+         anonymousList: { other: number }[];
+         strings: string[];
+         unrelated: Unrelated;
+         directOmit: Omit<Config, "modules">;
+         generic: Generic<number>;
+       }
+       export default function Example(_props: Props) { return null; }`,
+    );
+
+    const run = spawnSync(
+      process.execPath,
+      [
+        "--import",
+        import.meta.resolve("tsx"),
+        path.resolve(__dirname, "generate-schema.ts"),
+        "--skip-apps",
+      ],
+      { cwd: fixture, encoding: "utf8", timeout: 30_000 },
+    );
+    expect(run.status, run.error?.message ?? run.stderr).toBe(0);
+    const meta = JSON.parse(readFileSync(path.join(fixture, ".deco/meta.gen.json"), "utf8"));
+    const section = meta.schema.definitions[btoa("site/sections/Example.tsx")];
+    const ref = section.allOf.find((part: Schema) => part.$ref).$ref;
+    props = meta.schema.definitions[ref.replace("#/definitions/", "")];
+  }, 30_000);
+
+  afterAll(() => {
+    if (fixture) rmSync(fixture, { recursive: true, force: true });
+  });
+
+  function field(name: string): Schema {
+    const schema = props.properties?.[name];
+    expect(schema, name).toBeDefined();
+    return schema!;
+  }
+
+  function inline(schema: Schema): Schema {
+    return schema.anyOf?.find((branch) => branch.type) ?? schema;
+  }
+
+  function expectLoader(schema: Schema, name: string) {
+    expect(schema.anyOf).toEqual(expect.arrayContaining([{ $ref: "#/definitions/Resolvable" }]));
+    expect(schema.anyOf).toContainEqual({
+      $ref: `#/definitions/${btoa(`site/loaders/${name}.ts`)}`,
+    });
+    expect(schema.properties).toBeUndefined();
+    expect(schema.anyOf).not.toContainEqual({
+      $ref: `#/definitions/${btoa("site/loaders/anonymousList.ts")}`,
+    });
+  }
+
+  it("matches an imported Omit alias, including a nullable async loader", () => {
+    expectLoader(field("settings"), "settings");
+    expectLoader(field("settings"), "nullable");
+    expect(props.required).toContain("settings");
+  });
+
+  it("matches Pick and plain object aliases without changing optionality", () => {
+    expectLoader(field("picked"), "picked");
+    expectLoader(field("plain"), "plain");
+    expect(props.required).not.toContain("picked");
+  });
+
+  it("matches aliases through arrays, Promise and nullable wrappers", () => {
+    expectLoader(field("list"), "list");
+    expectLoader(field("nullableList"), "list");
+    expect(props.required).not.toContain("nullableList");
+  });
+
+  it("matches a recursive alias without expanding its fields", () => {
+    expectLoader(field("tree"), "tree");
+  });
+
+  it("keeps named-interface array loaders working", () => {
+    expectLoader(field("products"), "products");
+  });
+
+  it("keeps unrelated object arrays editable and resolves their nested settings", () => {
+    const collections = inline(field("collections"));
+    expect(collections.type).toBe("array");
+    expect(collections.items?.properties?.label.type).toBe("string");
+    expectLoader(collections.items!.properties!.settings, "settings");
+  });
+
+  it("does not collapse unrelated anonymous arrays into an __type[] bucket", () => {
+    expect(inline(field("anonymousList")).items?.properties?.other.type).toBe("number");
+  });
+
+  it("does not register generic utility types or match different instantiations", () => {
+    expect(inline(field("directOmit")).properties?.title.type).toBe("string");
+    expect(inline(field("generic")).properties?.value.type).toBe("number");
+  });
+
+  it("does not match primitives, anonymous objects or unrelated named aliases", () => {
+    expect(inline(field("strings")).items?.type).toBe("string");
+    expect(inline(field("anonymous")).properties?.title.type).toBe("string");
+    expect(inline(field("unrelated")).properties?.title.type).toBe("string");
+  });
+});

package/scripts/generate-schema-workspaces.test.ts

@@ -0,0 +1,180 @@
+import { spawnSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+interface Schema {
+  type?: string;
+  $ref?: string;
+  allOf?: Schema[];
+  properties?: Record<string, Schema>;
+  required?: string[];
+}
+
+interface Meta {
+  manifest: { blocks: { loaders: Record<string, Schema>; apps: Record<string, Schema> } };
+  schema: { definitions: Record<string, Schema> };
+}
+
+describe("generate-schema workspace app packages", () => {
+  let workspace: string;
+  let site: string;
+
+  function write(relative: string, contents: string) {
+    const file = path.join(workspace, relative);
+    mkdirSync(path.dirname(file), { recursive: true });
+    writeFileSync(file, contents);
+  }
+
+  function installApp(base: string, field: string) {
+    const directory = `${base}/node_modules/@decocms/apps-catalog`;
+    write(
+      `${directory}/package.json`,
+      JSON.stringify({
+        name: "@decocms/apps-catalog",
+        version: "1.0.0",
+        type: "module",
+        exports: { "./mod": "./src/mod.ts" },
+      }),
+    );
+    write(
+      `${directory}/src/mod.ts`,
+      `export interface Props { account: string; }
+       export default function app(_props: Props) { return {}; }`,
+    );
+    write(
+      `${directory}/src/loaders/product.ts`,
+      `export interface Props {
+         ${field}: string;
+         limit?: number;
+       }
+       export interface Product { sku: string; }
+       export default function loader(_props: Props): Product {
+         throw new Error("Fixture loaders must never execute during generation");
+       }`,
+    );
+  }
+
+  function runGenerator(script: string, args: string[] = []): string {
+    const result = spawnSync(
+      process.execPath,
+      ["--import", import.meta.resolve("tsx"), path.resolve(__dirname, script), ...args],
+      { cwd: site, encoding: "utf8", timeout: 30_000 },
+    );
+    expect(result.status, result.error?.message ?? result.stderr).toBe(0);
+    return result.stdout;
+  }
+
+  function readMeta(): Meta {
+    return JSON.parse(readFileSync(path.join(site, ".deco/meta.gen.json"), "utf8"));
+  }
+
+  function generate(): Meta {
+    runGenerator("generate-schema.ts");
+    return readMeta();
+  }
+
+  function definition(meta: Meta, reference: Schema): Schema {
+    expect(reference?.$ref).toBeDefined();
+    return meta.schema.definitions[reference.$ref!.replace("#/definitions/", "")];
+  }
+
+  beforeEach(() => {
+    workspace = mkdtempSync(path.join(tmpdir(), "schema-workspaces-"));
+    site = path.join(workspace, "apps/website");
+    write("package.json", JSON.stringify({ private: true, workspaces: ["apps/*"] }));
+    write(
+      "apps/website/package.json",
+      JSON.stringify({
+        name: "@example/website",
+        private: true,
+        dependencies: { "@decocms/apps-catalog": "1.0.0" },
+      }),
+    );
+    write(
+      "apps/website/tsconfig.json",
+      JSON.stringify({
+        compilerOptions: {
+          target: "ES2022",
+          module: "ESNext",
+          moduleResolution: "Bundler",
+          strict: true,
+        },
+      }),
+    );
+    write(
+      "apps/website/src/apps/catalog.ts",
+      'export { default } from "@decocms/apps-catalog/mod";',
+    );
+    mkdirSync(path.join(site, "src/sections"), { recursive: true });
+  });
+
+  afterEach(() => {
+    if (workspace) rmSync(workspace, { recursive: true, force: true });
+  });
+
+  it("emits loaders and their Props from an app hoisted above the website", () => {
+    installApp(".", "productId");
+
+    const meta = generate();
+    const loader = definition(meta, meta.manifest.blocks.loaders["catalog/loaders/product.ts"]);
+    expect(loader.properties).toMatchObject({
+      productId: { type: "string" },
+      limit: { type: "number" },
+    });
+    expect(loader.required).toEqual(["__resolveType", "productId"]);
+
+    const app = definition(meta, meta.manifest.blocks.apps["site/apps/catalog.ts"]);
+    const props = definition(meta, app.allOf!.find((part) => part.$ref)!);
+    expect(props.properties?.account).toMatchObject({ type: "string" });
+    expect(props.required).toEqual(["account"]);
+  }, 30_000);
+
+  it("uses the nearest app package without merging loaders from the hoisted copy", () => {
+    installApp(".", "parentProductId");
+    write(
+      "node_modules/@decocms/apps-catalog/src/loaders/parentOnly.ts",
+      "export default function loader(): string { return 'parent'; }",
+    );
+    installApp("apps/website", "localProductId");
+
+    const meta = generate();
+    const loader = definition(meta, meta.manifest.blocks.loaders["catalog/loaders/product.ts"]);
+    expect(loader.properties?.localProductId).toMatchObject({ type: "string" });
+    expect(loader.properties?.parentProductId).toBeUndefined();
+    expect(loader.required).toEqual(["__resolveType", "localProductId"]);
+    expect(meta.manifest.blocks.loaders["catalog/loaders/parentOnly.ts"]).toBeUndefined();
+  }, 30_000);
+
+  it("invalidates a warm schema cache when hoisted loader Props change at the same version", () => {
+    installApp(".", "productId");
+    const args = ["--only", "schema"];
+    const key = "catalog/loaders/product.ts";
+    const first = runGenerator("generate.ts", args);
+    expect(first).toMatch(/\[generate\] schema \d+ms \(fresh\)/);
+    const before = readMeta();
+    expect(
+      definition(before, before.manifest.blocks.loaders[key]).properties?.productId,
+    ).toMatchObject({ type: "string" });
+
+    const warm = runGenerator("generate.ts", args);
+    expect(warm).toMatch(/\[generate\] schema \d+ms \(cached(?:, content-verified)?\)/);
+
+    // A linked/workspace app can change its source without a version bump.
+    // Only the hoisted loader changes; the site and package manifest stay put.
+    const relative = "node_modules/@decocms/apps-catalog/src/loaders/product.ts";
+    const source = readFileSync(path.join(workspace, relative), "utf8");
+    write(relative, source.replace("productId: string;", "productId: number; category?: string;"));
+
+    const updated = runGenerator("generate.ts", args);
+    expect(updated).toMatch(/\[generate\] schema \d+ms \(fresh\)/);
+    const after = readMeta();
+    const loader = definition(after, after.manifest.blocks.loaders[key]);
+    expect(loader.properties).toMatchObject({
+      productId: { type: "number" },
+      category: { type: "string" },
+    });
+    expect(loader.required).toEqual(["__resolveType", "productId"]);
+  }, 30_000);
+});

package/scripts/generate-schema.test.ts

@@ -156,7 +156,7 @@ describe("typeToJsonSchema with intersection types", () => {
       useInMemoryFileSystem: true,
       compilerOptions: { skipLibCheck: true },
     });
-    // Mirrors the granado header `SiteNavigationElement` recursive workaround:
+    // Mirrors a production 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(
@@ -191,6 +191,68 @@ describe("typeToJsonSchema with intersection types", () => {
   }, 30_000);
 });
 
+describe("typeToJsonSchema Section-typed props", () => {
+  // The framework's `Section` is opaque (`export type Section = any`), so a
+  // Section-typed prop is a "pick any section" reference emitted as a
+  // __SECTION_REF__ picker. This must keep working.
+  it("emits a __SECTION_REF__ picker for the framework's opaque Section[]", () => {
+    const project = new Project({
+      useInMemoryFileSystem: true,
+      compilerOptions: { skipLibCheck: true },
+    });
+    const sf = project.createSourceFile(
+      "props.ts",
+      `
+        type Section = any;
+        export interface Props {
+          children?: Section[] | null;
+        }
+      `,
+    );
+    const schema = typeToJsonSchema(sf.getInterfaceOrThrow("Props").getType());
+
+    expect(schema.properties.children).toMatchObject({
+      type: "array",
+      items: { $ref: "#/definitions/__SECTION_REF__" },
+    });
+  }, 30_000);
+
+  // Regression (a production footer): a component that declares its own local
+  // `type Section = { label; items }` used to collide with the magic name and
+  // collapse into a non-editable __SECTION_REF__ picker — the footer columns
+  // showed only a drag handle, no expand arrow, no form. A concretely-shaped
+  // local type is user data and must render as an inline editable object.
+  it("keeps a user-defined local `type Section` as an inline editable object", () => {
+    const project = new Project({
+      useInMemoryFileSystem: true,
+      compilerOptions: { skipLibCheck: true },
+    });
+    const sf = project.createSourceFile(
+      "props.ts",
+      `
+        interface Item { label: string; href: string; }
+        type Section = { label: string; items: Item[] };
+        export interface Props {
+          sections?: Section[];
+        }
+      `,
+    );
+    const schema = typeToJsonSchema(sf.getInterfaceOrThrow("Props").getType());
+
+    const sections = schema.properties.sections;
+    // Editable array of objects — NOT a section-picker reference.
+    expect(sections.type).toBe("array");
+    expect(JSON.stringify(sections)).not.toContain("__SECTION_REF__");
+
+    const item = sections.items;
+    expect(item.type).toBe("object");
+    expect(item.properties.label).toMatchObject({ type: "string" });
+    expect(item.properties.items.type).toBe("array");
+    expect(item.properties.items.items.type).toBe("object");
+    expect(item.properties.items.items.properties.href).toMatchObject({ type: "string" });
+  }, 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
@@ -252,10 +314,10 @@ describe("typeToJsonSchema loader block-ref matching", () => {
 });
 
 // ---------------------------------------------------------------------------
-// Default output path (.deco/) + legacy warning — subprocess, mirrors the
-// pattern in generate-sections.test.ts. generate-schema.ts IS guarded by
-// isMainModule(), but it's still driven as a subprocess here so the CLI's
-// argv-parsed OUT_REL/legacy-check top-level code runs against a real cwd.
+// Default output path (.deco/) — subprocess, mirrors the pattern in
+// generate-sections.test.ts. generate-schema.ts IS guarded by isMainModule(),
+// but it's still driven as a subprocess here so the CLI's argv-parsed OUT_REL
+// top-level code runs against a real cwd.
 // ---------------------------------------------------------------------------
 
 const SCRIPT = path.resolve(__dirname, "generate-schema.ts");
@@ -313,32 +375,9 @@ describe("generate-schema default output path (.deco/)", () => {
     expect(meta.manifest.blocks.sections).toHaveProperty("site/sections/Hero.tsx");
   }, 30_000);
 
-  it("warns once to stderr naming both paths when the OLD default file exists and no --out is passed, but still writes the NEW default", () => {
-    const oldDefaultDir = path.join(tmpDir, "src", "server", "admin");
-    fs.mkdirSync(oldDefaultDir, { recursive: true });
-    fs.writeFileSync(path.join(oldDefaultDir, "meta.gen.json"), "{}");
-
+  it("does not warn about a legacy default path", () => {
     const { code, stderr } = runGenerator(["--skip-apps"], { cwd: tmpDir });
     expect(code).toBe(0);
-
-    expect(stderr).toContain("src/server/admin/meta.gen.json");
-    expect(stderr).toContain(".deco/meta.gen.json");
-    expect(stderr).toContain("Move the file and update its importers");
-
-    const newDefault = path.join(tmpDir, ".deco", "meta.gen.json");
-    expect(fs.existsSync(newDefault)).toBe(true);
-  }, 30_000);
-
-  it("does not warn when an explicit --out is passed, even if the OLD default file exists", () => {
-    const oldDefaultDir = path.join(tmpDir, "src", "server", "admin");
-    fs.mkdirSync(oldDefaultDir, { recursive: true });
-    fs.writeFileSync(path.join(oldDefaultDir, "meta.gen.json"), "{}");
-
-    const explicitOut = path.join(tmpDir, "custom", "meta.gen.json");
-    const { code, stderr } = runGenerator(["--skip-apps", "--out", explicitOut], { cwd: tmpDir });
-    expect(code).toBe(0);
-
     expect(stderr).not.toContain("Generator default output moved");
-    expect(fs.existsSync(explicitOut)).toBe(true);
   }, 30_000);
 });