@prisma-next/family-sql 0.9.0 → 0.10.0

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

@@ -7,6 +7,7 @@ import type {
   SchemaIssue,
   SchemaVerificationNode,
 } from '@prisma-next/framework-components/control';
+import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import type {
   ForeignKey,
   Index,
@@ -133,12 +134,14 @@ export function verifyPrimaryKey(
   contractPK: PrimaryKey,
   schemaPK: PrimaryKey | undefined,
   tableName: string,
+  namespaceId: string,
   issues: SchemaIssue[],
 ): 'pass' | 'fail' {
   if (!schemaPK) {
     issues.push({
       kind: 'primary_key_mismatch',
       table: tableName,
+      namespaceId,
       expected: contractPK.columns.join(', '),
       message: `Table "${tableName}" is missing primary key`,
     });
@@ -149,6 +152,7 @@ export function verifyPrimaryKey(
     issues.push({
       kind: 'primary_key_mismatch',
       table: tableName,
+      namespaceId,
       expected: contractPK.columns.join(', '),
       actual: schemaPK.columns.join(', '),
       message: `Table "${tableName}" has primary key mismatch: expected columns [${contractPK.columns.join(', ')}], got [${schemaPK.columns.join(', ')}]`,
@@ -173,6 +177,7 @@ export function verifyForeignKeys(
   contractFKs: readonly ForeignKey[],
   schemaFKs: readonly SqlForeignKeyIR[],
   tableName: string,
+  namespaceId: string,
   tablePath: string,
   issues: SchemaIssue[],
   strict: boolean,
@@ -181,12 +186,23 @@ export function verifyForeignKeys(
 
   // Check each contract FK exists in schema
   for (const contractFK of contractFKs) {
-    const fkPath = `${tablePath}.foreignKeys[${contractFK.columns.join(',')}]`;
+    const fkPath = `${tablePath}.foreignKeys[${contractFK.source.columns.join(',')}]`;
     const matchingFK = schemaFKs.find((fk) => {
+      // When the schema FK carries referencedSchema (populated by the Postgres
+      // adapter for cross-schema FKs), compare the full (namespace, table) pair
+      // against the contract FK's target coordinate. When referencedSchema is
+      // absent (same-schema FKs, older introspection, or hand-crafted test
+      // fixtures), fall back to table-name-only comparison so same-namespace
+      // contracts continue to verify correctly.
+      const tablesMatch =
+        fk.referencedSchema !== undefined && contractFK.target.namespaceId !== UNBOUND_NAMESPACE_ID
+          ? fk.referencedSchema === contractFK.target.namespaceId &&
+            fk.referencedTable === contractFK.target.tableName
+          : fk.referencedTable === contractFK.target.tableName;
       return (
-        arraysEqual(fk.columns, contractFK.columns) &&
-        fk.referencedTable === contractFK.references.table &&
-        arraysEqual(fk.referencedColumns, contractFK.references.columns)
+        arraysEqual(fk.columns, contractFK.source.columns) &&
+        tablesMatch &&
+        arraysEqual(fk.referencedColumns, contractFK.target.columns)
       );
     });
 
@@ -194,13 +210,14 @@ export function verifyForeignKeys(
       issues.push({
         kind: 'foreign_key_mismatch',
         table: tableName,
-        expected: `${contractFK.columns.join(', ')} -> ${contractFK.references.table}(${contractFK.references.columns.join(', ')})`,
-        message: `Table "${tableName}" is missing foreign key: ${contractFK.columns.join(', ')} -> ${contractFK.references.table}(${contractFK.references.columns.join(', ')})`,
+        namespaceId,
+        expected: `${contractFK.source.columns.join(', ')} -> ${contractFK.target.tableName}(${contractFK.target.columns.join(', ')})`,
+        message: `Table "${tableName}" is missing foreign key: ${contractFK.source.columns.join(', ')} -> ${contractFK.target.tableName}(${contractFK.target.columns.join(', ')})`,
       });
       nodes.push({
         status: 'fail',
         kind: 'foreignKey',
-        name: `foreignKey(${contractFK.columns.join(', ')})`,
+        name: `foreignKey(${contractFK.source.columns.join(', ')})`,
         contractPath: fkPath,
         code: 'foreign_key_mismatch',
         message: 'Foreign key missing',
@@ -217,17 +234,18 @@ export function verifyForeignKeys(
         issues.push({
           kind: 'foreign_key_mismatch',
           table: tableName,
+          namespaceId,
           // Set indexOrConstraint so the planner classifies this as a non-additive
           // conflict (existing FK with wrong actions cannot be fixed additively).
-          indexOrConstraint: matchingFK.name ?? `fk(${contractFK.columns.join(',')})`,
+          indexOrConstraint: matchingFK.name ?? `fk(${contractFK.source.columns.join(',')})`,
           expected: combinedExpected,
           actual: combinedActual,
-          message: `Table "${tableName}" foreign key ${contractFK.columns.join(', ')} -> ${contractFK.references.table}: ${combinedMessage}`,
+          message: `Table "${tableName}" foreign key ${contractFK.source.columns.join(', ')} -> ${contractFK.target.tableName}: ${combinedMessage}`,
         });
         nodes.push({
           status: 'fail',
           kind: 'foreignKey',
-          name: `foreignKey(${contractFK.columns.join(', ')})`,
+          name: `foreignKey(${contractFK.source.columns.join(', ')})`,
           contractPath: fkPath,
           code: 'foreign_key_mismatch',
           message: combinedMessage,
@@ -239,7 +257,7 @@ export function verifyForeignKeys(
         nodes.push({
           status: 'pass',
           kind: 'foreignKey',
-          name: `foreignKey(${contractFK.columns.join(', ')})`,
+          name: `foreignKey(${contractFK.source.columns.join(', ')})`,
           contractPath: fkPath,
           code: '',
           message: '',
@@ -255,10 +273,15 @@ export function verifyForeignKeys(
   if (strict) {
     for (const schemaFK of schemaFKs) {
       const matchingFK = contractFKs.find((fk) => {
+        const tablesMatch =
+          schemaFK.referencedSchema !== undefined && fk.target.namespaceId !== UNBOUND_NAMESPACE_ID
+            ? schemaFK.referencedSchema === fk.target.namespaceId &&
+              schemaFK.referencedTable === fk.target.tableName
+            : schemaFK.referencedTable === fk.target.tableName;
         return (
-          arraysEqual(fk.columns, schemaFK.columns) &&
-          fk.references.table === schemaFK.referencedTable &&
-          arraysEqual(fk.references.columns, schemaFK.referencedColumns)
+          arraysEqual(fk.source.columns, schemaFK.columns) &&
+          tablesMatch &&
+          arraysEqual(fk.target.columns, schemaFK.referencedColumns)
         );
       });
 
@@ -266,6 +289,7 @@ export function verifyForeignKeys(
         issues.push({
           kind: 'extra_foreign_key',
           table: tableName,
+          namespaceId,
           indexOrConstraint: schemaFK.name ?? `fk(${schemaFK.columns.join(',')})`,
           message: `Extra foreign key found in database (not in contract): ${schemaFK.columns.join(', ')} -> ${schemaFK.referencedTable}(${schemaFK.referencedColumns.join(', ')})`,
         });
@@ -303,6 +327,7 @@ export function verifyUniqueConstraints(
   schemaUniques: readonly SqlUniqueIR[],
   schemaIndexes: readonly SqlIndexIR[],
   tableName: string,
+  namespaceId: string,
   tablePath: string,
   issues: SchemaIssue[],
   strict: boolean,
@@ -327,6 +352,7 @@ export function verifyUniqueConstraints(
       issues.push({
         kind: 'unique_constraint_mismatch',
         table: tableName,
+        namespaceId,
         expected: contractUnique.columns.join(', '),
         message: `Table "${tableName}" is missing unique constraint: ${contractUnique.columns.join(', ')}`,
       });
@@ -369,6 +395,7 @@ export function verifyUniqueConstraints(
         issues.push({
           kind: 'extra_unique_constraint',
           table: tableName,
+          namespaceId,
           indexOrConstraint: schemaUnique.name ?? `unique(${schemaUnique.columns.join(',')})`,
           message: `Extra unique constraint found in database (not in contract): ${schemaUnique.columns.join(', ')}`,
         });
@@ -406,6 +433,7 @@ export function verifyIndexes(
   schemaIndexes: readonly SqlIndexIR[],
   schemaUniques: readonly SqlUniqueIR[],
   tableName: string,
+  namespaceId: string,
   tablePath: string,
   issues: SchemaIssue[],
   strict: boolean,
@@ -436,6 +464,7 @@ export function verifyIndexes(
       issues.push({
         kind: 'index_mismatch',
         table: tableName,
+        namespaceId,
         expected: contractIndex.columns.join(', '),
         message: `Table "${tableName}" is missing index: ${contractIndex.columns.join(', ')}`,
       });
@@ -484,6 +513,7 @@ export function verifyIndexes(
         issues.push({
           kind: 'extra_index',
           table: tableName,
+          namespaceId,
           indexOrConstraint: schemaIndex.name ?? `idx(${schemaIndex.columns.join(',')})`,
           message: `Extra index found in database (not in contract): ${schemaIndex.columns.join(', ')}`,
         });

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

@@ -20,6 +20,7 @@ import {
   type PostgresEnumStorageEntry,
   type SqlStorage,
   type StorageColumn,
+  StorageTable,
   type StorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
@@ -128,7 +129,21 @@ export function verifySqlSchema(options: VerifySqlSchemaOptions): VerifyDatabase
 
   const { contractStorageHash, contractProfileHash, contractTarget } =
     extractContractMetadata(contract);
-  const storageTypes = (contract.storage.types ?? {}) as Readonly<
+  const allStorageTypesMap: Record<string, PostgresEnumStorageEntry | StorageTypeInstance> = {
+    ...((contract.storage.types ?? {}) as Record<
+      string,
+      PostgresEnumStorageEntry | StorageTypeInstance
+    >),
+  };
+  for (const ns of Object.values(contract.storage.namespaces)) {
+    const nsTypes = (ns as { types?: Record<string, PostgresEnumStorageEntry> }).types;
+    if (nsTypes) {
+      for (const [k, v] of Object.entries(nsTypes)) {
+        allStorageTypesMap[k] = v;
+      }
+    }
+  }
+  const storageTypes = allStorageTypesMap as Readonly<
     Record<string, PostgresEnumStorageEntry | StorageTypeInstance>
   >;
   const { issues, rootChildren } = verifySchemaTables({
@@ -335,52 +350,73 @@ function verifySchemaTables(options: {
   } = options;
   const issues: SchemaIssue[] = [];
   const rootChildren: SchemaVerificationNode[] = [];
-  const contractTables = contract.storage.tables;
   const schemaTables = schema.tables;
+  const namespaceIds = Object.keys(contract.storage.namespaces).sort((a, b) =>
+    a < b ? -1 : a > b ? 1 : 0,
+  );
 
-  for (const [tableName, contractTable] of Object.entries(contractTables)) {
-    const schemaTable = schemaTables[tableName];
-    const tablePath = `storage.tables.${tableName}`;
+  for (const namespaceId of namespaceIds) {
+    const ns = contract.storage.namespaces[namespaceId];
+    if (!ns) continue;
+    for (const [tableName, contractTableRaw] of Object.entries(ns.tables)) {
+      if (!(contractTableRaw instanceof StorageTable)) {
+        throw new Error(
+          `verifySqlSchema: expected StorageTable at storage.namespaces.${namespaceId}.tables.${tableName}`,
+        );
+      }
+      const contractTable = contractTableRaw;
+      const schemaTable = schemaTables[tableName];
+      const tablePath = `storage.namespaces.${namespaceId}.tables.${tableName}`;
 
-    if (!schemaTable) {
-      issues.push({
-        kind: 'missing_table',
-        table: tableName,
-        message: `Table "${tableName}" is missing from database`,
-      });
-      rootChildren.push({
-        status: 'fail',
-        kind: 'table',
-        name: `table ${tableName}`,
-        contractPath: tablePath,
-        code: 'missing_table',
-        message: `Table "${tableName}" is missing`,
-        expected: undefined,
-        actual: undefined,
-        children: [],
+      if (!schemaTable) {
+        issues.push({
+          kind: 'missing_table',
+          table: tableName,
+          namespaceId,
+          message: `Table "${tableName}" is missing from database`,
+        });
+        rootChildren.push({
+          status: 'fail',
+          kind: 'table',
+          name: `table ${tableName}`,
+          contractPath: tablePath,
+          code: 'missing_table',
+          message: `Table "${tableName}" is missing`,
+          expected: undefined,
+          actual: undefined,
+          children: [],
+        });
+        continue;
+      }
+
+      const tableChildren = verifyTableChildren({
+        contractTable,
+        schemaTable,
+        tableName,
+        namespaceId,
+        tablePath,
+        issues,
+        strict,
+        typeMetadataRegistry,
+        codecHooks,
+        storageTypes,
+        ...ifDefined('normalizeDefault', normalizeDefault),
+        ...ifDefined('normalizeNativeType', normalizeNativeType),
       });
-      continue;
+      rootChildren.push(buildTableNode(tableName, tablePath, tableChildren));
     }
-
-    const tableChildren = verifyTableChildren({
-      contractTable,
-      schemaTable,
-      tableName,
-      tablePath,
-      issues,
-      strict,
-      typeMetadataRegistry,
-      codecHooks,
-      storageTypes,
-      ...ifDefined('normalizeDefault', normalizeDefault),
-      ...ifDefined('normalizeNativeType', normalizeNativeType),
-    });
-    rootChildren.push(buildTableNode(tableName, tablePath, tableChildren));
   }
 
   if (strict) {
     for (const tableName of Object.keys(schemaTables)) {
-      if (!contractTables[tableName]) {
+      const claimed = namespaceIds.some(
+        (namespaceId) => contract.storage.namespaces[namespaceId]?.tables[tableName] !== undefined,
+      );
+      if (!claimed) {
+        // `namespaceId` is intentionally absent: an extra table exists in the
+        // live database but is not claimed by any contract namespace, so there
+        // is no contract coordinate to stamp here. Planners that consume this
+        // issue must handle the unstamped case (drop / quarantine by name).
         issues.push({
           kind: 'extra_table',
           table: tableName,
@@ -390,7 +426,7 @@ function verifySchemaTables(options: {
           status: 'fail',
           kind: 'table',
           name: `table ${tableName}`,
-          contractPath: `storage.tables.${tableName}`,
+          contractPath: `storage.namespaces.*.tables.${tableName}`,
           code: 'extra_table',
           message: `Extra table "${tableName}" found`,
           expected: undefined,
@@ -405,9 +441,10 @@ function verifySchemaTables(options: {
 }
 
 function verifyTableChildren(options: {
-  contractTable: Contract<SqlStorage>['storage']['tables'][string];
+  contractTable: StorageTable;
   schemaTable: SqlSchemaIR['tables'][string];
   tableName: string;
+  namespaceId: string;
   tablePath: string;
   issues: SchemaIssue[];
   strict: boolean;
@@ -421,6 +458,7 @@ function verifyTableChildren(options: {
     contractTable,
     schemaTable,
     tableName,
+    namespaceId,
     tablePath,
     issues,
     strict,
@@ -435,6 +473,7 @@ function verifyTableChildren(options: {
     contractTable,
     schemaTable,
     tableName,
+    namespaceId,
     tablePath,
     issues,
     strict,
@@ -452,6 +491,7 @@ function verifyTableChildren(options: {
       contractTable,
       schemaTable,
       tableName,
+      namespaceId,
       tablePath,
       issues,
       columnNodes,
@@ -463,6 +503,7 @@ function verifyTableChildren(options: {
       contractTable.primaryKey,
       schemaTable.primaryKey,
       tableName,
+      namespaceId,
       issues,
     );
     if (pkStatus === 'fail') {
@@ -494,6 +535,7 @@ function verifyTableChildren(options: {
     issues.push({
       kind: 'extra_primary_key',
       table: tableName,
+      namespaceId,
       message: 'Extra primary key found in database (not in contract)',
     });
     tableChildren.push({
@@ -518,6 +560,7 @@ function verifyTableChildren(options: {
       constraintFks,
       schemaTable.foreignKeys,
       tableName,
+      namespaceId,
       tablePath,
       issues,
       strict,
@@ -530,6 +573,7 @@ function verifyTableChildren(options: {
     schemaTable.uniques,
     schemaTable.indexes,
     tableName,
+    namespaceId,
     tablePath,
     issues,
     strict,
@@ -543,9 +587,9 @@ function verifyTableChildren(options: {
     .filter(
       (fk) =>
         fk.index === true &&
-        !contractTable.indexes.some((idx) => arraysEqual(idx.columns, fk.columns)),
+        !contractTable.indexes.some((idx) => arraysEqual(idx.columns, fk.source.columns)),
     )
-    .map((fk) => ({ columns: fk.columns }));
+    .map((fk) => ({ columns: fk.source.columns }));
   const allExpectedIndexes = [...contractTable.indexes, ...fkBackingIndexes];
 
   const indexStatuses = verifyIndexes(
@@ -553,6 +597,7 @@ function verifyTableChildren(options: {
     schemaTable.indexes,
     schemaTable.uniques,
     tableName,
+    namespaceId,
     tablePath,
     issues,
     strict,
@@ -563,9 +608,10 @@ function verifyTableChildren(options: {
 }
 
 function collectContractColumnNodes(options: {
-  contractTable: Contract<SqlStorage>['storage']['tables'][string];
+  contractTable: StorageTable;
   schemaTable: SqlSchemaIR['tables'][string];
   tableName: string;
+  namespaceId: string;
   tablePath: string;
   issues: SchemaIssue[];
   strict: boolean;
@@ -579,6 +625,7 @@ function collectContractColumnNodes(options: {
     contractTable,
     schemaTable,
     tableName,
+    namespaceId,
     tablePath,
     issues,
     strict,
@@ -598,6 +645,7 @@ function collectContractColumnNodes(options: {
       issues.push({
         kind: 'missing_column',
         table: tableName,
+        namespaceId,
         column: columnName,
         message: `Column "${tableName}"."${columnName}" is missing from database`,
       });
@@ -618,6 +666,7 @@ function collectContractColumnNodes(options: {
     columnNodes.push(
       verifyColumn({
         tableName,
+        namespaceId,
         columnName,
         contractColumn,
         schemaColumn,
@@ -637,19 +686,22 @@ function collectContractColumnNodes(options: {
 }
 
 function appendExtraColumnNodes(options: {
-  contractTable: Contract<SqlStorage>['storage']['tables'][string];
+  contractTable: StorageTable;
   schemaTable: SqlSchemaIR['tables'][string];
   tableName: string;
+  namespaceId: string;
   tablePath: string;
   issues: SchemaIssue[];
   columnNodes: SchemaVerificationNode[];
 }): void {
-  const { contractTable, schemaTable, tableName, tablePath, issues, columnNodes } = options;
+  const { contractTable, schemaTable, tableName, namespaceId, tablePath, issues, columnNodes } =
+    options;
   for (const [columnName, { nativeType }] of Object.entries(schemaTable.columns)) {
     if (!contractTable.columns[columnName]) {
       issues.push({
         kind: 'extra_column',
         table: tableName,
+        namespaceId,
         column: columnName,
         message: `Extra column "${tableName}"."${columnName}" found in database (not in contract)`,
       });
@@ -670,8 +722,9 @@ function appendExtraColumnNodes(options: {
 
 function verifyColumn(options: {
   tableName: string;
+  namespaceId: string;
   columnName: string;
-  contractColumn: Contract<SqlStorage>['storage']['tables'][string]['columns'][string];
+  contractColumn: StorageTable['columns'][string];
   schemaColumn: SqlSchemaIR['tables'][string]['columns'][string];
   columnPath: string;
   issues: SchemaIssue[];
@@ -684,6 +737,7 @@ function verifyColumn(options: {
 }): SchemaVerificationNode {
   const {
     tableName,
+    namespaceId,
     columnName,
     contractColumn,
     schemaColumn,
@@ -713,6 +767,7 @@ function verifyColumn(options: {
     issues.push({
       kind: 'type_mismatch',
       table: tableName,
+      namespaceId,
       column: columnName,
       expected: contractNativeType,
       actual: schemaNativeType,
@@ -768,6 +823,7 @@ function verifyColumn(options: {
     issues.push({
       kind: 'nullability_mismatch',
       table: tableName,
+      namespaceId,
       column: columnName,
       expected: String(contractColumn.nullable),
       actual: String(schemaColumn.nullable),
@@ -793,6 +849,7 @@ function verifyColumn(options: {
       issues.push({
         kind: 'default_missing',
         table: tableName,
+        namespaceId,
         column: columnName,
         expected: defaultDescription,
         message: `Column "${tableName}"."${columnName}" should have default ${defaultDescription} but database has no default`,
@@ -823,6 +880,7 @@ function verifyColumn(options: {
       issues.push({
         kind: 'default_mismatch',
         table: tableName,
+        namespaceId,
         column: columnName,
         expected: expectedDescription,
         actual: actualDescription,
@@ -845,6 +903,7 @@ function verifyColumn(options: {
     issues.push({
       kind: 'extra_default',
       table: tableName,
+      namespaceId,
       column: columnName,
       actual: schemaColumn.default,
       message: `Column "${tableName}"."${columnName}" has default ${schemaColumn.default} in database but contract specifies no default`,
@@ -1020,7 +1079,7 @@ function validateFrameworkComponentsForExtensions(
  * target-specific adapters (like Postgres) to provide their own expansion logic.
  */
 function renderExpectedNativeType(
-  contractColumn: Contract<SqlStorage>['storage']['tables'][string]['columns'][string],
+  contractColumn: StorageColumn,
   storageTypes: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>,
   codecHooks: Map<string, CodecControlHooks>,
   context?: {

package/dist/sql-contract-serializer-qUQCnP-k.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"sql-contract-serializer-qUQCnP-k.mjs","names":[],"sources":["../src/core/ir/sql-contract-serializer-base.ts","../src/core/ir/sql-contract-serializer.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type { ContractSerializer } from '@prisma-next/framework-components/control';\nimport { SqlStorage, type SqlStorageTypeEntry } from '@prisma-next/sql-contract/types';\nimport { validateSqlContractFully } from '@prisma-next/sql-contract/validators';\nimport type { JsonObject } from '@prisma-next/utils/json';\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  constructor(\n    private readonly entityTypeRegistry: ReadonlyMap<string, SqlEntityHydrationFactory>,\n  ) {}\n\n  deserializeContract(json: unknown): TContract {\n    const validated = this.parseSqlContractStructure(json);\n    const hydrated = this.hydrateSqlStorage(validated);\n    return this.constructTargetContract(hydrated);\n  }\n\n  serializeContract(contract: TContract): JsonObject {\n    // Targets that ship enumerable runtime-only fields must override\n    // this method (mirroring `MongoTargetContractSerializer.serializeContract`)\n    // to construct the persisted envelope explicitly; the default identity\n    // works only when every enumerable own property belongs in the JSON.\n    return contract as unknown as JsonObject;\n  }\n\n  /**\n   * Family-shared validation pipeline (delegates to\n   * `validateSqlContractFully` in `@prisma-next/sql-contract/validators`):\n   * structural arktype + framework-shared domain + SQL storage\n   * logical-consistency + SQL storage semantic + model ↔ storage\n   * reference checks. Subclasses override to add target-specific\n   * structural checks before hydration; the family default suffices\n   * for targets whose contract shape is the SQL-shared shape\n   * (Postgres, SQLite today).\n   */\n  protected parseSqlContractStructure(json: unknown): Contract<SqlStorage> {\n    return validateSqlContractFully<Contract<SqlStorage>>(json);\n  }\n\n  /**\n   * Family-shared hydration walker. Lifts the validated flat-data\n   * `storage` subtree into the SQL Contract IR class hierarchy by\n   * constructing a single `SqlStorage` instance — its constructor\n   * cascades nested instantiation of `StorageTable`, `StorageColumn`,\n   * `PrimaryKey`, `UniqueConstraint`, `Index`, `ForeignKey`,\n   * `ForeignKeyReferences`, and `StorageTypeInstance`. The rest of the\n   * contract envelope (target identity, hashes, capabilities, models,\n   * meta, …) is JSON-clean primitive data and passes through unchanged.\n   *\n   * Polymorphic `storage.types` entries are normalised before the\n   * `SqlStorage` constructor runs: when an entry carries an enumerable\n   * string `kind`, the serializer looks up a pack-registered hydration\n   * factory for that discriminator and delegates reconstruction. Entries\n   * with no registered factory pass through unchanged (codec-typed JSON\n   * stays codec-typed until `SqlStorage` normalises it).\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    return {\n      ...validated,\n      storage: new SqlStorage({\n        ...validated.storage,\n        ...(hydratedTypes !== undefined ? { types: hydratedTypes } : {}),\n      }),\n    };\n  }\n\n  /**\n   * Per-entry hydration dispatcher for `storage.types`. When `kind` is a\n   * string and the constructor registry supplies a factory for that key,\n   * the factory returns the hydrated `SqlStorageTypeEntry`. Otherwise the\n   * entry passes through unchanged for `SqlStorage` to normalise.\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  /**\n   * Target-specific construction hook. Defaults to identity; targets\n   * that need to wrap the hydrated contract (e.g. attach target-only\n   * derived fields, narrow the contract type to a target-specific\n   * subtype) override.\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,IAAsB,4BAAtB,MAEA;CAEqB;CADnB,YACE,oBACA;EADiB,KAAA,qBAAA;;CAGnB,oBAAoB,MAA0B;EAC5C,MAAM,YAAY,KAAK,0BAA0B,KAAK;EACtD,MAAM,WAAW,KAAK,kBAAkB,UAAU;EAClD,OAAO,KAAK,wBAAwB,SAAS;;CAG/C,kBAAkB,UAAiC;EAKjD,OAAO;;;;;;;;;;;;CAaT,0BAAoC,MAAqC;EACvE,OAAO,yBAA+C,KAAK;;;;;;;;;;;;;;;;;;;CAoB7D,kBAA4B,WAAuD;EACjF,MAAM,QAAQ,UAAU,QAAQ;EAChC,MAAM,gBACJ,UAAU,KAAA,IACN,OAAO,YACL,OAAO,QAAQ,MAAM,CAAC,KAAK,CAAC,MAAM,WAAW,CAC3C,MACA,KAAK,wBAAwB,MAAM,CACpC,CAAC,CACH,GACD,KAAA;EAEN,OAAO;GACL,GAAG;GACH,SAAS,IAAI,WAAW;IACtB,GAAG,UAAU;IACb,GAAI,kBAAkB,KAAA,IAAY,EAAE,OAAO,eAAe,GAAG,EAAE;IAChE,CAAC;GACH;;;;;;;;CASH,wBAAkC,OAAiD;EACjF,IAAI,OAAO,UAAU,YAAY,UAAU,MACzC,OAAO;EAET,MAAM,OAAQ,MAA6B;EAC3C,IAAI,OAAO,SAAS,UAClB,OAAO;EAET,MAAM,UAAU,KAAK,mBAAmB,IAAI,KAAK;EACjD,IAAI,YAAY,KAAA,GACd,OAAO;EAET,OAAO,QAAQ,MAAM;;;;;;;;CASvB,wBAAkC,UAA2C;EAC3E,OAAO;;;;;;;;;;;;;;ACxHX,IAAa,wBAAb,cAA2C,0BAAgD;CACzF,cAAc;EACZ,sBAAM,IAAI,KAAK,CAAC"}

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

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