@prisma-next/family-sql 0.12.0 → 0.13.0-dev.1

package/src/core/control-instance.ts

@@ -1,10 +1,13 @@
-import type { Contract, ContractMarkerRecord } from '@prisma-next/contract/types';
+import type {
+  Contract,
+  ContractMarkerRecord,
+  LedgerEntryRecord,
+} from '@prisma-next/contract/types';
 import type {
   TargetBoundComponentDescriptor,
   TargetDescriptor,
 } from '@prisma-next/framework-components/components';
 import type {
-  ControlDriverInstance,
   ControlFamilyInstance,
   ControlStack,
   CoreSchemaView,
@@ -28,17 +31,13 @@ import type { TypesImportSpec } from '@prisma-next/framework-components/emission
 import type { PslDocumentAst } from '@prisma-next/framework-components/psl-ast';
 import { assertDescriptorSelfConsistency } from '@prisma-next/migration-tools/spaces';
 import { sqlContractCanonicalizationHooks } from '@prisma-next/sql-contract/canonicalization-hooks';
-import type { SqlStorage } from '@prisma-next/sql-contract/types';
+import type { SqlControlDriverInstance, SqlStorage } from '@prisma-next/sql-contract/types';
 import type {
   AnyQueryAst,
+  DdlNode,
   LoweredStatement,
   LowererContext,
 } from '@prisma-next/sql-relational-core/ast';
-import {
-  ensureSchemaStatement,
-  ensureTableStatement,
-  writeContractMarker,
-} from '@prisma-next/sql-runtime';
 import { defaultIndexName } from '@prisma-next/sql-schema-ir/naming';
 import type { SqlSchemaIR, SqlTableIR } from '@prisma-next/sql-schema-ir/types';
 import { ifDefined } from '@prisma-next/utils/defined';
@@ -69,10 +68,10 @@ function extractCodecTypeIdsFromContract(contract: unknown): readonly string[] {
   ) {
     const namespaces = contract.storage.namespaces as Record<
       string,
-      { readonly tables?: Readonly<Record<string, unknown>> }
+      { readonly entries: { readonly table: Readonly<Record<string, unknown>> } }
     >;
     for (const ns of Object.values(namespaces)) {
-      const tbls = ns.tables;
+      const tbls = ns.entries.table;
       if (typeof tbls !== 'object' || tbls === null) continue;
       for (const table of Object.values(tbls)) {
         if (
@@ -203,7 +202,7 @@ export interface SqlControlFamilyInstance
   deserializeContract(contractJson: unknown): Contract;
 
   verify(options: {
-    readonly driver: ControlDriverInstance<'sql', string>;
+    readonly driver: SqlControlDriverInstance<string>;
     readonly contract: unknown;
     readonly expectedTargetId: string;
     readonly contractPath: string;
@@ -228,43 +227,77 @@ export interface SqlControlFamilyInstance
   }): VerifyDatabaseSchemaResult;
 
   sign(options: {
-    readonly driver: ControlDriverInstance<'sql', string>;
+    readonly driver: SqlControlDriverInstance<string>;
     readonly contract: unknown;
     readonly contractPath: string;
     readonly configPath?: string;
   }): Promise<SignDatabaseResult>;
 
   introspect(options: {
-    readonly driver: ControlDriverInstance<'sql', string>;
+    readonly driver: SqlControlDriverInstance<string>;
     readonly contract?: unknown;
   }): Promise<SqlSchemaIR>;
 
   inferPslContract(schemaIR: SqlSchemaIR): PslDocumentAst;
 
-  lowerAst(ast: AnyQueryAst, context: LowererContext<unknown>): LoweredStatement;
+  lowerAst(ast: AnyQueryAst | DdlNode, context: LowererContext<unknown>): LoweredStatement;
+
+  /**
+   * Inserts the initial marker row for `space` (upsert on `space`).
+   * Delegates to the target control adapter's write SPI; see
+   * `SqlControlAdapter.initMarker`.
+   */
+  initMarker(options: {
+    readonly driver: SqlControlDriverInstance<string>;
+    readonly space: string;
+    readonly destination: {
+      readonly storageHash: string;
+      readonly profileHash: string;
+      readonly invariants?: readonly string[];
+    };
+  }): Promise<void>;
+
+  /**
+   * Compare-and-swap advance of the marker row for `space`. Returns `true`
+   * when the swap matched a row; see `SqlControlAdapter.updateMarker`.
+   */
+  updateMarker(options: {
+    readonly driver: SqlControlDriverInstance<string>;
+    readonly space: string;
+    readonly expectedFrom: string;
+    readonly destination: {
+      readonly storageHash: string;
+      readonly profileHash: string;
+      readonly invariants?: readonly string[];
+    };
+  }): Promise<boolean>;
+
+  /**
+   * Appends a ledger entry for `space`; see
+   * `SqlControlAdapter.writeLedgerEntry`.
+   */
+  writeLedgerEntry(options: {
+    readonly driver: SqlControlDriverInstance<string>;
+    readonly space: string;
+    readonly entry: {
+      readonly edgeId: string;
+      readonly from: string;
+      readonly to: string;
+      readonly migrationName: string;
+      readonly migrationHash: string;
+      readonly operations: readonly unknown[];
+    };
+  }): Promise<void>;
+
+  bootstrapControlTableQueries(): readonly DdlNode[];
+
+  bootstrapSignMarkerQueries(): readonly DdlNode[];
 
   toOperationPreview(operations: readonly MigrationPlanOperation[]): OperationPreview;
 }
 
 export type SqlFamilyInstance = SqlControlFamilyInstance;
 
-function isSqlControlAdapter<TTargetId extends string>(
-  value: unknown,
-): value is SqlControlAdapter<TTargetId> {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    'introspect' in value &&
-    typeof (value as { introspect: unknown }).introspect === 'function' &&
-    'readMarker' in value &&
-    typeof (value as { readMarker: unknown }).readMarker === 'function' &&
-    'readAllMarkers' in value &&
-    typeof (value as { readAllMarkers: unknown }).readAllMarkers === 'function' &&
-    'lower' in value &&
-    typeof (value as { lower: unknown }).lower === 'function'
-  );
-}
-
 interface DescriptorWithStorageTypes {
   readonly targetId?: string | undefined;
   readonly types?:
@@ -314,6 +347,113 @@ function buildSqlTypeMetadataRegistry(options: {
   return registry;
 }
 
+interface CrossSpaceFkView {
+  readonly id: string;
+  readonly contractSpace?: {
+    readonly contractJson?: {
+      readonly extensionPacks?: Readonly<Record<string, unknown>>;
+      readonly storage?: {
+        readonly namespaces?: Readonly<Record<string, unknown>>;
+      };
+    };
+  };
+}
+
+/**
+ * Builds a map from each extension id to the set of extension ids it
+ * transitively depends on. Uses the same declared-dependency data that
+ * `buildExtensionLoadOrder` in control-stack uses.
+ */
+function buildTransitiveDependsOnMap(
+  extensions: readonly CrossSpaceFkView[],
+): Map<string, Set<string>> {
+  const directDeps = new Map<string, readonly string[]>();
+  for (const ext of extensions) {
+    const packs = ext.contractSpace?.contractJson?.extensionPacks;
+    const deps = packs !== null && typeof packs === 'object' ? Object.keys(packs) : [];
+    directDeps.set(ext.id, deps);
+  }
+
+  const result = new Map<string, Set<string>>();
+  const resolve = (id: string, visiting: Set<string>): Set<string> => {
+    const cached = result.get(id);
+    if (cached !== undefined) return cached;
+    const set = new Set<string>();
+    result.set(id, set);
+    for (const depId of directDeps.get(id) ?? []) {
+      set.add(depId);
+      if (!visiting.has(depId)) {
+        visiting.add(depId);
+        for (const transitive of resolve(depId, visiting)) {
+          set.add(transitive);
+        }
+        visiting.delete(depId);
+      }
+    }
+    return set;
+  };
+
+  for (const ext of extensions) {
+    resolve(ext.id, new Set([ext.id]));
+  }
+  return result;
+}
+
+/**
+ * Asserts that no cross-space FK in any extension points against the
+ * dependency direction.
+ *
+ * A cross-space FK (target.spaceId present) from extension A pointing at
+ * space B is a violation when B depends on A (directly or transitively),
+ * because that means A is pointing "upward" against the dependency arrows
+ * established by the extension load order.
+ *
+ * Throws with a diagnostic naming the violating extension (source), the
+ * target space, and the direction violation.
+ */
+function isObjectRecord(v: unknown): v is Record<string, unknown> {
+  return typeof v === 'object' && v !== null;
+}
+
+export function assertNoCrossSpaceFkReverseReferences(
+  extensions: readonly CrossSpaceFkView[],
+): void {
+  const dependsOnMap = buildTransitiveDependsOnMap(extensions);
+
+  for (const ext of extensions) {
+    const namespaces = ext.contractSpace?.contractJson?.storage?.namespaces;
+    if (!isObjectRecord(namespaces)) continue;
+    for (const ns of Object.values(namespaces)) {
+      if (!isObjectRecord(ns)) continue;
+      const entries = ns['entries'];
+      if (!isObjectRecord(entries)) continue;
+      for (const slot of Object.values(entries)) {
+        if (!isObjectRecord(slot)) continue;
+        for (const table of Object.values(slot)) {
+          if (!isObjectRecord(table)) continue;
+          const foreignKeys = table['foreignKeys'];
+          if (!Array.isArray(foreignKeys)) continue;
+          for (const fk of foreignKeys) {
+            if (!isObjectRecord(fk)) continue;
+            const target = fk['target'];
+            if (!isObjectRecord(target)) continue;
+            if (target['spaceId'] === undefined) continue;
+            const targetSpaceId = target['spaceId'];
+            if (typeof targetSpaceId !== 'string') continue;
+            // Check if targetSpaceId depends on ext.id (directly or transitively)
+            const targetDeps = dependsOnMap.get(targetSpaceId);
+            if (targetDeps?.has(ext.id)) {
+              throw new Error(
+                `Cross-space FK reverse-reference detected: extension "${ext.id}" has a cross-space FK targeting space "${targetSpaceId}", but "${targetSpaceId}" depends on "${ext.id}". Cross-space FKs must follow the dependency direction (a space can only reference spaces it depends on, not spaces that depend on it).`,
+              );
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
 export function createSqlFamilyInstance<TTargetId extends string>(
   stack: ControlStack<'sql', TTargetId>,
 ): SqlFamilyInstance {
@@ -353,6 +493,8 @@ export function createSqlFamilyInstance<TTargetId extends string>(
     }
   }
 
+  assertNoCrossSpaceFkReverseReferences(extensions);
+
   const { codecTypeImports, extensionIds } = stack;
 
   const typeMetadataRegistry = buildSqlTypeMetadataRegistry({
@@ -361,19 +503,20 @@ export function createSqlFamilyInstance<TTargetId extends string>(
     extensionPacks: extensions,
   });
 
-  // Family-instance methods accept `ControlDriverInstance<'sql', string>` —
-  // the family API isn't generic on the target id. Letting `isSqlControlAdapter`
-  // default its type parameter narrows the adapter to `SqlControlAdapter<string>`,
-  // which matches the family-level driver type without any cast at call sites.
-  const getControlAdapter = () => {
-    const controlAdapter = adapter.create(stack);
-    if (!isSqlControlAdapter(controlAdapter)) {
-      throw new Error(
-        'Adapter does not implement SqlControlAdapter (missing introspect, readMarker, or readAllMarkers)',
-      );
-    }
-    return controlAdapter;
-  };
+  // Lazily construct the control adapter on first use, then memoize it.
+  // Merely building a family instance must not instantiate the adapter —
+  // that would change the load/instantiate semantics of the whole stack
+  // wherever a family is created (every CLI command, emit, verify, …), not
+  // just the migration paths that actually need it. Memoizing also avoids
+  // the previous per-operation re-instantiation (a fresh adapter on every
+  // call). Family-instance methods accept `SqlControlDriverInstance<string>`
+  // (the family API isn't generic on the target id); the adapter
+  // descriptor's `create` returns the concrete `SqlControlAdapter<TTargetId>`,
+  // widened to `string` to match the family-level driver type without a
+  // per-method probe.
+  let controlAdapter: SqlControlAdapter<string> | undefined;
+  const getControlAdapter = (): SqlControlAdapter<string> =>
+    (controlAdapter ??= adapter.create(stack));
 
   const targetSerializer = (
     target as unknown as {
@@ -396,7 +539,7 @@ export function createSqlFamilyInstance<TTargetId extends string>(
     },
 
     async verify(verifyOptions: {
-      readonly driver: ControlDriverInstance<'sql', string>;
+      readonly driver: SqlControlDriverInstance<string>;
       readonly contract: unknown;
       readonly expectedTargetId: string;
       readonly contractPath: string;
@@ -544,7 +687,7 @@ export function createSqlFamilyInstance<TTargetId extends string>(
       });
     },
     async sign(options: {
-      readonly driver: ControlDriverInstance<'sql', string>;
+      readonly driver: SqlControlDriverInstance<string>;
       readonly contract: unknown;
       readonly contractPath: string;
       readonly configPath?: string;
@@ -561,24 +704,24 @@ export function createSqlFamilyInstance<TTargetId extends string>(
           : contractStorageHash;
       const contractTarget = contract.target;
 
-      await driver.query(ensureSchemaStatement.sql, ensureSchemaStatement.params);
-      await driver.query(ensureTableStatement.sql, ensureTableStatement.params);
+      const controlAdapter = getControlAdapter();
+      const lowererContext = { contract };
+      for (const query of controlAdapter.bootstrapSignMarkerQueries()) {
+        const lowered = controlAdapter.lower(query, lowererContext);
+        await driver.query(lowered.sql, lowered.params);
+      }
 
-      const existingMarker = await getControlAdapter().readMarker(driver, APP_SPACE_ID);
+      const existingMarker = await controlAdapter.readMarker(driver, APP_SPACE_ID);
 
       let markerCreated = false;
       let markerUpdated = false;
       let previousHashes: { storageHash?: string; profileHash?: string } | undefined;
 
       if (!existingMarker) {
-        const write = writeContractMarker({
-          space: APP_SPACE_ID,
+        await controlAdapter.insertMarker(driver, APP_SPACE_ID, {
           storageHash: contractStorageHash,
           profileHash: contractProfileHash,
-          contractJson: contractInput,
-          canonicalVersion: 1,
         });
-        await driver.query(write.insert.sql, write.insert.params);
         markerCreated = true;
       } else {
         const existingStorageHash = existingMarker.storageHash;
@@ -592,14 +735,18 @@ export function createSqlFamilyInstance<TTargetId extends string>(
             storageHash: existingStorageHash,
             profileHash: existingProfileHash,
           };
-          const write = writeContractMarker({
-            space: APP_SPACE_ID,
-            storageHash: contractStorageHash,
-            profileHash: contractProfileHash,
-            contractJson: contractInput,
-            canonicalVersion: existingMarker.canonicalVersion ?? 1,
-          });
-          await driver.query(write.update.sql, write.update.params);
+          const updated = await controlAdapter.updateMarker(
+            driver,
+            APP_SPACE_ID,
+            existingStorageHash,
+            {
+              storageHash: contractStorageHash,
+              profileHash: contractProfileHash,
+            },
+          );
+          if (!updated) {
+            throw new Error('CAS conflict: marker was modified by another process during sign');
+          }
           markerUpdated = true;
         }
       }
@@ -641,18 +788,66 @@ export function createSqlFamilyInstance<TTargetId extends string>(
       };
     },
     async readMarker(options: {
-      readonly driver: ControlDriverInstance<'sql', string>;
+      readonly driver: SqlControlDriverInstance<string>;
       readonly space: string;
     }): Promise<ContractMarkerRecord | null> {
       return getControlAdapter().readMarker(options.driver, options.space);
     },
     async readAllMarkers(options: {
-      readonly driver: ControlDriverInstance<'sql', string>;
+      readonly driver: SqlControlDriverInstance<string>;
     }): Promise<ReadonlyMap<string, ContractMarkerRecord>> {
       return getControlAdapter().readAllMarkers(options.driver);
     },
+    async readLedger(options: {
+      readonly driver: SqlControlDriverInstance<string>;
+      readonly space?: string;
+    }): Promise<readonly LedgerEntryRecord[]> {
+      return getControlAdapter().readLedger(options.driver, options.space);
+    },
+    async initMarker(options: {
+      readonly driver: SqlControlDriverInstance<string>;
+      readonly space: string;
+      readonly destination: {
+        readonly storageHash: string;
+        readonly profileHash: string;
+        readonly invariants?: readonly string[];
+      };
+    }): Promise<void> {
+      return getControlAdapter().initMarker(options.driver, options.space, options.destination);
+    },
+    async updateMarker(options: {
+      readonly driver: SqlControlDriverInstance<string>;
+      readonly space: string;
+      readonly expectedFrom: string;
+      readonly destination: {
+        readonly storageHash: string;
+        readonly profileHash: string;
+        readonly invariants?: readonly string[];
+      };
+    }): Promise<boolean> {
+      return getControlAdapter().updateMarker(
+        options.driver,
+        options.space,
+        options.expectedFrom,
+        options.destination,
+      );
+    },
+    async writeLedgerEntry(options: {
+      readonly driver: SqlControlDriverInstance<string>;
+      readonly space: string;
+      readonly entry: {
+        readonly edgeId: string;
+        readonly from: string;
+        readonly to: string;
+        readonly migrationName: string;
+        readonly migrationHash: string;
+        readonly operations: readonly unknown[];
+      };
+    }): Promise<void> {
+      return getControlAdapter().writeLedgerEntry(options.driver, options.space, options.entry);
+    },
     async introspect(options: {
-      readonly driver: ControlDriverInstance<'sql', string>;
+      readonly driver: SqlControlDriverInstance<string>;
       readonly contract?: unknown;
     }): Promise<SqlSchemaIR> {
       return getControlAdapter().introspect(options.driver, options.contract);
@@ -662,10 +857,18 @@ export function createSqlFamilyInstance<TTargetId extends string>(
       return sqlSchemaIrToPslAst(schemaIR);
     },
 
-    lowerAst(ast: AnyQueryAst, context: LowererContext<unknown>): LoweredStatement {
+    lowerAst(ast: AnyQueryAst | DdlNode, context: LowererContext<unknown>): LoweredStatement {
       return getControlAdapter().lower(ast, context);
     },
 
+    bootstrapControlTableQueries(): readonly DdlNode[] {
+      return getControlAdapter().bootstrapControlTableQueries();
+    },
+
+    bootstrapSignMarkerQueries(): readonly DdlNode[] {
+      return getControlAdapter().bootstrapSignMarkerQueries();
+    },
+
     toOperationPreview(operations: readonly MigrationPlanOperation[]): OperationPreview {
       return sqlOperationsToPreview(operations);
     },

package/src/core/default-namespace.ts

@@ -0,0 +1,9 @@
+export {
+  type ResolvedDomainModel,
+  resolveDomainModel,
+  UNBOUND_DOMAIN_NAMESPACE_ID,
+} from '@prisma-next/contract/types';
+export {
+  type ResolvedStorageTable,
+  resolveStorageTable,
+} from '@prisma-next/sql-contract/resolve-storage-table';

package/src/core/ir/sql-contract-serializer-base.ts

@@ -16,6 +16,8 @@ import {
   SqlUnboundNamespace,
   StorageTable,
   type StorageTableInput,
+  StorageValueSet,
+  type StorageValueSetInput,
 } from '@prisma-next/sql-contract/types';
 import {
   createSqlContractSchema,
@@ -29,16 +31,16 @@ import { type Type, type } from 'arktype';
 const NamespaceRawSchema = type({
   id: 'string',
   'kind?': 'string',
-  // Undeclared keys (`tables`, `enum`, and any pack-contributed slot maps)
-  // intentionally pass through; the slot loop below iterates them by name.
-  '+': 'ignore',
+  entries: type({
+    '+': 'ignore',
+  }),
 });
 
 function isPlainRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
-export type SqlEntityHydrationFactory = (entry: unknown) => SqlStorageTypeEntry;
+export type SqlEntityHydrationFactory = (entry: unknown) => unknown;
 
 /**
  * SQL family `ContractSerializer` abstract base. Carries the SQL-shared
@@ -70,7 +72,10 @@ export abstract class SqlContractSerializerBase<TContract extends Contract<SqlSt
   private readonly contractSchema: Type<unknown> | undefined;
 
   constructor(
-    private readonly entityTypeRegistry: ReadonlyMap<string, SqlEntityHydrationFactory> = new Map(),
+    protected readonly entityTypeRegistry: ReadonlyMap<
+      string,
+      SqlEntityHydrationFactory
+    > = new Map(),
     validatorFragments?: ReadonlyMap<string, Type<unknown>>,
   ) {
     // Only build a fragments-aware contract schema when pack contributions
@@ -158,7 +163,12 @@ export abstract class SqlContractSerializerBase<TContract extends Contract<SqlSt
         const namespaceMaterialised =
           namespaceHydrated instanceof NamespaceBase
             ? namespaceHydrated
-            : buildSqlNamespace(namespaceHydrated);
+            : buildSqlNamespace(
+                blindCast<
+                  SqlNamespaceTablesInput,
+                  'hydrateSqlNamespaceEntry returns SqlNamespaceTablesInput when raw is not a NamespaceBase'
+                >(namespaceHydrated),
+              );
         return [nsId, namespaceMaterialised];
       }),
     );
@@ -172,69 +182,72 @@ export abstract class SqlContractSerializerBase<TContract extends Contract<SqlSt
       return raw;
     }
     const rawRecord = isPlainRecord(raw) ? raw : {};
+    if (
+      Object.hasOwn(rawRecord, 'tables') ||
+      Object.hasOwn(rawRecord, 'enum') ||
+      Object.hasOwn(rawRecord, 'collections')
+    ) {
+      throw new ContractValidationError(
+        'Namespace envelope uses deprecated flat slot keys; expected `entries: { table? }`',
+        'structural',
+      );
+    }
     const id = typeof rawRecord['id'] === 'string' ? rawRecord['id'] : nsId;
     const parsed = NamespaceRawSchema({ ...rawRecord, id });
     if (parsed instanceof type.errors) {
       const messages = parsed.map((p: { message: string }) => p.message).join('; ');
       throw new ContractValidationError(`Namespace hydration failed: ${messages}`, 'structural');
     }
-    const result: Record<string, unknown> = { id };
-
-    for (const [propertyKey, slotValue] of Object.entries(parsed)) {
-      if (propertyKey === 'id') continue;
-      if (slotValue === null || typeof slotValue !== 'object') continue;
-
-      if (propertyKey === 'tables') {
-        result['tables'] = Object.fromEntries(
-          Object.entries(slotValue as Record<string, unknown>).map(([tableName, table]) => [
+    // Default to empty table; overwritten below if raw entries carry a table slot.
+    const entriesInput: {
+      table: Record<string, StorageTable>;
+      valueSet?: Record<string, StorageValueSet>;
+    } = { table: {} };
+    const entriesRaw = parsed.entries;
+    if (entriesRaw !== undefined && typeof entriesRaw === 'object' && entriesRaw !== null) {
+      const rawEntries = entriesRaw as Record<string, unknown>;
+      const tableSlot = rawEntries['table'];
+      if (tableSlot !== null && typeof tableSlot === 'object' && !Array.isArray(tableSlot)) {
+        entriesInput.table = Object.fromEntries(
+          Object.entries(tableSlot as Record<string, unknown>).map(([tableName, table]) => [
             tableName,
             table instanceof StorageTable ? table : new StorageTable(table as StorageTableInput),
           ]),
         );
-        continue;
-      }
-
-      const hydratedSlot = Object.fromEntries(
-        Object.entries(slotValue as Record<string, unknown>).map(([entryName, entry]) => {
-          if (typeof entry !== 'object' || entry === null) {
-            return [entryName, entry];
-          }
-          const kind = (entry as { kind?: unknown }).kind;
-          if (typeof kind === 'string') {
-            const factory = this.entityTypeRegistry.get(kind);
-            if (factory !== undefined) {
-              return [entryName, factory(entry)];
-            }
-          }
-          return [entryName, entry];
-        }),
-      );
-      if (Object.keys(hydratedSlot).length > 0) {
-        result[propertyKey] = hydratedSlot;
       }
-    }
-
-    const enumRaw = rawRecord['enum'];
-    if (enumRaw !== undefined && typeof enumRaw === 'object' && enumRaw !== null) {
-      for (const entry of Object.values(enumRaw as Record<string, unknown>)) {
-        if (typeof entry !== 'object' || entry === null) continue;
-        const kind = (entry as { kind?: unknown }).kind;
-        if (typeof kind === 'string' && this.entityTypeRegistry.get(kind) === undefined) {
-          throw new ContractValidationError(
-            `Entry kind '${kind}' has no registered hydration factory.`,
-            'structural',
-          );
-        }
+      const valueSetSlot = rawEntries['valueSet'];
+      if (
+        valueSetSlot !== null &&
+        typeof valueSetSlot === 'object' &&
+        !Array.isArray(valueSetSlot)
+      ) {
+        entriesInput.valueSet = Object.fromEntries(
+          Object.entries(
+            blindCast<
+              Record<string, unknown>,
+              'valueSet slot is a plain record after object check'
+            >(valueSetSlot),
+          ).map(([vsName, vs]) => [
+            vsName,
+            vs instanceof StorageValueSet
+              ? vs
+              : new StorageValueSet(
+                  blindCast<
+                    StorageValueSetInput,
+                    'non-instance valueSet entry is StorageValueSetInput'
+                  >(vs),
+                ),
+          ]),
+        );
       }
+      // Target-specific slots (e.g. postgres `type`) are left for target
+      // overrides to extract from the original `raw` parameter.
     }
 
-    const tables = (result['tables'] ?? {}) as Record<string, StorageTable>;
-    const enumSlot = result['enum'] as NonNullable<SqlNamespaceTablesInput['enum']> | undefined;
-    return {
-      ...result,
-      tables,
-      ...(enumSlot !== undefined ? { enum: enumSlot } : {}),
-    } as SqlNamespaceTablesInput;
+    return blindCast<SqlNamespaceTablesInput, 'hydrated namespace tables input'>({
+      id,
+      entries: entriesInput,
+    });
   }
 
   protected hydrateStorageTypeEntry(entry: SqlStorageTypeEntry): SqlStorageTypeEntry {
@@ -249,7 +262,10 @@ export abstract class SqlContractSerializerBase<TContract extends Contract<SqlSt
     if (factory === undefined) {
       return entry;
     }
-    return factory(entry);
+    return blindCast<
+      SqlStorageTypeEntry,
+      'entity registry factory returns SqlStorageTypeEntry for storage.types entries'
+    >(factory(entry));
   }
 
   protected constructTargetContract(hydrated: Contract<SqlStorage>): TContract {