@prisma-next/sql-contract-ts 0.12.0 → 0.13.0-dev.10

package/src/build-contract.ts

@@ -6,11 +6,12 @@ import {
 import {
   asNamespaceId,
   type ColumnDefault,
-  type ColumnDefaultLiteralInputValue,
   type Contract,
+  type ContractEnum,
   type ContractField,
   type ContractModel,
   type ContractRelation,
+  type ContractRelationThrough,
   type ContractValueObject,
   type CrossReference,
   coreHash,
@@ -18,6 +19,7 @@ import {
   type ExecutionMutationDefault,
   type JsonValue,
   type StorageHashBase,
+  type ValueSetRef,
 } from '@prisma-next/contract/types';
 import { type CapabilityMatrix, mergeCapabilityMatrices } from '@prisma-next/contract-authoring';
 import type { CodecLookup } from '@prisma-next/framework-components/codec';
@@ -32,6 +34,7 @@ import {
 import {
   applyFkDefaults,
   buildSqlNamespace,
+  type CheckConstraintInput,
   isPostgresEnumStorageEntry,
   type PostgresEnumStorageEntry,
   type SqlNamespaceTablesInput,
@@ -41,6 +44,7 @@ import {
   StorageTable,
   type StorageTableInput,
   type StorageTypeInstance,
+  type StorageValueSetInput,
   toStorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
 import { validateStorageSemantics } from '@prisma-next/sql-contract/validators';
@@ -50,6 +54,7 @@ import type {
   ContractDefinition,
   FieldNode,
   ModelNode,
+  RelationNode,
   ValueObjectFieldNode,
 } from './contract-definition';
 
@@ -57,16 +62,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(
@@ -79,7 +83,7 @@ function encodeColumnDefault(
   }
   return {
     kind: 'literal',
-    value: encodeDefaultLiteralValue(defaultInput.value, codecId, codecLookup),
+    value: encodeViaCodec(defaultInput.value, codecId, codecLookup),
   };
 }
 
@@ -118,14 +122,23 @@ function assertStorageSemantics(
 
 function assertKnownTargetModel(
   modelsByName: ReadonlyMap<string, ModelNode>,
+  modelsByCoordinate: ReadonlyMap<string, ModelNode>,
   sourceModelName: string,
   targetModelName: string,
+  targetNamespaceId: string | undefined,
   context: string,
 ): ModelNode {
-  const targetModel = modelsByName.get(targetModelName);
+  const targetModel =
+    targetNamespaceId !== undefined && targetNamespaceId.length > 0
+      ? modelsByCoordinate.get(`${targetNamespaceId}:${targetModelName}`)
+      : modelsByName.get(targetModelName);
   if (!targetModel) {
+    const qualified =
+      targetNamespaceId !== undefined && targetNamespaceId.length > 0
+        ? `${targetNamespaceId}.${targetModelName}`
+        : targetModelName;
     throw new Error(
-      `${context} on model "${sourceModelName}" references unknown model "${targetModelName}"`,
+      `${context} on model "${sourceModelName}" references unknown model "${qualified}"`,
     );
   }
   return targetModel;
@@ -156,16 +169,54 @@ const JSONB_NATIVE_TYPE = 'jsonb';
 function resolveModelNamespaceId(
   model: ModelNode,
   modelNameToNamespaceId: ReadonlyMap<string, string>,
-  targetId: string,
+  defaultNamespaceId: string,
 ): string {
   if (model.namespaceId !== undefined && model.namespaceId.length > 0) {
     return model.namespaceId;
   }
-  return modelNameToNamespaceId.get(model.modelName) ?? defaultModelNamespaceId(targetId);
+  return modelNameToNamespaceId.get(model.modelName) ?? defaultNamespaceId;
+}
+
+function buildThroughDescriptor(
+  through: NonNullable<RelationNode['through']>,
+  tableNamespaceByName: ReadonlyMap<string, string>,
+  targetModel: ModelNode,
+  modelName: string,
+  fieldName: string,
+): ContractRelationThrough {
+  const namespaceId = tableNamespaceByName.get(through.table);
+  if (namespaceId === undefined) {
+    throw new Error(
+      `buildSqlContractFromDefinition: junction table "${through.table}" for relation "${modelName}.${fieldName}" is not a declared model.`,
+    );
+  }
+
+  return {
+    table: through.table,
+    namespaceId,
+    parentColumns: through.parentColumns,
+    childColumns: through.childColumns,
+    targetColumns: targetColumnsForJunction(targetModel, fieldName),
+  };
+}
+
+function targetColumnsForJunction(targetModel: ModelNode, fieldName: string): readonly string[] {
+  const primaryKeyColumns = targetModel.id?.columns;
+  if (primaryKeyColumns && primaryKeyColumns.length > 0) {
+    return primaryKeyColumns;
+  }
+  const firstUnique = targetModel.uniques?.find((u) => u.columns.length > 0);
+  if (firstUnique) {
+    return firstUnique.columns;
+  }
+  throw new Error(
+    `M:N target model "${targetModel.modelName}" (relation field "${fieldName}") has no primary id or unique key to derive junction targetColumns.`,
+  );
 }
 
 function buildStorageColumn(
   field: FieldNode | ValueObjectFieldNode,
+  storageValueSetRef: ValueSetRef | undefined,
   codecLookup?: CodecLookup,
 ): StorageColumn {
   if (isValueObjectField(field)) {
@@ -203,12 +254,14 @@ function buildStorageColumn(
     ...ifDefined('typeParams', field.descriptor.typeParams),
     ...ifDefined('default', encodedDefault),
     ...ifDefined('typeRef', field.descriptor.typeRef),
+    ...ifDefined('valueSet', storageValueSetRef),
   };
 }
 
 function buildDomainField(
   field: FieldNode | ValueObjectFieldNode,
   column: StorageColumn,
+  domainValueSetRef: ValueSetRef | undefined,
 ): ContractField {
   if (isValueObjectField(field)) {
     return {
@@ -226,12 +279,13 @@ function buildDomainField(
     },
     nullable: column.nullable,
     ...(field.many ? { many: true } : {}),
+    ...ifDefined('valueSet', domainValueSetRef),
   };
 }
 
 function collectStorageNamespaceCoordinateIds(definition: ContractDefinition): Set<string> {
   const ids = new Set<string>();
-  ids.add(defaultModelNamespaceId(definition.target.targetId));
+  ids.add(definition.target.defaultNamespaceId);
   for (const id of definition.namespaces ?? []) {
     if (id.length > 0) {
       ids.add(id);
@@ -245,22 +299,38 @@ function collectStorageNamespaceCoordinateIds(definition: ContractDefinition): S
   return ids;
 }
 
-const POSTGRES_ENUM_NAMESPACE_ID = 'public';
-const POSTGRES_DEFAULT_NAMESPACE_ID = 'public';
-
-function defaultModelNamespaceId(targetId: string): string {
-  return targetId === 'postgres' ? POSTGRES_DEFAULT_NAMESPACE_ID : UNBOUND_NAMESPACE_ID;
+function ensureUnboundNamespaceSlot(
+  namespaces: SqlStorageInput['namespaces'],
+  createNamespace: ContractDefinition['createNamespace'],
+): SqlStorageInput['namespaces'] {
+  if (Object.hasOwn(namespaces, UNBOUND_NAMESPACE_ID)) {
+    return namespaces;
+  }
+  const unboundInput: SqlNamespaceTablesInput = {
+    id: UNBOUND_NAMESPACE_ID,
+    entries: { table: {} },
+  };
+  const unbound = createNamespace ? createNamespace(unboundInput) : buildSqlNamespace(unboundInput);
+  return blindCast<
+    SqlStorageInput['namespaces'],
+    'createNamespace may return a target namespace concretion; the unbound slot matches SqlNamespace at runtime'
+  >({
+    [UNBOUND_NAMESPACE_ID]: unbound,
+    ...namespaces,
+  });
 }
 
+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 | PostgresEnumStorageEntry>;
+  readonly documentTypes: Record<string, StorageTypeInstance>;
   readonly namespaceEnumTypesById: Record<string, Record<string, PostgresEnumStorageEntry>>;
 } {
-  const documentTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {};
+  const documentTypes: Record<string, StorageTypeInstance> = {};
   const namespaceEnumTypesById: Record<string, Record<string, PostgresEnumStorageEntry>> = {};
   for (const [name, entry] of Object.entries(types)) {
     if (isPostgresEnumStorageEntry(entry)) {
@@ -304,24 +374,47 @@ export function buildSqlContractFromDefinition(
   codecLookup?: CodecLookup,
 ): Contract<SqlStorage> {
   const target = definition.target.targetId;
+  const defaultNamespaceId = definition.target.defaultNamespaceId;
   const targetFamily = 'sql';
+  const resolveNamespaceId = (m: ModelNode): string =>
+    m.namespaceId !== undefined && m.namespaceId.length > 0 ? m.namespaceId : defaultNamespaceId;
   const modelsByName = new Map(definition.models.map((m) => [m.modelName, m]));
+  const tableNamespaceByName = new Map(
+    definition.models.map((m) => [
+      m.tableName,
+      m.namespaceId !== undefined && m.namespaceId.length > 0 ? m.namespaceId : defaultNamespaceId,
+    ]),
+  );
+  const modelsByCoordinate = new Map(
+    definition.models.map((m) => [`${resolveNamespaceId(m)}:${m.modelName}`, m]),
+  );
 
   const tablesByNamespace: Record<string, Record<string, StorageTable>> = {};
-  const tableNameToNamespaceId = new Map<string, string>();
   const modelNameToNamespaceId = new Map<string, string>();
   const executionDefaults: ExecutionMutationDefault[] = [];
   const modelsByNamespace: Record<string, Record<string, ContractModel>> = {};
-  const roots: Record<string, CrossReference> = {};
+  const rootEntries: Array<{
+    readonly tableName: string;
+    readonly namespaceId: string;
+    readonly ref: CrossReference;
+  }> = [];
 
   for (const semanticModel of definition.models) {
     const tableName = semanticModel.tableName;
     const namespaceId =
       semanticModel.namespaceId !== undefined && semanticModel.namespaceId.length > 0
         ? semanticModel.namespaceId
-        : defaultModelNamespaceId(target);
+        : defaultNamespaceId;
     modelNameToNamespaceId.set(semanticModel.modelName, namespaceId);
-    roots[tableName] = crossRef(semanticModel.modelName, namespaceId);
+    // STI variants share the base table; the base model already owns this
+    // table name and its root, so the variant contributes neither.
+    if (!semanticModel.sharesBaseTable) {
+      rootEntries.push({
+        tableName,
+        namespaceId,
+        ref: crossRef(semanticModel.modelName, namespaceId),
+      });
+    }
 
     // --- Build storage table ---
 
@@ -348,11 +441,34 @@ export function buildSqlContractFromDefinition(
         }
       }
 
-      const column = buildStorageColumn(field, codecLookup);
+      const enumHandle = !isValueObjectField(field) ? field.enumTypeHandle : undefined;
+      // Authored enums are always registered under the contract's defaultNamespaceId
+      // (see the enum registration loop below), so refs must point there regardless
+      // of which namespace the consuming model lives in.
+      const storageValueSetRef: ValueSetRef | undefined =
+        enumHandle !== undefined
+          ? {
+              plane: 'storage',
+              entityKind: 'value-set',
+              namespaceId: defaultNamespaceId,
+              name: enumHandle.enumName,
+            }
+          : undefined;
+      const domainValueSetRef: ValueSetRef | undefined =
+        enumHandle !== undefined
+          ? {
+              plane: 'domain',
+              entityKind: 'enum',
+              namespaceId: defaultNamespaceId,
+              name: enumHandle.enumName,
+            }
+          : undefined;
+
+      const column = buildStorageColumn(field, storageValueSetRef, codecLookup);
       columns[field.columnName] = column;
       fieldToColumn[field.fieldName] = field.columnName;
 
-      domainFields[field.fieldName] = buildDomainField(field, column);
+      domainFields[field.fieldName] = buildDomainField(field, column, domainValueSetRef);
 
       if (isValueObjectField(field)) {
         domainFieldRefs[field.fieldName] = {
@@ -374,10 +490,37 @@ export function buildSqlContractFromDefinition(
     }
 
     const foreignKeys = (semanticModel.foreignKeys ?? []).map((fk) => {
+      if (fk.references.spaceId !== undefined) {
+        // Cross-space FK: the target lives in a different contract space.
+        // Skip local model lookup and carry the spaceId coordinate through.
+        const targetNamespaceId = fk.references.namespaceId ?? defaultNamespaceId;
+        return {
+          source: { namespaceId: asNamespaceId(namespaceId), tableName, columns: fk.columns },
+          target: {
+            namespaceId: asNamespaceId(targetNamespaceId),
+            tableName: fk.references.table,
+            columns: fk.references.columns,
+            spaceId: fk.references.spaceId,
+          },
+          ...applyFkDefaults(
+            {
+              ...ifDefined('constraint', fk.constraint),
+              ...ifDefined('index', fk.index),
+            },
+            definition.foreignKeyDefaults,
+          ),
+          ...ifDefined('name', fk.name),
+          ...ifDefined('onDelete', fk.onDelete),
+          ...ifDefined('onUpdate', fk.onUpdate),
+        };
+      }
+
       const targetModel = assertKnownTargetModel(
         modelsByName,
+        modelsByCoordinate,
         semanticModel.modelName,
         fk.references.model,
+        fk.references.namespaceId,
         'Foreign key',
       );
       assertTargetTableMatches(
@@ -390,7 +533,7 @@ export function buildSqlContractFromDefinition(
         fk.references.namespaceId ??
         (targetModel.namespaceId !== undefined && targetModel.namespaceId.length > 0
           ? targetModel.namespaceId
-          : defaultModelNamespaceId(target));
+          : defaultNamespaceId);
       return {
         source: { namespaceId: asNamespaceId(namespaceId), tableName, columns: fk.columns },
         target: {
@@ -411,48 +554,56 @@ export function buildSqlContractFromDefinition(
       };
     });
 
-    const existingNs = tableNameToNamespaceId.get(tableName);
-    if (existingNs !== undefined && existingNs !== namespaceId) {
-      throw new Error(
-        `buildSqlContractFromDefinition: table "${tableName}" is mapped in namespace "${namespaceId}" but already exists in namespace "${existingNs}".`,
+    // STI variants share the base table: their columns are already
+    // materialised onto the base `ModelNode`, so the variant builds a domain
+    // model (below) but no storage table of its own.
+    if (!semanticModel.sharesBaseTable) {
+      const checksForTable: CheckConstraintInput[] = Object.entries(columns).flatMap(
+        ([columnName, col]) => {
+          const valueSet = col.valueSet;
+          return valueSet === undefined
+            ? []
+            : [{ name: `${tableName}_${columnName}_check`, column: columnName, valueSet }];
+        },
       );
-    }
-    tableNameToNamespaceId.set(tableName, namespaceId);
 
-    const tableInput: StorageTableInput = {
-      columns,
-      uniques: (semanticModel.uniques ?? []).map((u) => ({
-        columns: u.columns,
-        ...ifDefined('name', u.name),
-      })),
-      indexes: (semanticModel.indexes ?? []).map((i) => ({
-        columns: i.columns,
-        ...ifDefined('name', i.name),
-        ...ifDefined('type', i.type),
-        ...ifDefined('options', i.options),
-      })),
-      foreignKeys,
-      ...(semanticModel.id
-        ? {
-            primaryKey: {
-              columns: semanticModel.id.columns,
-              ...ifDefined('name', semanticModel.id.name),
-            },
-          }
-        : {}),
-    };
+      const tableInput: StorageTableInput = {
+        columns,
+        ...ifDefined('control', semanticModel.control),
+        uniques: (semanticModel.uniques ?? []).map((u) => ({
+          columns: u.columns,
+          ...ifDefined('name', u.name),
+        })),
+        indexes: (semanticModel.indexes ?? []).map((i) => ({
+          columns: i.columns,
+          ...ifDefined('name', i.name),
+          ...ifDefined('type', i.type),
+          ...ifDefined('options', i.options),
+        })),
+        foreignKeys,
+        ...(semanticModel.id
+          ? {
+              primaryKey: {
+                columns: semanticModel.id.columns,
+                ...ifDefined('name', semanticModel.id.name),
+              },
+            }
+          : {}),
+        ...(checksForTable.length > 0 ? { checks: checksForTable } : {}),
+      };
 
-    let nsTables = tablesByNamespace[namespaceId];
-    if (nsTables === undefined) {
-      nsTables = {};
-      tablesByNamespace[namespaceId] = nsTables;
-    }
-    if (nsTables[tableName] !== undefined) {
-      throw new Error(
-        `buildSqlContractFromDefinition: duplicate table "${tableName}" in namespace "${namespaceId}".`,
-      );
+      let nsTables = tablesByNamespace[namespaceId];
+      if (nsTables === undefined) {
+        nsTables = {};
+        tablesByNamespace[namespaceId] = nsTables;
+      }
+      if (nsTables[tableName] !== undefined) {
+        throw new Error(
+          `buildSqlContractFromDefinition: duplicate table "${tableName}" in namespace "${namespaceId}".`,
+        );
+      }
+      nsTables[tableName] = new StorageTable(tableInput);
     }
-    nsTables[tableName] = new StorageTable(tableInput);
 
     // --- Build contract model ---
 
@@ -466,47 +617,70 @@ export function buildSqlContractFromDefinition(
     );
     const modelRelations: Record<string, ContractRelation> = {};
     for (const relation of semanticModel.relations ?? []) {
+      // Cross-space relations have `spaceId` set — the target model lives in
+      // a different contract space, so skip local model lookup and validation.
+      if (relation.spaceId !== undefined) {
+        const targetNamespaceId = relation.namespaceId ?? defaultNamespaceId;
+        modelRelations[relation.fieldName] = {
+          to: crossRef(relation.toModel, targetNamespaceId, relation.spaceId),
+          // Cross-space belongsTo relations are always N:1 (the FK-owning side).
+          cardinality: 'N:1',
+          on: {
+            localFields: relation.on.parentColumns.map((col) => columnToField.get(col) ?? col),
+            // For cross-space targets the lowering carries field names directly
+            // (no fieldToColumn map available for the remote model).
+            targetFields: relation.on.childColumns,
+          },
+        };
+        continue;
+      }
+
       const targetModel = assertKnownTargetModel(
         modelsByName,
+        modelsByCoordinate,
         semanticModel.modelName,
         relation.toModel,
+        relation.toNamespaceId,
         'Relation',
       );
       assertTargetTableMatches(semanticModel.modelName, targetModel, relation.toTable, 'Relation');
 
-      if (relation.cardinality === 'N:M' && !relation.through) {
-        throw new Error(
-          `Relation "${semanticModel.modelName}.${relation.fieldName}" with cardinality "N:M" requires through metadata`,
-        );
-      }
-
       const targetColumnToField = new Map(
         targetModel.fields.map((f) => [f.columnName, f.fieldName]),
       );
 
-      modelRelations[relation.fieldName] = {
-        to: crossRef(
-          relation.toModel,
-          resolveModelNamespaceId(targetModel, modelNameToNamespaceId, target),
-        ),
-        // RelationDefinition.cardinality includes 'N:M' which isn't in
-        // ContractReferenceRelation yet — cast is needed until the contract
-        // type is extended to cover many-to-many.
-        cardinality: relation.cardinality as ContractRelation['cardinality'],
-        on: {
-          localFields: relation.on.parentColumns.map((col) => columnToField.get(col) ?? col),
-          targetFields: relation.on.childColumns.map((col) => targetColumnToField.get(col) ?? col),
-        },
-        ...(relation.through
-          ? {
-              through: {
-                table: relation.through.table,
-                parentCols: relation.through.parentColumns,
-                childCols: relation.through.childColumns,
-              },
-            }
-          : undefined),
+      const to = crossRef(
+        relation.toModel,
+        relation.toNamespaceId !== undefined && relation.toNamespaceId.length > 0
+          ? relation.toNamespaceId
+          : resolveModelNamespaceId(targetModel, modelNameToNamespaceId, defaultNamespaceId),
+      );
+      const on = {
+        localFields: relation.on.parentColumns.map((col) => columnToField.get(col) ?? col),
+        targetFields: relation.on.childColumns.map((col) => targetColumnToField.get(col) ?? col),
       };
+
+      if (relation.cardinality === 'N:M') {
+        if (!relation.through) {
+          throw new Error(
+            `Relation "${semanticModel.modelName}.${relation.fieldName}" with cardinality "N:M" requires through metadata`,
+          );
+        }
+        modelRelations[relation.fieldName] = {
+          to,
+          cardinality: 'N:M',
+          on,
+          through: buildThroughDescriptor(
+            relation.through,
+            tableNamespaceByName,
+            targetModel,
+            semanticModel.modelName,
+            relation.fieldName,
+          ),
+        };
+      } else {
+        modelRelations[relation.fieldName] = { to, cardinality: relation.cardinality, on };
+      }
     }
 
     let namespaceModels = modelsByNamespace[namespaceId];
@@ -517,6 +691,7 @@ export function buildSqlContractFromDefinition(
     namespaceModels[semanticModel.modelName] = {
       storage: {
         table: tableName,
+        namespaceId,
         fields: storageFields,
       },
       fields: domainFields,
@@ -526,6 +701,24 @@ export function buildSqlContractFromDefinition(
 
   // --- Assemble contract ---
 
+  // Aggregate roots are keyed by bare storage table name. When two models in
+  // different namespaces map to the same bare table name, the bare key would
+  // collide (last write wins, silently dropping a root), so those entries fall
+  // back to a namespace-qualified key. Single-namespace contracts never
+  // collide and keep their bare keys unchanged.
+  const rootTableNameCounts = new Map<string, number>();
+  for (const entry of rootEntries) {
+    rootTableNameCounts.set(entry.tableName, (rootTableNameCounts.get(entry.tableName) ?? 0) + 1);
+  }
+  const roots: Record<string, CrossReference> = {};
+  for (const entry of rootEntries) {
+    const key =
+      (rootTableNameCounts.get(entry.tableName) ?? 0) > 1
+        ? `${entry.namespaceId}.${entry.tableName}`
+        : entry.tableName;
+    roots[key] = entry.ref;
+  }
+
   // Normalise raw codec-triple inputs to the `kind: 'codec-instance'`
   // discriminator shape before hashing so the storageHash matches the
   // persisted JSON envelope produced from the SqlStorage class instance
@@ -557,6 +750,42 @@ export function buildSqlContractFromDefinition(
   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.
+  const domainEnumsByNs: Record<string, Record<string, ContractEnum>> = {};
+  const storageValueSetsByNs: Record<string, Record<string, StorageValueSetInput>> = {};
+  for (const [enumName, handle] of Object.entries(definition.enums ?? {})) {
+    if (enumName !== handle.enumName) {
+      throw new Error(
+        `enum declaration key "${enumName}" must match enumType name "${handle.enumName}". Aliases are not supported.`,
+      );
+    }
+    const nsId = defaultNamespaceId;
+    let domainSlot = domainEnumsByNs[nsId];
+    if (domainSlot === undefined) {
+      domainSlot = {};
+      domainEnumsByNs[nsId] = domainSlot;
+    }
+    domainSlot[enumName] = {
+      codecId: handle.codecId,
+      members: handle.enumMembers.map((m) => ({
+        name: m.name,
+        value: encodeViaCodec(m.value, handle.codecId, codecLookup),
+      })),
+    };
+
+    let storageSlot = storageValueSetsByNs[nsId];
+    if (storageSlot === undefined) {
+      storageSlot = {};
+      storageValueSetsByNs[nsId] = storageSlot;
+    }
+    storageSlot[enumName] = {
+      kind: 'value-set',
+      values: handle.values.map((v) => encodeViaCodec(v, handle.codecId, codecLookup)),
+    };
+  }
+
   const { createNamespace } = definition;
   const namespaces = blindCast<
     SqlStorageInput['namespaces'],
@@ -565,18 +794,26 @@ export function buildSqlContractFromDefinition(
     Object.fromEntries(
       [...namespaceCoordinateIds].sort().map((id) => {
         const enumTypes = namespaceEnumTypesById[id];
+        const valueSetEntries = storageValueSetsByNs[id];
         const nsInput: SqlNamespaceTablesInput = {
           id,
-          tables: tablesByNamespace[id] ?? {},
-          ...ifDefined('enum', enumTypes),
+          entries: {
+            table: tablesByNamespace[id] ?? {},
+            ...(valueSetEntries !== undefined && Object.keys(valueSetEntries).length > 0
+              ? { valueSet: valueSetEntries }
+              : {}),
+          },
         };
-        return [id, createNamespace ? createNamespace(nsInput) : buildSqlNamespace(nsInput)];
+        return [
+          id,
+          createNamespace ? createNamespace(nsInput, enumTypes) : buildSqlNamespace(nsInput),
+        ];
       }),
     ),
   );
   const storageWithoutHash = {
     ...(Object.keys(documentTypes).length > 0 ? { types: documentTypes } : {}),
-    namespaces,
+    namespaces: ensureUnboundNamespaceSlot(namespaces, createNamespace),
   };
   const storageHash: StorageHashBase<string> = definition.storageHash
     ? coreHash(definition.storageHash)
@@ -672,7 +909,6 @@ export function buildSqlContractFromDefinition(
         )
       : undefined;
 
-  const defaultNamespaceId = defaultModelNamespaceId(target);
   const domainNamespaceIds = new Set(Object.keys(modelsByNamespace));
   if (domainNamespaceIds.size === 0) {
     domainNamespaceIds.add(defaultNamespaceId);
@@ -680,13 +916,22 @@ export function buildSqlContractFromDefinition(
   if (valueObjects !== undefined) {
     domainNamespaceIds.add(defaultNamespaceId);
   }
+  for (const nsId of Object.keys(domainEnumsByNs)) {
+    domainNamespaceIds.add(nsId);
+  }
   const domainNamespaces = Object.fromEntries(
     [...domainNamespaceIds].sort().map((namespaceId) => {
       const modelsInNs = modelsByNamespace[namespaceId] ?? {};
-      const namespaceSlice =
-        namespaceId === defaultNamespaceId && valueObjects !== undefined
-          ? { models: modelsInNs, valueObjects }
-          : { models: modelsInNs };
+      const enumsInNs = domainEnumsByNs[namespaceId];
+      const namespaceSlice = {
+        models: modelsInNs,
+        ...(namespaceId === defaultNamespaceId && valueObjects !== undefined
+          ? { valueObjects }
+          : {}),
+        ...(enumsInNs !== undefined && Object.keys(enumsInNs).length > 0
+          ? { enum: enumsInNs }
+          : {}),
+      };
       return [namespaceId, namespaceSlice];
     }),
   );
@@ -694,6 +939,7 @@ export function buildSqlContractFromDefinition(
   const contract: Contract<SqlStorage> = {
     target,
     targetFamily,
+    ...ifDefined('defaultControlPolicy', definition.defaultControlPolicy),
     domain: { namespaces: domainNamespaces },
     roots,
     storage,