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

package/src/ir/storage-table.ts

@@ -0,0 +1,63 @@
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import { ForeignKey, type ForeignKeyInput } from './foreign-key';
+import { PrimaryKey, type PrimaryKeyInput } from './primary-key';
+import { Index, type IndexInput } from './sql-index';
+import { SqlNode } from './sql-node';
+import { StorageColumn, type StorageColumnInput } from './storage-column';
+import { UniqueConstraint, type UniqueConstraintInput } from './unique-constraint';
+
+export interface StorageTableInput {
+  readonly columns: Record<string, StorageColumn | StorageColumnInput>;
+  readonly primaryKey?: PrimaryKey | PrimaryKeyInput;
+  readonly uniques: ReadonlyArray<UniqueConstraint | UniqueConstraintInput>;
+  readonly indexes: ReadonlyArray<Index | IndexInput>;
+  readonly foreignKeys: ReadonlyArray<ForeignKey | ForeignKeyInput>;
+}
+
+/**
+ * SQL Contract IR node for a single table entry in `SqlStorage.tables`.
+ *
+ * The constructor normalises nested IR-class fields (columns, primary
+ * key, uniques, indexes, foreign keys) into the appropriate class
+ * instances so downstream walks see a uniform AST regardless of whether
+ * the input was a JSON literal or an already-constructed class.
+ *
+ * The table's `name` is not on the class — tables are keyed by name in
+ * the parent `SqlStorage.tables: Record<string, StorageTable>` map.
+ * A future namespace-aware milestone will add a `namespaceId` field
+ * when namespace-keyed storage lands; today's single-namespace shape
+ * needs neither field.
+ */
+export class StorageTable extends SqlNode {
+  readonly columns: Readonly<Record<string, StorageColumn>>;
+  readonly uniques: ReadonlyArray<UniqueConstraint>;
+  readonly indexes: ReadonlyArray<Index>;
+  readonly foreignKeys: ReadonlyArray<ForeignKey>;
+  declare readonly primaryKey?: PrimaryKey;
+
+  constructor(input: StorageTableInput) {
+    super();
+    this.columns = Object.freeze(
+      Object.fromEntries(
+        Object.entries(input.columns).map(([name, col]) => [
+          name,
+          col instanceof StorageColumn ? col : new StorageColumn(col),
+        ]),
+      ),
+    );
+    if (input.primaryKey !== undefined) {
+      this.primaryKey =
+        input.primaryKey instanceof PrimaryKey
+          ? input.primaryKey
+          : new PrimaryKey(input.primaryKey);
+    }
+    this.uniques = Object.freeze(
+      input.uniques.map((u) => (u instanceof UniqueConstraint ? u : new UniqueConstraint(u))),
+    );
+    this.indexes = Object.freeze(input.indexes.map((i) => (i instanceof Index ? i : new Index(i))));
+    this.foreignKeys = Object.freeze(
+      input.foreignKeys.map((fk) => (fk instanceof ForeignKey ? fk : new ForeignKey(fk))),
+    );
+    freezeNode(this);
+  }
+}

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 { ContractValidationError } from '@prisma-next/contract/validate-contract';
+import { ContractValidationError } from '@prisma-next/contract/contract-validation-error';
+import type { Contract, ContractField, ContractModel } from '@prisma-next/contract/types';
+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 {
@@ -256,16 +324,12 @@ export function validateModel(value: unknown): unknown {
 }
 
 /**
- * Validates the structural shape of an SQL contract using Arktype.
- *
- * Ensures all required fields are present and have the correct types,
- * including SQL-specific storage structure (tables, columns, constraints).
- *
- * @param value - The contract value to validate (typically from a JSON import)
- * @returns The validated contract if structure is valid
- * @throws ContractValidationError if the contract structure is invalid
+ * Structural arktype validation of an SQL contract envelope. Internal
+ * helper for {@link validateSqlContractFully} — exposed only inside
+ * this module, since the family seam-of-record is the
+ * `SqlContractSerializerBase.deserializeContract` SPI.
  */
-export function validateSqlContract<T extends Contract<SqlStorage>>(value: unknown): T {
+function validateSqlContractStructure<T extends Contract<SqlStorage>>(value: unknown): T {
   if (typeof value !== 'object' || value === null) {
     throw new ContractValidationError(
       'Contract structural validation failed: value must be an object',
@@ -449,3 +513,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 = validateSqlContractStructure<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