@prisma-next/target-postgres 0.13.0-dev.3 → 0.13.0-dev.30

package/src/core/migrations/postgres-migration.ts

@@ -7,7 +7,7 @@ import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import type { SqlStorage } from '@prisma-next/sql-contract/types';
 import type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';
 import { errorPostgresMigrationStackMissing } from '../errors';
-import { CreateSchemaCall, CreateTableCall } from './op-factory-call';
+import { AddColumnCall, CreateSchemaCall, CreateTableCall } from './op-factory-call';
 import { type DataTransformOptions, dataTransform } from './operations/data-transform';
 import type { PostgresPlanTargetDetails } from './planner-target-details';
 
@@ -64,7 +64,7 @@ export abstract class PostgresMigration extends SqlMigration<
     contract: TContract,
     name: string,
     options: DataTransformOptions,
-  ): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {
+  ): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
     if (!this.controlAdapter) {
       throw errorPostgresMigrationStackMissing();
     }
@@ -82,7 +82,7 @@ export abstract class PostgresMigration extends SqlMigration<
     readonly ifNotExists?: boolean;
     readonly columns: readonly DdlColumn[];
     readonly constraints?: readonly DdlTableConstraint[];
-  }): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
     if (!this.controlAdapter) {
       throw errorPostgresMigrationStackMissing();
     }
@@ -102,10 +102,25 @@ export abstract class PostgresMigration extends SqlMigration<
   protected createSchema(options: {
     readonly schema: string;
     readonly ifNotExists?: boolean;
-  }): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
     if (!this.controlAdapter) {
       throw errorPostgresMigrationStackMissing();
     }
     return new CreateSchemaCall(options.schema).toOp(this.controlAdapter);
   }
+
+  protected addColumn(options: {
+    readonly schema?: string;
+    readonly table: string;
+    readonly column: DdlColumn;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new AddColumnCall(
+      options.schema ?? UNBOUND_NAMESPACE_ID,
+      options.table,
+      options.column,
+    ).toOp(this.controlAdapter);
+  }
 }

package/src/core/migrations/render-ops.ts

@@ -1,7 +1,11 @@
 import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';
-import type { Lowerer } from '@prisma-next/family-sql/control-adapter';
-import type { OpFactoryCall } from '@prisma-next/framework-components/control';
+import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
+import type {
+  MigrationPlanOperation,
+  OpFactoryCall,
+} from '@prisma-next/framework-components/control';
 import { blindCast } from '@prisma-next/utils/casts';
+import { isThenable } from '@prisma-next/utils/promise';
 import type { PostgresPlanTargetDetails } from './planner-target-details';
 
 type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
@@ -13,11 +17,11 @@ type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
  * silently flow through to postgres-shaped renderers — exactly the
  * place to fail loudly with op metadata (`id` + `target.id`).
  */
-function assertPostgresOp(
-  op: ReturnType<OpFactoryCall['toOp']>,
-  callFactoryName: string,
-): asserts op is Op {
-  const targetId = (op as Partial<Op>).target?.id;
+function assertPostgresOp(op: MigrationPlanOperation, callFactoryName: string): asserts op is Op {
+  const targetId = blindCast<
+    { target?: { id?: string } },
+    'op.target is present on concrete SqlMigrationPlanOperation but absent on the framework MigrationPlanOperation base'
+  >(op).target?.id;
   if (targetId !== 'postgres') {
     throw new Error(
       `renderOps: expected postgres op but got target.id="${String(targetId)}" for op.id="${op.id}" (factoryName="${callFactoryName}"). An OpFactoryCall produced an op for a different target on the postgres planner path; check the call's target binding.`,
@@ -25,13 +29,22 @@ function assertPostgresOp(
   }
 }
 
-export function renderOps(calls: readonly OpFactoryCall[], lowerer?: Lowerer): Op[] {
+export function renderOps(
+  calls: readonly OpFactoryCall[],
+  lowerer?: ExecuteRequestLowerer,
+): (Op | Promise<Op>)[] {
   return calls.map((c) => {
-    const op = blindCast<
-      { toOp(lowerer?: Lowerer): ReturnType<OpFactoryCall['toOp']> },
-      'PG OpFactoryCall.toOp accepts an optional Lowerer; the framework interface omits it because not all targets need a lowerer — the PG target overrides with this extended signature'
+    const opOrPromise = blindCast<
+      { toOp(lowerer?: ExecuteRequestLowerer): Op | Promise<Op> },
+      'PG OpFactoryCall.toOp accepts an optional ExecuteRequestLowerer; the framework interface omits it because not all targets need a lowerer — the PG target overrides with this extended signature'
     >(c).toOp(lowerer);
-    assertPostgresOp(op, c.factoryName);
-    return op;
+    if (isThenable(opOrPromise)) {
+      return opOrPromise.then((op) => {
+        assertPostgresOp(op, c.factoryName);
+        return op;
+      });
+    }
+    assertPostgresOp(opOrPromise, c.factoryName);
+    return opOrPromise;
   });
 }

package/src/core/migrations/runner.ts

@@ -18,13 +18,13 @@ import { APP_SPACE_ID } from '@prisma-next/framework-components/control';
 import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import type { SqlControlDriverInstance, SqlStorage } from '@prisma-next/sql-contract/types';
 import { SqlQueryError } from '@prisma-next/sql-errors';
-import type { LoweredStatement } from '@prisma-next/sql-relational-core/ast';
+import type { SqlExecuteRequest } from '@prisma-next/sql-relational-core/ast';
+import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { Result } from '@prisma-next/utils/result';
 import { notOk, ok, okVoid } from '@prisma-next/utils/result';
 import { parsePostgresDefault } from '../default-normalizer';
 import { normalizeSchemaNativeType } from '../native-type-normalizer';
-import { createResolveExistingEnumValues } from './enum-planning';
 import type { PostgresPlanTargetDetails } from './planner-target-details';
 
 interface ApplyPlanSuccessValue {
@@ -86,6 +86,12 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     const space = options.plan.spaceId;
     const lockKey = `${LOCK_DOMAIN}:${schema}:${space}`;
 
+    // Materialize any async ops before running checks or executing.
+    const planOps = blindCast<
+      readonly SqlMigrationPlanOperation<PostgresPlanTargetDetails>[],
+      'ops were produced by the PG planner and are SqlMigrationPlanOperation<PostgresPlanTargetDetails>; MigrationPlan.operations uses the wider framework type to accommodate Promise covariance'
+    >(await Promise.all(options.plan.operations));
+
     // Static checks (idempotent — safe to run again when the caller is
     // `execute(...)` because the cost is a single object comparison).
     const destinationCheck = this.ensurePlanMatchesDestinationContract(
@@ -94,7 +100,7 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     );
     if (!destinationCheck.ok) return destinationCheck;
 
-    const policyCheck = this.enforcePolicyCompatibility(options.policy, options.plan.operations);
+    const policyCheck = this.enforcePolicyCompatibility(options.policy, planOps);
     if (!policyCheck.ok) return policyCheck;
 
     await this.acquireLock(driver, lockKey);
@@ -113,7 +119,7 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     if (skipOperations) {
       applyValue = { operationsExecuted: 0, executedOperations: [] };
     } else {
-      const applyResult = await this.applyPlan(driver, options);
+      const applyResult = await this.applyPlan(driver, options, planOps);
       if (!applyResult.ok) return applyResult;
       applyValue = applyResult.value;
     }
@@ -137,9 +143,6 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
         frameworkComponents: options.frameworkComponents,
         normalizeDefault: parsePostgresDefault,
         normalizeNativeType: normalizeSchemaNativeType,
-        resolveExistingEnumValues: createResolveExistingEnumValues(
-          options.destinationContract.storage,
-        ),
       });
       if (!schemaVerifyResult.ok) {
         return runnerFailure('SCHEMA_VERIFY_FAILED', schemaVerifyResult.summary, {
@@ -158,11 +161,16 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     if (!isSelfEdgeNoOp) {
       const markerResult = await this.upsertMarker(driver, options, existingMarker, space);
       if (!markerResult.ok) return markerResult;
-      await this.recordLedgerEntries(driver, options, applyValue.executedOperations);
+      await this.recordLedgerEntries(
+        driver,
+        options,
+        applyValue.executedOperations,
+        planOps.length,
+      );
     }
 
     return runnerSuccess({
-      operationsPlanned: options.plan.operations.length,
+      operationsPlanned: planOps.length,
       operationsExecuted: applyValue.operationsExecuted,
     });
   }
@@ -209,6 +217,7 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
   private async applyPlan(
     driver: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['driver'],
     options: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>,
+    ops: readonly SqlMigrationPlanOperation<PostgresPlanTargetDetails>[],
   ): Promise<Result<ApplyPlanSuccessValue, SqlMigrationRunnerFailure>> {
     const checks = options.executionChecks;
     const runPrechecks = checks?.prechecks !== false; // Default true
@@ -217,7 +226,7 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
 
     let operationsExecuted = 0;
     const executedOperations: Array<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> = [];
-    for (const operation of options.plan.operations) {
+    for (const operation of ops) {
       options.callbacks?.onOperationStart?.(operation);
       try {
         // Idempotency probe: only run if both postchecks and idempotency checks are enabled
@@ -282,13 +291,13 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     if (schemaQuery === undefined) {
       throw new Error('Postgres control-table bootstrap must include CREATE SCHEMA');
     }
-    await this.executeStatement(driver, this.family.lowerAst(schemaQuery, lowererContext));
+    await this.executeStatement(driver, await this.family.lowerAst(schemaQuery, lowererContext));
     const legacyDetection = await this.detectLegacyMarkerShape(driver);
     if (!legacyDetection.ok) {
       return legacyDetection;
     }
     for (const query of tableQueries) {
-      await this.executeStatement(driver, this.family.lowerAst(query, lowererContext));
+      await this.executeStatement(driver, await this.family.lowerAst(query, lowererContext));
     }
     return okVoid();
   }
@@ -629,14 +638,15 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     driver: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['driver'],
     options: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>,
     executedOperations: readonly SqlMigrationPlanOperation<PostgresPlanTargetDetails>[],
+    planOpsLength: number,
   ): Promise<void> {
     const plan = options.plan;
     const space = plan.spaceId;
     const edges = options.migrationEdges;
     const totalEdgeOps = edges.reduce((sum, edge) => sum + edge.operationCount, 0);
-    if (totalEdgeOps !== plan.operations.length) {
+    if (totalEdgeOps !== planOpsLength) {
       throw new Error(
-        `Ledger write: plan.operations length (${plan.operations.length}) does not match sum of migrationEdges operationCount (${totalEdgeOps})`,
+        `Ledger write: plan.operations length (${planOpsLength}) does not match sum of migrationEdges operationCount (${totalEdgeOps})`,
       );
     }
     // The ledger records the operations as executed — idempotency-skipped ops
@@ -688,12 +698,8 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
 
   private async executeStatement(
     driver: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['driver'],
-    statement: LoweredStatement,
+    statement: SqlExecuteRequest,
   ): Promise<void> {
-    if (statement.params.length > 0) {
-      await driver.query(statement.sql, statement.params);
-      return;
-    }
-    await driver.query(statement.sql);
+    await driver.query(statement.sql, statement.params);
   }
 }

package/src/core/postgres-contract-serializer.ts

@@ -17,9 +17,7 @@ import {
 import type { SqlNamespaceTablesInput, SqlStorage } from '@prisma-next/sql-contract/types';
 import { blindCast } from '@prisma-next/utils/casts';
 import type { JsonObject } from '@prisma-next/utils/json';
-import type { Type } from 'arktype';
 import { postgresAuthoringEntityTypes } from './authoring';
-import type { PostgresEnumType } from './postgres-enum-type';
 import { isPostgresSchema, PostgresSchema } from './postgres-schema';
 
 const POSTGRES_AUTHORING_CTX: AuthoringEntityContext = {
@@ -38,27 +36,21 @@ function isAuthoringEntityTypeFactoryOutput(
 }
 
 /**
- * Walks a pack's entity-type namespace tree and emits the maps the
- * family base consumes — hydrators and validator-schema fragments, both
- * keyed by the descriptor's `discriminator`.
+ * Walks a pack's entity-type namespace tree and emits hydration factories
+ * keyed by the descriptor's `discriminator`. Used for `storage.types`
+ * (codec-triple hydration). Namespace entries hydration dispatches by
+ * entries key, not discriminator — handled by `hydrateEntriesKind`.
  */
-function collectEntityRegistryContributions(namespace: AuthoringEntityTypeNamespace): {
-  readonly entityTypeRegistry: ReadonlyMap<string, SqlEntityHydrationFactory>;
-  readonly validatorFragments: ReadonlyMap<string, Type<unknown>>;
-} {
-  const entityTypeRegistry = new Map<string, SqlEntityHydrationFactory>();
-  const validatorFragments = new Map<string, Type<unknown>>();
+function collectStorageTypesHydrators(
+  namespace: AuthoringEntityTypeNamespace,
+): ReadonlyMap<string, SqlEntityHydrationFactory> {
+  const registry = new Map<string, SqlEntityHydrationFactory>();
   const walk = (node: AuthoringEntityTypeNamespace): void => {
     for (const value of Object.values(node)) {
       if (isAuthoringEntityTypeDescriptor(value)) {
         if (isAuthoringEntityTypeFactoryOutput(value.output)) {
           const { factory } = value.output;
-          entityTypeRegistry.set(value.discriminator, (raw) =>
-            factory(raw, POSTGRES_AUTHORING_CTX),
-          );
-        }
-        if (value.validatorSchema !== undefined) {
-          validatorFragments.set(value.discriminator, value.validatorSchema);
+          registry.set(value.discriminator, (raw) => factory(raw, POSTGRES_AUTHORING_CTX));
         }
         continue;
       }
@@ -68,15 +60,13 @@ function collectEntityRegistryContributions(namespace: AuthoringEntityTypeNamesp
     }
   };
   walk(namespace);
-  return { entityTypeRegistry, validatorFragments };
+  return registry;
 }
 
 export class PostgresContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {
   constructor() {
-    const { entityTypeRegistry, validatorFragments } = collectEntityRegistryContributions(
-      postgresAuthoringEntityTypes,
-    );
-    super(entityTypeRegistry, validatorFragments);
+    const storageTypesHydrators = collectStorageTypesHydrators(postgresAuthoringEntityTypes);
+    super(storageTypesHydrators);
   }
 
   protected override hydrateSqlNamespaceEntry(
@@ -88,40 +78,22 @@ export class PostgresContractSerializer extends SqlContractSerializerBase<Contra
     }
     const hydrated = blindCast<
       SqlNamespaceTablesInput,
-      'super.hydrateSqlNamespaceEntry returns the tables form when raw is not a NamespaceBase'
+      'super.hydrateSqlNamespaceEntry returns SqlNamespaceTablesInput when raw is not a NamespaceBase'
     >(super.hydrateSqlNamespaceEntry(nsId, raw));
     const { id, entries } = hydrated;
 
-    // Extract the postgres-specific `type` slot directly from raw input.
-    // The family base handles the `table` slot; the postgres target owns `type`.
-    const rawRecord = raw as Record<string, unknown>;
-    const rawEntries = rawRecord['entries'];
-    let typeSlot: Record<string, PostgresEnumType> | undefined;
-    if (rawEntries !== null && typeof rawEntries === 'object' && !Array.isArray(rawEntries)) {
-      const rawTypeSlot = (rawEntries as Record<string, unknown>)['type'];
-      if (rawTypeSlot !== null && typeof rawTypeSlot === 'object' && !Array.isArray(rawTypeSlot)) {
-        const enumFactory = this.entityTypeRegistry.get('postgres-enum');
-        typeSlot = Object.fromEntries(
-          Object.entries(rawTypeSlot as Record<string, unknown>).map(([name, entry]) => [
-            name,
-            blindCast<PostgresEnumType, 'postgres-enum factory returns PostgresEnumType'>(
-              enumFactory !== undefined ? enumFactory(entry) : entry,
-            ),
-          ]),
-        );
-      }
-    }
-
-    const emptyTables = Object.keys(entries.table).length === 0;
-    const emptyTypes = !typeSlot || Object.keys(typeSlot).length === 0;
-    if (id === UNBOUND_NAMESPACE_ID && emptyTables && emptyTypes) {
+    const valueSetSlot = entries['valueSet'];
+    const hasValueSets = valueSetSlot !== undefined && Object.keys(valueSetSlot).length > 0;
+    const emptyTables = Object.keys(entries['table'] ?? {}).length === 0;
+    if (id === UNBOUND_NAMESPACE_ID && emptyTables && !hasValueSets) {
       return PostgresSchema.unbound;
     }
     return new PostgresSchema({
       id,
       entries: {
-        table: entries.table,
-        type: typeSlot ?? {},
+        ...entries,
+        table: entries['table'] ?? {},
+        ...(hasValueSets ? { valueSet: valueSetSlot } : {}),
       },
     });
   }
@@ -139,7 +111,7 @@ export class PostgresContractSerializer extends SqlContractSerializerBase<Contra
           kind: isUnboundSlot ? 'postgres-unbound-schema' : 'postgres-schema',
           entries: {
             table: Object.fromEntries(
-              Object.entries(ns.entries.table).map(([tableName, table]) => [
+              Object.entries(ns.entries.table ?? {}).map(([tableName, table]) => [
                 tableName,
                 this.serializeJsonValue(table) as JsonObject,
               ]),
@@ -167,19 +139,25 @@ export class PostgresContractSerializer extends SqlContractSerializerBase<Contra
 
   private serializePostgresNamespace(ns: PostgresSchema, isUnboundSlot: boolean): JsonObject {
     const tablesOut: Record<string, JsonObject> = {};
-    for (const [tableName, table] of Object.entries(ns.entries.table)) {
+    for (const [tableName, table] of Object.entries(ns.table)) {
       tablesOut[tableName] = this.serializeJsonValue(table) as JsonObject;
     }
-    const typeOut: Record<string, JsonObject> = {};
-    for (const [typeName, ty] of Object.entries(ns.entries.type)) {
-      typeOut[typeName] = this.serializeJsonValue(ty) as JsonObject;
+    const valueSetEntries = ns.valueSet;
+    const valueSetOut: Record<string, JsonObject> = {};
+    if (valueSetEntries !== undefined) {
+      for (const [valueSetName, valueSet] of Object.entries(valueSetEntries)) {
+        valueSetOut[valueSetName] = blindCast<
+          JsonObject,
+          'serializeJsonValue round-trips the value-set node through JSON, yielding a JsonObject'
+        >(this.serializeJsonValue(valueSet));
+      }
     }
     return {
       id: ns.id,
       kind: isUnboundSlot ? 'postgres-unbound-schema' : 'postgres-schema',
       entries: {
         table: tablesOut,
-        type: typeOut,
+        ...(Object.keys(valueSetOut).length > 0 ? { valueSet: valueSetOut } : {}),
       },
     };
   }

package/src/core/postgres-enum-type-schema.ts

@@ -0,0 +1,17 @@
+import { type } from 'arktype';
+
+const ControlPolicySchema = type("'managed' | 'tolerated' | 'external' | 'observed'");
+
+/**
+ * Arktype validator for a `postgres-enum` entry under
+ * `storage.namespaces[id].entries.type[name]`. Registered by the Postgres
+ * target pack against the `'type'` entries key so the family-layer namespace
+ * validator accepts (and rejects) entries of this kind.
+ */
+export const PostgresEnumTypeSchema = type({
+  kind: "'postgres-enum'",
+  'name?': 'string',
+  'nativeType?': 'string',
+  values: type.string.array().readonly(),
+  'control?': ControlPolicySchema,
+});

package/src/core/postgres-schema.ts

@@ -4,21 +4,20 @@ import {
   UNBOUND_NAMESPACE_ID,
 } from '@prisma-next/framework-components/ir';
 import {
-  type PostgresEnumStorageEntry,
   type SqlNamespaceTablesInput,
   type SqlStorage,
   StorageTable,
   type StorageTableInput,
+  StorageValueSet,
+  type StorageValueSetInput,
 } from '@prisma-next/sql-contract/types';
-import { PostgresEnumType, type PostgresEnumTypeInput } from './postgres-enum-type';
+import { blindCast } from '@prisma-next/utils/casts';
+import { ifDefined } from '@prisma-next/utils/defined';
 import { escapeLiteral } from './sql-utils';
 
 export interface PostgresSchemaInput {
   readonly id: string;
-  readonly entries: {
-    readonly table: Record<string, StorageTable | StorageTableInput>;
-    readonly type: Record<string, PostgresEnumType | PostgresEnumTypeInput>;
-  };
+  readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
 }
 
 /**
@@ -27,7 +26,7 @@ export interface PostgresSchemaInput {
  * `namespaces: Record<NamespaceId, PostgresSchema>` map populated by
  * the Postgres PSL interpreter from `namespace { … }` AST buckets.
  *
- * `entries` holds entity-kind slot maps (`table`, `type`). Qualifier
+ * `entries` holds entity-kind maps (`table`, `valueSet`). Qualifier
  * emission is the rendering seam: DDL / SQL emission asks the namespace
  * for its qualifier (`"<schema>"`) or for a qualified table name
  * (`"<schema>"."<table>"`) and consumes the result polymorphically.
@@ -47,31 +46,49 @@ export class PostgresSchema extends NamespaceBase {
 
   declare readonly kind: 'schema';
   readonly id: string;
-  readonly entries: Readonly<{
-    readonly table: Readonly<Record<string, StorageTable>>;
-    readonly type: Readonly<Record<string, PostgresEnumType>>;
-  }>;
+  readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
 
   constructor(input: PostgresSchemaInput) {
     super();
     this.id = input.id;
+
+    const carried: Record<string, Readonly<Record<string, unknown>>> = {};
+    let table: Readonly<Record<string, StorageTable>> = Object.freeze({});
+    let valueSet: Readonly<Record<string, StorageValueSet>> | undefined;
+    for (const [kind, rawMap] of Object.entries(input.entries)) {
+      if (kind === 'table') {
+        const tableMap: Record<string, StorageTable> = {};
+        for (const [name, v] of Object.entries(
+          blindCast<
+            Record<string, StorageTableInput>,
+            'entries[table] holds StorageTableInput by construction'
+          >(rawMap),
+        )) {
+          tableMap[name] = new StorageTable(v);
+        }
+        table = Object.freeze(tableMap);
+      } else if (kind === 'valueSet') {
+        const vsMap: Record<string, StorageValueSet> = {};
+        for (const [name, v] of Object.entries(
+          blindCast<
+            Record<string, StorageValueSetInput>,
+            'entries[valueSet] holds StorageValueSetInput by construction'
+          >(rawMap),
+        )) {
+          vsMap[name] = new StorageValueSet(v);
+        }
+        if (Object.keys(vsMap).length > 0) {
+          valueSet = Object.freeze(vsMap);
+        }
+      } else {
+        carried[kind] = Object.freeze(rawMap);
+      }
+    }
+
     this.entries = Object.freeze({
-      table: Object.freeze(
-        Object.fromEntries(
-          Object.entries(input.entries.table).map(([k, v]) => [
-            k,
-            v instanceof StorageTable ? v : new StorageTable(v as StorageTableInput),
-          ]),
-        ),
-      ),
-      type: Object.freeze(
-        Object.fromEntries(
-          Object.entries(input.entries.type).map(([k, v]) => [
-            k,
-            v instanceof PostgresEnumType ? v : new PostgresEnumType(v as PostgresEnumTypeInput),
-          ]),
-        ),
-      ),
+      ...carried,
+      table,
+      ...ifDefined('valueSet', valueSet),
     });
     Object.defineProperty(this, 'kind', {
       value: 'schema',
@@ -82,6 +99,14 @@ export class PostgresSchema extends NamespaceBase {
     freezeNode(this);
   }
 
+  get table(): Readonly<Record<string, StorageTable>> {
+    return this.entries['table'] ?? Object.freeze({});
+  }
+
+  get valueSet(): Readonly<Record<string, StorageValueSet>> | undefined {
+    return this.entries['valueSet'] as Readonly<Record<string, StorageValueSet>> | undefined;
+  }
+
   /**
    * The bare schema qualifier as it would appear in a rendered SQL
    * fragment (already quoted). The unbound-schema singleton overrides
@@ -162,7 +187,7 @@ export class PostgresUnboundSchema extends PostgresSchema {
   static readonly instance: PostgresUnboundSchema = new PostgresUnboundSchema();
 
   constructor(input?: PostgresSchemaInput) {
-    super(input ?? { id: UNBOUND_NAMESPACE_ID, entries: { table: {}, type: {} } });
+    super(input ?? { id: UNBOUND_NAMESPACE_ID, entries: { table: {} } });
   }
 
   override qualifier(): string {
@@ -204,15 +229,12 @@ export function isPostgresSchema(ns: unknown): ns is PostgresSchema {
  * by reference and trust the resulting `SqlStorage.namespaces` map to
  * be value-stable for a given input set.
  */
-export function postgresCreateNamespace(
-  input: SqlNamespaceTablesInput,
-  enumTypes?: Readonly<Record<string, PostgresEnumStorageEntry>>,
-): PostgresSchema {
+export function postgresCreateNamespace(input: SqlNamespaceTablesInput): PostgresSchema {
   const schemaInput: PostgresSchemaInput = {
     id: input.id,
     entries: {
-      table: input.entries.table,
-      type: (enumTypes ?? {}) as Record<string, PostgresEnumTypeInput>,
+      ...input.entries,
+      table: input.entries['table'] ?? {},
     },
   };
   if (input.id === UNBOUND_NAMESPACE_ID) {

package/src/exports/codecs.ts

@@ -2,7 +2,6 @@ export type {
   PgBitDescriptor,
   PgBoolDescriptor,
   PgCharDescriptor,
-  PgEnumDescriptor,
   PgFloat4Descriptor,
   PgFloat8Descriptor,
   PgFloatDescriptor,
@@ -19,6 +18,7 @@ export type {
   PgTimestampDescriptor,
   PgTimestamptzDescriptor,
   PgTimetzDescriptor,
+  PgUuidDescriptor,
   PgVarbitDescriptor,
   PgVarcharDescriptor,
 } from '../core/codecs';
@@ -26,7 +26,6 @@ export {
   pgBitColumn,
   pgBoolColumn,
   pgCharColumn,
-  pgEnumColumn,
   pgFloat4Column,
   pgFloat8Column,
   pgFloatColumn,
@@ -43,6 +42,7 @@ export {
   pgTimestampColumn,
   pgTimestamptzColumn,
   pgTimetzColumn,
+  pgUuidColumn,
   pgVarbitColumn,
   pgVarcharColumn,
 } from '../core/codecs';

package/src/exports/contract-free.ts

@@ -3,5 +3,5 @@ export {
   buildControlTableBootstrapQueries,
   buildSignMarkerBootstrapQueries,
 } from '../contract-free/control-bootstrap';
-export { createSchema, createTable } from '../contract-free/ddl';
+export { addColumnAction, alterTable, createSchema, createTable } from '../contract-free/ddl';
 export { PostgresTableSource } from '../core/ast/table-source';

package/src/exports/control.ts

@@ -10,10 +10,6 @@ import type {
 import type { SqlStorage, StorageColumn } from '@prisma-next/sql-contract/types';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { postgresTargetDescriptorMeta } from '../core/descriptor-meta';
-import {
-  enumStorageCompoundKey,
-  resolveDdlSchemaForNamespaceStorage,
-} from '../core/migrations/enum-planning';
 import { createPostgresMigrationPlanner } from '../core/migrations/planner';
 import { renderDefaultLiteral } from '../core/migrations/planner-ddl-builders';
 import type { PostgresPlanTargetDetails } from '../core/migrations/planner-target-details';
@@ -34,12 +30,6 @@ function buildNativeTypeExpander(
     readonly typeParams?: Record<string, unknown>;
   }) => {
     if (!input.typeParams) return input.nativeType;
-    // Mirror `renderExpectedNativeType` in verify-sql-schema: when a codec
-    // has no `expandNativeType` hook (e.g. `pg/enum@1`, whose typeParams
-    // describe the value set rather than a DDL suffix), fall back to the
-    // bare native type rather than throwing. Throwing here would reject
-    // every plan involving an enum-/values-typed column as soon as its
-    // `typeRef` resolved to a `StorageTypeInstance` carrying typeParams.
     if (!input.codecId) return input.nativeType;
     const hooks = codecHooks.get(input.codecId);
     if (!hooks?.expandNativeType) return input.nativeType;
@@ -80,18 +70,6 @@ const postgresTargetDescriptor: SqlControlTargetDescriptor<'postgres', PostgresP
           annotationNamespace: 'pg',
           ...ifDefined('expandNativeType', expander),
           renderDefault: postgresRenderDefault,
-          // Schema-qualify enum annotation keys so the projected "from" IR's
-          // `storageTypes` match `readExistingEnumValues` on the read side
-          // (the contract-to-contract `migration plan` path). The DDL-schema
-          // resolution + compound-key format stay here in the target layer;
-          // the family projector treats the returned string as opaque.
-          // `undefined` schema IR ⇒ the unbound coordinate resolves to the
-          // default `public` landing schema, matching the read-side fallback.
-          resolveEnumStorageKey: (storage, namespaceId, nativeType) =>
-            enumStorageCompoundKey(
-              resolveDdlSchemaForNamespaceStorage(storage, namespaceId, undefined),
-              nativeType,
-            ),
         });
       },
     },