@prisma-next/sql-contract-ts 0.13.0 → 0.14.0

package/package.json

@@ -1,27 +1,27 @@
 {
   "name": "@prisma-next/sql-contract-ts",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "SQL-specific TypeScript contract authoring surface for Prisma Next",
   "dependencies": {
-    "@prisma-next/config": "0.13.0",
-    "@prisma-next/contract": "0.13.0",
-    "@prisma-next/contract-authoring": "0.13.0",
-    "@prisma-next/framework-components": "0.13.0",
-    "@prisma-next/sql-contract": "0.13.0",
-    "@prisma-next/utils": "0.13.0",
+    "@prisma-next/config": "0.14.0",
+    "@prisma-next/contract": "0.14.0",
+    "@prisma-next/contract-authoring": "0.14.0",
+    "@prisma-next/framework-components": "0.14.0",
+    "@prisma-next/sql-contract": "0.14.0",
+    "@prisma-next/utils": "0.14.0",
     "arktype": "^2.2.0",
     "pathe": "^2.0.3",
     "ts-toolbelt": "^9.6.0"
   },
   "devDependencies": {
-    "@prisma-next/test-utils": "0.13.0",
-    "@prisma-next/tsconfig": "0.13.0",
+    "@prisma-next/test-utils": "0.14.0",
+    "@prisma-next/tsconfig": "0.14.0",
     "@types/pg": "8.20.0",
     "pg": "8.21.0",
-    "@prisma-next/tsdown": "0.13.0",
+    "@prisma-next/tsdown": "0.14.0",
     "tsdown": "0.22.1",
     "typescript": "5.9.3",
     "vitest": "4.1.8"

package/src/build-contract.ts

@@ -6,7 +6,6 @@ import {
 import {
   asNamespaceId,
   type ColumnDefault,
-  type ColumnDefaultLiteralInputValue,
   type Contract,
   type ContractEnum,
   type ContractField,
@@ -36,13 +35,10 @@ import {
   applyFkDefaults,
   buildSqlNamespace,
   type CheckConstraintInput,
-  isPostgresEnumStorageEntry,
-  type PostgresEnumStorageEntry,
   type SqlNamespaceTablesInput,
   SqlStorage,
   type SqlStorageInput,
   type StorageColumn,
-  StorageTable,
   type StorageTableInput,
   type StorageTypeInstance,
   type StorageValueSetInput,
@@ -63,16 +59,15 @@ type DomainFieldRef =
   | { readonly kind: 'scalar'; readonly many?: boolean }
   | { readonly kind: 'valueObject'; readonly name: string; readonly many?: boolean };
 
-function encodeDefaultLiteralValue(
-  value: ColumnDefaultLiteralInputValue,
-  codecId: string,
-  codecLookup?: CodecLookup,
-): JsonValue {
+function encodeViaCodec(value: unknown, codecId: string, codecLookup?: CodecLookup): JsonValue {
   const codec = codecLookup?.get(codecId);
   if (codec) {
     return codec.encodeJson(value);
   }
-  return value as JsonValue;
+  return blindCast<
+    JsonValue,
+    'no codec lookup at build time: literal/enum member value is already JSON-safe'
+  >(value);
 }
 
 function encodeColumnDefault(
@@ -85,7 +80,7 @@ function encodeColumnDefault(
   }
   return {
     kind: 'literal',
-    value: encodeDefaultLiteralValue(defaultInput.value, codecId, codecLookup),
+    value: encodeViaCodec(defaultInput.value, codecId, codecLookup),
   };
 }
 
@@ -185,13 +180,18 @@ function buildThroughDescriptor(
   targetModel: ModelNode,
   modelName: string,
   fieldName: string,
+  defaultNamespaceId: string,
 ): ContractRelationThrough {
-  const namespaceId = tableNamespaceByName.get(through.table);
-  if (namespaceId === undefined) {
+  if (!tableNamespaceByName.has(through.table)) {
     throw new Error(
       `buildSqlContractFromDefinition: junction table "${through.table}" for relation "${modelName}.${fieldName}" is not a declared model.`,
     );
   }
+  // Junction table names are unique per namespace, not globally. Prefer the
+  // junction's own declared namespace (carried on the through node); fall back to
+  // the target's default namespace. Resolving by bare table name would pick the
+  // wrong namespace when the same junction table name exists in two namespaces.
+  const namespaceId = through.namespaceId ?? defaultNamespaceId;
 
   return {
     table: through.table,
@@ -322,55 +322,6 @@ function ensureUnboundNamespaceSlot(
   });
 }
 
-const POSTGRES_ENUM_NAMESPACE_ID = 'public';
-
-function partitionStorageTypesForTarget(
-  targetId: string,
-  types: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
-  namespaceTypes?: Readonly<Record<string, Readonly<Record<string, PostgresEnumStorageEntry>>>>,
-): {
-  readonly documentTypes: Record<string, StorageTypeInstance>;
-  readonly namespaceEnumTypesById: Record<string, Record<string, PostgresEnumStorageEntry>>;
-} {
-  const documentTypes: Record<string, StorageTypeInstance> = {};
-  const namespaceEnumTypesById: Record<string, Record<string, PostgresEnumStorageEntry>> = {};
-  for (const [name, entry] of Object.entries(types)) {
-    if (isPostgresEnumStorageEntry(entry)) {
-      if (targetId !== 'postgres') {
-        throw new Error(
-          `buildSqlContractFromDefinition: postgres enum "${name}" is only valid when target is "postgres" (got "${targetId}").`,
-        );
-      }
-      let slot = namespaceEnumTypesById[POSTGRES_ENUM_NAMESPACE_ID];
-      if (slot === undefined) {
-        slot = {};
-        namespaceEnumTypesById[POSTGRES_ENUM_NAMESPACE_ID] = slot;
-      }
-      slot[name] = entry;
-      continue;
-    }
-    documentTypes[name] = entry;
-  }
-  if (namespaceTypes !== undefined) {
-    for (const [nsId, enumsInNs] of Object.entries(namespaceTypes)) {
-      for (const [name, entry] of Object.entries(enumsInNs)) {
-        if (targetId !== 'postgres') {
-          throw new Error(
-            `buildSqlContractFromDefinition: postgres enum "${name}" is only valid when target is "postgres" (got "${targetId}").`,
-          );
-        }
-        let slot = namespaceEnumTypesById[nsId];
-        if (slot === undefined) {
-          slot = {};
-          namespaceEnumTypesById[nsId] = slot;
-        }
-        slot[name] = entry;
-      }
-    }
-  }
-  return { documentTypes, namespaceEnumTypesById };
-}
-
 export function buildSqlContractFromDefinition(
   definition: ContractDefinition,
   codecLookup?: CodecLookup,
@@ -391,7 +342,7 @@ export function buildSqlContractFromDefinition(
     definition.models.map((m) => [`${resolveNamespaceId(m)}:${m.modelName}`, m]),
   );
 
-  const tablesByNamespace: Record<string, Record<string, StorageTable>> = {};
+  const tablesByNamespace: Record<string, Record<string, StorageTableInput>> = {};
   const modelNameToNamespaceId = new Map<string, string>();
   const executionDefaults: ExecutionMutationDefault[] = [];
   const modelsByNamespace: Record<string, Record<string, ContractModel>> = {};
@@ -451,9 +402,9 @@ export function buildSqlContractFromDefinition(
         enumHandle !== undefined
           ? {
               plane: 'storage',
-              entityKind: 'value-set',
+              entityKind: 'valueSet',
               namespaceId: defaultNamespaceId,
-              name: enumHandle.enumName,
+              entityName: enumHandle.enumName,
             }
           : undefined;
       const domainValueSetRef: ValueSetRef | undefined =
@@ -462,7 +413,7 @@ export function buildSqlContractFromDefinition(
               plane: 'domain',
               entityKind: 'enum',
               namespaceId: defaultNamespaceId,
-              name: enumHandle.enumName,
+              entityName: enumHandle.enumName,
             }
           : undefined;
 
@@ -484,7 +435,7 @@ export function buildSqlContractFromDefinition(
 
       if (executionDefaultPhases) {
         executionDefaults.push({
-          ref: { table: tableName, column: field.columnName },
+          ref: { namespace: namespaceId, table: tableName, column: field.columnName },
           ...ifDefined('onCreate', executionDefaultPhases.onCreate),
           ...ifDefined('onUpdate', executionDefaultPhases.onUpdate),
         });
@@ -604,7 +555,7 @@ export function buildSqlContractFromDefinition(
           `buildSqlContractFromDefinition: duplicate table "${tableName}" in namespace "${namespaceId}".`,
         );
       }
-      nsTables[tableName] = new StorageTable(tableInput);
+      nsTables[tableName] = tableInput;
     }
 
     // --- Build contract model ---
@@ -678,6 +629,7 @@ export function buildSqlContractFromDefinition(
             targetModel,
             semanticModel.modelName,
             relation.fieldName,
+            defaultNamespaceId,
           ),
         };
       } else {
@@ -725,13 +677,9 @@ export function buildSqlContractFromDefinition(
   // discriminator shape before hashing so the storageHash matches the
   // persisted JSON envelope produced from the SqlStorage class instance
   // (which always carries the discriminator).
-  const rawStorageTypes = (definition.storageTypes ?? {}) as Record<
-    string,
-    StorageTypeInstance | PostgresEnumStorageEntry
-  >;
-  const storageTypes = Object.fromEntries(
+  const rawStorageTypes = definition.storageTypes ?? {};
+  const documentTypes: Record<string, StorageTypeInstance> = Object.fromEntries(
     Object.entries(rawStorageTypes).map(([name, entry]) => {
-      if (isPostgresEnumStorageEntry(entry)) return [name, entry];
       if ((entry as { kind?: unknown }).kind === 'codec-instance') return [name, entry];
       return [
         name,
@@ -743,15 +691,7 @@ export function buildSqlContractFromDefinition(
       ];
     }),
   );
-  const { documentTypes, namespaceEnumTypesById } = partitionStorageTypesForTarget(
-    target,
-    storageTypes,
-    definition.namespaceTypes,
-  );
   const namespaceCoordinateIds = collectStorageNamespaceCoordinateIds(definition);
-  for (const id of Object.keys(namespaceEnumTypesById)) {
-    namespaceCoordinateIds.add(id);
-  }
 
   // Build per-namespace registries for `enumType()` handles.
   // All authored enums target the contract's default namespace.
@@ -771,7 +711,10 @@ export function buildSqlContractFromDefinition(
     }
     domainSlot[enumName] = {
       codecId: handle.codecId,
-      members: handle.enumMembers,
+      members: handle.enumMembers.map((m) => ({
+        name: m.name,
+        value: encodeViaCodec(m.value, handle.codecId, codecLookup),
+      })),
     };
 
     let storageSlot = storageValueSetsByNs[nsId];
@@ -780,8 +723,8 @@ export function buildSqlContractFromDefinition(
       storageValueSetsByNs[nsId] = storageSlot;
     }
     storageSlot[enumName] = {
-      kind: 'value-set',
-      values: handle.values,
+      kind: 'valueSet',
+      values: handle.values.map((v) => encodeViaCodec(v, handle.codecId, codecLookup)),
     };
   }
 
@@ -792,7 +735,6 @@ export function buildSqlContractFromDefinition(
   >(
     Object.fromEntries(
       [...namespaceCoordinateIds].sort().map((id) => {
-        const enumTypes = namespaceEnumTypesById[id];
         const valueSetEntries = storageValueSetsByNs[id];
         const nsInput: SqlNamespaceTablesInput = {
           id,
@@ -803,16 +745,16 @@ export function buildSqlContractFromDefinition(
               : {}),
           },
         };
-        return [
-          id,
-          createNamespace ? createNamespace(nsInput, enumTypes) : buildSqlNamespace(nsInput),
-        ];
+        return [id, createNamespace ? createNamespace(nsInput) : buildSqlNamespace(nsInput)];
       }),
     ),
   );
   const storageWithoutHash = {
     ...(Object.keys(documentTypes).length > 0 ? { types: documentTypes } : {}),
-    namespaces: ensureUnboundNamespaceSlot(namespaces, createNamespace),
+    namespaces:
+      defaultNamespaceId === UNBOUND_NAMESPACE_ID
+        ? ensureUnboundNamespaceSlot(namespaces, createNamespace)
+        : namespaces,
   };
   const storageHash: StorageHashBase<string> = definition.storageHash
     ? coreHash(definition.storageHash)

package/src/contract-builder.ts

@@ -7,11 +7,7 @@ import type {
   TargetPackRef,
 } from '@prisma-next/framework-components/components';
 import type { Namespace } from '@prisma-next/framework-components/ir';
-import type {
-  PostgresEnumStorageEntry,
-  SqlNamespaceTablesInput,
-  StorageTypeInstance,
-} from '@prisma-next/sql-contract/types';
+import type { SqlNamespaceTablesInput, StorageTypeInstance } from '@prisma-next/sql-contract/types';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { buildSqlContractFromDefinition } from './build-contract';
@@ -55,13 +51,14 @@ type ModelLike = {
 type ContractDefinition<
   Family extends FamilyPackRef<string>,
   Target extends TargetPackRef<'sql', string>,
-  Types extends Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
+  Types extends Record<string, StorageTypeInstance>,
   Models extends Record<string, ModelLike>,
   ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined,
   Naming extends ContractInput['naming'] | undefined,
   StorageHash extends string | undefined,
   ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined,
   Namespaces extends readonly string[] | undefined = undefined,
+  Enums extends Record<string, EnumTypeHandle> = Record<string, EnumTypeHandle>,
 > = {
   readonly family: Family;
   readonly target: Target;
@@ -75,7 +72,7 @@ type ContractDefinition<
   readonly types?: Types;
   readonly models?: Models;
   readonly codecLookup?: CodecLookup;
-  readonly enums?: Record<string, EnumTypeHandle>;
+  readonly enums?: Enums;
 };
 
 type ContractScaffold<
@@ -86,6 +83,7 @@ type ContractScaffold<
   StorageHash extends string | undefined,
   ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined,
   Namespaces extends readonly string[] | undefined = undefined,
+  Enums extends Record<string, EnumTypeHandle> = Record<string, EnumTypeHandle>,
 > = {
   readonly family: Family;
   readonly target: Target;
@@ -99,18 +97,20 @@ type ContractScaffold<
   readonly types?: never;
   readonly models?: never;
   readonly codecLookup?: CodecLookup;
-  readonly enums?: Record<string, EnumTypeHandle>;
+  readonly enums?: Enums;
 };
 
 type ContractFactory<
   Family extends FamilyPackRef<string>,
   Target extends TargetPackRef<'sql', string>,
-  Types extends Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
+  Types extends Record<string, StorageTypeInstance>,
   Models extends Record<string, ModelLike>,
   ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined,
+  Enums extends Record<string, EnumTypeHandle> = Record<string, EnumTypeHandle>,
 > = (helpers: ComposedAuthoringHelpers<Family, Target, ExtensionPacks>) => {
   readonly types?: Types;
   readonly models?: Models;
+  readonly enums?: Enums;
 };
 
 function validateTargetPackRef(
@@ -300,10 +300,7 @@ function buildContractFromDsl<Definition extends ContractInput>(
 // Input for buildBoundContract — all fields from ContractInput except family/target
 // (those are injected by the builder, pre-bound at the call site).
 type BoundDefinitionInput<
-  Types extends Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = Record<
-    never,
-    never
-  >,
+  Types extends Record<string, StorageTypeInstance> = Record<never, never>,
   Models extends Record<string, ModelLike> = Record<never, never>,
   ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined,
   Naming extends ContractInput['naming'] | undefined = undefined,
@@ -324,6 +321,20 @@ type BoundDefinitionInput<
   readonly enums?: Record<string, EnumTypeHandle>;
 };
 
+// A bare `Record<string, EnumTypeHandle>` (no literal keys) is the widened
+// default for a side that declared no enums; drop it so the merge keeps only
+// literally-authored enum handles.
+type LiteralEnums<E extends Record<string, EnumTypeHandle>> = string extends keyof E
+  ? Record<never, never>
+  : E;
+
+// Merges enum handles authored on the scaffold definition with those returned
+// from the factory callback. Either side may be the widened default (empty).
+export type MergeEnums<
+  ScaffoldEnums extends Record<string, EnumTypeHandle>,
+  FactoryEnums extends Record<string, EnumTypeHandle>,
+> = LiteralEnums<ScaffoldEnums> & LiteralEnums<FactoryEnums>;
+
 // Merges a bound input with the pre-bound family/target to produce a full ContractDefinition.
 type WithFamilyTarget<
   Input,
@@ -343,7 +354,7 @@ export function buildBoundContract<
   const F extends FamilyPackRef<string>,
   const T extends TargetPackRef<'sql', string>,
   const Definition extends BoundDefinitionInput<
-    Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
+    Record<string, StorageTypeInstance>,
     Record<string, ModelLike>,
     Record<string, ExtensionPackRef<'sql', string>> | undefined,
     ContractInput['naming'] | undefined,
@@ -364,7 +375,7 @@ export function buildBoundContract<
   const F extends FamilyPackRef<string>,
   const T extends TargetPackRef<'sql', string>,
   const Definition extends BoundDefinitionInput<
-    Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
+    Record<string, StorageTypeInstance>,
     Record<string, ModelLike>,
     Record<string, ExtensionPackRef<'sql', string>> | undefined,
     ContractInput['naming'] | undefined,
@@ -373,8 +384,9 @@ export function buildBoundContract<
     readonly string[] | undefined
   >,
   const Built extends {
-    readonly types?: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>;
+    readonly types?: Record<string, StorageTypeInstance>;
     readonly models?: Record<string, ModelLike>;
+    readonly enums?: Record<string, EnumTypeHandle>;
   },
 >(
   family: F,
@@ -397,8 +409,9 @@ export function buildBoundContract(
           Record<string, ExtensionPackRef<'sql', string>> | undefined
         >,
       ) => {
-        readonly types?: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>;
+        readonly types?: Record<string, StorageTypeInstance>;
         readonly models?: Record<string, ModelLike>;
+        readonly enums?: Record<string, EnumTypeHandle>;
       })
     | undefined,
 ) {
@@ -412,10 +425,12 @@ export function buildBoundContract(
         extensionPacks: definition.extensionPacks,
       }),
     );
+    const mergedEnums = { ...(definition.enums ?? {}), ...built.enums };
     return buildContractFromDsl({
       ...full,
       ...ifDefined('types', built.types),
       ...ifDefined('models', built.models),
+      ...ifDefined('enums', Object.keys(mergedEnums).length > 0 ? mergedEnums : undefined),
     });
   }
 
@@ -425,10 +440,7 @@ export function buildBoundContract(
 export function defineContract<
   const Family extends FamilyPackRef<string>,
   const Target extends TargetPackRef<'sql', string>,
-  const Types extends Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = Record<
-    never,
-    never
-  >,
+  const Types extends Record<string, StorageTypeInstance> = Record<never, never>,
   const Models extends Record<string, ModelLike> = Record<never, never>,
   const ExtensionPacks extends
     | Record<string, ExtensionPackRef<'sql', string>>
@@ -437,6 +449,7 @@ export function defineContract<
   const StorageHash extends string | undefined = undefined,
   const ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined = undefined,
   const Namespaces extends readonly string[] | undefined = undefined,
+  const Enums extends Record<string, EnumTypeHandle> = Record<string, EnumTypeHandle>,
 >(
   definition: ContractDefinition<
     Family,
@@ -447,7 +460,8 @@ export function defineContract<
     Naming,
     StorageHash,
     ForeignKeyDefaults,
-    Namespaces
+    Namespaces,
+    Enums
   >,
 ): SqlContractResult<
   ContractDefinition<
@@ -459,16 +473,14 @@ export function defineContract<
     Naming,
     StorageHash,
     ForeignKeyDefaults,
-    Namespaces
+    Namespaces,
+    Enums
   >
 >;
 export function defineContract<
   const Family extends FamilyPackRef<string>,
   const Target extends TargetPackRef<'sql', string>,
-  const Types extends Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = Record<
-    never,
-    never
-  >,
+  const Types extends Record<string, StorageTypeInstance> = Record<never, never>,
   const Models extends Record<string, ModelLike> = Record<never, never>,
   const ExtensionPacks extends
     | Record<string, ExtensionPackRef<'sql', string>>
@@ -477,6 +489,8 @@ export function defineContract<
   const StorageHash extends string | undefined = undefined,
   const ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined = undefined,
   const Namespaces extends readonly string[] | undefined = undefined,
+  const ScaffoldEnums extends Record<string, EnumTypeHandle> = Record<string, EnumTypeHandle>,
+  const FactoryEnums extends Record<string, EnumTypeHandle> = Record<string, EnumTypeHandle>,
 >(
   definition: ContractScaffold<
     Family,
@@ -485,9 +499,10 @@ export function defineContract<
     Naming,
     StorageHash,
     ForeignKeyDefaults,
-    Namespaces
+    Namespaces,
+    ScaffoldEnums
   >,
-  factory: ContractFactory<Family, Target, Types, Models, ExtensionPacks>,
+  factory: ContractFactory<Family, Target, Types, Models, ExtensionPacks, FactoryEnums>,
 ): SqlContractResult<
   ContractDefinition<
     Family,
@@ -498,7 +513,8 @@ export function defineContract<
     Naming,
     StorageHash,
     ForeignKeyDefaults,
-    Namespaces
+    Namespaces,
+    MergeEnums<ScaffoldEnums, FactoryEnums>
   >
 >;
 export function defineContract(
@@ -506,7 +522,7 @@ export function defineContract(
   factory?: ContractFactory<
     FamilyPackRef<string>,
     TargetPackRef<'sql', string>,
-    Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
+    Record<string, StorageTypeInstance>,
     Record<string, ModelLike>,
     Record<string, ExtensionPackRef<'sql', string>> | undefined
   >,

package/src/contract-definition.ts

@@ -8,7 +8,6 @@ import type { ColumnTypeDescriptor } from '@prisma-next/framework-components/cod
 import type { ExtensionPackRef, TargetPackRef } from '@prisma-next/framework-components/components';
 import type { Namespace } from '@prisma-next/framework-components/ir';
 import type {
-  PostgresEnumStorageEntry,
   ReferentialAction,
   SqlNamespaceTablesInput,
   StorageTypeInstance,
@@ -105,6 +104,14 @@ export interface RelationNode {
   };
   readonly through?: {
     readonly table: string;
+    /**
+     * Namespace the junction table lives in. Set from the junction model's
+     * declared namespace at lowering time; junction table names are unique per
+     * namespace, not globally, so this disambiguates a junction whose bare table
+     * name also exists in another namespace. Omitted for a junction in the
+     * default namespace (resolved to the target's default at build time).
+     */
+    readonly namespaceId?: string;
     readonly parentColumns: readonly string[];
     readonly childColumns: readonly string[];
   };
@@ -162,33 +169,14 @@ export interface ContractDefinition {
   readonly extensionPacks?: Record<string, ExtensionPackRef<'sql', string>>;
   readonly storageHash?: string;
   readonly foreignKeyDefaults?: ForeignKeyDefaultsState;
-  readonly storageTypes?: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>;
-  /**
-   * Enum types declared inside a named `namespace { enum … }` block,
-   * keyed first by namespace id then by type name. These are routed to
-   * `storage.namespaces[nsId].entries.type` rather than the implicit fallback
-   * namespace used for top-level `storageTypes` enums.
-   */
-  readonly namespaceTypes?: Readonly<
-    Record<string, Readonly<Record<string, PostgresEnumStorageEntry>>>
-  >;
+  readonly storageTypes?: Record<string, StorageTypeInstance>;
   /**
    * Declared namespace coordinates for this contract — populates
    * `SqlStorage.namespaces` together with `createNamespace`.
    */
   readonly namespaces?: readonly string[];
-  /**
-   * Target-supplied factory that materialises a `Namespace` concretion
-   * for a declared namespace coordinate. Mirrors
-   * `ContractInput.createNamespace`.
-   *
-   * The optional second argument carries target-specific enum types for the
-   * namespace (e.g. postgres enum registrations keyed by type name).
-   */
-  readonly createNamespace?: (
-    input: SqlNamespaceTablesInput,
-    enumTypes?: Readonly<Record<string, PostgresEnumStorageEntry>>,
-  ) => Namespace;
+  /** Target-supplied factory that materialises a `Namespace` concretion for a declared namespace coordinate. */
+  readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
   readonly models: readonly ModelNode[];
   readonly valueObjects?: readonly ValueObjectNode[];
   /**