@metaobjectsdev/codegen-ts 0.9.0 → 0.11.0-rc.1

package/src/templates/queries.ts

@@ -5,13 +5,19 @@ import { code, imp, type Code } from "ts-poet";
 import type { MetaObject } from "@metaobjectsdev/metadata";
 import { IDENTITY_ATTR_FIELDS } from "@metaobjectsdev/metadata";
 import type { RenderContext } from "../render-context.js";
-import { variableNameFromEntity, pluralize } from "../naming.js";
+import {
+  findByIdFnName,
+  listFnName,
+  createFnName,
+  updateFnName,
+  deleteByIdFnName,
+} from "../naming.js";
 
 /** Get the PK field name and its TS type for a given entity. */
-function getPkInfo(entity: MetaObject, ctx: RenderContext): { fieldName: string; tsType: string } {
+export function getPkInfo(entity: MetaObject, ctx: RenderContext): { fieldName: string; tsType: string } {
   // Use primaryIdentity() to find the primary identity (may be inherited from extends:/super:).
   const primary = entity.primaryIdentity();
-  const rawFields = primary?.ownAttr(IDENTITY_ATTR_FIELDS);
+  const rawFields = primary?.attr(IDENTITY_ATTR_FIELDS);
   const fields = Array.isArray(rawFields) ? rawFields : (typeof rawFields === "string" ? [rawFields] : undefined);
   const pkFieldName = fields?.[0] ?? "id";
   const pkInfo = ctx.pkMap.get(entity.name);
@@ -26,11 +32,11 @@ function getPkInfo(entity: MetaObject, ctx: RenderContext): { fieldName: string;
 }
 
 export function renderFindByIdFn(entity: MetaObject, ctx: RenderContext): Code {
-  const varName = variableNameFromEntity(entity.name);
+  const varName = ctx.collectionName(entity.name);
   const entityName = entity.name;
   const singularVar = entityName.charAt(0).toLowerCase() + entityName.slice(1);
   const { fieldName: pkField, tsType: pkType } = getPkInfo(entity, ctx);
-  const fnName = `find${entityName}ById`;
+  const fnName = findByIdFnName(entityName);
   const eqSym = imp("eq@drizzle-orm");
 
   return code`
@@ -41,12 +47,12 @@ export async function ${fnName}(db: Db, ${pkField}: ${pkType}): Promise<${entity
 `;
 }
 
-export function renderListFn(entity: MetaObject, _ctx: RenderContext): Code {
-  const varName = variableNameFromEntity(entity.name);
+export function renderListFn(entity: MetaObject, ctx: RenderContext): Code {
+  const varName = ctx.collectionName(entity.name);
   const entityName = entity.name;
   // Pluralize the PascalCase entity name, preserving capitalization
   // (e.g., "Category" -> "Categories", not "Categorys").
-  const fnName = `list${pluralize(entityName)}`;
+  const fnName = listFnName(entityName);
 
   return code`
 export async function ${fnName}(db: Db, opts?: { limit?: number; offset?: number }): Promise<${entityName}[]> {
@@ -58,11 +64,11 @@ export async function ${fnName}(db: Db, opts?: { limit?: number; offset?: number
 `;
 }
 
-export function renderCreateFn(entity: MetaObject, _ctx: RenderContext): Code {
-  const varName = variableNameFromEntity(entity.name);
+export function renderCreateFn(entity: MetaObject, ctx: RenderContext): Code {
+  const varName = ctx.collectionName(entity.name);
   const entityName = entity.name;
   const singularVar = entityName.charAt(0).toLowerCase() + entityName.slice(1);
-  const fnName = `create${entityName}`;
+  const fnName = createFnName(entityName);
   const schemaName = `${entityName}InsertSchema`;
 
   return code`
@@ -75,11 +81,11 @@ export async function ${fnName}(db: Db, data: unknown): Promise<${entityName}> {
 }
 
 export function renderUpdateFn(entity: MetaObject, ctx: RenderContext): Code {
-  const varName = variableNameFromEntity(entity.name);
+  const varName = ctx.collectionName(entity.name);
   const entityName = entity.name;
   const singularVar = entityName.charAt(0).toLowerCase() + entityName.slice(1);
   const { fieldName: pkField, tsType: pkType } = getPkInfo(entity, ctx);
-  const fnName = `update${entityName}`;
+  const fnName = updateFnName(entityName);
   const schemaName = `${entityName}InsertSchema`;
   const eqSym = imp("eq@drizzle-orm");
 
@@ -93,10 +99,10 @@ export async function ${fnName}(db: Db, ${pkField}: ${pkType}, data: unknown): P
 }
 
 export function renderDeleteByIdFn(entity: MetaObject, ctx: RenderContext): Code {
-  const varName = variableNameFromEntity(entity.name);
+  const varName = ctx.collectionName(entity.name);
   const entityName = entity.name;
   const { fieldName: pkField, tsType: pkType } = getPkInfo(entity, ctx);
-  const fnName = `delete${entityName}ById`;
+  const fnName = deleteByIdFnName(entityName);
   const eqSym = imp("eq@drizzle-orm");
 
   return code`

package/src/templates/relations-block.ts

@@ -6,7 +6,6 @@ import type { MetaObject } from "@metaobjectsdev/metadata";
 import { CARDINALITY_ONE, CARDINALITY_MANY } from "@metaobjectsdev/metadata";
 import { type RenderContext } from "../render-context.js";
 import { crossEntitySpecifier } from "../import-path.js";
-import { variableNameFromEntity } from "../naming.js";
 import type { RelationEntry } from "../relation-resolver.js";
 
 /**
@@ -17,7 +16,7 @@ export function renderRelationsBlock(entity: MetaObject, ctx: RenderContext): Co
   const entries = ctx.relationMap.get(entity.name);
   if (!entries || entries.length === 0) return null;
 
-  const varName = variableNameFromEntity(entity.name);
+  const varName = ctx.collectionName(entity.name);
   const relationsFn = imp("relations@drizzle-orm");
   const relationsVarName = `${varName}Relations`;
 
@@ -46,6 +45,23 @@ function renderRelationEntry(
   thisVarName: string,
   thisEntityPackage: string | undefined,
 ): Code {
+  // FR-018 M:N: the source navigates through the junction table, so the Drizzle
+  // many() targets the JUNCTION, not the target entity (the relational query API
+  // then hops junction → target via the junction's one() sides). The
+  // mountM2mRoute the routes generator emits performs the flattened two-stage
+  // traversal for the REST contract.
+  if (entry.cardinality === CARDINALITY_MANY && entry.junctionEntity !== undefined) {
+    const junctionSpec = crossEntitySpecifier(
+      ctx.outputLayout,
+      thisEntityPackage,
+      ctx.packageOf.get(entry.junctionEntity),
+      entry.junctionEntity,
+      ctx.extStyle,
+    );
+    const junctionVarSym = imp(`${ctx.collectionName(entry.junctionEntity)}@${junctionSpec}`);
+    return code`  ${entry.name}: many(${junctionVarSym})`;
+  }
+
   // Use imp() for cross-entity references so ts-poet tracks and emits the import.
   const targetSpec = crossEntitySpecifier(
     ctx.outputLayout,
@@ -54,7 +70,7 @@ function renderRelationEntry(
     entry.targetEntity,
     ctx.extStyle,
   );
-  const targetVarSym = imp(`${variableNameFromEntity(entry.targetEntity)}@${targetSpec}`);
+  const targetVarSym = imp(`${ctx.collectionName(entry.targetEntity)}@${targetSpec}`);
 
   if (entry.cardinality === CARDINALITY_ONE) {
     const pkInfo = ctx.pkMap.get(entry.targetEntity);

package/src/templates/render-helper.ts

@@ -43,6 +43,7 @@ import {
   TEMPLATE_ATTR_SUBJECT_REF,
   TEMPLATE_ATTR_HTML_BODY_REF,
   TEMPLATE_ATTR_TEXT_BODY_REF,
+  refMatchesObject,
 } from "@metaobjectsdev/metadata";
 import {
   verify,
@@ -53,7 +54,7 @@ import {
 } from "@metaobjectsdev/render";
 
 function findObject(root: MetaData, name: string): MetaData | undefined {
-  return root.ownChildren().find((c) => c.type === TYPE_OBJECT && c.name === name);
+  return root.ownChildren().find((c) => c.type === TYPE_OBJECT && refMatchesObject(c, name));
 }
 
 function findTemplate(root: MetaData, name: string): MetaData | undefined {
@@ -80,7 +81,7 @@ function derivePayloadFieldTree(
   const fields: PayloadField[] = [];
   for (const f of vo.children().filter((c) => c.type === TYPE_FIELD)) {
     if (f.subType === FIELD_SUBTYPE_OBJECT) {
-      const ref = f.ownAttr(FIELD_ATTR_OBJECT_REF);
+      const ref = f.attr(FIELD_ATTR_OBJECT_REF);
       if (typeof ref === "string") {
         fields.push({ name: f.name, fields: derivePayloadFieldTree(root, ref, nextSeen) });
         continue;
@@ -192,7 +193,7 @@ export function renderRenderHelper(
 
     return `import { render } from "@metaobjectsdev/render";
 import type { Provider, EmailDocument } from "@metaobjectsdev/render";
-import type { ${payloadRef} } from "./payloads.js";
+import type { ${payloadRef} } from "./${payloadRef}.js";
 
 /**
  * Render the ${templateName} email (subject + html body${typeof textBodyRef === "string" ? " + text body" : ""}) from a
@@ -230,7 +231,7 @@ export function ${fnName}(payload: ${payloadRef}, provider: Provider): EmailDocu
 
   return `import { render } from "@metaobjectsdev/render";
 import type { Provider } from "@metaobjectsdev/render";
-import type { ${payloadRef} } from "./payloads.js";
+import type { ${payloadRef} } from "./${payloadRef}.js";
 
 /**
  * Render the ${templateName} document from a typed ${payloadRef} payload. Wraps the

package/src/templates/routes-file-hono.ts

@@ -29,7 +29,6 @@ import type { MetaObject } from "@metaobjectsdev/metadata";
 import { type RenderContext } from "../render-context.js";
 import { entityModuleSpecifier } from "../import-path.js";
 import { GENERATED_HEADER } from "../constants.js";
-import { variableNameFromEntity } from "../naming.js";
 import { isProjection } from "../projection/projection-detector.js";
 
 export function renderRoutesFileHono(entity: MetaObject, ctx: RenderContext): string {
@@ -97,7 +96,7 @@ export function ${handlerName}(app: ${HonoSym}<any, any, any>, deps: { db: unkno
   }
 
   // --- Vanilla / write-through entity path: full CRUD routes ---
-  const tableVar = variableNameFromEntity(entityName);
+  const tableVar = ctx.collectionName(entityName);
 
   const HonoSym = imp("t:Hono@hono");
   const mountCrudRoutesSym = imp("mountCrudRoutes@@metaobjectsdev/runtime-ts/hono");

package/src/templates/routes-file.ts

@@ -15,17 +15,31 @@
 // the existing queries-file template). The entity's Drizzle table const is
 // imported alongside the Zod schemas + constants from the sibling Entity.ts.
 
-import { code, imp } from "ts-poet";
+import { code, imp, joinCode, type Code } from "ts-poet";
 import type { MetaObject } from "@metaobjectsdev/metadata";
+import {
+  TYPE_FIELD,
+  resolveColumnName,
+} from "@metaobjectsdev/metadata";
 import { type RenderContext } from "../render-context.js";
-import { entityModuleSpecifier, relativeModuleSpecifier } from "../import-path.js";
+import { crossEntitySpecifier, entityModuleSpecifier, relativeModuleSpecifier } from "../import-path.js";
 import { GENERATED_HEADER } from "../constants.js";
-import { variableNameFromEntity } from "../naming.js";
+import { routesHandlerName } from "../naming.js";
 import { isProjection } from "../projection/projection-detector.js";
+import type { RelationEntry } from "../relation-resolver.js";
+import { isTphDiscriminatorBase, tphPlan } from "./tph-discriminator.js";
 
 export function renderRoutesFile(entity: MetaObject, ctx: RenderContext): string {
+  // FR-017 Tier 2 — a TPH discriminator base mounts polymorphic list/get at the
+  // base path plus a full per-subtype CRUD route set scoped to each
+  // discriminator value. (Subtype entities are filtered out of the routes
+  // generator entirely — their routes live here.)
+  if (isTphDiscriminatorBase(entity, ctx.loadedRoot)) {
+    return renderTphRoutesFile(entity, ctx);
+  }
+
   const entityName = entity.name;
-  const handlerName = `${entityName.charAt(0).toLowerCase()}${entityName.slice(1)}Routes`;
+  const handlerName = routesHandlerName(entityName);
   // Import the entity's own file. Same target → relative "./Entity"; cross
   // target → importBase-qualified package path.
   const entityFileSpec = entityModuleSpecifier(
@@ -108,11 +122,24 @@ export async function ${handlerName}(fastify: ${FastifyInstanceSym}) {
   }
 
   // --- Vanilla / write-through entity path: full CRUD routes ---
-  const tableVar = variableNameFromEntity(entityName);
+  const tableVar = ctx.collectionName(entityName);
 
   const FastifyInstanceSym = imp("t:FastifyInstance@fastify");
   const mountCrudRoutesSym = imp("mountCrudRoutes@@metaobjectsdev/runtime-ts/drizzle-fastify");
 
+  // FR-018 M:N traversal: for each many-to-many navigation declared on this
+  // entity, emit a mountM2mRoute(...) that traverses the junction. The junction
+  // FK columns were derived from the junction's identity.reference children (the
+  // SSOT) by the relation-resolver pre-pass; here we resolve them to physical
+  // column names for the Drizzle two-stage join.
+  const m2mEntries = (ctx.relationMap.get(entityName) ?? []).filter(
+    (e): e is RelationEntry & { junctionEntity: string } => e.junctionEntity !== undefined,
+  );
+  // Two fastify-scope variants: under an apiPrefix the mounts live inside the
+  // register-block (`instance`); otherwise they bind directly to `fastify`.
+  const m2mMountsPrefixed = renderM2mMounts(m2mEntries, entity, ctx, "instance");
+  const m2mMountsFlat = renderM2mMounts(m2mEntries, entity, ctx, "fastify");
+
   const literalImports = code`
 import { db } from ${JSON.stringify(dbImportSpec)};
 import {
@@ -148,7 +175,7 @@ export async function ${handlerName}(fastify: ${FastifyInstanceSym}) {
       sortAllowlist: ${entityName}SortAllowlist,
       dialect: ${JSON.stringify(ctx.dialect)},
     });
-  }, { prefix: ${JSON.stringify(ctx.apiPrefix)} });
+${m2mMountsPrefixed}  }, { prefix: ${JSON.stringify(ctx.apiPrefix)} });
 }
 `
     : code`
@@ -172,8 +199,208 @@ export async function ${handlerName}(fastify: ${FastifyInstanceSym}) {
     sortAllowlist: ${entityName}SortAllowlist,
     dialect: ${JSON.stringify(ctx.dialect)},
   });
-}
+${m2mMountsFlat}}
 `;
 
   return header + literalImports.toString() + body.toString();
 }
+
+/**
+ * Render the M:N traversal mounts for an entity as a single Code fragment to
+ * interpolate INTO the handler-body code template (so the junction/target table
+ * + mountM2mRoute imports hoist with the rest of the body's imports, not inline
+ * mid-function). `fastifyVar` is the in-scope Fastify reference (`instance`
+ * under an apiPrefix register-block, else `fastify`). Returns "" when the entity
+ * has no M:N relationships — CRUD-only output stays byte-identical to before.
+ */
+function renderM2mMounts(
+  entries: ReadonlyArray<RelationEntry & { junctionEntity: string }>,
+  source: MetaObject,
+  ctx: RenderContext,
+  fastifyVar: string,
+): Code | string {
+  if (entries.length === 0) return "";
+  const mounts = entries.map((e) => renderM2mMount(e, source, ctx, fastifyVar));
+  return code`${joinCode(mounts, { on: "\n", trim: false })}
+`;
+}
+
+/**
+ * Render one M:N traversal mount. The junction + target Drizzle table consts are
+ * imported from their sibling entity files (imp() lets ts-poet track + emit the
+ * import). The source/target FK columns + the target PK are resolved to PHYSICAL
+ * column names via resolveColumnName (the runtime two-stage join queries by
+ * column). mountM2mRoute appends `/:id/<relationName>` to the source $path.
+ */
+function renderM2mMount(
+  entry: RelationEntry & { junctionEntity: string },
+  source: MetaObject,
+  ctx: RenderContext,
+  fastifyVar: string,
+): Code {
+  const junctionVarSym = imp(
+    `${ctx.collectionName(entry.junctionEntity)}@${crossEntitySpecifier(
+      ctx.outputLayout,
+      source.package,
+      ctx.packageOf.get(entry.junctionEntity),
+      entry.junctionEntity,
+      ctx.extStyle,
+    )}`,
+  );
+  const targetVarSym = imp(
+    `${ctx.collectionName(entry.targetEntity)}@${crossEntitySpecifier(
+      ctx.outputLayout,
+      source.package,
+      ctx.packageOf.get(entry.targetEntity),
+      entry.targetEntity,
+      ctx.extStyle,
+    )}`,
+  );
+  const mountM2mRouteSym = imp("mountM2mRoute@@metaobjectsdev/runtime-ts/drizzle-fastify");
+  const junction = ctx.loadedRoot.findObject(entry.junctionEntity);
+  const target = ctx.loadedRoot.findObject(entry.targetEntity);
+  const sourceColumn = junction
+    ? resolveJunctionColumn(junction, entry.sourceJoinField!, ctx)
+    : entry.sourceJoinField!;
+  const targetColumn = junction
+    ? resolveJunctionColumn(junction, entry.targetJoinField!, ctx)
+    : entry.targetJoinField!;
+  const targetPkColumn = target
+    ? resolveJunctionColumn(target, ctx.pkMap.get(entry.targetEntity)?.fieldName ?? "id", ctx)
+    : "id";
+
+  return code`  ${mountM2mRouteSym}({
+    fastify: ${fastifyVar},
+    path: ${source.name}.$path,
+    relationName: ${JSON.stringify(entry.name)},
+    db,
+    junctionTable: ${junctionVarSym},
+    targetTable: ${targetVarSym},
+    sourceColumn: ${JSON.stringify(sourceColumn)},
+    targetColumn: ${JSON.stringify(targetColumn)},
+    targetPkColumn: ${JSON.stringify(targetPkColumn)},
+    symmetric: ${entry.symmetric ? "true" : "false"},
+  });`;
+}
+
+/** Resolve a field's physical column name on an entity (defaults if missing). */
+function resolveJunctionColumn(entity: MetaObject, fieldName: string, ctx: RenderContext): string {
+  const field = entity.ownChildren().find((c) => c.type === TYPE_FIELD && c.name === fieldName);
+  if (!field) return fieldName;
+  return resolveColumnName(field, ctx.columnNamingStrategy);
+}
+
+/**
+ * FR-017 Tier 2 — the routes file for a TPH discriminator base.
+ *
+ * Mounts a polymorphic list/get route set at the base path (`GET /auths`,
+ * `GET /auths/:id` — rows carry the discriminator by value), then a full
+ * per-subtype CRUD route set at `<basePath>/<discriminatorValue lowercased>`
+ * (`/auths/bridge`, ...). The per-subtype create body OMITS the discriminator
+ * (the URL names the subtype); the runtime helper injects it. The per-subtype
+ * route set is scoped to its discriminator value via the `discriminator` option
+ * (cross-subtype get/update/delete 404; update strips the discriminator).
+ *
+ * Subtype route segment defaults to the lowercased `@discriminatorValue`
+ * (`"Bridge"` → `bridge`) — a robust, value-derived path that matches the
+ * FR-017 design's `/auths/bridge` examples. Fastify resolves the static
+ * `/auths/bridge` ahead of the parametric `/auths/:id`, so the two coexist.
+ */
+function renderTphRoutesFile(base: MetaObject, ctx: RenderContext): string {
+  const baseName = base.name;
+  const handlerName = routesHandlerName(baseName);
+  // Single source of truth for the discriminator field + subtypes + route segments.
+  const plan = tphPlan(base, ctx.loadedRoot)!;
+  const discField = plan.discriminatorField;
+  const tableVar = ctx.collectionName(baseName);
+
+  const baseFileSpec = entityModuleSpecifier(
+    ctx.selfTarget, ctx.entityModuleTarget, base.package, baseName, ctx.extStyle,
+  );
+  const dbImportSpec = relativeModuleSpecifier(ctx.outputLayout, base.package, ctx.dbImport);
+
+  const FastifyInstanceSym = imp("t:FastifyInstance@fastify");
+  const mountCrudRoutesSym = imp("mountCrudRoutes@@metaobjectsdev/runtime-ts/drizzle-fastify");
+  const dbSym = imp(`db@${dbImportSpec}`);
+  const tableSym = imp(`${tableVar}@${baseFileSpec}`);
+  const baseConstSym = imp(`${baseName}@${baseFileSpec}`);
+  const baseInsertSym = imp(`${baseName}InsertSchema@${baseFileSpec}`);
+  const baseUpdateSym = imp(`${baseName}UpdateSchema@${baseFileSpec}`);
+  const baseFilterSym = imp(`${baseName}FilterAllowlist@${baseFileSpec}`);
+  const baseSortSym = imp(`${baseName}SortAllowlist@${baseFileSpec}`);
+
+  const fastifyRef = ctx.apiPrefix ? "instance" : "fastify";
+  const dialectLit = JSON.stringify(ctx.dialect);
+
+  const polymorphic = code`
+    ${mountCrudRoutesSym}({
+      fastify: ${fastifyRef},
+      path: ${baseConstSym}.$path,
+      db: ${dbSym},
+      table: ${tableSym},
+      insertSchema: ${baseInsertSym},
+      updateSchema: ${baseUpdateSym},
+      filterAllowlist: ${baseFilterSym},
+      sortAllowlist: ${baseSortSym},
+      dialect: ${dialectLit},
+      expose: ["list", "get"],
+    });`;
+
+  const subtypeMounts: Code[] = plan.subtypes.map(({ entity: sub, value, routeSegment: segment }) => {
+    const subFileSpec = entityModuleSpecifier(
+      ctx.selfTarget, ctx.entityModuleTarget, sub.package, sub.name, ctx.extStyle,
+    );
+    const subInsertSym = imp(`${sub.name}InsertSchema@${subFileSpec}`);
+    // FR-017 Tier 3: each subtype carries its OWN filter/sort allowlist
+    // (discriminator excluded — it's pinned by this path).
+    const subFilterSym = imp(`${sub.name}FilterAllowlist@${subFileSpec}`);
+    const subSortSym = imp(`${sub.name}SortAllowlist@${subFileSpec}`);
+    return code`
+    ${mountCrudRoutesSym}({
+      fastify: ${fastifyRef},
+      path: ${baseConstSym}.$path + ${JSON.stringify("/" + segment)},
+      db: ${dbSym},
+      table: ${tableSym},
+      insertSchema: ${subInsertSym}.omit({ ${discField}: true }),
+      updateSchema: ${subInsertSym}.omit({ ${discField}: true }).partial(),
+      filterAllowlist: ${subFilterSym},
+      sortAllowlist: ${subSortSym},
+      dialect: ${dialectLit},
+      discriminator: { column: ${JSON.stringify(discField)}, value: ${JSON.stringify(value)} },
+    });`;
+  });
+
+  const mounts = joinCode([polymorphic, ...subtypeMounts], { on: "\n" });
+
+  const fn = ctx.apiPrefix
+    ? code`
+/**
+ * Mount polymorphic + per-subtype REST endpoints for the ${baseName} TPH hierarchy.
+ *
+ * GET ${baseName}.$path (+ /:id) lists/gets the discriminated union; each
+ * /${baseName}.$path/<subtype> path is a full per-subtype CRUD set.
+ */
+export async function ${handlerName}(fastify: ${FastifyInstanceSym}) {
+  await fastify.register(async (instance) => {
+${mounts}
+  }, { prefix: ${JSON.stringify(ctx.apiPrefix)} });
+}
+`
+    : code`
+/**
+ * Mount polymorphic + per-subtype REST endpoints for the ${baseName} TPH hierarchy.
+ *
+ * GET ${baseName}.$path (+ /:id) lists/gets the discriminated union; each
+ * /${baseName}.$path/<subtype> path is a full per-subtype CRUD set.
+ */
+export async function ${handlerName}(fastify: ${FastifyInstanceSym}) {
+${mounts}
+}
+`;
+
+  const header =
+    `// ${GENERATED_HEADER} — DO NOT EDIT.\n` +
+    `// Source metadata: ${baseName} (${base.fqn()}) — TPH discriminator base\n` +
+    `// Customize via ${baseName}.extra.ts in this directory (e.g., auth, additional handlers).\n`;
+  return header + fn.toString();
+}