@metaobjectsdev/codegen-ts 1.0.5-rc.1 → 1.0.5-rc.2

package/src/templates/drizzle-schema.ts

@@ -25,7 +25,8 @@ import { resolveTableSchema } from "@metaobjectsdev/metadata";
 import { renderEnumIntCustomType } from "./enum-int-codec.js";
 import { renderRelationsBlock } from "./relations-block.js";
 import { renderDocsFor } from "./jsdoc.js";
-import { collectTphSubtypeFields } from "./tph-discriminator.js";
+import { collectTphSubtypeFields, tphConcreteSubtypes } from "./tph-discriminator.js";
+import { tphStorageObject } from "./zod-validators.js";
 import { effectivePackage } from "../docs-paths.js";
 
 /**
@@ -411,7 +412,19 @@ interface FkInfo {
 /** Pre-pass: map fkFieldName → FkInfo for this entity's effective (own + inherited) identity.reference children. */
 function buildFkMapForEntity(obj: MetaObject, ctx: RenderContext): Map<string, FkInfo> {
   const result = new Map<string, FkInfo>();
-  for (const ref of obj.referenceIdentities()) {
+  // FR-017 TPH: a discriminator base's table carries every concrete subtype's folded
+  // columns (collectTphSubtypeFields), so it carries their FKs too — otherwise a reference
+  // declared on a subtype, or on an abstract level between it and the base, lands as a
+  // plain column. Same effective, not-already-on-the-base rule as the column fold.
+  // A copy: referenceIdentities() is the node's cached array, and loaded metadata is read-only.
+  const refs = [...obj.referenceIdentities()];
+  const baseRefNames = new Set(refs.map((r) => r.name));
+  for (const sub of tphConcreteSubtypes(obj, ctx.loadedRoot)) {
+    for (const ref of sub.referenceIdentities()) {
+      if (!baseRefNames.has(ref.name)) refs.push(ref);
+    }
+  }
+  for (const ref of refs) {
     // @enforce: false → logical-only reference. Skip the .references() emission;
     // the column stays plain. Drizzle's relations() block (driven by
     // relation-resolver) still includes the relationship for query navigation.
@@ -419,6 +432,8 @@ function buildFkMapForEntity(obj: MetaObject, ctx: RenderContext): Map<string, F
     const fkFieldNames = ref.fields;
     if (fkFieldNames.length === 0) continue;
     const fkField = fkFieldNames[0]!;
+    // Two subtypes declaring the same reference fold to one column with one FK.
+    if (result.has(fkField)) continue;
     const targetName = ref.targetEntity;
     if (!targetName) continue;
     // @references may be authored bare OR package-qualified, and the loader can
@@ -427,10 +442,12 @@ function buildFkMapForEntity(obj: MetaObject, ctx: RenderContext): Map<string, F
     // relation-resolver, which already does this.
     const targetObj = ctx.loadedRoot.findObject(stripPackage(targetName));
     if (!targetObj) continue;
+    // A TPH subtype has no table const of its own; its rows live in the base's table.
+    const storage = tphStorageObject(targetObj);
     const targetPkField = ref.resolvedTargetPkField(ctx.loadedRoot) ?? "id";
     result.set(fkField, {
-      targetVarName: ctx.collectionName(targetObj.name),
-      targetEntityName: targetObj.name,
+      targetVarName: ctx.collectionName(storage.name),
+      targetEntityName: storage.name,
       targetPkField,
     });
   }

package/src/templates/relations-block.ts

@@ -8,6 +8,7 @@ import { type RenderContext } from "../render-context.js";
 import { crossEntitySpecifier } from "../import-path.js";
 import type { RelationEntry } from "../relation-resolver.js";
 import { effectivePackage } from "../docs-paths.js";
+import { tphStorageName } from "./zod-validators.js";
 
 /**
  * Render the relations() block for one entity.
@@ -31,7 +32,7 @@ export function renderRelationsBlock(entity: MetaObject, ctx: RenderContext): Co
 
   const thisEntityPackage = effectivePackage(entity);
   const lines: Code[] = entries.map((entry) =>
-    renderRelationEntry(entry, ctx, varName, thisEntityPackage),
+    renderRelationEntry(entry, ctx, entity.name, varName, thisEntityPackage),
   );
 
   return code`export const ${relationsVarName} = ${relationsFn}(${varName}, (${params}) => ({
@@ -43,6 +44,7 @@ ${joinCode(lines, { on: ",\n", trim: false })}
 function renderRelationEntry(
   entry: RelationEntry,
   ctx: RenderContext,
+  thisEntityName: string,
   thisVarName: string,
   thisEntityPackage: string | undefined,
 ): Code {
@@ -63,18 +65,24 @@ function renderRelationEntry(
     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,
-    thisEntityPackage,
-    ctx.packageOf.get(entry.targetEntity),
-    entry.targetEntity,
-    ctx.extStyle,
-  );
-  const targetVarSym = imp(`${ctx.collectionName(entry.targetEntity)}@${targetSpec}`);
+  // Bind to the table that stores the target's rows: a TPH subtype's module has no
+  // table const, so a navigation onto `Carrier` binds `parties` from `Party`.
+  const targetTableEntity = tphStorageName(entry.targetEntity, ctx.loadedRoot);
+  // A navigation onto this entity's OWN table (`Order.parent`, or a TPH base onto one of
+  // its subtypes) names the local const: importing it from this very module clashes with
+  // its declaration (TS2440). Otherwise imp() tracks and emits the cross-entity import.
+  const targetVarSym = targetTableEntity === thisEntityName
+    ? thisVarName
+    : imp(`${ctx.collectionName(targetTableEntity)}@${crossEntitySpecifier(
+      ctx.outputLayout,
+      thisEntityPackage,
+      ctx.packageOf.get(targetTableEntity),
+      targetTableEntity,
+      ctx.extStyle,
+    )}`);
 
   if (entry.cardinality === CARDINALITY_ONE) {
-    const pkInfo = ctx.pkMap.get(entry.targetEntity);
+    const pkInfo = ctx.pkMap.get(targetTableEntity);
     const targetPkField = pkInfo?.fieldName ?? "id";
     return code`  ${entry.name}: one(${targetVarSym}, { fields: [${thisVarName}.${entry.fkField ?? "id"}], references: [${targetVarSym}.${targetPkField}] })`;
   }

package/src/templates/routes-file.ts

@@ -31,6 +31,7 @@ import type { RelationEntry } from "../relation-resolver.js";
 import { isTphDiscriminatorBase, tphPlan } from "./tph-discriminator.js";
 import { authSeamJsDoc, type CrudVerb, exposeLine, intersectExpose, TPH_POLYMORPHIC_VERBS } from "../routes-expose.js";
 import { effectivePackage } from "../docs-paths.js";
+import { tphDiscriminatorPin, tphStorageObject } from "./zod-validators.js";
 
 export function renderRoutesFile(
   entity: MetaObject,
@@ -288,18 +289,30 @@ function renderM2mMount(
       ctx.extStyle,
     )}`,
   );
-  const targetVarSym = imp(
-    `${ctx.collectionName(entry.targetEntity)}@${crossEntitySpecifier(
-      ctx.outputLayout,
-      sourcePkg,
-      ctx.packageOf.get(entry.targetEntity),
-      entry.targetEntity,
-      ctx.extStyle,
-    )}`,
-  );
+  // An M:N onto a TPH subtype traverses into its discriminator BASE's table — the
+  // subtype has no table const, and the junction FK can only point at the base table —
+  // and filters the rows to the subtype, because a Broker id in that FK column is not a
+  // Carrier. Every other target binds to itself, and emits no filter.
+  const declaredTarget = ctx.loadedRoot.findObject(entry.targetEntity);
+  const target = declaredTarget === undefined ? undefined : tphStorageObject(declaredTarget);
+  const targetTableEntity = target?.name ?? entry.targetEntity;
+  const pin = declaredTarget === undefined ? undefined : tphDiscriminatorPin(declaredTarget);
+  // A self-join's target table IS the source table, which this file already imports from
+  // the entity module; a second import of the same binding is TS2300, and a SyntaxError
+  // when Node loads the module.
+  const targetVarSym = targetTableEntity === source.name
+    ? ctx.collectionName(source.name)
+    : imp(
+      `${ctx.collectionName(targetTableEntity)}@${crossEntitySpecifier(
+        ctx.outputLayout,
+        sourcePkg,
+        ctx.packageOf.get(targetTableEntity),
+        targetTableEntity,
+        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);
   // fromPackage = source.package: this routes file is SOURCE's own module, never the
   // junction's or the target's — see resolveJunctionColumn's doc comment (B1).
   const sourceColumn: Code = junction
@@ -309,8 +322,12 @@ function renderM2mMount(
     ? resolveJunctionColumn(junction, entry.targetJoinField!, ctx, sourcePkg)
     : code`${JSON.stringify(entry.targetJoinField!)}`;
   const targetPkColumn: Code = target
-    ? resolveJunctionColumn(target, ctx.pkMap.get(entry.targetEntity)?.fieldName ?? "id", ctx, sourcePkg)
+    ? resolveJunctionColumn(target, ctx.pkMap.get(targetTableEntity)?.fieldName ?? "id", ctx, sourcePkg)
     : code`${JSON.stringify("id")}`;
+  const discriminatorLine: Code | string = pin !== undefined && target !== undefined
+    ? code`
+    targetDiscriminator: { column: ${resolveJunctionColumn(target, pin.fieldName, ctx, sourcePkg)}, value: ${JSON.stringify(pin.value)} },`
+    : "";
 
   return code`  ${mountM2mRouteSym}({
     fastify: ${fastifyVar},
@@ -322,7 +339,7 @@ function renderM2mMount(
     sourceColumn: ${sourceColumn},
     targetColumn: ${targetColumn},
     targetPkColumn: ${targetPkColumn},
-    symmetric: ${entry.symmetric ? "true" : "false"},
+    symmetric: ${entry.symmetric ? "true" : "false"},${discriminatorLine}
   });`;
 }
 

package/src/templates/zod-validators.ts

@@ -10,7 +10,7 @@
 // downstream (e.g. to LLM tool_use input_schema) lost the nested object shape.
 
 import { code, joinCode, imp, type Code } from "ts-poet";
-import { MetaObject, MetaField, stripPackage } from "@metaobjectsdev/metadata";
+import { MetaObject, MetaField, type MetaRoot, stripPackage } from "@metaobjectsdev/metadata";
 import {
   FIELD_SUBTYPE_STRING, FIELD_SUBTYPE_INT, FIELD_SUBTYPE_LONG, FIELD_SUBTYPE_CURRENCY,
   FIELD_SUBTYPE_BOOLEAN, FIELD_SUBTYPE_DOUBLE, FIELD_SUBTYPE_FLOAT,
@@ -75,6 +75,28 @@ export function tphDiscriminatorBase(obj: MetaObject): MetaObject | undefined {
   return tphDiscriminatorLevel(obj)?.base;
 }
 
+/**
+ * The object whose TABLE stores `obj`'s rows: the discriminator base for anything beneath
+ * a TPH base — a concrete subtype or an abstract level in between — otherwise `obj`.
+ *
+ * Neither a subtype's module nor an abstract level's emits a table const, so anything
+ * that binds to "the other side" of a reference or relationship — an FK's `.references()`,
+ * a `relations()` entry, an M:N traversal's target table — must bind here and never to the
+ * target's own name. Binding to the subtype imported `carriers` from a `Carrier.ts` that
+ * does not export it.
+ */
+export function tphStorageObject(obj: MetaObject): MetaObject {
+  if (declaresTphDiscriminator(obj)) return obj;
+  return tphDiscriminatorBase(obj) ?? obj;
+}
+
+/** {@link tphStorageObject} by entity name, for the name-keyed relation map. A name the
+ *  root does not resolve is returned unchanged. */
+export function tphStorageName(entityName: string, root: MetaRoot): string {
+  const obj = root.findObject(entityName);
+  return obj === undefined ? entityName : tphStorageObject(obj).name;
+}
+
 /**
  * True when this object itself DECLARES `@discriminator` — the level of a TPH hierarchy
  * that owns the discriminator, whether or not any concrete subtype extends it yet.