@prisma-next/family-sql 0.15.0 → 0.16.0-dev.10

package/package.json

@@ -1,35 +1,37 @@
 {
   "name": "@prisma-next/family-sql",
-  "version": "0.15.0",
+  "version": "0.16.0-dev.10",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "SQL family descriptor for Prisma Next",
   "dependencies": {
-    "@prisma-next/contract": "0.15.0",
-    "@prisma-next/emitter": "0.15.0",
-    "@prisma-next/framework-components": "0.15.0",
-    "@prisma-next/migration-tools": "0.15.0",
-    "@prisma-next/operations": "0.15.0",
-    "@prisma-next/sql-contract": "0.15.0",
-    "@prisma-next/sql-contract-emitter": "0.15.0",
-    "@prisma-next/sql-contract-ts": "0.15.0",
-    "@prisma-next/sql-operations": "0.15.0",
-    "@prisma-next/sql-relational-core": "0.15.0",
-    "@prisma-next/sql-runtime": "0.15.0",
-    "@prisma-next/sql-schema-ir": "0.15.0",
-    "@prisma-next/utils": "0.15.0",
-    "arktype": "^2.2.2"
+    "@prisma-next/contract": "0.16.0-dev.10",
+    "@prisma-next/emitter": "0.16.0-dev.10",
+    "@prisma-next/framework-components": "0.16.0-dev.10",
+    "@prisma-next/migration-tools": "0.16.0-dev.10",
+    "@prisma-next/operations": "0.16.0-dev.10",
+    "@prisma-next/sql-contract": "0.16.0-dev.10",
+    "@prisma-next/sql-contract-emitter": "0.16.0-dev.10",
+    "@prisma-next/sql-contract-ts": "0.16.0-dev.10",
+    "@prisma-next/sql-operations": "0.16.0-dev.10",
+    "@prisma-next/sql-relational-core": "0.16.0-dev.10",
+    "@prisma-next/sql-runtime": "0.16.0-dev.10",
+    "@prisma-next/sql-schema-ir": "0.16.0-dev.10",
+    "@prisma-next/utils": "0.16.0-dev.10",
+    "arktype": "^2.2.2",
+    "pluralize": "^8.0.0"
   },
   "devDependencies": {
-    "@prisma-next/driver-postgres": "0.15.0",
-    "@prisma-next/psl-parser": "0.15.0",
-    "@prisma-next/psl-printer": "0.15.0",
-    "@prisma-next/sql-contract-psl": "0.15.0",
-    "@prisma-next/test-utils": "0.15.0",
-    "@prisma-next/tsconfig": "0.15.0",
-    "@prisma-next/tsdown": "0.15.0",
-    "tsdown": "0.22.3",
+    "@prisma-next/driver-postgres": "0.16.0-dev.10",
+    "@prisma-next/psl-parser": "0.16.0-dev.10",
+    "@prisma-next/psl-printer": "0.16.0-dev.10",
+    "@prisma-next/sql-contract-psl": "0.16.0-dev.10",
+    "@prisma-next/test-utils": "0.16.0-dev.10",
+    "@prisma-next/tsconfig": "0.16.0-dev.10",
+    "@prisma-next/tsdown": "0.16.0-dev.10",
+    "@types/pluralize": "^0.0.33",
+    "tsdown": "0.22.8",
     "typescript": "5.9.3",
     "vitest": "4.1.10"
   },

package/src/core/diff/schema-verify.ts

@@ -23,7 +23,7 @@ import type {
   VerifierOutcome,
   VerifyDatabaseSchemaResult,
 } from '@prisma-next/framework-components/control';
-import { dispositionForCategory } from '@prisma-next/framework-components/control';
+import { dispositionForCategory, issueOutcome } from '@prisma-next/framework-components/control';
 import { isStorageTypeInstance, type SqlStorage } from '@prisma-next/sql-contract/types';
 import { RelationalSchemaNodeKind, type SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';
 import { blindCast } from '@prisma-next/utils/casts';
@@ -101,10 +101,10 @@ export function classifySqlDiffIssue(
   issue: SchemaDiffIssue,
   granularityOf: (nodeKind: string) => DiffSubjectGranularity,
 ): VerifierIssueCategory {
-  if (issue.reason === 'not-found') {
+  if (issueOutcome(issue) === 'not-found') {
     return 'declaredMissing';
   }
-  if (issue.reason === 'not-expected') {
+  if (issueOutcome(issue) === 'not-expected') {
     const granularity = classifyDiffSubjectGranularity(issue, granularityOf);
     if (granularity === 'entity' || granularity === 'namespace') {
       return 'extraTopLevelObject';
@@ -173,7 +173,7 @@ export function computeSqlDiffVerdict(input: SqlDiffVerdictInput): SqlDiffVerdic
   for (const issue of input.issues) {
     if (
       !input.strict &&
-      issue.reason === 'not-expected' &&
+      issueOutcome(issue) === 'not-expected' &&
       isStrictOnlyExtra(issue, input.granularityOf)
     ) {
       continue;
@@ -300,7 +300,7 @@ export function verifySqlSchemaByDiff(
       : undefined;
   return {
     ok,
-    ...(ok ? {} : { code: 'PN-SCHEMA-0001' }),
+    ...(ok ? {} : { code: 'CONTRACT.SCHEMA_VERIFICATION_FAILED' }),
     summary: ok
       ? 'Database schema satisfies contract'
       : `Database schema does not satisfy contract (${failCount} failure${failCount === 1 ? '' : 's'})`,

package/src/core/diff/verifier-disposition.ts

@@ -4,7 +4,7 @@ import type {
   VerifierIssueCategory,
   VerifierOutcome,
 } from '@prisma-next/framework-components/control';
-import { dispositionForCategory } from '@prisma-next/framework-components/control';
+import { dispositionForCategory, issueOutcome } from '@prisma-next/framework-components/control';
 
 /**
  * Classifies a codec `verifyType` hook finding into the target-neutral
@@ -13,10 +13,10 @@ import { dispositionForCategory } from '@prisma-next/framework-components/contro
  * to its value set, so a paired mismatch always classifies as `valueDrift`.
  */
 export function classifyStorageTypeDiffIssue(issue: SchemaDiffIssue): VerifierIssueCategory {
-  if (issue.reason === 'not-found') {
+  if (issueOutcome(issue) === 'not-found') {
     return 'declaredMissing';
   }
-  if (issue.reason === 'not-expected') {
+  if (issueOutcome(issue) === 'not-expected') {
     return 'extraAuxiliary';
   }
   return 'valueDrift';

package/src/core/migrations/contract-to-schema-ir.ts

@@ -1,6 +1,9 @@
 import type { ColumnDefault, Contract, JsonValue } from '@prisma-next/contract/types';
 import type { CodecRef } from '@prisma-next/framework-components/codec';
-import type { MigrationPlannerConflict } from '@prisma-next/framework-components/control';
+import type {
+  MigrationPlannerConflict,
+  SchemaNodeRef,
+} from '@prisma-next/framework-components/control';
 import {
   type CheckConstraint,
   type ForeignKey,
@@ -12,8 +15,8 @@ import {
   type StorageTypeInstance,
   type UniqueConstraint,
 } from '@prisma-next/sql-contract/types';
-import { defaultIndexName } from '@prisma-next/sql-schema-ir/naming';
 import {
+  RelationalSchemaNodeKind,
   type SqlAnnotations,
   type SqlCheckConstraintIRInput,
   type SqlColumnIRInput,
@@ -25,7 +28,6 @@ import {
 } from '@prisma-next/sql-schema-ir/types';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
-import { backingIndexColumnKeys } from '../foreign-key-index-backing';
 
 /**
  * Target-specific callback that expands a column's base `nativeType` and optional
@@ -54,6 +56,17 @@ export type NativeTypeExpander = (input: {
  */
 export type DefaultRenderer = (def: ColumnDefault, column: StorageColumn) => string;
 
+/**
+ * Target-supplied hook (same IoC seam as `NativeTypeExpander`/`DefaultRenderer`)
+ * that normalizes a contract-declared `ColumnDefault` into the resolved shape
+ * the target's introspection parses from the live database — e.g. a
+ * `dbgenerated("'{}'::jsonb")` function call and the literal Postgres reports
+ * are the same value in different shapes, and `resolvedDefaultsEqual`
+ * compares `kind` before content. When omitted, the contract's raw default
+ * is the resolved default unchanged.
+ */
+export type DefaultResolver = (def: ColumnDefault, resolvedNativeType: string) => ColumnDefault;
+
 /**
  * Target-supplied callback that resolves a contract namespace to the live
  * database schema its enums are stored under.
@@ -75,6 +88,7 @@ function convertColumn(
   storageTypes: ResolvedStorageTypes,
   expandNativeType: NativeTypeExpander | undefined,
   renderDefault: DefaultRenderer | undefined,
+  resolveDefault: DefaultResolver | undefined,
 ): SqlColumnIRInput {
   // Resolve `typeRef` so columns that delegate their `nativeType`/`codecId`/
   // `typeParams` to a named `storage.types` entry expand the same way as
@@ -105,6 +119,11 @@ function convertColumn(
   // agree on as the comparable "expanded" type.
   const nativeType = baseNativeType;
   const resolvedNativeType = column.many ? `${baseNativeType}[]` : baseNativeType;
+  const rawColumnDefault = column.default ?? undefined;
+  const resolvedColumnDefault =
+    rawColumnDefault !== undefined && resolveDefault
+      ? resolveDefault(rawColumnDefault, resolvedNativeType)
+      : rawColumnDefault;
   return {
     name,
     nativeType,
@@ -115,11 +134,14 @@ function convertColumn(
       column.default != null && renderDefault ? renderDefault(column.default, column) : undefined,
     ),
     // Contract-derived columns are resolved by construction: the computed
-    // full native type doubles as the resolved value, and the contract's
-    // structured default is the resolved default (the introspected side
-    // stamps its normalizer's parse of the raw expression).
+    // full native type doubles as the resolved value. The contract's raw
+    // structured default becomes the resolved default after passing through
+    // the target's `resolveDefault` hook (when supplied), so a default the
+    // target's introspection side would normalize differently (e.g. a
+    // `dbgenerated(...)` function call that is actually a literal) compares
+    // equal instead of drifting on `kind` alone.
     resolvedNativeType,
-    ...ifDefined('resolvedDefault', column.default ?? undefined),
+    ...ifDefined('resolvedDefault', resolvedColumnDefault),
     // The column's codec identity, carried the same way the query AST
     // carries `CodecRef` (TML-2456) — the migration planner's op-builders
     // resolve DDL rendering from this at plan time (Decision 5), instead of
@@ -246,14 +268,15 @@ function convertCheck(check: CheckConstraint, storage: SqlStorage): SqlCheckCons
   };
 }
 
-function convertUnique(unique: UniqueConstraint): SqlUniqueIRInput {
+function convertUnique(unique: UniqueConstraint, tableName: string): SqlUniqueIRInput {
   return {
     columns: unique.columns,
     ...ifDefined('name', unique.name),
+    dependsOn: flatColumnDependsOn(tableName, unique.columns),
   };
 }
 
-function convertIndex(index: Index): SqlIndexIRInput {
+function convertIndex(index: Index, tableName: string): SqlIndexIRInput {
   return {
     columns: index.columns,
     unique: false,
@@ -262,9 +285,42 @@ function convertIndex(index: Index): SqlIndexIRInput {
     // introspected side (the legacy walk read them from the contract).
     ...ifDefined('type', index.type),
     ...ifDefined('options', index.options),
+    dependsOn: flatColumnDependsOn(tableName, index.columns),
   };
 }
 
+/**
+ * The referenced table's chain in the flat (single-schema) tree
+ * `contractToSchemaIR`/`contractNamespaceToSchemaIR` build: the root
+ * (`SqlSchemaIR`, fixed `'database'` id) followed by the table's own id.
+ * Postgres discards this when it re-derives the FK against its own
+ * multi-schema tree shape (`contractToPostgresDatabaseSchemaNode`); SQLite's
+ * flat tree uses it as-is.
+ */
+function flatSchemaDependsOn(tableName: string): SchemaNodeRef {
+  return [
+    { nodeKind: RelationalSchemaNodeKind.schema, id: 'database' },
+    { nodeKind: RelationalSchemaNodeKind.table, id: tableName },
+  ];
+}
+
+/**
+ * The chains from a table-child object (foreign key, index, unique, primary
+ * key) to each of the own columns it is built on, in the flat tree. Dropping
+ * a covered column auto-drops the object, so the object's drop must precede
+ * the column's; the graph derives that direction from these edges.
+ */
+function flatColumnDependsOn(
+  tableName: string,
+  columns: readonly string[],
+): readonly SchemaNodeRef[] {
+  return columns.map((column) => [
+    { nodeKind: RelationalSchemaNodeKind.schema, id: 'database' },
+    { nodeKind: RelationalSchemaNodeKind.table, id: tableName },
+    { nodeKind: RelationalSchemaNodeKind.column, id: `column:${column}` },
+  ]);
+}
+
 /**
  * The FK's referenced-namespace identity comes from the target's namespace
  * node, not the raw namespace-id string. An unbound target namespace stamps
@@ -274,6 +330,10 @@ function convertIndex(index: Index): SqlIndexIRInput {
  * cross-space target whose namespace lives in another contract's storage)
  * stamps its coordinate verbatim; namespaced targets (Postgres) resolve the
  * real DDL schema downstream.
+ *
+ * `dependsOn` carries the referenced table (created before the FK, dropped
+ * after it) plus the FK's own columns (dropped after the FK, since dropping a
+ * column auto-drops the FK built on it).
  */
 function convertForeignKey(fk: ForeignKey, storage: SqlStorage): SqlForeignKeyIRInput {
   const targetNamespace = storage.namespaces[fk.target.namespaceId];
@@ -286,6 +346,10 @@ function convertForeignKey(fk: ForeignKey, storage: SqlStorage): SqlForeignKeyIR
     ...ifDefined('name', fk.name),
     ...ifDefined('onDelete', fk.onDelete),
     ...ifDefined('onUpdate', fk.onUpdate),
+    dependsOn: [
+      flatSchemaDependsOn(fk.target.tableName),
+      ...flatColumnDependsOn(fk.source.tableName, fk.source.columns),
+    ],
   };
 }
 
@@ -295,6 +359,7 @@ function convertTable(
   storageTypes: ResolvedStorageTypes,
   expandNativeType: NativeTypeExpander | undefined,
   renderDefault: DefaultRenderer | undefined,
+  resolveDefault: DefaultResolver | undefined,
   storage: SqlStorage,
 ): SqlTableIR {
   const columns: Record<string, SqlColumnIRInput> = {};
@@ -305,37 +370,36 @@ function convertTable(
       storageTypes,
       expandNativeType,
       renderDefault,
+      resolveDefault,
     );
   }
 
-  const satisfiedIndexColumns = new Set(backingIndexColumnKeys(table));
-  const fkBackingIndexes: SqlIndexIRInput[] = [];
-  for (const fk of table.foreignKeys) {
-    if (fk.index === false) continue;
-    const key = fk.source.columns.join(',');
-    if (satisfiedIndexColumns.has(key)) continue;
-    fkBackingIndexes.push({
-      columns: fk.source.columns,
-      unique: false,
-      name: defaultIndexName(name, fk.source.columns),
-    });
-    satisfiedIndexColumns.add(key);
-  }
-
   const checks: SqlCheckConstraintIRInput[] | undefined =
     table.checks && table.checks.length > 0
       ? table.checks.map((c) => convertCheck(c, storage))
       : undefined;
 
+  const primaryKey =
+    table.primaryKey !== undefined
+      ? {
+          columns: table.primaryKey.columns,
+          ...ifDefined('name', table.primaryKey.name),
+          dependsOn: flatColumnDependsOn(name, table.primaryKey.columns),
+        }
+      : undefined;
+
   return new SqlTableIR({
     name,
     columns,
-    ...ifDefined('primaryKey', table.primaryKey),
-    foreignKeys: table.foreignKeys
-      .filter((fk) => fk.constraint !== false)
-      .map((fk) => convertForeignKey(fk, storage)),
-    uniques: table.uniques.map(convertUnique),
-    indexes: [...table.indexes.map(convertIndex), ...fkBackingIndexes],
+    ...ifDefined('primaryKey', primaryKey),
+    // #989 persists a `constraint: false` FK's absence and its backing index as
+    // discrete entities at contract construction, so every `foreignKeys[]` entry
+    // is now constraint-bearing (no filter) and each FK-backing index is already
+    // a `table.indexes[]` entry — it flows through `convertIndex` below, carrying
+    // the object→own-column `dependsOn` edge like any other index.
+    foreignKeys: table.foreignKeys.map((fk) => convertForeignKey(fk, storage)),
+    uniques: table.uniques.map((u) => convertUnique(u, name)),
+    indexes: table.indexes.map((i) => convertIndex(i, name)),
     ...ifDefined('checks', checks),
   });
 }
@@ -402,6 +466,7 @@ export interface ContractToSchemaIROptions {
   readonly annotationNamespace: string;
   readonly expandNativeType?: NativeTypeExpander;
   readonly renderDefault?: DefaultRenderer;
+  readonly resolveDefault?: DefaultResolver;
   /**
    * Target-supplied resolver mapping a namespace to the live database schema
    * its enums are stored under. When provided (Postgres), namespace-scoped
@@ -462,6 +527,7 @@ export function contractNamespaceToSchemaIR(
       storageTypes,
       options.expandNativeType,
       options.renderDefault,
+      options.resolveDefault,
       storage,
     );
   }
@@ -498,6 +564,7 @@ export function contractToSchemaIR(
         storageTypes,
         options.expandNativeType,
         options.renderDefault,
+        options.resolveDefault,
         storage,
       );
     }

package/src/core/migrations/types.ts

@@ -334,9 +334,9 @@ export interface SqlMigrationPlannerPlanOptions {
    * or `null` for reconciliation flows that have no prior contract.
    *
    * Required at every call site so the structural fact "I have a prior
-   * contract / I don't" is visible in the type. `migration plan` reads
-   * the predecessor bundle's `end-contract.json` from disk and passes
-   * the parsed value; `db update` / `db init` reconcile against the
+   * contract / I don't" is visible in the type. `migration plan` reads the
+   * predecessor's contract from the snapshot store by its storage hash and
+   * passes the parsed value; `db update` / `db init` reconcile against the
    * live schema and pass `null`. Strategies that
    * need from/to column-shape comparisons (unsafe type change, nullability
    * tightening) use this to decide whether to emit `dataTransform`
@@ -346,6 +346,13 @@ export interface SqlMigrationPlannerPlanOptions {
    * plan's `describe()` as `fromContract?.storage.storageHash ?? null`.
    */
   readonly fromContract: Contract<SqlStorage> | null;
+  /**
+   * POSIX-relative path from the migration package dir to
+   * `migrations/snapshots`, e.g. `'../../snapshots'`. Threaded straight
+   * into the produced plan's `renderTypeScript()` metadata so the
+   * scaffold's contract-snapshot imports point at the deduplicated store.
+   */
+  readonly snapshotsImportPath: string;
   /**
    * Active framework components participating in this composition.
    * Each component is target-bound so SQL targets can dispatch
@@ -419,16 +426,16 @@ export interface SqlMigrationRunnerExecuteOptions<TTargetDetails> {
 }
 
 export type SqlMigrationRunnerErrorCode =
-  | 'DESTINATION_CONTRACT_MISMATCH'
-  | 'LEGACY_MARKER_SHAPE'
-  | 'MARKER_ORIGIN_MISMATCH'
-  | 'MARKER_CAS_FAILURE'
-  | 'POLICY_VIOLATION'
-  | 'PRECHECK_FAILED'
-  | 'POSTCHECK_FAILED'
-  | 'SCHEMA_VERIFY_FAILED'
-  | 'FOREIGN_KEY_VIOLATION'
-  | 'EXECUTION_FAILED';
+  | 'MIGRATION.DESTINATION_CONTRACT_MISMATCH'
+  | 'MIGRATION.LEGACY_MARKER_SHAPE'
+  | 'MIGRATION.MARKER_ORIGIN_MISMATCH'
+  | 'MIGRATION.MARKER_CAS_FAILURE'
+  | 'MIGRATION.POLICY_VIOLATION'
+  | 'MIGRATION.PRECHECK_FAILED'
+  | 'MIGRATION.POSTCHECK_FAILED'
+  | 'MIGRATION.SCHEMA_VERIFY_FAILED'
+  | 'MIGRATION.FOREIGN_KEY_VIOLATION'
+  | 'MIGRATION.EXECUTION_FAILED';
 
 export interface SqlMigrationRunnerFailure extends MigrationRunnerFailure {
   readonly code: SqlMigrationRunnerErrorCode;

package/src/core/psl-contract-infer/name-transforms.ts

@@ -1,3 +1,5 @@
+import pluralizeLib from 'pluralize';
+
 const PSL_RESERVED_WORDS = new Set(['model', 'enum', 'types', 'type', 'generator', 'datasource']);
 
 const IDENTIFIER_PART_PATTERN = /[A-Za-z0-9]+/g;
@@ -143,19 +145,7 @@ export function toEnumMemberName(value: string): string {
 }
 
 export function pluralize(word: string): string {
-  if (
-    word.endsWith('s') ||
-    word.endsWith('x') ||
-    word.endsWith('z') ||
-    word.endsWith('ch') ||
-    word.endsWith('sh')
-  ) {
-    return `${word}es`;
-  }
-  if (word.endsWith('y') && !/[aeiou]y$/i.test(word)) {
-    return `${word.slice(0, -1)}ies`;
-  }
-  return `${word}s`;
+  return pluralizeLib.plural(word);
 }
 
 export function deriveRelationFieldName(

package/src/core/psl-contract-infer/relation-inference.ts

@@ -1,5 +1,8 @@
+import {
+  backingIndexColumnKeys,
+  isBackedByColumnKeys,
+} from '@prisma-next/sql-contract/foreign-key-materialization';
 import type { SqlForeignKeyIR, SqlTableIR } from '@prisma-next/sql-schema-ir/types';
-import { backingIndexColumnKeys, isBackedByColumnKeys } from '../foreign-key-index-backing';
 import { deriveBackRelationFieldName, deriveRelationFieldName, pluralize } from './name-transforms';
 import type { RelationField } from './printer-config';
 

package/src/core/timestamp-now-generator.ts

@@ -73,3 +73,91 @@ export function temporalAuthoringPresets<
     },
   } as const satisfies Record<string, AuthoringFieldPresetDescriptor>;
 }
+
+const TEMPORAL_PRECISION_ARG = {
+  name: 'precision',
+  kind: 'number',
+  optional: true,
+  integer: true,
+  minimum: 0,
+} as const;
+
+const TEMPORAL_ON_CREATE_ARG = {
+  name: 'onCreate',
+  kind: 'option',
+  values: ['now'],
+  optional: true,
+} as const;
+
+const TEMPORAL_ON_UPDATE_ARG = {
+  name: 'onUpdate',
+  kind: 'option',
+  values: ['now'],
+  optional: true,
+} as const;
+
+/**
+ * Selects the `timestampNow` generator descriptor for the preset's `now`
+ * token. The token is preset vocabulary; the generator id never appears in a
+ * user's spelling (ADR 169 — `timestampNow` is preset-only).
+ */
+function temporalPhaseTemplate<const Index extends number>(index: Index) {
+  return {
+    kind: 'select',
+    index,
+    cases: { now: { kind: 'generator', id: TIMESTAMP_NOW_GENERATOR_ID } },
+  } as const;
+}
+
+/**
+ * Builds a `temporal.<codec>` field preset for a codec that takes a precision
+ * parameter (`pg/timestamp@1`, `pg/timestamptz@1`). Arguments change field
+ * properties only — never the codec, which the caller fixes here.
+ *
+ * All three arguments are optional: omitting `precision` omits `typeParams`
+ * entirely, and omitting a phase omits that phase (both omitted omits
+ * `executionDefaults`).
+ */
+/* @__NO_SIDE_EFFECTS__ */
+export function temporalCodecPresetWithPrecision<
+  const CodecId extends string,
+  const NativeType extends string,
+>(input: { readonly codecId: CodecId; readonly nativeType: NativeType }) {
+  return {
+    kind: 'fieldPreset',
+    args: [TEMPORAL_PRECISION_ARG, TEMPORAL_ON_CREATE_ARG, TEMPORAL_ON_UPDATE_ARG],
+    output: {
+      codecId: input.codecId,
+      nativeType: input.nativeType,
+      typeParams: { precision: { kind: 'arg', index: 0 } },
+      executionDefaults: {
+        onCreate: temporalPhaseTemplate(1),
+        onUpdate: temporalPhaseTemplate(2),
+      },
+    },
+  } as const satisfies AuthoringFieldPresetDescriptor;
+}
+
+/**
+ * Builds a `temporal.<codec>` field preset for a codec with no type
+ * parameters (`sqlite/datetime@1`). As with the precision-bearing variant,
+ * both phase arguments are optional and omitting one omits that phase.
+ */
+/* @__NO_SIDE_EFFECTS__ */
+export function temporalCodecPreset<
+  const CodecId extends string,
+  const NativeType extends string,
+>(input: { readonly codecId: CodecId; readonly nativeType: NativeType }) {
+  return {
+    kind: 'fieldPreset',
+    args: [TEMPORAL_ON_CREATE_ARG, TEMPORAL_ON_UPDATE_ARG],
+    output: {
+      codecId: input.codecId,
+      nativeType: input.nativeType,
+      executionDefaults: {
+        onCreate: temporalPhaseTemplate(0),
+        onUpdate: temporalPhaseTemplate(1),
+      },
+    },
+  } as const satisfies AuthoringFieldPresetDescriptor;
+}

package/src/exports/control.ts

@@ -21,6 +21,7 @@ export type {
 export type {
   ContractToSchemaIROptions,
   DefaultRenderer,
+  DefaultResolver,
   EnumNamespaceSchemaResolver,
   NativeTypeExpander,
 } from '../core/migrations/contract-to-schema-ir';
@@ -87,6 +88,8 @@ export type {
 } from '../core/migrations/types';
 export {
   temporalAuthoringPresets,
+  temporalCodecPreset,
+  temporalCodecPresetWithPrecision,
   timestampNowControlDescriptor,
 } from '../core/timestamp-now-generator';
 

package/dist/control-adapter-BQgad8Zc.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"control-adapter-BQgad8Zc.d.mts","names":[],"sources":["../src/core/diff/sql-schema-diff.ts","../src/core/control-adapter.ts"],"mappings":";;;;;;;;;;;KAeY,iBAAA,IACV,UAAA,UACA,UAAA,aACG,aAAa;;AAAA;AAOlB;;;KAAY,oBAAA,IAAwB,UAAkB;AAAA;AAKtD;;AALsD,iBAKtC,WAAA,CAAY,CAAA,qBAAsB,CAAoB;;;;AAftE;;;;;;UCQiB,OAAA;EACf,KAAA,CAAM,GAAA,EAAK,WAAA,GAAc,OAAA,EAAS,OAAA,EAAS,cAAA,YAA0B,gBAAA;AAAA;ADCvE;;;;AAAsD;AAKtD;AALA,UCQiB,qBAAA,SAA8B,OAAA;EAC7C,qBAAA,CACE,GAAA,EAAK,WAAA,GAAc,OAAA,EACnB,OAAA,GAAU,cAAA,YACT,OAAA,CAAQ,iBAAA;AAAA;ADPyD;;;;ACPtE;;ADOsE,UCgBrD,iBAAA,0CACP,sBAAA,QAA8B,OAAA,GACpC,qBAAA;EAxBS;;;;;;;;;;;;;;AAA0E;EAwCrF,UAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,KAAA,WACC,OAAA,CAAQ,oBAAA;EAlC0B;;;;;;;EA2CrC,cAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,IAChC,OAAA,CAAQ,WAAA,SAAoB,oBAAA;EA7CqB;;;;EAmDpD,UAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,KAAA,YACC,OAAA,UAAiB,iBAAA;EApDC;;;;;;EA4DrB,YAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,KAAA,UACA,WAAA;IAAA,SACW,WAAA;IAAA,SACA,WAAA;IAAA,SACA,UAAA;EAAA,IAEV,OAAA;EAxDmC;;;;;;EAgEtC,UAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,KAAA,UACA,WAAA;IAAA,SACW,WAAA;IAAA,SACA,WAAA;IAAA,SACA,UAAA;EAAA,IAEV,OAAA;EAlCO;;;;;;;EA2CV,YAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,KAAA,UACA,YAAA,UACA,WAAA;IAAA,SACW,WAAA;IAAA,SACA,WAAA;IAAA,SACA,UAAA;EAAA,IAEV,OAAA;EASgC;;;;;;EADnC,gBAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,KAAA,UACA,KAAA;IAAA,SACW,MAAA;IAAA,SACA,IAAA;IAAA,SACA,EAAA;IAAA,SACA,aAAA;IAAA,SACA,aAAA;IAAA,SACA,UAAA;IAAA,SACA,uBAAA;EAAA,IAEV,OAAA;EA/G8B;;;;;;;;;;;;;;;;;EAkIjC,UAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,QAAA,YACA,MAAA,YACC,OAAA,CAAQ,eAAA;EAhGX;;;;;EAAA,SAuGS,gBAAA,GAAmB,iBAAA;EApGR;;;;;EAAA,SA2GX,mBAAA,GAAsB,oBAAA;EA/FlB;;;;EAqGb,4BAAA,aAAyC,OAAA;EAzFzC;;;;EA+FA,0BAAA,aAAuC,OAAA;AAAA;;;;;;;UASxB,2BAAA;EAtFb;;;;;;EA6FF,MAAA,CAAO,KAAA,EAAO,YAAA,QAAoB,OAAA,IAAW,iBAAA,CAAkB,OAAA;AAAA"}

package/dist/foreign-key-index-backing-BP71iI-Q.mjs

@@ -1,32 +0,0 @@
-//#region src/core/foreign-key-index-backing.ts
-/**
-* The column-list keys (`"colA,colB"`, order preserved) a table's own
-* indexes, unique constraints, and primary key already back. A foreign key
-* whose source columns join to one of these keys needs no separately
-* derived backing index.
-*
-* Shared by {@link isBackedByColumnKeys}'s two callers, which must agree on
-* what counts as "backed": `contract-to-schema-ir.ts`'s `convertTable`
-* (deriving the FK-backing-index expectation `db verify` checks against a
-* live database) and the postgres PSL inferrer (deciding whether an
-* introspected relation needs an explicit `index: false`).
-*/
-function backingIndexColumnKeys(table) {
-	return [
-		...table.indexes.map((index) => index.columns.join(",")),
-		...table.uniques.map((unique) => unique.columns.join(",")),
-		...table.primaryKey ? [table.primaryKey.columns.join(",")] : []
-	];
-}
-/**
-* Whether `columns`, in order, matches one of `backingKeys` (see
-* {@link backingIndexColumnKeys}). Order-sensitive: `(a, b)` does not
-* satisfy a backing index declared as `(b, a)`.
-*/
-function isBackedByColumnKeys(columns, backingKeys) {
-	return backingKeys.includes(columns.join(","));
-}
-//#endregion
-export { isBackedByColumnKeys as n, backingIndexColumnKeys as t };
-
-//# sourceMappingURL=foreign-key-index-backing-BP71iI-Q.mjs.map

package/dist/foreign-key-index-backing-BP71iI-Q.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"foreign-key-index-backing-BP71iI-Q.mjs","names":[],"sources":["../src/core/foreign-key-index-backing.ts"],"sourcesContent":["export type BackingIndexCandidates = {\n  readonly indexes: readonly { readonly columns: readonly string[] }[];\n  readonly uniques: readonly { readonly columns: readonly string[] }[];\n  readonly primaryKey?: { readonly columns: readonly string[] } | undefined;\n};\n\n/**\n * The column-list keys (`\"colA,colB\"`, order preserved) a table's own\n * indexes, unique constraints, and primary key already back. A foreign key\n * whose source columns join to one of these keys needs no separately\n * derived backing index.\n *\n * Shared by {@link isBackedByColumnKeys}'s two callers, which must agree on\n * what counts as \"backed\": `contract-to-schema-ir.ts`'s `convertTable`\n * (deriving the FK-backing-index expectation `db verify` checks against a\n * live database) and the postgres PSL inferrer (deciding whether an\n * introspected relation needs an explicit `index: false`).\n */\nexport function backingIndexColumnKeys(table: BackingIndexCandidates): readonly string[] {\n  return [\n    ...table.indexes.map((index) => index.columns.join(',')),\n    ...table.uniques.map((unique) => unique.columns.join(',')),\n    ...(table.primaryKey ? [table.primaryKey.columns.join(',')] : []),\n  ];\n}\n\n/**\n * Whether `columns`, in order, matches one of `backingKeys` (see\n * {@link backingIndexColumnKeys}). Order-sensitive: `(a, b)` does not\n * satisfy a backing index declared as `(b, a)`.\n */\nexport function isBackedByColumnKeys(\n  columns: readonly string[],\n  backingKeys: readonly string[],\n): boolean {\n  return backingKeys.includes(columns.join(','));\n}\n"],"mappings":";;;;;;;;;;;;;AAkBA,SAAgB,uBAAuB,OAAkD;CACvF,OAAO;EACL,GAAG,MAAM,QAAQ,KAAK,UAAU,MAAM,QAAQ,KAAK,GAAG,CAAC;EACvD,GAAG,MAAM,QAAQ,KAAK,WAAW,OAAO,QAAQ,KAAK,GAAG,CAAC;EACzD,GAAI,MAAM,aAAa,CAAC,MAAM,WAAW,QAAQ,KAAK,GAAG,CAAC,IAAI,CAAC;CACjE;AACF;;;;;;AAOA,SAAgB,qBACd,SACA,aACS;CACT,OAAO,YAAY,SAAS,QAAQ,KAAK,GAAG,CAAC;AAC/C"}

package/dist/schema-differ-DnoopSXm.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema-differ-DnoopSXm.d.mts","names":[],"sources":["../src/core/migrations/schema-differ.ts"],"mappings":";;;;;;;;;AAcA;;;;;;UAAiB,mBAAA;EAiBU;EAAA,SAfhB,MAAA,WAAiB,eAAA;EAeY;;;;;;;;EAAA,SAN7B,oBAAA,GAAuB,KAAA,EAAO,eAAA,KAAoB,aAAA;EAMT;;;AAAuB;AAG3E;EAHoD,SAAzC,cAAA,EAAgB,aAAA;IAAA,SAAyB,MAAA,EAAQ,eAAA;EAAA;AAAA;AAAA,UAG3C,kBAAA;EAAA,SACN,QAAA,EAAU,QAAA,CAAS,UAAA;EAAA,SACnB,MAAA,EAAQ,eAAA;EAAA,SACR,mBAAA,EAAqB,aAAA,CAAc,8BAAA;AAAA;AAAA,KAGlC,eAAA,IAAmB,KAAA,EAAO,kBAAA,KAAuB,mBAAmB"}