@prisma-next/sql-contract-ts 0.12.0-dev.5 → 0.12.0-dev.50

package/package.json

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

package/src/build-contract.ts

@@ -156,12 +156,12 @@ 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 buildStorageColumn(
@@ -231,7 +231,7 @@ function buildDomainField(
 
 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 +245,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,6 +320,7 @@ export function buildSqlContractFromDefinition(
   codecLookup?: CodecLookup,
 ): Contract<SqlStorage> {
   const target = definition.target.targetId;
+  const defaultNamespaceId = definition.target.defaultNamespaceId;
   const targetFamily = 'sql';
   const modelsByName = new Map(definition.models.map((m) => [m.modelName, m]));
 
@@ -319,9 +336,13 @@ export function buildSqlContractFromDefinition(
     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) {
+      roots[tableName] = crossRef(semanticModel.modelName, namespaceId);
+    }
 
     // --- Build storage table ---
 
@@ -390,7 +411,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 +432,54 @@ 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}".`,
-      );
-    }
-    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),
-            },
-          }
-        : {}),
-    };
+    // 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 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}".`,
+        );
+      }
+      tableNameToNamespaceId.set(tableName, namespaceId);
+
+      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),
+              },
+            }
+          : {}),
+      };
 
-    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 ---
 
@@ -487,7 +514,7 @@ export function buildSqlContractFromDefinition(
       modelRelations[relation.fieldName] = {
         to: crossRef(
           relation.toModel,
-          resolveModelNamespaceId(targetModel, modelNameToNamespaceId, target),
+          resolveModelNamespaceId(targetModel, modelNameToNamespaceId, defaultNamespaceId),
         ),
         // RelationDefinition.cardinality includes 'N:M' which isn't in
         // ContractReferenceRelation yet — cast is needed until the contract
@@ -517,6 +544,7 @@ export function buildSqlContractFromDefinition(
     namespaceModels[semanticModel.modelName] = {
       storage: {
         table: tableName,
+        namespaceId,
         fields: storageFields,
       },
       fields: domainFields,
@@ -567,16 +595,20 @@ export function buildSqlContractFromDefinition(
         const enumTypes = namespaceEnumTypesById[id];
         const nsInput: SqlNamespaceTablesInput = {
           id,
-          tables: tablesByNamespace[id] ?? {},
-          ...ifDefined('enum', enumTypes),
+          entries: {
+            table: tablesByNamespace[id] ?? {},
+          },
         };
-        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 +704,6 @@ export function buildSqlContractFromDefinition(
         )
       : undefined;
 
-  const defaultNamespaceId = defaultModelNamespaceId(target);
   const domainNamespaceIds = new Set(Object.keys(modelsByNamespace));
   if (domainNamespaceIds.size === 0) {
     domainNamespaceIds.add(defaultNamespaceId);
@@ -694,6 +725,7 @@ export function buildSqlContractFromDefinition(
   const contract: Contract<SqlStorage> = {
     target,
     targetFamily,
+    ...ifDefined('defaultControlPolicy', definition.defaultControlPolicy),
     domain: { namespaces: domainNamespaces },
     roots,
     storage,

package/src/config-types.ts

@@ -1,6 +1,7 @@
 import { pathToFileURL } from 'node:url';
 import type { ContractConfig } from '@prisma-next/config/config-types';
-import type { Contract } from '@prisma-next/contract/types';
+import { applySpecifierDefaultControlPolicy } from '@prisma-next/contract/apply-specifier-default-control-policy';
+import type { Contract, ControlPolicy } from '@prisma-next/contract/types';
 import type { TargetPackRef } from '@prisma-next/framework-components/components';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { ok } from '@prisma-next/utils/result';
@@ -19,22 +20,35 @@ function defaultOutputFromContractPath(contractPath: string): string {
   return `${contractPath.slice(0, -ext.length)}.json`;
 }
 
+export interface TypeScriptContractSpecifierOptions {
+  readonly defaultControlPolicy?: ControlPolicy;
+}
+
 export function emptyContract(options: {
   readonly output?: string;
   readonly target: TargetPackRef<'sql', string>;
+  readonly defaultControlPolicy?: ControlPolicy;
 }): ContractConfig {
   return {
     source: {
-      load: async () => ok(buildSqlContractFromDefinition({ target: options.target, models: [] })),
+      load: async () => {
+        const built = buildSqlContractFromDefinition({ target: options.target, models: [] });
+        return ok(applySpecifierDefaultControlPolicy(built, options.defaultControlPolicy));
+      },
     },
     ...ifDefined('output', options.output),
   };
 }
 
-export function typescriptContract(contract: Contract, output?: string): ContractConfig {
+export function typescriptContract(
+  contract: Contract,
+  output?: string,
+  options?: TypeScriptContractSpecifierOptions,
+): ContractConfig {
   return {
     source: {
-      load: async () => ok(contract),
+      load: async () =>
+        ok(applySpecifierDefaultControlPolicy(contract, options?.defaultControlPolicy)),
     },
     // The in-memory variant has no input path to anchor on; fall through to
     // the global default in `normalizeContractConfig` when caller doesn't pin it.
@@ -42,7 +56,11 @@ export function typescriptContract(contract: Contract, output?: string): Contrac
   };
 }
 
-export function typescriptContractFromPath(contractPath: string, output?: string): ContractConfig {
+export function typescriptContractFromPath(
+  contractPath: string,
+  output?: string,
+  options?: TypeScriptContractSpecifierOptions,
+): ContractConfig {
   return {
     source: {
       inputs: [contractPath],
@@ -60,7 +78,7 @@ export function typescriptContractFromPath(contractPath: string, output?: string
             `typescriptContractFromPath: module at "${absolutePath}" has no "default" or "contract" export.`,
           );
         }
-        return ok(contract);
+        return ok(applySpecifierDefaultControlPolicy(contract, options?.defaultControlPolicy));
       },
     },
     output: output ?? defaultOutputFromContractPath(contractPath),

package/src/contract-builder.ts

@@ -1,3 +1,4 @@
+import type { ControlPolicy } from '@prisma-next/contract/types';
 import type { ForeignKeyDefaultsState } from '@prisma-next/contract-authoring';
 import type { CodecLookup } from '@prisma-next/framework-components/codec';
 import type {
@@ -12,6 +13,7 @@ import type {
   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';
 import {
   type ComposedAuthoringHelpers,
@@ -65,6 +67,7 @@ type ContractDefinition<
   readonly naming?: Naming;
   readonly storageHash?: StorageHash;
   readonly foreignKeyDefaults?: ForeignKeyDefaults;
+  readonly defaultControlPolicy?: ControlPolicy;
   readonly namespaces?: Namespaces;
   readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
   readonly types?: Types;
@@ -87,6 +90,7 @@ type ContractScaffold<
   readonly naming?: Naming;
   readonly storageHash?: StorageHash;
   readonly foreignKeyDefaults?: ForeignKeyDefaults;
+  readonly defaultControlPolicy?: ControlPolicy;
   readonly namespaces?: Namespaces;
   readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
   readonly types?: never;
@@ -289,6 +293,130 @@ function buildContractFromDsl<Definition extends ContractInput>(
   >(buildSqlContractFromDefinition(buildContractDefinition(definition), definition.codecLookup));
 }
 
+// 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
+  >,
+  Models extends Record<string, ModelLike> = Record<never, never>,
+  ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined,
+  Naming extends ContractInput['naming'] | undefined = undefined,
+  StorageHash extends string | undefined = undefined,
+  ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined = undefined,
+  Namespaces extends readonly string[] | undefined = undefined,
+> = {
+  readonly extensionPacks?: ExtensionPacks;
+  readonly naming?: Naming;
+  readonly storageHash?: StorageHash;
+  readonly foreignKeyDefaults?: ForeignKeyDefaults;
+  readonly defaultControlPolicy?: ControlPolicy;
+  readonly namespaces?: Namespaces;
+  readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
+  readonly types?: Types;
+  readonly models?: Models;
+  readonly codecLookup?: CodecLookup;
+};
+
+// Merges a bound input with the pre-bound family/target to produce a full ContractDefinition.
+type WithFamilyTarget<
+  Input,
+  F extends FamilyPackRef<string>,
+  T extends TargetPackRef<'sql', string>,
+> = Input & { readonly family: F; readonly target: T };
+
+/**
+ * Shared builder that assembles a SqlContract with pre-bound family and target.
+ * Extension wrappers keep their own public overloads and delegate their impl body here;
+ * this is a plain overloaded function (not a factory returning an overloaded function)
+ * so no overloaded-function-return cast is needed.
+ *
+ * Overload 1: definition form (no factory).
+ */
+export function buildBoundContract<
+  const F extends FamilyPackRef<string>,
+  const T extends TargetPackRef<'sql', string>,
+  const Definition extends BoundDefinitionInput<
+    Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
+    Record<string, ModelLike>,
+    Record<string, ExtensionPackRef<'sql', string>> | undefined,
+    ContractInput['naming'] | undefined,
+    string | undefined,
+    ForeignKeyDefaultsState | undefined,
+    readonly string[] | undefined
+  >,
+>(
+  family: F,
+  target: T,
+  definition: Definition,
+  factory?: undefined,
+): SqlContractResult<WithFamilyTarget<Definition, F, T>>;
+/**
+ * Overload 2: factory form.
+ */
+export function buildBoundContract<
+  const F extends FamilyPackRef<string>,
+  const T extends TargetPackRef<'sql', string>,
+  const Definition extends BoundDefinitionInput<
+    Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
+    Record<string, ModelLike>,
+    Record<string, ExtensionPackRef<'sql', string>> | undefined,
+    ContractInput['naming'] | undefined,
+    string | undefined,
+    ForeignKeyDefaultsState | undefined,
+    readonly string[] | undefined
+  >,
+  const Built extends {
+    readonly types?: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>;
+    readonly models?: Record<string, ModelLike>;
+  },
+>(
+  family: F,
+  target: T,
+  definition: Definition,
+  factory: (
+    helpers: ComposedAuthoringHelpers<F, T, NonNullable<Definition['extensionPacks']>>,
+  ) => Built,
+): SqlContractResult<WithFamilyTarget<Definition & Built, F, T>>;
+/** Implementation. */
+export function buildBoundContract(
+  family: FamilyPackRef<string>,
+  target: TargetPackRef<'sql', string>,
+  definition: Omit<ContractInput, 'family' | 'target'>,
+  factory?:
+    | ((
+        helpers: ComposedAuthoringHelpers<
+          FamilyPackRef<string>,
+          TargetPackRef<'sql', string>,
+          Record<string, ExtensionPackRef<'sql', string>> | undefined
+        >,
+      ) => {
+        readonly types?: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>;
+        readonly models?: Record<string, ModelLike>;
+      })
+    | undefined,
+) {
+  const full = { ...definition, family, target };
+
+  if (factory !== undefined) {
+    const built = factory(
+      createComposedAuthoringHelpers({
+        family,
+        target,
+        extensionPacks: definition.extensionPacks,
+      }),
+    );
+    return buildContractFromDsl({
+      ...full,
+      ...ifDefined('types', built.types),
+      ...ifDefined('models', built.models),
+    });
+  }
+
+  return buildContractFromDsl(full);
+}
+
 export function defineContract<
   const Family extends FamilyPackRef<string>,
   const Target extends TargetPackRef<'sql', string>,
@@ -384,22 +512,10 @@ export function defineContract(
     );
   }
 
-  if (!factory) {
-    return buildContractFromDsl(definition);
+  if (factory !== undefined) {
+    return buildBoundContract(definition.family, definition.target, definition, factory);
   }
-
-  const builtDefinition = {
-    ...definition,
-    ...factory(
-      createComposedAuthoringHelpers({
-        family: definition.family,
-        target: definition.target,
-        extensionPacks: definition.extensionPacks,
-      }),
-    ),
-  };
-
-  return buildContractFromDsl(builtDefinition);
+  return buildBoundContract(definition.family, definition.target, definition);
 }
 
 export type {

package/src/contract-definition.ts

@@ -1,4 +1,8 @@
-import type { ColumnDefault, ExecutionMutationDefaultPhases } from '@prisma-next/contract/types';
+import type {
+  ColumnDefault,
+  ControlPolicy,
+  ExecutionMutationDefaultPhases,
+} from '@prisma-next/contract/types';
 import type { ForeignKeyDefaultsState } from '@prisma-next/contract-authoring';
 import type { ColumnTypeDescriptor } from '@prisma-next/framework-components/codec';
 import type { ExtensionPackRef, TargetPackRef } from '@prisma-next/framework-components/components';
@@ -113,10 +117,20 @@ export interface ModelNode {
   readonly indexes?: readonly IndexNode[];
   readonly foreignKeys?: readonly ForeignKeyNode[];
   readonly relations?: readonly RelationNode[];
+  readonly control?: ControlPolicy;
+  /**
+   * Single-table-inheritance variants share their base model's storage table:
+   * the variant's columns are materialised onto the base `ModelNode`, and this
+   * model contributes a domain model but no storage table of its own. When set,
+   * the assembler builds the domain model but skips creating a (shadow) storage
+   * table and a root for this model — the base owns both.
+   */
+  readonly sharesBaseTable?: boolean;
 }
 
 export interface ContractDefinition {
   readonly target: TargetPackRef<'sql', string>;
+  readonly defaultControlPolicy?: ControlPolicy;
   readonly extensionPacks?: Record<string, ExtensionPackRef<'sql', string>>;
   readonly storageHash?: string;
   readonly foreignKeyDefaults?: ForeignKeyDefaultsState;
@@ -124,7 +138,7 @@ export interface ContractDefinition {
   /**
    * 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].enum` rather than the implicit fallback
+   * `storage.namespaces[nsId].entries.type` rather than the implicit fallback
    * namespace used for top-level `storageTypes` enums.
    */
   readonly namespaceTypes?: Readonly<
@@ -139,8 +153,14 @@ export interface ContractDefinition {
    * 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) => Namespace;
+  readonly createNamespace?: (
+    input: SqlNamespaceTablesInput,
+    enumTypes?: Readonly<Record<string, PostgresEnumStorageEntry>>,
+  ) => Namespace;
   readonly models: readonly ModelNode[];
   readonly valueObjects?: readonly ValueObjectNode[];
 }

package/src/contract-dsl.ts

@@ -1,6 +1,7 @@
 import type {
   ColumnDefault,
   ColumnDefaultLiteralInputValue,
+  ControlPolicy,
   ExecutionMutationDefaultPhases,
   ExecutionMutationDefaultValue,
 } from '@prisma-next/contract/types';
@@ -785,6 +786,7 @@ export type ModelAttributesSpec = {
 
 export type SqlStageSpec = {
   readonly table?: string;
+  readonly control?: ControlPolicy;
   readonly indexes?: readonly IndexConstraint[];
   readonly foreignKeys?: readonly ForeignKeyConstraint[];
 };
@@ -1216,6 +1218,7 @@ export type ContractInput<
   readonly naming?: NamingConfig;
   readonly storageHash?: string;
   readonly foreignKeyDefaults?: ForeignKeyDefaultsState;
+  readonly defaultControlPolicy?: ControlPolicy;
   /**
    * Declared namespace coordinates the contract recognises. Per-model
    * `namespace` references must reference an entry in this list (or the

package/src/contract-lowering.ts

@@ -614,6 +614,7 @@ function resolveModelNode(
     ...(indexes.length > 0 ? { indexes } : {}),
     ...(foreignKeys.length > 0 ? { foreignKeys } : {}),
     ...(relations.length > 0 ? { relations } : {}),
+    ...ifDefined('control', spec.sqlSpec?.control),
   };
 }
 
@@ -707,6 +708,7 @@ export function buildContractDefinition(definition: ContractInput): ContractDefi
 
   return {
     target: definition.target,
+    ...ifDefined('defaultControlPolicy', definition.defaultControlPolicy),
     ...(definition.extensionPacks ? { extensionPacks: definition.extensionPacks } : {}),
     ...(definition.storageHash ? { storageHash: definition.storageHash } : {}),
     ...(definition.foreignKeyDefaults ? { foreignKeyDefaults: definition.foreignKeyDefaults } : {}),