TML-3037: contract infer output round-trips through contract emit

packages/2-sql/1-core/schema-ir/test/sql-column-ir.test.ts

@@ -167,4 +167,25 @@ describe('SqlColumnIR', () => {
       expect(column.resolvedDefault).toEqual({ kind: 'literal', value: 'x' });
     });
   });
+
+  describe('identity columns (introspected, no raw default)', () => {
+    it('yields a default child node from resolvedDefault alone, with no raw default', () => {
+      // A `GENERATED ... AS IDENTITY` column has no `column_default` at
+      // all — the postgres control adapter sets `resolvedDefault` directly
+      // to `autoincrement()` without a raw expression to parse, so
+      // `children()` must still produce a default node without a `default`
+      // (raw) field.
+      const column = new SqlColumnIR({
+        name: 'id',
+        nativeType: 'int4',
+        nullable: false,
+        resolvedDefault: { kind: 'function', expression: 'autoincrement()' },
+      });
+      expect(column.children()).toEqual([
+        new SqlColumnDefaultIR({
+          resolved: { kind: 'function', expression: 'autoincrement()' },
+        }),
+      ]);
+    });
+  });
 });

packages/2-sql/2-authoring/contract-psl/src/interpreter.ts

@@ -79,7 +79,7 @@ import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 
-import { getAttribute, mapFieldNamesToColumns } from './psl-attribute-parsing';
+import { getAttribute, getNamedArgument, mapFieldNamesToColumns } from './psl-attribute-parsing';
 import type { ColumnDescriptor } from './psl-column-resolution';
 import {
   checkUncomposedNamespace,
@@ -103,7 +103,7 @@ import {
   interpretRelationAttribute,
   type ModelBackrelationCandidate,
   normalizeReferentialAction,
-  validateNavigationListFieldAttributes,
+  validateBackrelationFieldAttributes,
 } from './psl-relation-resolution';
 import {
   baseModelSpec,
@@ -668,6 +668,21 @@ interface BuildModelNodeResult {
   readonly modelAttributeEntities: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
 }
 
+/**
+ * The owning side of a relation is the one that declares `fields`/`references` on its
+ * `@relation` attribute — those name the FK columns. A singular model-typed field whose
+ * `@relation` carries only a name (or nothing at all) is the back side: infer prints exactly
+ * that shape for a 1:1 back-relation whenever the FK needs disambiguating (two FKs between the
+ * same table pair, or a self-referencing unique FK). Checking for the attribute's mere presence
+ * would misclassify that back side as the owning side.
+ */
+function relationAttributeDeclaresOwningSide(relationAttribute: ResolvedAttribute): boolean {
+  return (
+    getNamedArgument(relationAttribute, 'fields') !== undefined ||
+    getNamedArgument(relationAttribute, 'references') !== undefined
+  );
+}
+
 function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult {
   const { model, mapping, sourceId, diagnostics } = input;
   const tableName = mapping.tableName;
@@ -726,10 +741,20 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
 
   const resultBackrelationCandidates: ModelBackrelationCandidate[] = [];
   for (const field of Object.values(model.fields)) {
-    if (!field.list || !input.modelNames.has(field.typeName)) {
+    if (!input.modelNames.has(field.typeName)) {
+      continue;
+    }
+    const relationAttribute = getAttribute(field.attributes, 'relation');
+    if (
+      !field.list &&
+      relationAttribute &&
+      relationAttributeDeclaresOwningSide(relationAttribute)
+    ) {
+      // The owning side of the relation: it declares fields/references and is
+      // lowered separately below, by the `relationAttributes` FK-building loop.
       continue;
     }
-    const attributesValid = validateNavigationListFieldAttributes({
+    const attributesValid = validateBackrelationFieldAttributes({
       modelName: model.name,
       field,
       sourceId,
@@ -739,7 +764,6 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
       familyId: input.familyId,
       targetId: input.targetId,
     });
-    const relationAttribute = getAttribute(field.attributes, 'relation');
     let relationName: string | undefined;
     if (relationAttribute) {
       const parsedRelation = interpretRelationAttribute({
@@ -786,6 +810,7 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
       tableName,
       field,
       targetModelName: field.typeName,
+      isList: field.list,
       ...ifDefined('relationName', relationName),
     });
   }
@@ -1095,6 +1120,13 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
       continue;
     }
 
+    if (!relationAttributeDeclaresOwningSide(relationAttribute.relation)) {
+      // A singular model-typed field whose `@relation` carries only a name (or nothing) is the
+      // back side of a 1:1 relation, already lowered above via backrelationCandidates. It is
+      // not the owning side, so it has no fields/references to validate here.
+      continue;
+    }
+
     // Cross-contract-space relation: the target model lives in a different contract space
     // identified by `typeContractSpaceId` (e.g. `supabase:auth.User`).
     if (fieldTypeContractSpaceId !== undefined) {

packages/2-sql/2-authoring/contract-psl/src/psl-column-resolution.ts

@@ -697,7 +697,11 @@ export function resolveFieldTypeDescriptor(input: {
  * Declarative specification for @db.* native type attributes.
  *
  * Argument kinds:
- * - `noArgs`: No arguments accepted; `codecId: null` means inherit from baseDescriptor.
+ * - `noArgs`: No arguments accepted; `codecId: null` means resolve at runtime
+ *   from the target-contributed `scalarTypeDescriptors` map keyed by the
+ *   attribute's own name (e.g. `"db.Date"`), falling back to `baseDescriptor`
+ *   (the base PSL type's own codec) when the target contributes nothing
+ *   under that key — see `resolveDbNativeTypeAttribute`.
  * - `optionalLength`: Zero or one positional integer (minimum 1), stored as `{ length }`.
  * - `optionalPrecision`: Zero or one positional integer (minimum 0), stored as `{ precision }`.
  * - `optionalNumeric`: Zero, one, or two positional integers (precision + scale).
@@ -783,6 +787,18 @@ export function resolveDbNativeTypeAttribute(input: {
   readonly attribute: ResolvedAttribute;
   readonly baseType: string;
   readonly baseDescriptor: ColumnDescriptor;
+  /**
+   * Target-contributed descriptor lookup, keyed by PSL scalar type name
+   * (e.g. `"DateTime"`) everywhere else it's used — but also consulted here
+   * by the full `@db.*` attribute name (e.g. `"db.Date"`) as a `noArgs`
+   * spec's codec-id source. A `noArgs` spec with `codecId: null` can't
+   * simply inherit the base type's own descriptor (that's `baseDescriptor`,
+   * already the wrong codec for e.g. `@db.Date` vs its `DateTime` base); the
+   * target contributes the attribute-specific codec id under its own key in
+   * the same map instead, keeping this family module free of any target's
+   * concrete codec id.
+   */
+  readonly scalarTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>;
   readonly diagnostics: ContractSourceDiagnostic[];
   readonly sourceId: string;
   readonly entityLabel: string;
@@ -818,7 +834,10 @@ export function resolveDbNativeTypeAttribute(input: {
         });
       }
       return {
-        codecId: spec.codecId ?? input.baseDescriptor.codecId,
+        codecId:
+          spec.codecId ??
+          input.scalarTypeDescriptors.get(input.attribute.name)?.codecId ??
+          input.baseDescriptor.codecId,
         nativeType: spec.nativeType,
       };
     }

packages/2-sql/2-authoring/contract-psl/src/psl-field-resolution.ts

@@ -347,6 +347,13 @@ export function collectResolvedFields(input: CollectResolvedFieldsInput): Resolv
     if (field.typeContractSpaceId !== undefined && relationAttribute) {
       continue;
     }
+    // A model-typed, non-list field with no `@relation` is the back side of a
+    // 1:1 relation — the owning side always carries `@relation(fields: [...],
+    // references: [...])`. It is lowered separately, via the interpreter's
+    // backrelation-candidate matching, not as a scalar column here.
+    if (isModelField) {
+      continue;
+    }
 
     const isValueObjectField = compositeTypeNames.has(field.typeName);
     const isListField = field.list;

packages/2-sql/2-authoring/contract-psl/src/psl-named-type-resolution.ts

@@ -210,6 +210,7 @@ export function resolveNamedTypeDeclarations(input: ResolveNamedTypeDeclarations
         attribute: dbNativeTypeAttribute,
         baseType,
         baseDescriptor,
+        scalarTypeDescriptors: input.scalarTypeDescriptors,
         diagnostics: input.diagnostics,
         sourceId: input.sourceId,
         entityLabel: `Named type "${declaration.name}"`,

packages/2-sql/2-authoring/contract-psl/src/psl-relation-resolution.ts

@@ -62,6 +62,8 @@ export type ModelBackrelationCandidate = {
   readonly tableName: string;
   readonly field: FieldSymbol;
   readonly targetModelName: string;
+  /** Whether the PSL field itself is list-typed (`Target[]`) rather than singular (`Target?`). A singular candidate is the back side of a 1:1 relation and can never be many-to-many. */
+  readonly isList: boolean;
   readonly relationName?: string;
 };
 
@@ -453,35 +455,39 @@ export function applyBackrelationCandidates(input: {
       : [...pairMatches];
 
     if (matches.length === 0) {
-      const { pairs: junctionPairs, nearMisses } = findJunctionFkPairs({
-        candidate,
-        fkRelationsByDeclaringModel: input.fkRelationsByDeclaringModel,
-        modelIdColumns: input.modelIdColumns,
-      });
-      const junctionPair = junctionPairs[0];
-      if (junctionPairs.length === 1 && junctionPair) {
-        relationsForModel(input.modelRelations, candidate.modelName).push(
-          manyToManyRelationNode(candidate, junctionPair),
-        );
-        continue;
-      }
-      if (junctionPairs.length > 1) {
-        input.diagnostics.push({
-          code: 'PSL_AMBIGUOUS_BACKRELATION_LIST',
-          message: `Backrelation list field "${candidate.modelName}.${candidate.field.name}" matches multiple junction FK pairs for a many-to-many relation. Add @relation(name: "...") (or @relation("...")) to the list field and the junction FK-side relation pointing back at "${candidate.modelName}" to disambiguate.`,
-          sourceId: input.sourceId,
-          span: candidate.field.span,
+      // A singular candidate is the back side of a 1:1 — many-to-many junction
+      // matching only makes sense for a list-typed backrelation.
+      if (candidate.isList) {
+        const { pairs: junctionPairs, nearMisses } = findJunctionFkPairs({
+          candidate,
+          fkRelationsByDeclaringModel: input.fkRelationsByDeclaringModel,
+          modelIdColumns: input.modelIdColumns,
         });
-        continue;
-      }
-      const nearMiss = nearMisses[0];
-      if (nearMiss) {
-        input.diagnostics.push(junctionNearMissDiagnostic(candidate, nearMiss, input.sourceId));
-        continue;
+        const junctionPair = junctionPairs[0];
+        if (junctionPairs.length === 1 && junctionPair) {
+          relationsForModel(input.modelRelations, candidate.modelName).push(
+            manyToManyRelationNode(candidate, junctionPair),
+          );
+          continue;
+        }
+        if (junctionPairs.length > 1) {
+          input.diagnostics.push({
+            code: 'PSL_AMBIGUOUS_BACKRELATION_LIST',
+            message: `Backrelation list field "${candidate.modelName}.${candidate.field.name}" matches multiple junction FK pairs for a many-to-many relation. Add @relation(name: "...") (or @relation("...")) to the list field and the junction FK-side relation pointing back at "${candidate.modelName}" to disambiguate.`,
+            sourceId: input.sourceId,
+            span: candidate.field.span,
+          });
+          continue;
+        }
+        const nearMiss = nearMisses[0];
+        if (nearMiss) {
+          input.diagnostics.push(junctionNearMissDiagnostic(candidate, nearMiss, input.sourceId));
+          continue;
+        }
       }
       input.diagnostics.push({
         code: 'PSL_ORPHANED_BACKRELATION_LIST',
-        message: `Backrelation list field "${candidate.modelName}.${candidate.field.name}" has no matching FK-side relation on model "${candidate.targetModelName}". Add @relation(fields: [...], references: [...]) on the FK-side relation or use an explicit join model for many-to-many.`,
+        message: `Backrelation field "${candidate.modelName}.${candidate.field.name}" has no matching FK-side relation on model "${candidate.targetModelName}". Add @relation(fields: [...], references: [...]) on the FK-side relation${candidate.isList ? ' or use an explicit join model for many-to-many' : ''}.`,
         sourceId: input.sourceId,
         span: candidate.field.span,
       });
@@ -490,7 +496,7 @@ export function applyBackrelationCandidates(input: {
     if (matches.length > 1) {
       input.diagnostics.push({
         code: 'PSL_AMBIGUOUS_BACKRELATION_LIST',
-        message: `Backrelation list field "${candidate.modelName}.${candidate.field.name}" matches multiple FK-side relations on model "${candidate.targetModelName}". Add @relation(name: "...") (or @relation("...")) to both sides to disambiguate.`,
+        message: `Backrelation field "${candidate.modelName}.${candidate.field.name}" matches multiple FK-side relations on model "${candidate.targetModelName}". Add @relation(name: "...") (or @relation("...")) to both sides to disambiguate.`,
         sourceId: input.sourceId,
         span: candidate.field.span,
       });
@@ -506,7 +512,7 @@ export function applyBackrelationCandidates(input: {
       toModel: matched.declaringModelName,
       toTable: matched.declaringTableName,
       ...ifDefined('toNamespaceId', matched.declaringNamespaceId),
-      cardinality: '1:N',
+      cardinality: candidate.isList ? '1:N' : '1:1',
       on: {
         parentTable: candidate.tableName,
         parentColumns: matched.referencedColumns,
@@ -517,7 +523,7 @@ export function applyBackrelationCandidates(input: {
   }
 }
 
-export function validateNavigationListFieldAttributes(input: {
+export function validateBackrelationFieldAttributes(input: {
   readonly modelName: string;
   readonly field: FieldSymbol;
   readonly sourceId: string;

packages/2-sql/2-authoring/contract-psl/test/fixtures.ts

@@ -270,6 +270,10 @@ export const postgresScalarTypeDescriptors = new Map([
   ['DateTime', { codecId: 'pg/timestamptz@1', nativeType: 'timestamptz' }],
   ['Json', { codecId: 'pg/jsonb@1', nativeType: 'jsonb' }],
   ['Bytes', { codecId: 'pg/bytea@1', nativeType: 'bytea' }],
+  // Keyed by the full `@db.*` attribute name, not a PSL base type — see the
+  // matching entry (and its comment) in the real target's
+  // `postgresScalarTypeDescriptors`, `control-mutation-defaults.ts`.
+  ['db.Date', { codecId: 'pg/date@1', nativeType: 'date' }],
 ] as const);
 
 export function buildSymbolTableInput(