feat(codegen-ts): neutral structural template data-dict builder

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LuZWKnWzYGVnESijL7uuky

Author: dmealing

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

@@ -0,0 +1,79 @@
+// The NEUTRAL, structural codegen template data dict (SP-1 §3.2). Distinct from
+// the Markdown-flavored EntityDocData — this carries raw structural facts only,
+// so a consumer's Mustache template can emit any language's code from it. The
+// field names here are a byte-gated cross-port contract; change them only via the
+// spec (and the conformance corpus).
+import type { MetaObject, MetaRoot, MetaField } from "@metaobjectsdev/metadata";
+import { FIELD_ATTR_VALUES, FIELD_SUBTYPE_ENUM } from "@metaobjectsdev/metadata";
+
+export interface FieldTemplateData {
+  name: string;
+  /** Neutral field subtype, e.g. "string" | "int" | "currency" | "enum".
+   *  Arrayness is carried by `isArray`, NOT appended here. */
+  type: string;
+  required: boolean;
+  isArray: boolean;
+  maxLength?: number;
+  enumValues?: string[];
+}
+export interface IdentityTemplateData { kind: string; fields: string[]; }
+export interface RelationshipTemplateData { name: string; cardinality: string; targetRef: string; }
+export interface EntityTemplateData {
+  name: string;
+  package: string;
+  fields: FieldTemplateData[];
+  identities: IdentityTemplateData[];
+  relationships: RelationshipTemplateData[];
+}
+export interface PackageTemplateData { package: string; entities: EntityTemplateData[]; }
+export interface ModelTemplateData { packages: PackageTemplateData[]; }
+
+function fieldData(field: MetaField): FieldTemplateData {
+  const d: FieldTemplateData = {
+    name: field.name,
+    type: field.subType,
+    required: field.isRequired,
+    isArray: field.isArray === true,
+  };
+  if (typeof field.maxLength === "number") d.maxLength = field.maxLength;
+  if (field.subType === FIELD_SUBTYPE_ENUM) {
+    const vals = field.attr(FIELD_ATTR_VALUES);
+    if (Array.isArray(vals)) d.enumValues = vals.map((v) => String(v));
+  }
+  return d;
+}
+
+export function buildEntityTemplateData(entity: MetaObject): EntityTemplateData {
+  return {
+    name: entity.name,
+    package: entity.package ?? "",
+    fields: entity.fields().map(fieldData),
+    identities: entity.identities().map((i) => ({ kind: i.subType, fields: [...i.fields] })),
+    relationships: entity.relationships().map((r) => ({
+      name: r.name,
+      cardinality: r.cardinality ?? "",
+      targetRef: r.objectRef ?? "",
+    })),
+  };
+}
+
+export function buildPackageTemplateData(pkg: string, entities: MetaObject[]): PackageTemplateData {
+  return { package: pkg, entities: entities.map(buildEntityTemplateData) };
+}
+
+/** Groups concrete (non-abstract) objects by package — packages ascending,
+ *  entities in `root.objects()` order. Abstract objects never emit instance
+ *  artifacts, so they are excluded. */
+export function buildModelTemplateData(root: MetaRoot): ModelTemplateData {
+  const concrete = root.objects().filter((o) => o.isAbstract !== true);
+  const byPkg = new Map<string, MetaObject[]>();
+  for (const o of concrete) {
+    const pkg = o.package ?? "";
+    let bucket = byPkg.get(pkg);
+    if (bucket === undefined) { bucket = []; byPkg.set(pkg, bucket); }
+    bucket.push(o);
+  }
+  return {
+    packages: [...byPkg.keys()].sort().map((pkg) => buildPackageTemplateData(pkg, byPkg.get(pkg)!)),
+  };
+}

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

@@ -0,0 +1,49 @@
+import { describe, test, expect } from "bun:test";
+import { buildEntityTemplateData, buildModelTemplateData } from "../../src/template-codegen/template-data.js";
+import { MetaDataLoader } from "@metaobjectsdev/metadata";
+import { FileSource } from "@metaobjectsdev/metadata/core";
+import { resolve } from "node:path";
+
+async function load(path: string) {
+  const loader = new MetaDataLoader();
+  const res = await loader.load([new FileSource(path)]);
+  expect(res.errors).toEqual([]);
+  return res.root;
+}
+
+describe("buildEntityTemplateData", () => {
+  test("emits neutral structural fields (subtype, required, isArray)", async () => {
+    const root = await load(resolve(import.meta.dir, "../fixtures/single-entity.json"));
+    const entity = root.objects()[0]!;
+    const data = buildEntityTemplateData(entity);
+    expect(data.name).toBe(entity.name);
+    expect(data.package).toBe(entity.package ?? "");
+    expect(Array.isArray(data.fields)).toBe(true);
+    for (const f of data.fields) {
+      expect(typeof f.type).toBe("string");
+      expect(f.type).not.toContain("[]");           // isArray carries arrayness
+      expect(typeof f.required).toBe("boolean");
+      expect(typeof f.isArray).toBe("boolean");
+    }
+    // the `title` field carries @required + @maxLength=200 in the fixture
+    const title = data.fields.find((f) => f.name === "title");
+    expect(title?.required).toBe(true);
+    expect(title?.maxLength).toBe(200);
+    for (const id of data.identities) {
+      expect(typeof id.kind).toBe("string");
+      expect(Array.isArray(id.fields)).toBe(true);
+    }
+  });
+});
+
+describe("buildModelTemplateData", () => {
+  test("groups by package ascending; abstracts excluded", async () => {
+    const root = await load(resolve(import.meta.dir, "../fixtures/single-entity.json"));
+    const model = buildModelTemplateData(root);
+    const pkgs = model.packages.map((p) => p.package);
+    expect(pkgs).toEqual([...pkgs].sort());
+    const names = model.packages.flatMap((p) => p.entities.map((e) => e.name)).sort();
+    const concrete = root.objects().filter((o) => o.isAbstract !== true).map((o) => o.name).sort();
+    expect(names).toEqual(concrete);
+  });
+});