@prisma-next/sql-contract 0.7.0-dev.7 → 0.8.0-dev.1

package/src/ir/storage-type-instance.ts

@@ -0,0 +1,60 @@
+import type { StorageType } from '@prisma-next/framework-components/ir';
+
+/**
+ * Sentinel kind for the legacy codec-triple shape persisted under
+ * `SqlStorage.types`. Plain JSON-clean object literals carry this
+ * discriminator so the polymorphic slot dispatch can route them down
+ * the codec path while target-specific IR class instances (e.g. the
+ * Postgres enum class) keep their own narrower `kind` literal.
+ */
+export const CODEC_INSTANCE_KIND = 'codec-instance' as const;
+
+/**
+ * Structural sub-interface of {@link StorageType} for codec-typed entries
+ * in `SqlStorage.types`. These are plain object literals — there is no
+ * runtime IR class, the JSON envelope round-trips through the slot
+ * unchanged. The `kind: 'codec-instance'` discriminator is the dispatch
+ * key that distinguishes codec-typed entries from class-instance entries
+ * (e.g. `PostgresEnumType`) sharing the polymorphic slot.
+ */
+export interface StorageTypeInstance extends StorageType {
+  readonly kind: typeof CODEC_INSTANCE_KIND;
+  readonly codecId: string;
+  readonly nativeType: string;
+  readonly typeParams: Record<string, unknown>;
+}
+
+/**
+ * Construction-time input for a codec-triple entry. Symmetric with the
+ * structural runtime shape minus the `kind` discriminator — callers may
+ * omit `kind`; the helper {@link toStorageTypeInstance} stamps it on.
+ */
+export interface StorageTypeInstanceInput {
+  readonly codecId: string;
+  readonly nativeType: string;
+  readonly typeParams: Record<string, unknown>;
+}
+
+/**
+ * Stamp the codec-instance `kind` discriminator on a caller-supplied
+ * codec triple. Idempotent: input that already carries the discriminator
+ * passes through unchanged.
+ */
+export function toStorageTypeInstance(input: StorageTypeInstanceInput): StorageTypeInstance {
+  return {
+    kind: CODEC_INSTANCE_KIND,
+    codecId: input.codecId,
+    nativeType: input.nativeType,
+    typeParams: input.typeParams,
+  };
+}
+
+/**
+ * Type-guard for codec-typed entries on the polymorphic
+ * `SqlStorage.types` slot. Distinguishes `StorageTypeInstance` from
+ * class-instance kinds (e.g. `PostgresEnumType`).
+ */
+export function isStorageTypeInstance(value: unknown): value is StorageTypeInstance {
+  if (typeof value !== 'object' || value === null) return false;
+  return (value as { kind?: unknown }).kind === CODEC_INSTANCE_KIND;
+}

package/src/ir/unique-constraint.ts

@@ -0,0 +1,22 @@
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import { SqlNode } from './sql-node';
+
+export interface UniqueConstraintInput {
+  readonly columns: readonly string[];
+  readonly name?: string;
+}
+
+/**
+ * SQL Contract IR node for a table-level unique constraint.
+ */
+export class UniqueConstraint extends SqlNode {
+  readonly columns: readonly string[];
+  declare readonly name?: string;
+
+  constructor(input: UniqueConstraintInput) {
+    super();
+    this.columns = input.columns;
+    if (input.name !== undefined) this.name = input.name;
+    freezeNode(this);
+  }
+}

package/src/types.ts

@@ -1,58 +1,42 @@
-import type { ColumnDefault, StorageBase } from '@prisma-next/contract/types';
 import type { CodecTrait } from '@prisma-next/framework-components/codec';
-
-/**
- * A column definition in storage.
- *
- * `typeParams` is optional because most columns use non-parameterized types.
- * Columns with parameterized types can either inline `typeParams` or reference
- * a named {@link StorageTypeInstance} via `typeRef`.
- */
-export type StorageColumn = {
-  readonly nativeType: string;
-  readonly codecId: string;
-  readonly nullable: boolean;
-  /**
-   * Opaque, codec-owned JS/type parameters.
-   * The codec that owns `codecId` defines the shape and semantics.
-   * Mutually exclusive with `typeRef`.
-   */
-  readonly typeParams?: Record<string, unknown>;
-  /**
-   * Reference to a named type instance in `storage.types`.
-   * Mutually exclusive with `typeParams`.
-   */
-  readonly typeRef?: string;
-  /**
-   * Default value for the column.
-   * Can be a literal value or database function.
-   */
-  readonly default?: ColumnDefault;
-};
-
-export type PrimaryKey = {
-  readonly columns: readonly string[];
-  readonly name?: string;
-};
-
-export type UniqueConstraint = {
-  readonly columns: readonly string[];
-  readonly name?: string;
-};
-
-export type Index = {
-  readonly columns: readonly string[];
-  readonly name?: string;
-  readonly type?: string;
-  readonly options?: Record<string, unknown>;
-};
-
-export type ForeignKeyReferences = {
-  readonly table: string;
-  readonly columns: readonly string[];
-};
-
-export type ReferentialAction = 'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault';
+import type { ReferentialAction } from './ir/foreign-key';
+
+export {
+  ForeignKey,
+  type ForeignKeyInput,
+  type ReferentialAction,
+} from './ir/foreign-key';
+export {
+  ForeignKeyReferences,
+  type ForeignKeyReferencesInput,
+} from './ir/foreign-key-references';
+export {
+  isPostgresEnumStorageEntry,
+  POSTGRES_ENUM_KIND,
+  type PostgresEnumStorageEntry,
+} from './ir/postgres-enum-storage-entry';
+export { PrimaryKey, type PrimaryKeyInput } from './ir/primary-key';
+export { Index, type IndexInput } from './ir/sql-index';
+export { SqlNode } from './ir/sql-node';
+export {
+  SqlStorage,
+  type SqlStorageInput,
+  type SqlStorageTypeEntry,
+} from './ir/sql-storage';
+export { SqlUnspecifiedNamespace } from './ir/sql-unspecified-namespace';
+export { StorageColumn, type StorageColumnInput } from './ir/storage-column';
+export { StorageTable, type StorageTableInput } from './ir/storage-table';
+export {
+  CODEC_INSTANCE_KIND,
+  isStorageTypeInstance,
+  type StorageTypeInstance,
+  type StorageTypeInstanceInput,
+  toStorageTypeInstance,
+} from './ir/storage-type-instance';
+export {
+  UniqueConstraint,
+  type UniqueConstraintInput,
+} from './ir/unique-constraint';
 
 export type ForeignKeyOptions = {
   readonly name?: string;
@@ -60,51 +44,6 @@ export type ForeignKeyOptions = {
   readonly onUpdate?: ReferentialAction;
 };
 
-export type ForeignKey = {
-  readonly columns: readonly string[];
-  readonly references: ForeignKeyReferences;
-  readonly name?: string;
-  readonly onDelete?: ReferentialAction;
-  readonly onUpdate?: ReferentialAction;
-  /** Whether to emit FK constraint DDL (ALTER TABLE … ADD CONSTRAINT … FOREIGN KEY). */
-  readonly constraint: boolean;
-  /** Whether to emit a backing index for the FK columns. */
-  readonly index: boolean;
-};
-
-export type StorageTable = {
-  readonly columns: Record<string, StorageColumn>;
-  readonly primaryKey?: PrimaryKey;
-  readonly uniques: ReadonlyArray<UniqueConstraint>;
-  readonly indexes: ReadonlyArray<Index>;
-  readonly foreignKeys: ReadonlyArray<ForeignKey>;
-};
-
-/**
- * A named, parameterized type instance.
- * These are registered in `storage.types` for reuse across columns
- * and to enable ergonomic schema surfaces like `schema.types.MyType`.
- *
- * Unlike {@link StorageColumn}, `typeParams` is required here because
- * `StorageTypeInstance` exists specifically to define reusable parameterized types.
- * A type instance without parameters would be redundant—columns can reference
- * the codec directly via `codecId`.
- */
-export type StorageTypeInstance = {
-  readonly codecId: string;
-  readonly nativeType: string;
-  readonly typeParams: Record<string, unknown>;
-};
-
-export type SqlStorage<THash extends string = string> = StorageBase<THash> & {
-  readonly tables: Record<string, StorageTable>;
-  /**
-   * Named type instances for parameterized/custom types.
-   * Columns can reference these via `typeRef`.
-   */
-  readonly types?: Record<string, StorageTypeInstance>;
-};
-
 export type SqlModelFieldStorage = {
   readonly column: string;
   readonly codecId?: string;

package/src/validators.ts

@@ -1,14 +1,17 @@
-import type { Contract } from '@prisma-next/contract/types';
+import type { Contract, ContractField, ContractModel } from '@prisma-next/contract/types';
 import { ContractValidationError } from '@prisma-next/contract/validate-contract';
+import { validateContractDomain } from '@prisma-next/contract/validate-domain';
 import { type } from 'arktype';
-import type {
-  ForeignKey,
-  ForeignKeyReferences,
-  PrimaryKey,
-  ReferentialAction,
+import {
+  type ForeignKeyInput,
+  type ForeignKeyReferencesInput,
+  type PrimaryKeyInput,
+  type ReferentialAction,
+  type SqlModelStorage,
   SqlStorage,
-  StorageTypeInstance,
-  UniqueConstraint,
+  type SqlStorageInput,
+  type StorageTypeInstanceInput,
+  type UniqueConstraintInput,
 } from './types';
 
 type ColumnDefaultLiteral = {
@@ -77,18 +80,66 @@ const StorageColumnSchema = type({
   return true;
 });
 
-const StorageTypeInstanceSchema = type.declare<StorageTypeInstance>().type({
-  codecId: 'string',
+/**
+ * Codec-triple entry persisted under `storage.types[name]`. Carries an
+ * enumerable literal `kind: 'codec-instance'` discriminator so the
+ * polymorphic slot dispatch can distinguish codec triples from
+ * class-instance kinds (e.g. `'postgres-enum'`) sharing the slot.
+ */
+const StorageTypeInstanceSchema = type
+  .declare<StorageTypeInstanceInput & { kind: 'codec-instance' }>()
+  .type({
+    kind: "'codec-instance'",
+    codecId: 'string',
+    nativeType: 'string',
+    typeParams: 'Record<string, unknown>',
+  });
+
+/**
+ * Polymorphic enum-type entry under `storage.types[name]`. Carries an
+ * enumerable literal `kind: 'postgres-enum'` discriminator so the
+ * per-target hydration walker can dispatch cleanly back to a typed
+ * IR-class instance during `deserializeContract`. The discriminator
+ * reflects target-level behaviour (Postgres-native enums versus
+ * family-layer codec triples) — not the family abstract altitude alone.
+ *
+ * The schema literal lives at the family layer today because
+ * registry-driven validation for arbitrary slot shapes is not wired
+ * yet; once a second polymorphic kind ships through the slot, this
+ * structural enumeration can move to the registry-dispatch site and
+ * per-target schemas can live in their target packages.
+ */
+const PostgresEnumTypeSchema = type({
+  kind: "'postgres-enum'",
+  name: 'string',
   nativeType: 'string',
-  typeParams: 'Record<string, unknown>',
+  values: type.string.array().readonly(),
 });
 
-const PrimaryKeySchema = type.declare<PrimaryKey>().type({
+/**
+ * Family-layer arktype validation enumerates the polymorphic shapes the
+ * SQL family ships today (codec-instance + Postgres-enum). Pack-contributed
+ * entity types ship a parallel arktype schema entry here when they
+ * introduce a new persisted shape; the registry-driven hydration seam at
+ * `SqlContractSerializerBase.hydrateStorageTypeEntry` is open, but the
+ * family-layer structural validator is closed by design — extension
+ * packs cannot inject arbitrary persisted shapes through the slot
+ * without their structural shape being known at the family layer.
+ *
+ * A future refinement is to lift `StorageTypeEntrySchema` toward an
+ * `unknown` fallback and move structural diagnostics to the
+ * registry-dispatch site at hydration time, earned once a non-enum
+ * storage shape needs to flow through the slot without growing another
+ * closed union arm here first.
+ */
+const StorageTypeEntrySchema = PostgresEnumTypeSchema.or(StorageTypeInstanceSchema);
+
+const PrimaryKeySchema = type.declare<PrimaryKeyInput>().type({
   columns: type.string.array().readonly(),
   'name?': 'string',
 });
 
-const UniqueConstraintSchema = type.declare<UniqueConstraint>().type({
+const UniqueConstraintSchema = type.declare<UniqueConstraintInput>().type({
   columns: type.string.array().readonly(),
   'name?': 'string',
 });
@@ -100,7 +151,7 @@ export const IndexSchema = type({
   'options?': 'Record<string, unknown>',
 });
 
-export const ForeignKeyReferencesSchema = type.declare<ForeignKeyReferences>().type({
+export const ForeignKeyReferencesSchema = type.declare<ForeignKeyReferencesInput>().type({
   table: 'string',
   columns: type.string.array().readonly(),
 });
@@ -109,7 +160,7 @@ export const ReferentialActionSchema = type
   .declare<ReferentialAction>()
   .type("'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault'");
 
-export const ForeignKeySchema = type.declare<ForeignKey>().type({
+export const ForeignKeySchema = type.declare<ForeignKeyInput>().type({
   columns: type.string.array().readonly(),
   references: ForeignKeyReferencesSchema,
   'name?': 'string',
@@ -128,11 +179,25 @@ const StorageTableSchema = type({
   foreignKeys: ForeignKeySchema.array().readonly(),
 });
 
+/**
+ * Namespace entry under `storage.namespaces[id]`. SQL contracts honour
+ * the framework `Storage.namespaces` invariant from PR1; today every
+ * contract binds to the singleton placeholder
+ * (`SqlUnspecifiedNamespace.instance`) and the persisted shape carries
+ * just the namespace id. Per-target namespace concretions
+ * (`PostgresSchema`, `SqliteUnspecifiedDatabase`) can additively grow
+ * the persisted shape when they earn their slots.
+ */
+const NamespaceEntrySchema = type({
+  id: 'string',
+});
+
 const StorageSchema = type({
   '+': 'reject',
   storageHash: 'string',
   tables: type({ '[string]': StorageTableSchema }),
-  'types?': type({ '[string]': StorageTypeInstanceSchema }),
+  'types?': type({ '[string]': StorageTypeEntrySchema }),
+  'namespaces?': type({ '[string]': NamespaceEntrySchema }),
 });
 
 function isPlainRecord(value: unknown): value is Record<string, unknown> {
@@ -228,7 +293,6 @@ const SqlContractSchema = type({
 // includes bigint | Date (runtime-only types after decoding) which cannot be expressed
 // in Arktype's JSON validation DSL. The `as SqlStorage` cast in validateStorage() bridges
 // the gap between the JSON-safe Arktype output and the runtime TypeScript type.
-// See decodeContractDefaults() in validate.ts for the decoding step.
 
 /**
  * Validates the structural shape of SqlStorage using Arktype.
@@ -243,7 +307,11 @@ export function validateStorage(value: unknown): SqlStorage {
     const messages = result.map((p: { message: string }) => p.message).join('; ');
     throw new Error(`Storage validation failed: ${messages}`);
   }
-  return result as SqlStorage;
+  // The arktype-validated shape matches `SqlStorageInput`
+  // structurally. Funnel through the constructor so nested IR fields
+  // (`tables`, `types`) are normalised into class instances and the
+  // branded `storageHash` is preserved on the returned `SqlStorage`.
+  return new SqlStorage(result as SqlStorageInput);
 }
 
 export function validateModel(value: unknown): unknown {
@@ -449,3 +517,179 @@ export function validateStorageSemantics(storage: SqlStorage): string[] {
 
   return errors;
 }
+
+/**
+ * SQL storage logical-consistency checks: every model.storage.table
+ * resolves to a real table, every model.storage.fields[*].column
+ * resolves to a real column, and value-object fields land on JSON-native
+ * columns. Throws `ContractValidationError` on the first mismatch.
+ */
+export function validateModelStorageReferences(contract: Contract<SqlStorage>): void {
+  const models = contract.models as Record<string, ContractModel<SqlModelStorage>>;
+  for (const [modelName, model] of Object.entries(models)) {
+    const storageTable = model.storage.table;
+
+    const table = contract.storage.tables[storageTable] as
+      | (typeof contract.storage.tables)[string]
+      | undefined;
+    if (!table) {
+      throw new ContractValidationError(
+        `Model "${modelName}" references non-existent table "${storageTable}"`,
+        'storage',
+      );
+    }
+
+    const columnNames = new Set(Object.keys(table.columns));
+    for (const [fieldName, field] of Object.entries(model.storage.fields)) {
+      if (!columnNames.has(field.column)) {
+        throw new ContractValidationError(
+          `Model "${modelName}" field "${fieldName}" references non-existent column "${field.column}" in table "${storageTable}"`,
+          'storage',
+        );
+      }
+    }
+
+    const JSON_NATIVE_TYPES = new Set(['json', 'jsonb']);
+    for (const [fieldName, domainField] of Object.entries(model.fields ?? {})) {
+      const f = domainField as ContractField;
+      if (f.type?.kind !== 'valueObject') continue;
+      const storageField = model.storage.fields[fieldName];
+      if (!storageField) continue;
+      const column = table.columns[storageField.column];
+      if (!column) continue;
+      if (!JSON_NATIVE_TYPES.has(column.nativeType)) {
+        throw new ContractValidationError(
+          `Model "${modelName}" field "${fieldName}" is a value object but storage column "${storageField.column}" has nativeType "${column.nativeType}" (expected json or jsonb)`,
+          'storage',
+        );
+      }
+    }
+  }
+}
+
+/**
+ * Cross-table consistency checks for SQL storage: primary key, unique,
+ * index, and foreign key column references resolve to real columns;
+ * NOT NULL columns don't carry a literal `null` default; FK column
+ * counts match their referenced columns. Throws on the first mismatch.
+ */
+export function validateSqlStorageConsistency(contract: Contract<SqlStorage>): void {
+  const tableNames = new Set(Object.keys(contract.storage.tables));
+
+  for (const [tableName, table] of Object.entries(contract.storage.tables)) {
+    const columnNames = new Set(Object.keys(table.columns));
+
+    if (table.primaryKey) {
+      for (const colName of table.primaryKey.columns) {
+        if (!columnNames.has(colName)) {
+          throw new ContractValidationError(
+            `Table "${tableName}" primaryKey references non-existent column "${colName}"`,
+            'storage',
+          );
+        }
+      }
+    }
+
+    for (const unique of table.uniques) {
+      for (const colName of unique.columns) {
+        if (!columnNames.has(colName)) {
+          throw new ContractValidationError(
+            `Table "${tableName}" unique constraint references non-existent column "${colName}"`,
+            'storage',
+          );
+        }
+      }
+    }
+
+    for (const index of table.indexes) {
+      for (const colName of index.columns) {
+        if (!columnNames.has(colName)) {
+          throw new ContractValidationError(
+            `Table "${tableName}" index references non-existent column "${colName}"`,
+            'storage',
+          );
+        }
+      }
+    }
+
+    for (const [colName, column] of Object.entries(table.columns)) {
+      if (!column.nullable && column.default?.kind === 'literal' && column.default.value === null) {
+        throw new ContractValidationError(
+          `Table "${tableName}" column "${colName}" is NOT NULL but has a literal null default`,
+          'storage',
+        );
+      }
+    }
+
+    for (const fk of table.foreignKeys) {
+      for (const colName of fk.columns) {
+        if (!columnNames.has(colName)) {
+          throw new ContractValidationError(
+            `Table "${tableName}" foreignKey references non-existent column "${colName}"`,
+            'storage',
+          );
+        }
+      }
+
+      if (!tableNames.has(fk.references.table)) {
+        throw new ContractValidationError(
+          `Table "${tableName}" foreignKey references non-existent table "${fk.references.table}"`,
+          'storage',
+        );
+      }
+
+      const referencedTable = contract.storage.tables[fk.references.table];
+      if (!referencedTable) continue;
+      const referencedColumnNames = new Set(Object.keys(referencedTable.columns));
+      for (const colName of fk.references.columns) {
+        if (!referencedColumnNames.has(colName)) {
+          throw new ContractValidationError(
+            `Table "${tableName}" foreignKey references non-existent column "${colName}" in table "${fk.references.table}"`,
+            'storage',
+          );
+        }
+      }
+
+      if (fk.columns.length !== fk.references.columns.length) {
+        throw new ContractValidationError(
+          `Table "${tableName}" foreignKey column count (${fk.columns.length}) does not match referenced column count (${fk.references.columns.length})`,
+          'storage',
+        );
+      }
+    }
+  }
+}
+
+/**
+ * Full SQL contract validation: structural (arktype) +
+ * framework-shared domain + SQL storage logical-consistency + SQL
+ * storage semantic + model ↔ storage reference checks. Throws
+ * `ContractValidationError` on the first failure. Returns the
+ * validated flat-data shape; IR class hydration happens in the SPI
+ * base on top of this helper.
+ */
+export function validateSqlContractFully<T extends Contract<SqlStorage>>(value: unknown): T {
+  const stripped =
+    typeof value === 'object' && value !== null
+      ? (() => {
+          const { schemaVersion: _, _generated: _g, ...rest } = value as Record<string, unknown>;
+          return rest;
+        })()
+      : value;
+  const validated = validateSqlContract<T>(stripped);
+  validateContractDomain({
+    roots: validated.roots,
+    models: validated.models,
+    ...(validated.valueObjects ? { valueObjects: validated.valueObjects } : {}),
+  });
+  validateSqlStorageConsistency(validated);
+  const semanticErrors = validateStorageSemantics(validated.storage);
+  if (semanticErrors.length > 0) {
+    throw new ContractValidationError(
+      `Contract semantic validation failed: ${semanticErrors.join('; ')}`,
+      'storage',
+    );
+  }
+  validateModelStorageReferences(validated);
+  return validated;
+}

package/dist/types-hgzy8ME1.mjs

@@ -1,13 +0,0 @@
-//#region src/types.ts
-const DEFAULT_FK_CONSTRAINT = true;
-const DEFAULT_FK_INDEX = true;
-function applyFkDefaults(fk, overrideDefaults) {
-	return {
-		constraint: fk.constraint ?? overrideDefaults?.constraint ?? true,
-		index: fk.index ?? overrideDefaults?.index ?? true
-	};
-}
-//#endregion
-export { DEFAULT_FK_INDEX as n, applyFkDefaults as r, DEFAULT_FK_CONSTRAINT as t };
-
-//# sourceMappingURL=types-hgzy8ME1.mjs.map

package/dist/types-hgzy8ME1.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-hgzy8ME1.mjs","names":[],"sources":["../src/types.ts"],"sourcesContent":["import type { ColumnDefault, StorageBase } from '@prisma-next/contract/types';\nimport type { CodecTrait } from '@prisma-next/framework-components/codec';\n\n/**\n * A column definition in storage.\n *\n * `typeParams` is optional because most columns use non-parameterized types.\n * Columns with parameterized types can either inline `typeParams` or reference\n * a named {@link StorageTypeInstance} via `typeRef`.\n */\nexport type StorageColumn = {\n  readonly nativeType: string;\n  readonly codecId: string;\n  readonly nullable: boolean;\n  /**\n   * Opaque, codec-owned JS/type parameters.\n   * The codec that owns `codecId` defines the shape and semantics.\n   * Mutually exclusive with `typeRef`.\n   */\n  readonly typeParams?: Record<string, unknown>;\n  /**\n   * Reference to a named type instance in `storage.types`.\n   * Mutually exclusive with `typeParams`.\n   */\n  readonly typeRef?: string;\n  /**\n   * Default value for the column.\n   * Can be a literal value or database function.\n   */\n  readonly default?: ColumnDefault;\n};\n\nexport type PrimaryKey = {\n  readonly columns: readonly string[];\n  readonly name?: string;\n};\n\nexport type UniqueConstraint = {\n  readonly columns: readonly string[];\n  readonly name?: string;\n};\n\nexport type Index = {\n  readonly columns: readonly string[];\n  readonly name?: string;\n  readonly type?: string;\n  readonly options?: Record<string, unknown>;\n};\n\nexport type ForeignKeyReferences = {\n  readonly table: string;\n  readonly columns: readonly string[];\n};\n\nexport type ReferentialAction = 'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault';\n\nexport type ForeignKeyOptions = {\n  readonly name?: string;\n  readonly onDelete?: ReferentialAction;\n  readonly onUpdate?: ReferentialAction;\n};\n\nexport type ForeignKey = {\n  readonly columns: readonly string[];\n  readonly references: ForeignKeyReferences;\n  readonly name?: string;\n  readonly onDelete?: ReferentialAction;\n  readonly onUpdate?: ReferentialAction;\n  /** Whether to emit FK constraint DDL (ALTER TABLE … ADD CONSTRAINT … FOREIGN KEY). */\n  readonly constraint: boolean;\n  /** Whether to emit a backing index for the FK columns. */\n  readonly index: boolean;\n};\n\nexport type StorageTable = {\n  readonly columns: Record<string, StorageColumn>;\n  readonly primaryKey?: PrimaryKey;\n  readonly uniques: ReadonlyArray<UniqueConstraint>;\n  readonly indexes: ReadonlyArray<Index>;\n  readonly foreignKeys: ReadonlyArray<ForeignKey>;\n};\n\n/**\n * A named, parameterized type instance.\n * These are registered in `storage.types` for reuse across columns\n * and to enable ergonomic schema surfaces like `schema.types.MyType`.\n *\n * Unlike {@link StorageColumn}, `typeParams` is required here because\n * `StorageTypeInstance` exists specifically to define reusable parameterized types.\n * A type instance without parameters would be redundant—columns can reference\n * the codec directly via `codecId`.\n */\nexport type StorageTypeInstance = {\n  readonly codecId: string;\n  readonly nativeType: string;\n  readonly typeParams: Record<string, unknown>;\n};\n\nexport type SqlStorage<THash extends string = string> = StorageBase<THash> & {\n  readonly tables: Record<string, StorageTable>;\n  /**\n   * Named type instances for parameterized/custom types.\n   * Columns can reference these via `typeRef`.\n   */\n  readonly types?: Record<string, StorageTypeInstance>;\n};\n\nexport type SqlModelFieldStorage = {\n  readonly column: string;\n  readonly codecId?: string;\n  readonly nullable?: boolean;\n};\n\nexport type SqlModelStorage = {\n  readonly table: string;\n  readonly fields: Record<string, SqlModelFieldStorage>;\n};\n\nexport const DEFAULT_FK_CONSTRAINT = true;\nexport const DEFAULT_FK_INDEX = true;\n\nexport function applyFkDefaults(\n  fk: { constraint?: boolean | undefined; index?: boolean | undefined },\n  overrideDefaults?: { constraint?: boolean | undefined; index?: boolean | undefined },\n): { constraint: boolean; index: boolean } {\n  return {\n    constraint: fk.constraint ?? overrideDefaults?.constraint ?? DEFAULT_FK_CONSTRAINT,\n    index: fk.index ?? overrideDefaults?.index ?? DEFAULT_FK_INDEX,\n  };\n}\n\nexport type TypeMaps<\n  TCodecTypes extends Record<string, { output: unknown }> = Record<string, never>,\n  TQueryOperationTypes extends Record<string, unknown> = Record<string, never>,\n  TFieldOutputTypes extends Record<string, Record<string, unknown>> = Record<string, never>,\n  TFieldInputTypes extends Record<string, Record<string, unknown>> = Record<string, never>,\n> = {\n  readonly codecTypes: TCodecTypes;\n  readonly queryOperationTypes: TQueryOperationTypes;\n  readonly fieldOutputTypes: TFieldOutputTypes;\n  readonly fieldInputTypes: TFieldInputTypes;\n};\n\nexport type CodecTypesOf<T> = [T] extends [never]\n  ? Record<string, never>\n  : T extends { readonly codecTypes: infer C }\n    ? C extends Record<string, { output: unknown }>\n      ? C\n      : Record<string, never>\n    : Record<string, never>;\n\n/**\n * Dispatch hint identifying the first-argument target of an operation.\n *\n * Used by ORM column helpers to decide whether an operation is reachable on a\n * field. Either names a concrete codec identity or a set of capability traits\n * that the field's codec must carry.\n */\nexport type QueryOperationSelfSpec =\n  | { readonly codecId: string; readonly traits?: never }\n  | { readonly traits: readonly CodecTrait[]; readonly codecId?: never };\n\n/**\n * Structural shape an operation's impl must return: any value carrying a\n * codec-exact `returnType` descriptor. `Expression<T>` (from\n * `@prisma-next/sql-relational-core/expression`, with `T extends ScopeField`)\n * extends this. Trait-targeted returns are deliberately excluded — predicate\n * detection and result decoding both depend on knowing the concrete return\n * codec.\n */\nexport type QueryOperationReturn = {\n  readonly returnType: { readonly codecId: string; readonly nullable: boolean };\n};\n\nexport type QueryOperationTypeEntry = {\n  readonly self?: QueryOperationSelfSpec;\n  readonly impl: (...args: never[]) => QueryOperationReturn;\n};\n\nexport type SqlQueryOperationTypes<\n  _CT extends Record<string, { readonly input: unknown; readonly output: unknown }>,\n  T extends Record<string, QueryOperationTypeEntry>,\n> = T;\n\nexport type QueryOperationTypesBase = Record<string, QueryOperationTypeEntry>;\n\nexport type QueryOperationTypesOf<T> = [T] extends [never]\n  ? Record<string, never>\n  : T extends { readonly queryOperationTypes: infer Q }\n    ? Q extends Record<string, unknown>\n      ? Q\n      : Record<string, never>\n    : Record<string, never>;\n\nexport type TypeMapsPhantomKey = '__@prisma-next/sql-contract/typeMaps@__';\n\nexport type ContractWithTypeMaps<TContract, TTypeMaps> = TContract & {\n  readonly [K in TypeMapsPhantomKey]?: TTypeMaps;\n};\n\nexport type ExtractTypeMapsFromContract<T> = TypeMapsPhantomKey extends keyof T\n  ? NonNullable<T[TypeMapsPhantomKey & keyof T]>\n  : never;\n\nexport type FieldOutputTypesOf<T> = [T] extends [never]\n  ? Record<string, never>\n  : T extends { readonly fieldOutputTypes: infer F }\n    ? F extends Record<string, Record<string, unknown>>\n      ? F\n      : Record<string, never>\n    : Record<string, never>;\n\nexport type FieldInputTypesOf<T> = [T] extends [never]\n  ? Record<string, never>\n  : T extends { readonly fieldInputTypes: infer F }\n    ? F extends Record<string, Record<string, unknown>>\n      ? F\n      : Record<string, never>\n    : Record<string, never>;\n\nexport type ExtractCodecTypes<T> = CodecTypesOf<ExtractTypeMapsFromContract<T>>;\nexport type ExtractQueryOperationTypes<T> = QueryOperationTypesOf<ExtractTypeMapsFromContract<T>>;\nexport type ExtractFieldOutputTypes<T> = FieldOutputTypesOf<ExtractTypeMapsFromContract<T>>;\nexport type ExtractFieldInputTypes<T> = FieldInputTypesOf<ExtractTypeMapsFromContract<T>>;\n\nexport type ResolveCodecTypes<TContract, TTypeMaps> = [TTypeMaps] extends [never]\n  ? ExtractCodecTypes<TContract>\n  : CodecTypesOf<TTypeMaps>;\n"],"mappings":";AAsHA,MAAa,wBAAwB;AACrC,MAAa,mBAAmB;AAEhC,SAAgB,gBACd,IACA,kBACyC;CACzC,OAAO;EACL,YAAY,GAAG,cAAc,kBAAkB,cAAA;EAC/C,OAAO,GAAG,SAAS,kBAAkB,SAAA;EACtC"}