@prisma-next/family-sql 0.11.0-dev.9 → 0.12.0

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

@@ -1,5 +1,6 @@
 import type { ColumnDefault, Contract } from '@prisma-next/contract/types';
 import type { MigrationPlannerConflict } from '@prisma-next/framework-components/control';
+import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import {
   type ForeignKey,
   type Index,
@@ -52,6 +53,26 @@ export type NativeTypeExpander = (input: {
  */
 export type DefaultRenderer = (def: ColumnDefault, column: StorageColumn) => string;
 
+/**
+ * Target-supplied callback that computes the schema-qualified annotation-map
+ * key for a namespace-scoped enum storage type.
+ *
+ * Enum lookups (`readExistingEnumValues`) are namespace/schema-qualified so two
+ * namespaces holding an enum with the same TypeScript name (and even the same
+ * native type) resolve to distinct live-database types. The *format* of that
+ * key — and the namespace → DDL-schema resolution it depends on — is a
+ * target-specific concern (Postgres schemas; SQLite/MySQL differ), so the
+ * target injects it here as data rather than the family layer importing a
+ * concrete `ddlSchemaName`/key implementation. This keeps the family layer
+ * target-agnostic (no `@prisma-next/target-*` dependency) while the projection
+ * still emits keys that match the target's read side exactly.
+ */
+export type EnumStorageKeyResolver = (
+  storage: SqlStorage,
+  namespaceId: string,
+  nativeType: string,
+) => string;
+
 function convertColumn(
   name: string,
   column: StorageColumn,
@@ -152,6 +173,8 @@ function convertForeignKey(fk: ForeignKey): SqlForeignKeyIR {
     referencedSchema: fk.target.namespaceId,
     referencedColumns: fk.target.columns,
     ...ifDefined('name', fk.name),
+    ...ifDefined('onDelete', fk.onDelete),
+    ...ifDefined('onUpdate', fk.onUpdate),
   };
 }
 
@@ -263,6 +286,14 @@ export interface ContractToSchemaIROptions {
   readonly annotationNamespace: string;
   readonly expandNativeType?: NativeTypeExpander;
   readonly renderDefault?: DefaultRenderer;
+  /**
+   * Target-supplied resolver for namespace/schema-qualified enum annotation
+   * keys. When provided (Postgres), every namespace-scoped enum is keyed by the
+   * resolver's output so the projected `storageTypes` map matches the target's
+   * `readExistingEnumValues` lookup. Targets without namespace-qualified enum
+   * storage (SQLite) omit it; enums are absent there.
+   */
+  readonly resolveEnumStorageKey?: EnumStorageKeyResolver;
 }
 
 /**
@@ -328,7 +359,11 @@ export function contractToSchemaIR(
     }
   }
 
-  const annotations = deriveAnnotations(storage, options.annotationNamespace);
+  const annotations = deriveAnnotations(
+    storage,
+    options.annotationNamespace,
+    options.resolveEnumStorageKey,
+  );
 
   return {
     tables,
@@ -336,47 +371,61 @@ export function contractToSchemaIR(
   };
 }
 
+/**
+ * Normalises a native enum storage entry to the codec-typed annotation shape
+ * `{codecId, nativeType, typeParams}` the introspector writes and
+ * `readExistingEnumValues` reads (`existing.codecId` + `existing.typeParams.values`).
+ * Without this the projector would emit the raw `PostgresEnumStorageEntry`
+ * shape (top-level `values`, no `typeParams`) and the enum would read as new.
+ */
+function normalizeEnumAnnotation(entry: PostgresEnumStorageEntry): StorageTypeInstance {
+  return toStorageTypeInstance({
+    codecId: entry.codecId,
+    nativeType: entry.nativeType,
+    typeParams: { values: entry.values },
+  });
+}
+
 function deriveAnnotations(
   storage: SqlStorage,
   annotationNamespace: string,
+  resolveEnumStorageKey: EnumStorageKeyResolver | undefined,
 ): SqlAnnotations | undefined {
-  const allTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {
-    ...((storage.types ?? {}) as ResolvedStorageTypes),
-  };
-  for (const ns of Object.values(storage.namespaces)) {
-    const nsEnums = (ns as { enum?: Record<string, PostgresEnumStorageEntry> }).enum;
-    if (nsEnums) {
-      for (const [k, v] of Object.entries(nsEnums)) {
-        allTypes[k] = v;
-      }
-    }
-  }
-  const types = allTypes as ResolvedStorageTypes;
-  if (Object.keys(types).length === 0) return undefined;
-  // Re-key by nativeType, normalising every variant to the codec-typed
-  // annotation shape `{codecId, nativeType, typeParams}` produced by the
-  // adapter introspector (`introspectPostgresEnumTypes` writes that shape;
-  // see also `enum-planning.ts § readExistingEnumValues`, which reads
-  // `existing.codecId` + `existing.typeParams.values`). Without this
-  // normalisation, the projector would emit the raw
-  // `PostgresEnumStorageEntry` shape (top-level `values`, no `typeParams`)
-  // and downstream Schema IR consumers that walk the codec-typed shape
-  // would see enum entries as new (e.g. the planner emits a fresh
-  // `CreateEnumTypeCall` instead of the rebuild recipe). Unknown future
-  // kinds without `nativeType` are skipped rather than crashing.
-  const byNativeType: Record<string, StorageTypeInstance> = {};
-  for (const typeInstance of Object.values(types)) {
+  const storageTypes: Record<string, StorageTypeInstance> = {};
+
+  // Top-level `storage.types`: codec-typed entries (vector, decimal, …) keyed
+  // by bare `nativeType` (unchanged). Post-S1.B enums live in
+  // `namespaces[*].enum`, not here; a defensive top-level enum is still
+  // namespace/schema-qualified via the resolver under the unbound coordinate
+  // so it never collides on a bare name.
+  for (const typeInstance of Object.values((storage.types ?? {}) as ResolvedStorageTypes)) {
     if (isPostgresEnumStorageEntry(typeInstance)) {
-      byNativeType[typeInstance.nativeType] = toStorageTypeInstance({
-        codecId: typeInstance.codecId,
-        nativeType: typeInstance.nativeType,
-        typeParams: { values: typeInstance.values },
-      });
+      const key = resolveEnumStorageKey
+        ? resolveEnumStorageKey(storage, UNBOUND_NAMESPACE_ID, typeInstance.nativeType)
+        : typeInstance.nativeType;
+      storageTypes[key] = normalizeEnumAnnotation(typeInstance);
       continue;
     }
     if (isStorageTypeInstance(typeInstance)) {
-      byNativeType[typeInstance.nativeType] = typeInstance;
+      storageTypes[typeInstance.nativeType] = typeInstance;
+    }
+  }
+
+  // Namespace-scoped enums: schema-qualified compound key matching the target's
+  // `readExistingEnumValues` read side, so two namespaces sharing an enum name
+  // (or native type) resolve to distinct live-database types.
+  for (const [namespaceId, ns] of Object.entries(storage.namespaces)) {
+    const nsEnums = (ns as { enum?: Record<string, PostgresEnumStorageEntry> }).enum;
+    if (!nsEnums) continue;
+    for (const entry of Object.values(nsEnums)) {
+      if (!isPostgresEnumStorageEntry(entry)) continue;
+      const key = resolveEnumStorageKey
+        ? resolveEnumStorageKey(storage, namespaceId, entry.nativeType)
+        : entry.nativeType;
+      storageTypes[key] = normalizeEnumAnnotation(entry);
     }
   }
-  return { [annotationNamespace]: { storageTypes: byNativeType } };
+
+  if (Object.keys(storageTypes).length === 0) return undefined;
+  return { [annotationNamespace]: { storageTypes } };
 }

package/src/core/migrations/types.ts

@@ -15,7 +15,8 @@ import type {
   MigrationPlanOperation,
   MigrationRunnerExecutionChecks,
   MigrationRunnerFailure,
-  MigrationRunnerSuccessValue,
+  MigrationRunnerPerSpaceSuccessValue,
+  MigrationRunnerResult,
   OperationContext,
   OpFactoryCall,
   SchemaIssue,
@@ -234,7 +235,7 @@ export interface SqlMigrationPlan<TTargetDetails> extends MigrationPlan {
    * pass the extension's space id. Required at every call site so the
    * type system surfaces every place that needs to thread the value
    * (rather than letting an `?? APP_SPACE_ID` fall-through silently
-   * collapse multi-space markers onto the `'app'` row).
+   * collapse per-space markers onto the `'app'` row).
    *
    * @see specs/framework-mechanism.spec.md § 2.
    */
@@ -401,7 +402,7 @@ export interface SqlMigrationRunnerFailure extends MigrationRunnerFailure {
   readonly meta?: AnyRecord;
 }
 
-export interface SqlMigrationRunnerSuccessValue extends MigrationRunnerSuccessValue {}
+export interface SqlMigrationRunnerSuccessValue extends MigrationRunnerPerSpaceSuccessValue {}
 
 export type SqlMigrationRunnerResult = Result<
   SqlMigrationRunnerSuccessValue,
@@ -410,22 +411,29 @@ export type SqlMigrationRunnerResult = Result<
 
 export interface SqlMigrationRunner<TTargetDetails> {
   /**
-   * Apply a single migration plan, opening and managing its own
-   * transaction (and any target-specific connection-level setup, e.g.
-   * SQLite's `PRAGMA foreign_keys` toggle). Existing single-space
-   * callers route through here.
+   * Apply one or more per-space migration plans, opening and managing the
+   * outer transaction (and any target-specific connection-level setup, e.g.
+   * SQLite's `PRAGMA foreign_keys` toggle). An apply that targets one space
+   * passes a one-element `perSpaceOptions` list.
+   *
+   * The caller orders the input list (typically via the aggregate planner's
+   * `applyOrder`: extensions alphabetical, then app). A failure on any space
+   * rolls back every space's writes.
+   *
+   * Each entry must reference the same `driver` as the top-level `driver`
+   * (the connection the outer transaction is open on).
    */
-  execute(
-    options: SqlMigrationRunnerExecuteOptions<TTargetDetails>,
-  ): Promise<SqlMigrationRunnerResult>;
+  execute(options: {
+    readonly driver: ControlDriverInstance<'sql', string>;
+    readonly perSpaceOptions: ReadonlyArray<SqlMigrationRunnerExecuteOptions<TTargetDetails>>;
+  }): Promise<MigrationRunnerResult>;
 
   /**
    * Apply a single migration plan against an already-open connection
    * **without** opening a transaction. The caller is responsible for
    * wrapping the call (and any siblings) in `BEGIN` / `COMMIT` /
-   * `ROLLBACK`. Used by the per-space runner wiring to fan out across
-   * contract spaces inside one outer transaction so a mid-apply
-   * failure rolls back every space's writes.
+   * `ROLLBACK`. Used by {@link SqlMigrationRunner.execute} to fan out
+   * across contract spaces inside one outer transaction.
    *
    * Idempotent control-table setup (`prisma_contract.*`) and marker
    * writes use `options.space` to address the per-space marker row.
@@ -433,40 +441,8 @@ export interface SqlMigrationRunner<TTargetDetails> {
   executeOnConnection(
     options: SqlMigrationRunnerExecuteOptions<TTargetDetails>,
   ): Promise<SqlMigrationRunnerResult>;
-
-  /**
-   * Apply per-space plans across multiple contract spaces inside a
-   * single outer transaction. The caller orders the input list
-   * (typically via the aggregate planner's `applyOrder`: extensions
-   * alphabetical, then app); the runner is responsible for opening
-   * / committing the outer
-   * transaction (and any target-specific connection-level setup such
-   * as the SQLite FK pragma toggle). A failure on any space rolls
-   * back every space's writes.
-   *
-   * Each space's `SqlMigrationRunnerExecuteOptions` must reference the
-   * same `driver` (the connection the outer transaction is open on).
-   * Per-space marker writes use `options.space` to address the row.
-   */
-  executeAcrossSpaces(options: {
-    readonly driver: ControlDriverInstance<'sql', string>;
-    readonly perSpaceOptions: ReadonlyArray<SqlMigrationRunnerExecuteOptions<TTargetDetails>>;
-  }): Promise<MultiSpaceRunnerResult>;
-}
-
-export interface MultiSpaceRunnerSuccessValue {
-  readonly perSpaceResults: ReadonlyArray<{
-    readonly space: string;
-    readonly value: SqlMigrationRunnerSuccessValue;
-  }>;
-}
-
-export interface MultiSpaceRunnerFailure extends SqlMigrationRunnerFailure {
-  readonly failingSpace: string;
 }
 
-export type MultiSpaceRunnerResult = Result<MultiSpaceRunnerSuccessValue, MultiSpaceRunnerFailure>;
-
 export interface SqlControlTargetDescriptor<
   TTargetId extends string,
   TTargetDetails,

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

@@ -14,6 +14,7 @@ import type {
   SchemaVerificationNode,
   VerifyDatabaseSchemaResult,
 } from '@prisma-next/framework-components/control';
+import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import {
   isPostgresEnumStorageEntry,
   isStorageTypeInstance,
@@ -98,6 +99,7 @@ export interface VerifySqlSchemaOptions {
   readonly resolveExistingEnumValues?: (
     schema: SqlSchemaIR,
     enumType: PostgresEnumStorageEntry,
+    namespaceId: string,
   ) => readonly string[] | null;
 }
 
@@ -129,6 +131,8 @@ export function verifySqlSchema(options: VerifySqlSchemaOptions): VerifyDatabase
 
   const { contractStorageHash, contractProfileHash, contractTarget } =
     extractContractMetadata(contract);
+  // Column `typeRef` resolution map: keyed by the bare contract type name
+  // (columns carry bare `typeRef`s). Used by `verifySchemaTables` only.
   const allStorageTypesMap: Record<string, PostgresEnumStorageEntry | StorageTypeInstance> = {
     ...((contract.storage.types ?? {}) as Record<
       string,
@@ -159,48 +163,86 @@ export function verifySqlSchema(options: VerifySqlSchemaOptions): VerifyDatabase
 
   validateFrameworkComponentsForExtensions(contract, options.frameworkComponents);
 
-  // Verify storage type instances. PostgresEnumStorageEntry entries are walked
-  // natively (using the bridging adapter `resolveExistingEnumValues`);
-  // remaining codec-typed entries continue to dispatch through the
-  // generic codec-hook `verifyType` path.
-  const storageTypeEntries = Object.entries(storageTypes);
-  if (storageTypeEntries.length > 0) {
-    const typeNodes: SchemaVerificationNode[] = [];
-    for (const [typeName, typeInstance] of storageTypeEntries) {
-      let typeIssues: readonly SchemaIssue[];
-      if (isPostgresEnumStorageEntry(typeInstance)) {
-        typeIssues = verifyEnumType({
+  // Verify storage type instances. Codec-typed `storage.types` entries dispatch
+  // through the generic codec-hook `verifyType` path (keyed by bare name).
+  // `PostgresEnumStorageEntry` enums are walked natively *per namespace* (using
+  // the bridging adapter `resolveExistingEnumValues`) so two namespaces that
+  // declare an enum with the same name are each verified with their own
+  // namespace coordinate — a bare-name aggregation would collapse them
+  // (last-write-wins) and verify only one.
+  const typeNodes: SchemaVerificationNode[] = [];
+  const pushTypeNode = (
+    typeName: string,
+    contractPath: string,
+    typeIssues: readonly SchemaIssue[],
+  ): void => {
+    if (typeIssues.length > 0) {
+      issues.push(...typeIssues);
+    }
+    typeNodes.push({
+      status: typeIssues.length > 0 ? 'fail' : 'pass',
+      kind: 'storageType',
+      name: `type ${typeName}`,
+      contractPath,
+      code: typeIssues.length > 0 ? (typeIssues[0]?.kind ?? '') : '',
+      message:
+        typeIssues.length > 0
+          ? `${typeIssues.length} issue${typeIssues.length === 1 ? '' : 's'}`
+          : '',
+      expected: undefined,
+      actual: undefined,
+      children: [],
+    });
+  };
+
+  // Top-level `storage.types`: codec-typed entries via codec hooks; a
+  // defensive top-level enum is verified under the unbound coordinate.
+  for (const [typeName, typeInstance] of Object.entries(contract.storage.types ?? {})) {
+    if (isPostgresEnumStorageEntry(typeInstance)) {
+      pushTypeNode(
+        typeName,
+        `storage.types.${typeName}`,
+        verifyEnumType({
           typeName,
           typeInstance,
           schema,
           resolveExistingEnumValues,
-        });
-      } else if (isStorageTypeInstance(typeInstance)) {
-        const hook = codecHooks.get(typeInstance.codecId);
-        typeIssues = hook?.verifyType ? hook.verifyType({ typeName, typeInstance, schema }) : [];
-      } else {
-        typeIssues = [];
-      }
-      if (typeIssues.length > 0) {
-        issues.push(...typeIssues);
-      }
-      const typeStatus = typeIssues.length > 0 ? 'fail' : 'pass';
-      const typeCode = typeIssues.length > 0 ? (typeIssues[0]?.kind ?? '') : '';
-      typeNodes.push({
-        status: typeStatus,
-        kind: 'storageType',
-        name: `type ${typeName}`,
-        contractPath: `storage.types.${typeName}`,
-        code: typeCode,
-        message:
-          typeIssues.length > 0
-            ? `${typeIssues.length} issue${typeIssues.length === 1 ? '' : 's'}`
-            : '',
-        expected: undefined,
-        actual: undefined,
-        children: [],
-      });
+          namespaceId: UNBOUND_NAMESPACE_ID,
+        }),
+      );
+    } else if (isStorageTypeInstance(typeInstance)) {
+      const hook = codecHooks.get(typeInstance.codecId);
+      pushTypeNode(
+        typeName,
+        `storage.types.${typeName}`,
+        hook?.verifyType ? hook.verifyType({ typeName, typeInstance, schema }) : [],
+      );
     }
+  }
+
+  // Namespace-scoped enums, verified per `(namespaceId, typeName)`.
+  for (const nsId of Object.keys(contract.storage.namespaces)) {
+    const ns = contract.storage.namespaces[nsId];
+    if (!ns) continue;
+    const nsEnums = ns.enum;
+    if (!nsEnums) continue;
+    for (const [typeName, entry] of Object.entries(nsEnums)) {
+      if (!isPostgresEnumStorageEntry(entry)) continue;
+      pushTypeNode(
+        typeName,
+        `storage.namespaces.${nsId}.enum.${typeName}`,
+        verifyEnumType({
+          typeName,
+          typeInstance: entry,
+          schema,
+          resolveExistingEnumValues,
+          namespaceId: nsId,
+        }),
+      );
+    }
+  }
+
+  if (typeNodes.length > 0) {
     const typesStatus = typeNodes.some((n) => n.status === 'fail') ? 'fail' : 'pass';
     rootChildren.push({
       status: typesStatus,
@@ -275,18 +317,24 @@ function verifyEnumType(options: {
   readonly typeName: string;
   readonly typeInstance: PostgresEnumStorageEntry;
   readonly schema: SqlSchemaIR;
+  readonly namespaceId: string;
   readonly resolveExistingEnumValues?:
-    | ((schema: SqlSchemaIR, enumType: PostgresEnumStorageEntry) => readonly string[] | null)
+    | ((
+        schema: SqlSchemaIR,
+        enumType: PostgresEnumStorageEntry,
+        namespaceId: string,
+      ) => readonly string[] | null)
     | undefined;
 }): readonly SchemaIssue[] {
-  const { typeName, typeInstance, schema, resolveExistingEnumValues } = options;
+  const { typeName, typeInstance, schema, namespaceId, resolveExistingEnumValues } = options;
   const desired = typeInstance.values;
-  const existing = resolveExistingEnumValues?.(schema, typeInstance) ?? null;
+  const existing = resolveExistingEnumValues?.(schema, typeInstance, namespaceId) ?? null;
   if (!existing) {
     return [
       {
         kind: 'type_missing',
         typeName,
+        namespaceId,
         message: `Type "${typeName}" is missing from database`,
       },
     ];
@@ -305,6 +353,7 @@ function verifyEnumType(options: {
   return [
     {
       kind: 'enum_values_changed' as const,
+      namespaceId,
       typeName,
       addedValues,
       removedValues,

package/src/exports/control.ts

@@ -17,6 +17,7 @@ export type { SqlControlFamilyInstance } from '../core/control-instance';
 export type {
   ContractToSchemaIROptions,
   DefaultRenderer,
+  EnumStorageKeyResolver,
   NativeTypeExpander,
 } from '../core/migrations/contract-to-schema-ir';
 // Contract → SchemaIR conversion for offline migration planning
@@ -40,9 +41,6 @@ export type {
   ExpandNativeTypeInput,
   FieldEvent,
   FieldEventContext,
-  MultiSpaceRunnerFailure,
-  MultiSpaceRunnerResult,
-  MultiSpaceRunnerSuccessValue,
   ResolveIdentityValueInput,
   SqlControlAdapterDescriptor,
   SqlControlExtensionDescriptor,

package/dist/sql-contract-serializer-VVoSAnYg.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"sql-contract-serializer-VVoSAnYg.mjs","names":[],"sources":["../src/core/ir/sql-contract-serializer-base.ts","../src/core/ir/sql-contract-serializer.ts"],"sourcesContent":["import { ContractValidationError } from '@prisma-next/contract/contract-validation-error';\nimport type { Contract } from '@prisma-next/contract/types';\nimport type { ContractSerializer } from '@prisma-next/framework-components/control';\nimport { type Namespace, NamespaceBase } from '@prisma-next/framework-components/ir';\nimport {\n  type SqlNamespaceTablesInput,\n  SqlStorage,\n  type SqlStorageTypeEntry,\n  StorageTable,\n  type StorageTableInput,\n} from '@prisma-next/sql-contract/types';\nimport {\n  createSqlContractSchema,\n  validateSqlContractFully,\n} from '@prisma-next/sql-contract/validators';\nimport type { JsonObject } from '@prisma-next/utils/json';\nimport { type Type, type } from 'arktype';\n\nconst NamespaceRawSchema = type({\n  id: 'string',\n  'kind?': 'string',\n  // Undeclared keys (`tables`, `enum`, and any pack-contributed slot maps)\n  // intentionally pass through; the slot loop below iterates them by name.\n  '+': 'ignore',\n});\n\nfunction isPlainRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\nexport type SqlEntityHydrationFactory = (entry: unknown) => SqlStorageTypeEntry;\n\n/**\n * SQL family `ContractSerializer` abstract base. Carries the SQL-shared\n * deserialization pipeline:\n *\n * 1. `parseSqlContractStructure` validates the on-disk JSON envelope\n *    against the SQL contract arktype schema (`validateSqlContractFully`)\n *    and returns the validated flat-data shape.\n * 2. `hydrateSqlStorage` walks the validated `storage` subtree and\n *    constructs the family-shared SQL Contract IR class hierarchy\n *    (`SqlStorage` -> `StorageTable` -> `StorageColumn` / `PrimaryKey`\n *    / …). The rest of the contract envelope is JSON-clean primitive\n *    data and passes through unchanged.\n * 3. `constructTargetContract` is the target-specific extension hook;\n *    defaults to identity. Targets that need to attach target-only\n *    fields (e.g. target-specific derived storage fields) override it.\n *\n * Default `serializeContract` is identity over the contract — concrete\n * SQL targets ship JSON-clean class instances, so the contract value\n * can be stringified directly. The non-enumerable family-level `kind`\n * discriminator on `SqlNode` instances stays out of the persisted\n * envelope automatically. Targets that need to canonicalize on the way\n * out (key ordering, dropping computed-only fields) override\n * `serializeContract` directly.\n */\nexport abstract class SqlContractSerializerBase<TContract extends Contract<SqlStorage>>\n  implements ContractSerializer<TContract>\n{\n  private readonly contractSchema: Type<unknown> | undefined;\n\n  constructor(\n    private readonly entityTypeRegistry: ReadonlyMap<string, SqlEntityHydrationFactory> = new Map(),\n    validatorFragments?: ReadonlyMap<string, Type<unknown>>,\n  ) {\n    // Only build a fragments-aware contract schema when pack contributions\n    // exist. The cached module-level default in `validators.ts` covers the\n    // no-contributions case and avoids per-instance schema compilation.\n    this.contractSchema =\n      validatorFragments !== undefined && validatorFragments.size > 0\n        ? createSqlContractSchema(validatorFragments)\n        : undefined;\n  }\n\n  deserializeContract<T extends TContract = TContract>(json: unknown): T {\n    const validated = this.parseSqlContractStructure(json);\n    const hydrated = this.hydrateSqlStorage(validated);\n    return this.constructTargetContract(hydrated) as T;\n  }\n\n  serializeContract(contract: TContract): JsonObject {\n    return contract as unknown as JsonObject;\n  }\n\n  protected parseSqlContractStructure(json: unknown): Contract<SqlStorage> {\n    return validateSqlContractFully<Contract<SqlStorage>>(\n      json,\n      this.contractSchema !== undefined ? { contractSchema: this.contractSchema } : undefined,\n    );\n  }\n\n  protected hydrateSqlStorage(validated: Contract<SqlStorage>): Contract<SqlStorage> {\n    const types = validated.storage.types;\n    const hydratedTypes =\n      types !== undefined\n        ? Object.fromEntries(\n            Object.entries(types).map(([name, entry]) => [\n              name,\n              this.hydrateStorageTypeEntry(entry),\n            ]),\n          )\n        : undefined;\n\n    const rawNamespaces = validated.storage.namespaces;\n    const hydratedNamespaces =\n      rawNamespaces !== undefined ? this.hydrateSqlNamespaceMap(rawNamespaces) : undefined;\n\n    return {\n      ...validated,\n      storage: new SqlStorage({\n        storageHash: validated.storage.storageHash,\n        ...(hydratedTypes !== undefined ? { types: hydratedTypes } : {}),\n        ...(hydratedNamespaces !== undefined ? { namespaces: hydratedNamespaces } : {}),\n      }),\n    };\n  }\n\n  protected hydrateSqlNamespaceMap(\n    namespaces: Readonly<Record<string, Namespace | Record<string, unknown>>>,\n  ): Readonly<Record<string, Namespace | SqlNamespaceTablesInput>> {\n    return Object.fromEntries(\n      Object.entries(namespaces).map(([nsId, raw]) => [\n        nsId,\n        this.hydrateSqlNamespaceEntry(nsId, raw),\n      ]),\n    );\n  }\n\n  protected hydrateSqlNamespaceEntry(\n    nsId: string,\n    raw: Namespace | Record<string, unknown>,\n  ): Namespace | SqlNamespaceTablesInput {\n    if (raw instanceof NamespaceBase) {\n      return raw;\n    }\n    const rawRecord = isPlainRecord(raw) ? raw : {};\n    const id = typeof rawRecord['id'] === 'string' ? rawRecord['id'] : nsId;\n    const parsed = NamespaceRawSchema({ ...rawRecord, id });\n    if (parsed instanceof type.errors) {\n      const messages = parsed.map((p: { message: string }) => p.message).join('; ');\n      throw new ContractValidationError(`Namespace hydration failed: ${messages}`, 'structural');\n    }\n    const result: Record<string, unknown> = { id };\n\n    for (const [propertyKey, slotValue] of Object.entries(parsed)) {\n      if (propertyKey === 'id') continue;\n      if (slotValue === null || typeof slotValue !== 'object') continue;\n\n      if (propertyKey === 'tables') {\n        result['tables'] = Object.fromEntries(\n          Object.entries(slotValue as Record<string, unknown>).map(([tableName, table]) => [\n            tableName,\n            table instanceof StorageTable ? table : new StorageTable(table as StorageTableInput),\n          ]),\n        );\n        continue;\n      }\n\n      const hydratedSlot = Object.fromEntries(\n        Object.entries(slotValue as Record<string, unknown>).map(([entryName, entry]) => {\n          if (typeof entry !== 'object' || entry === null) {\n            return [entryName, entry];\n          }\n          const kind = (entry as { kind?: unknown }).kind;\n          if (typeof kind === 'string') {\n            const factory = this.entityTypeRegistry.get(kind);\n            if (factory !== undefined) {\n              return [entryName, factory(entry)];\n            }\n          }\n          return [entryName, entry];\n        }),\n      );\n      if (Object.keys(hydratedSlot).length > 0) {\n        result[propertyKey] = hydratedSlot;\n      }\n    }\n\n    const enumRaw = rawRecord['enum'];\n    if (enumRaw !== undefined && typeof enumRaw === 'object' && enumRaw !== null) {\n      for (const entry of Object.values(enumRaw as Record<string, unknown>)) {\n        if (typeof entry !== 'object' || entry === null) continue;\n        const kind = (entry as { kind?: unknown }).kind;\n        if (typeof kind === 'string' && this.entityTypeRegistry.get(kind) === undefined) {\n          throw new ContractValidationError(\n            `Entry kind '${kind}' has no registered hydration factory.`,\n            'structural',\n          );\n        }\n      }\n    }\n\n    const tables = (result['tables'] ?? {}) as Record<string, StorageTable>;\n    const enumSlot = result['enum'] as NonNullable<SqlNamespaceTablesInput['enum']> | undefined;\n    return {\n      ...result,\n      tables,\n      ...(enumSlot !== undefined ? { enum: enumSlot } : {}),\n    } as SqlNamespaceTablesInput;\n  }\n\n  protected hydrateStorageTypeEntry(entry: SqlStorageTypeEntry): SqlStorageTypeEntry {\n    if (typeof entry !== 'object' || entry === null) {\n      return entry;\n    }\n    const kind = (entry as { kind?: unknown }).kind;\n    if (typeof kind !== 'string') {\n      return entry;\n    }\n    const factory = this.entityTypeRegistry.get(kind);\n    if (factory === undefined) {\n      return entry;\n    }\n    return factory(entry);\n  }\n\n  protected constructTargetContract(hydrated: Contract<SqlStorage>): TContract {\n    return hydrated as TContract;\n  }\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { SqlContractSerializerBase } from './sql-contract-serializer-base';\n\n/**\n * Default SQL family `ContractSerializer` concretion. Inherits the\n * full SQL-shared deserialization pipeline (structural validation +\n * IR-class hydration) without pack-registered `storage.types`\n * hydration factories — targets that emit polymorphic JSON outside the\n * codec-typed envelope wire a target-specific subclass with a populated\n * registry (see Postgres). Family-level call sites instantiate this\n * default directly when no target serializer is supplied.\n */\nexport class SqlContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {\n  constructor() {\n    super(new Map());\n  }\n}\n"],"mappings":"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"}

package/dist/types-hQoMXr54.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-hQoMXr54.d.mts","names":[],"sources":["../src/core/control-instance.ts","../src/core/migrations/types.ts"],"mappings":"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"}

package/dist/verify-sql-schema-Bfvz07Ik.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"verify-sql-schema-Bfvz07Ik.d.mts","names":[],"sources":["../src/core/schema-verify/verify-sql-schema.ts"],"mappings":";;;;;;;;;;;KA2CY,iBAAA,IACV,UAAA,UACA,UAAA,aACG,aAAA;;;;;AAYL;KALY,oBAAA,IAAwB,UAAA;;;;UAKnB,sBAAA;EAQI;EAAA,SANV,QAAA,EAAU,QAAA,CAAS,UAAA;EAagB;EAAA,SAXnC,MAAA,EAAQ,WAAA;EAiBW;EAAA,SAfnB,MAAA;EAkCC;EAAA,SAhCD,OAAA,GAAU,gBAAA;EAiCiB;EAAA,SA/B3B,oBAAA,EAAsB,WAAA;IAAsB,UAAA;EAAA;EARzB;;;;EAAA,SAanB,mBAAA,EAAqB,aAAA,CAAc,8BAAA;EAPzB;;;;;EAAA,SAaV,gBAAA,GAAmB,iBAAA;EANgB;;;;;EAAA,SAYnC,mBAAA,GAAsB,oBAAA;EAarB;;;;;;AAeZ;;;;;EAfY,SADD,yBAAA,IACP,MAAA,EAAQ,WAAA,EACR,QAAA,EAAU,wBAAA;AAAA;;;;;;;;;;;iBAcE,eAAA,CAAgB,OAAA,EAAS,sBAAA,GAAyB,0BAAA"}