no-mistakes(review): fix perPackage effective-package grouping and validate template-spec format

Author: dmealing

server/typescript/packages/codegen-ts/src/generator.ts

@@ -1,6 +1,7 @@
 import type { MetaObject, MetaRoot } from "@metaobjectsdev/metadata";
 import type { RenderContext } from "./render-context.js";
 import type { ResolvedGenConfig } from "./metaobjects-config.js";
+import { effectivePackage } from "./docs-paths.js";
 
 export interface EmittedFile {
   /** Path relative to ResolvedGenConfig.outDir. */
@@ -107,7 +108,7 @@ export function perPackage(
     const matched = ctx.entities.filter(ctx.matches);
     const byPkg = new Map<string, MetaObject[]>();
     for (const e of matched) {
-      const pkg = e.package ?? "";
+      const pkg = effectivePackage(e) ?? "";
       let bucket = byPkg.get(pkg);
       if (bucket === undefined) { bucket = []; byPkg.set(pkg, bucket); }
       bucket.push(e);

server/typescript/packages/codegen-ts/src/template-codegen/template-spec.ts

@@ -1,11 +1,12 @@
 // The declarative JSON template-spec the CLI ports (C#/Python) consume, and TS
 // can spread into `generators`. The JSON shape is the cross-port contract
 // (SP-1 §4); a JSON Schema (template-spec.schema.json) sits beside it.
-import type { RenderFormat } from "@metaobjectsdev/render";
+import { ESCAPERS, type RenderFormat } from "@metaobjectsdev/render";
 import type { Generator } from "../generator.js";
 import { templateGenerator, type TemplateScope } from "../generators/template-generator.js";
 
 const SCOPES = ["perEntity", "perPackage", "perModel"] as const satisfies readonly TemplateScope[];
+const FORMATS = Object.keys(ESCAPERS) as readonly RenderFormat[];
 
 export interface TemplateSpecEntry {
   name: string;
@@ -45,7 +46,14 @@ export function parseTemplateSpec(json: unknown): TemplateSpecFile {
       scope: raw.scope as TemplateScope,
       outputPattern: raw.outputPattern as string,
     };
-    if (typeof raw.format === "string") entry.format = raw.format as RenderFormat;
+    if (raw.format !== undefined) {
+      if (typeof raw.format !== "string" || !FORMATS.includes(raw.format as RenderFormat)) {
+        throw new Error(
+          `template-spec generators[${i}]: format must be one of ${FORMATS.join(" | ")}, got '${String(raw.format)}'`,
+        );
+      }
+      entry.format = raw.format as RenderFormat;
+    }
     if (typeof raw.target === "string") entry.target = raw.target;
     return entry;
   });

server/typescript/packages/codegen-ts/test/template-codegen/scope-helpers.test.ts

@@ -27,9 +27,9 @@ describe("perPackage", () => {
       return { path: `${pkg || "_"}/out.txt`, content: `${ents.length}` } as EmittedFile;
     });
     const files = await gen(ctx);
-    const pkgs = [...new Set(ctx.entities.map((e) => e.package ?? ""))].sort();
-    expect(seen).toEqual(pkgs);
-    expect(files.length).toBe(pkgs.length);
+    expect(seen).toEqual(["demo"]);
+    expect(files.length).toBe(1);
+    expect(ctx.entities.every((e) => e.package == null)).toBe(true);
   });
 });
 

server/typescript/packages/codegen-ts/test/template-codegen/template-spec.test.ts

@@ -27,6 +27,19 @@ describe("parseTemplateSpec", () => {
   test("rejects a non-object", () => {
     expect(() => parseTemplateSpec(null)).toThrow();
   });
+  test("rejects an unknown format", () => {
+    expect(() => parseTemplateSpec({
+      generators: [{ name: "x", template: "t", scope: "perModel", outputPattern: "x", format: "xml-typo" }],
+    })).toThrow(/format/i);
+  });
+  test("accepts every schema-enumerated format", () => {
+    for (const fmt of ["text", "html", "xml", "csv", "json", "markdown", "spreadsheet"] as const) {
+      const spec = parseTemplateSpec({
+        generators: [{ name: "x", template: "t", scope: "perModel", outputPattern: "x", format: fmt }],
+      });
+      expect(spec.generators[0]!.format).toBe(fmt);
+    }
+  });
 });
 
 describe("templateSpecToGenerators", () => {
@@ -42,4 +55,13 @@ describe("schema ↔ parser drift", () => {
       .properties.generators.items.properties.scope.enum;
     expect(scopeEnum).toEqual(["perEntity", "perPackage", "perModel"]);
   });
+  test("schema enumerates the same formats the parser accepts", () => {
+    const formatEnum = (schema as { properties: { generators: { items: { properties: { format: { enum: string[] } } } } } })
+      .properties.generators.items.properties.format.enum;
+    for (const fmt of formatEnum) {
+      expect(() => parseTemplateSpec({
+        generators: [{ name: "x", template: "t", scope: "perModel", outputPattern: "x", format: fmt }],
+      })).not.toThrow();
+    }
+  });
 });