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

package/package.json

@@ -1,32 +1,32 @@
 {
   "name": "@prisma-next/target-postgres",
-  "version": "0.13.0-dev.3",
+  "version": "0.13.0-dev.31",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Postgres target pack for Prisma Next",
   "dependencies": {
-    "@prisma-next/cli": "0.13.0-dev.3",
-    "@prisma-next/contract": "0.13.0-dev.3",
-    "@prisma-next/errors": "0.13.0-dev.3",
-    "@prisma-next/family-sql": "0.13.0-dev.3",
-    "@prisma-next/framework-components": "0.13.0-dev.3",
-    "@prisma-next/migration-tools": "0.13.0-dev.3",
-    "@prisma-next/ts-render": "0.13.0-dev.3",
-    "@prisma-next/sql-contract": "0.13.0-dev.3",
-    "@prisma-next/sql-errors": "0.13.0-dev.3",
-    "@prisma-next/sql-operations": "0.13.0-dev.3",
-    "@prisma-next/sql-relational-core": "0.13.0-dev.3",
-    "@prisma-next/sql-schema-ir": "0.13.0-dev.3",
-    "@prisma-next/utils": "0.13.0-dev.3",
+    "@prisma-next/cli": "0.13.0-dev.31",
+    "@prisma-next/contract": "0.13.0-dev.31",
+    "@prisma-next/errors": "0.13.0-dev.31",
+    "@prisma-next/family-sql": "0.13.0-dev.31",
+    "@prisma-next/framework-components": "0.13.0-dev.31",
+    "@prisma-next/migration-tools": "0.13.0-dev.31",
+    "@prisma-next/ts-render": "0.13.0-dev.31",
+    "@prisma-next/sql-contract": "0.13.0-dev.31",
+    "@prisma-next/sql-errors": "0.13.0-dev.31",
+    "@prisma-next/sql-operations": "0.13.0-dev.31",
+    "@prisma-next/sql-relational-core": "0.13.0-dev.31",
+    "@prisma-next/sql-schema-ir": "0.13.0-dev.31",
+    "@prisma-next/utils": "0.13.0-dev.31",
     "@standard-schema/spec": "^1.1.0",
     "arktype": "^2.2.0",
     "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "@prisma-next/test-utils": "0.13.0-dev.3",
-    "@prisma-next/tsconfig": "0.13.0-dev.3",
-    "@prisma-next/tsdown": "0.13.0-dev.3",
+    "@prisma-next/test-utils": "0.13.0-dev.31",
+    "@prisma-next/tsconfig": "0.13.0-dev.31",
+    "@prisma-next/tsdown": "0.13.0-dev.31",
     "tsdown": "0.22.1",
     "typescript": "5.9.3",
     "vitest": "4.1.8"
@@ -53,7 +53,6 @@
     "./data-transform": "./dist/data-transform.mjs",
     "./ddl": "./dist/ddl.mjs",
     "./default-normalizer": "./dist/default-normalizer.mjs",
-    "./enum-planning": "./dist/enum-planning.mjs",
     "./errors": "./dist/errors.mjs",
     "./issue-planner": "./dist/issue-planner.mjs",
     "./migration": "./dist/migration.mjs",

package/src/contract-free/ddl.ts

@@ -1,5 +1,11 @@
 import type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';
-import { PostgresCreateSchema, PostgresCreateTable } from '../core/ddl/nodes';
+import {
+  AddColumnAction,
+  type AnyAlterTableAction,
+  PostgresAlterTable,
+  PostgresCreateSchema,
+  PostgresCreateTable,
+} from '../core/ddl/nodes';
 
 /**
  * Build a Postgres `CREATE TABLE` query node.
@@ -35,3 +41,24 @@ export function createSchema(options: {
 }): PostgresCreateSchema {
   return new PostgresCreateSchema(options);
 }
+
+/**
+ * Build an `ADD COLUMN` action for use inside {@link alterTable}.
+ * The column is a structured `DdlColumn` so codec-encoded defaults flow
+ * through the adapter's `pgRenderDdlColumn` → `pgRenderDdlColumnDefault` path.
+ */
+export function addColumnAction(column: DdlColumn): AddColumnAction {
+  return new AddColumnAction(column);
+}
+
+/**
+ * Build a Postgres `ALTER TABLE` query node carrying one or more actions.
+ * See {@link addColumnAction} for building actions.
+ */
+export function alterTable(options: {
+  readonly table: string;
+  readonly schema?: string;
+  readonly actions: readonly AnyAlterTableAction[];
+}): PostgresAlterTable {
+  return new PostgresAlterTable(options);
+}

package/src/core/authoring.ts

@@ -4,53 +4,10 @@ import type {
   AuthoringFieldNamespace,
   AuthoringTypeNamespace,
 } from '@prisma-next/framework-components/authoring';
-import type { PostgresEnumStorageEntry } from '@prisma-next/sql-contract/types';
-import { PostgresEnumTypeSchema } from '@prisma-next/sql-contract/validators';
-import { PostgresEnumType, type PostgresEnumTypeInput } from './postgres-enum-type';
 
 export const postgresAuthoringTypes = {} as const satisfies AuthoringTypeNamespace;
 
-/**
- * Entity type contributions surface as top-level helpers on the
- * composed-helpers shape (e.g. `helpers.enum({...})`), flattened
- * alongside the built-in `model` / `rel` helpers. Pack contributions
- * still ship via the contribution data structure
- * `authoring.entityTypes.<name>`; the composed-helpers template
- * performs the rename in the type system.
- *
- * `enum` is the first real consumer of the entities-namespace mechanism:
- * the factory constructs a `PostgresEnumType` IR-class instance from
- * the user-supplied input. Both authoring runtimes (TS DSL and PSL)
- * dispatch through this single contribution — PSL `enum Status { … }`
- * declarations are lowered by the interpreter into a factory call
- * with the parsed name + value list; TS DSL `helpers.enum({...})`
- * resolves through the same path. Removing this contribution makes
- * both surfaces fail with a "no entity helper named `enum`" type
- * error at the contract-definition site.
- */
-/**
- * The factory constructs a `PostgresEnumType` instance natively — the
- * `SqlStorage.types` slot accepts polymorphic IR (the framework
- * `StorageType` alphabet), so no cast is needed at the contribution
- * surface. The declared return type is the structural
- * `PostgresEnumStorageEntry` so the inferred contract type stays
- * portable (it names a type exported from
- * `@prisma-next/sql-contract/types`, a public surface every consumer
- * already imports). Sharpening the inferred contract type to surface
- * enum-specific narrowing through `EntityHelperFunction` is a
- * separable refinement and lives outside this PR.
- */
-export const postgresAuthoringEntityTypes = {
-  enum: {
-    kind: 'entity',
-    discriminator: 'postgres-enum',
-    validatorSchema: PostgresEnumTypeSchema,
-    output: {
-      factory: (input: PostgresEnumTypeInput): PostgresEnumStorageEntry =>
-        new PostgresEnumType(input),
-    },
-  },
-} as const satisfies AuthoringEntityTypeNamespace;
+export const postgresAuthoringEntityTypes = {} as const satisfies AuthoringEntityTypeNamespace;
 
 /**
  * Field presets contributed by the Postgres target pack.
@@ -59,6 +16,11 @@ export const postgresAuthoringEntityTypes = {
  * (see `createPostgresPslScalarTypeDescriptors`), so that authoring a field
  * via the TS callback surface (e.g. `field.int()`) and via the PSL scalar
  * surface (e.g. `Int`) lowers to byte-identical contracts.
+ *
+ * The `uuidNative` / `id.uuidv4Native` / `id.uuidv7Native` presets use the
+ * native Postgres `uuid` type (codecId `pg/uuid@1`). For cross-target
+ * portability use `uuidString` / `id.uuidv4String` / `id.uuidv7String` from
+ * the family pack instead.
  */
 export const postgresAuthoringFieldPresets = {
   text: {
@@ -128,4 +90,41 @@ export const postgresAuthoringFieldPresets = {
     codecId: 'pg/timestamptz@1',
     nativeType: 'timestamptz',
   }),
+  uuidNative: {
+    kind: 'fieldPreset',
+    output: {
+      codecId: 'pg/uuid@1',
+      nativeType: 'uuid',
+    },
+  },
+  id: {
+    uuidv4Native: {
+      kind: 'fieldPreset',
+      output: {
+        codecId: 'pg/uuid@1',
+        nativeType: 'uuid',
+        executionDefaults: {
+          onCreate: {
+            kind: 'generator',
+            id: 'uuidv4',
+          },
+        },
+        id: true,
+      },
+    },
+    uuidv7Native: {
+      kind: 'fieldPreset',
+      output: {
+        codecId: 'pg/uuid@1',
+        nativeType: 'uuid',
+        executionDefaults: {
+          onCreate: {
+            kind: 'generator',
+            id: 'uuidv7',
+          },
+        },
+        id: true,
+      },
+    },
+  },
 } as const satisfies AuthoringFieldNamespace;

package/src/core/codec-helpers.ts

@@ -109,23 +109,6 @@ export const pgIntervalDecode = (wire: string | Record<string, unknown>): string
   return JSON.stringify(wire);
 };
 
-export const pgEnumRenderOutputType = (typeParams: {
-  readonly values?: readonly unknown[];
-}): string => {
-  const values = typeParams.values;
-  if (!Array.isArray(values)) {
-    throw new Error(
-      `renderOutputType: expected array "values" in typeParams for enum, got ${typeof values}`,
-    );
-  }
-  if (!values.every((v): v is string => typeof v === 'string')) {
-    throw new Error(`renderOutputType: expected string[] "values" in typeParams for enum`);
-  }
-  return values
-    .map((value) => `'${value.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`)
-    .join(' | ');
-};
-
 export const pgJsonEncode = (value: string | JsonValue): string => JSON.stringify(value);
 export const pgJsonDecode = (wire: string | JsonValue): JsonValue =>
   typeof wire === 'string' ? JSON.parse(wire) : wire;

package/src/core/codec-ids.ts

@@ -8,7 +8,6 @@ export {
 } from '@prisma-next/sql-relational-core/ast';
 export const PG_TEXT_CODEC_ID = 'pg/text@1' as const;
 export const PG_TEXT_ARRAY_CODEC_ID = 'pg/text-array@1' as const;
-export const PG_ENUM_CODEC_ID = 'pg/enum@1' as const;
 export const PG_CHAR_CODEC_ID = 'pg/char@1' as const;
 export const PG_VARCHAR_CODEC_ID = 'pg/varchar@1' as const;
 export const PG_INT_CODEC_ID = 'pg/int@1' as const;
@@ -30,3 +29,4 @@ export const PG_INTERVAL_CODEC_ID = 'pg/interval@1' as const;
 export const PG_JSON_CODEC_ID = 'pg/json@1' as const;
 export const PG_JSONB_CODEC_ID = 'pg/jsonb@1' as const;
 export const PG_BYTEA_CODEC_ID = 'pg/bytea@1' as const;
+export const PG_UUID_CODEC_ID = 'pg/uuid@1' as const;

package/src/core/codec-type-map.ts

@@ -21,7 +21,6 @@ import {
   pgBoolDescriptor,
   pgByteaDescriptor,
   pgCharDescriptor,
-  pgEnumDescriptor,
   pgFloat4Descriptor,
   pgFloat8Descriptor,
   pgFloatDescriptor,
@@ -38,6 +37,7 @@ import {
   pgTimestampDescriptor,
   pgTimestamptzDescriptor,
   pgTimetzDescriptor,
+  pgUuidDescriptor,
   pgVarbitDescriptor,
   pgVarcharDescriptor,
 } from './codecs';
@@ -68,8 +68,8 @@ export const codecDescriptorMap = {
   bit: pgBitDescriptor,
   'bit varying': pgVarbitDescriptor,
   bytea: pgByteaDescriptor,
+  uuid: pgUuidDescriptor,
   interval: pgIntervalDescriptor,
-  enum: pgEnumDescriptor,
   json: pgJsonDescriptor,
   jsonb: pgJsonbDescriptor,
 } as const;

package/src/core/codecs.ts

@@ -36,10 +36,10 @@ import {
   sqlTimestampDescriptor,
   sqlVarcharDescriptor,
 } from '@prisma-next/sql-relational-core/ast';
+import { blindCast } from '@prisma-next/utils/casts';
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 import { type as arktype } from 'arktype';
 import {
-  pgEnumRenderOutputType,
   pgIntervalDecode,
   pgJsonbDecode,
   pgJsonbEncode,
@@ -59,7 +59,6 @@ import {
   PG_BOOL_CODEC_ID,
   PG_BYTEA_CODEC_ID,
   PG_CHAR_CODEC_ID,
-  PG_ENUM_CODEC_ID,
   PG_FLOAT_CODEC_ID,
   PG_FLOAT4_CODEC_ID,
   PG_FLOAT8_CODEC_ID,
@@ -77,6 +76,7 @@ import {
   PG_TIMESTAMP_CODEC_ID,
   PG_TIMESTAMPTZ_CODEC_ID,
   PG_TIMETZ_CODEC_ID,
+  PG_UUID_CODEC_ID,
   PG_VARBIT_CODEC_ID,
   PG_VARCHAR_CODEC_ID,
 } from './codec-ids';
@@ -84,7 +84,6 @@ import {
 type LengthParams = { readonly length?: number };
 type PrecisionParams = { readonly precision?: number };
 type NumericParams = { readonly precision: number; readonly scale?: number };
-type EnumParams = { readonly values?: readonly string[] };
 
 const lengthParamsSchema = arktype({
   'length?': 'number.integer > 0',
@@ -789,64 +788,58 @@ export const pgByteaColumn = () =>
 pgByteaColumn satisfies ColumnHelperFor<PgByteaDescriptor>;
 pgByteaColumn satisfies ColumnHelperForStrict<PgByteaDescriptor>;
 
-export class PgIntervalCodec extends CodecImpl<
-  typeof PG_INTERVAL_CODEC_ID,
+const PG_UUID_META = { db: { sql: { postgres: { nativeType: 'uuid' } } } } as const;
+
+export class PgUuidCodec extends CodecImpl<
+  typeof PG_UUID_CODEC_ID,
   readonly ['equality', 'order'],
-  string | Record<string, unknown>,
+  string,
   string
 > {
   async encode(value: string, _ctx: CodecCallContext): Promise<string> {
     return value;
   }
-  async decode(wire: string | Record<string, unknown>, _ctx: CodecCallContext): Promise<string> {
-    return pgIntervalDecode(wire);
+  async decode(wire: string, _ctx: CodecCallContext): Promise<string> {
+    return wire;
   }
   encodeJson(value: string): JsonValue {
     return value;
   }
   decodeJson(json: JsonValue): string {
-    return json as string;
+    return blindCast<string, 'uuid columns serialize to JSON as their wire string form'>(json);
   }
 }
 
-export class PgIntervalDescriptor extends CodecDescriptorImpl<PrecisionParams> {
-  override readonly codecId = PG_INTERVAL_CODEC_ID;
+export class PgUuidDescriptor extends CodecDescriptorImpl<void> {
+  override readonly codecId = PG_UUID_CODEC_ID;
   override readonly traits = ['equality', 'order'] as const;
-  override readonly targetTypes = ['interval'] as const;
-  override readonly meta = PG_INTERVAL_META;
-  override readonly paramsSchema =
-    precisionParamsSchema satisfies StandardSchemaV1<PrecisionParams>;
-  override renderOutputType(params: PrecisionParams): string | undefined {
-    return renderPrecision('Interval', params as Record<string, unknown>);
-  }
-  override factory(_params: PrecisionParams): (ctx: CodecInstanceContext) => PgIntervalCodec {
-    return () => new PgIntervalCodec(this);
+  override readonly targetTypes = ['uuid'] as const;
+  override readonly meta = PG_UUID_META;
+  override readonly paramsSchema: StandardSchemaV1<void> = voidParamsSchema;
+  override factory(): (ctx: CodecInstanceContext) => PgUuidCodec {
+    return () => new PgUuidCodec(this);
   }
 }
 
-export const pgIntervalDescriptor = new PgIntervalDescriptor();
+export const pgUuidDescriptor = new PgUuidDescriptor();
 
-export const pgIntervalColumn = (params: PrecisionParams = {}) =>
-  column(pgIntervalDescriptor.factory(params), pgIntervalDescriptor.codecId, params, 'interval');
+export const pgUuidColumn = () =>
+  column(pgUuidDescriptor.factory(), pgUuidDescriptor.codecId, undefined, 'uuid');
 
-pgIntervalColumn satisfies ColumnHelperFor<PgIntervalDescriptor>;
-pgIntervalColumn satisfies ColumnHelperForStrict<PgIntervalDescriptor>;
-
-const enumParamsSchema = arktype({
-  'values?': 'string[]',
-});
+pgUuidColumn satisfies ColumnHelperFor<PgUuidDescriptor>;
+pgUuidColumn satisfies ColumnHelperForStrict<PgUuidDescriptor>;
 
-export class PgEnumCodec extends CodecImpl<
-  typeof PG_ENUM_CODEC_ID,
+export class PgIntervalCodec extends CodecImpl<
+  typeof PG_INTERVAL_CODEC_ID,
   readonly ['equality', 'order'],
-  string,
+  string | Record<string, unknown>,
   string
 > {
   async encode(value: string, _ctx: CodecCallContext): Promise<string> {
     return value;
   }
-  async decode(wire: string, _ctx: CodecCallContext): Promise<string> {
-    return wire;
+  async decode(wire: string | Record<string, unknown>, _ctx: CodecCallContext): Promise<string> {
+    return pgIntervalDecode(wire);
   }
   encodeJson(value: string): JsonValue {
     return value;
@@ -856,26 +849,28 @@ export class PgEnumCodec extends CodecImpl<
   }
 }
 
-export class PgEnumDescriptor extends CodecDescriptorImpl<EnumParams> {
-  override readonly codecId = PG_ENUM_CODEC_ID;
+export class PgIntervalDescriptor extends CodecDescriptorImpl<PrecisionParams> {
+  override readonly codecId = PG_INTERVAL_CODEC_ID;
   override readonly traits = ['equality', 'order'] as const;
-  override readonly targetTypes = ['enum'] as const;
-  override readonly paramsSchema = enumParamsSchema satisfies StandardSchemaV1<EnumParams>;
-  override renderOutputType(params: EnumParams): string | undefined {
-    return pgEnumRenderOutputType(params);
+  override readonly targetTypes = ['interval'] as const;
+  override readonly meta = PG_INTERVAL_META;
+  override readonly paramsSchema =
+    precisionParamsSchema satisfies StandardSchemaV1<PrecisionParams>;
+  override renderOutputType(params: PrecisionParams): string | undefined {
+    return renderPrecision('Interval', params as Record<string, unknown>);
   }
-  override factory(_params: EnumParams): (ctx: CodecInstanceContext) => PgEnumCodec {
-    return () => new PgEnumCodec(this);
+  override factory(_params: PrecisionParams): (ctx: CodecInstanceContext) => PgIntervalCodec {
+    return () => new PgIntervalCodec(this);
   }
 }
 
-export const pgEnumDescriptor = new PgEnumDescriptor();
+export const pgIntervalDescriptor = new PgIntervalDescriptor();
 
-export const pgEnumColumn = (params: EnumParams = {}) =>
-  column(pgEnumDescriptor.factory(params), pgEnumDescriptor.codecId, params, 'enum');
+export const pgIntervalColumn = (params: PrecisionParams = {}) =>
+  column(pgIntervalDescriptor.factory(params), pgIntervalDescriptor.codecId, params, 'interval');
 
-pgEnumColumn satisfies ColumnHelperFor<PgEnumDescriptor>;
-pgEnumColumn satisfies ColumnHelperForStrict<PgEnumDescriptor>;
+pgIntervalColumn satisfies ColumnHelperFor<PgIntervalDescriptor>;
+pgIntervalColumn satisfies ColumnHelperForStrict<PgIntervalDescriptor>;
 
 export class PgJsonCodec extends CodecImpl<
   typeof PG_JSON_CODEC_ID,
@@ -1075,8 +1070,8 @@ export const codecDescriptors: readonly AnyCodecDescriptor[] = [
   pgBitDescriptor,
   pgVarbitDescriptor,
   pgByteaDescriptor,
+  pgUuidDescriptor,
   pgIntervalDescriptor,
-  pgEnumDescriptor,
   pgJsonDescriptor,
   pgJsonbDescriptor,
   pgTextArrayDescriptor,

package/src/core/ddl/nodes.ts

@@ -4,9 +4,44 @@ import {
   type DdlTableConstraint,
 } from '@prisma-next/sql-relational-core/ast';
 
+// ---------------------------------------------------------------------------
+// AlterTableAction — nested polymorphic hierarchy
+// ---------------------------------------------------------------------------
+
+export interface AlterTableActionVisitor<R> {
+  addColumn(action: AddColumnAction): R;
+}
+
+export abstract class AlterTableAction {
+  abstract readonly kind: string;
+  abstract accept<R>(visitor: AlterTableActionVisitor<R>): R;
+}
+
+export class AddColumnAction extends AlterTableAction {
+  readonly kind = 'add-column' as const;
+  readonly column: DdlColumn;
+
+  constructor(column: DdlColumn) {
+    super();
+    this.column = column;
+    Object.freeze(this);
+  }
+
+  override accept<R>(visitor: AlterTableActionVisitor<R>): R {
+    return visitor.addColumn(this);
+  }
+}
+
+export type AnyAlterTableAction = AddColumnAction;
+
+// ---------------------------------------------------------------------------
+// Top-level DDL visitor
+// ---------------------------------------------------------------------------
+
 export interface PostgresDdlVisitor<R> {
   createTable(node: PostgresCreateTable): R;
   createSchema(node: PostgresCreateSchema): R;
+  alterTable(node: PostgresAlterTable): R;
 }
 
 export abstract class PostgresDdlNode extends DdlNode {
@@ -69,4 +104,27 @@ export class PostgresCreateSchema extends PostgresDdlNode {
   }
 }
 
-export type AnyPostgresDdlNode = PostgresCreateTable | PostgresCreateSchema;
+export class PostgresAlterTable extends PostgresDdlNode {
+  readonly kind = 'alter-table' as const;
+  readonly table: string;
+  readonly schema: string | undefined;
+  readonly actions: ReadonlyArray<AnyAlterTableAction>;
+
+  constructor(options: {
+    readonly table: string;
+    readonly schema?: string;
+    readonly actions: readonly AnyAlterTableAction[];
+  }) {
+    super();
+    this.table = options.table;
+    this.schema = options.schema;
+    this.actions = Object.freeze([...options.actions]);
+    this.freeze();
+  }
+
+  override accept<R>(visitor: PostgresDdlVisitor<R>): R {
+    return visitor.alterTable(this);
+  }
+}
+
+export type AnyPostgresDdlNode = PostgresCreateTable | PostgresCreateSchema | PostgresAlterTable;

package/src/core/migrations/control-policy.ts

@@ -1,12 +1,8 @@
 import type { Contract } from '@prisma-next/contract/types';
 import type { ControlPolicySubject } from '@prisma-next/family-sql/control';
 import type { SchemaIssue } from '@prisma-next/framework-components/control';
-import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
-import {
-  isPostgresEnumStorageEntry,
-  type SqlStorage,
-  storageTableAt,
-} from '@prisma-next/sql-contract/types';
+import { entityAt, UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
+import type { SqlStorage, StorageTable } from '@prisma-next/sql-contract/types';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { isPostgresSchema } from '../postgres-schema';
 import type { PostgresOpFactoryCall } from './op-factory-call';
@@ -24,7 +20,6 @@ import type { PostgresOpFactoryCall } from './op-factory-call';
  */
 const OBJECT_CREATION_FACTORIES: ReadonlySet<string> = new Set<string>([
   'createTable',
-  'createEnumType',
   'createSchema',
 ]);
 
@@ -43,7 +38,11 @@ function resolveNamespaceIdForTable(
   ddlSchemaName: string | undefined,
 ): string {
   for (const namespaceId of Object.keys(contract.storage.namespaces)) {
-    const table = storageTableAt(contract.storage, namespaceId, tableName);
+    const table = entityAt<StorageTable>(contract.storage, {
+      namespaceId,
+      entityKind: 'table',
+      entityName: tableName,
+    });
     if (!table) continue;
     if (
       ddlSchemaName === undefined ||
@@ -75,7 +74,6 @@ interface PostgresCallFields {
   readonly schemaName?: string;
   readonly tableName?: string;
   readonly columnName?: string;
-  readonly typeName?: string;
 }
 
 function postgresCallFields(call: PostgresOpFactoryCall): PostgresCallFields {
@@ -83,7 +81,6 @@ function postgresCallFields(call: PostgresOpFactoryCall): PostgresCallFields {
     ...ifDefined('schemaName', 'schemaName' in call ? call.schemaName : undefined),
     ...ifDefined('tableName', 'tableName' in call ? call.tableName : undefined),
     ...ifDefined('columnName', 'columnName' in call ? call.columnName : undefined),
-    ...ifDefined('typeName', 'typeName' in call ? call.typeName : undefined),
   };
 }
 
@@ -96,10 +93,6 @@ export function formatPostgresControlPolicySubjectLabel(
     const ddlSchema = ddlSchemaNameForNamespace(contract, subject.namespaceId);
     return `${factoryName}(${ddlSchema}.${subject.table})`;
   }
-  if (subject?.typeName) {
-    const ddlSchema = ddlSchemaNameForNamespace(contract, subject.namespaceId);
-    return `${factoryName}(${ddlSchema}.${subject.typeName})`;
-  }
   return factoryName;
 }
 
@@ -117,29 +110,17 @@ export function resolvePostgresCallControlPolicySubject(
     };
   }
 
-  if (callFields.typeName && call.factoryName !== 'addColumn') {
-    const namespaceId = callFields.schemaName
-      ? resolveNamespaceIdForDdlSchema(contract, callFields.schemaName)
-      : UNBOUND_NAMESPACE_ID;
-    const ns = contract.storage.namespaces[namespaceId];
-    const rawEnum = isPostgresSchema(ns) ? ns.entries.type[callFields.typeName] : undefined;
-    const controlPolicy = isPostgresEnumStorageEntry(rawEnum) ? rawEnum.control : undefined;
-    return {
-      namespaceId,
-      ...ifDefined('explicitNodeControlPolicy', controlPolicy),
-      typeName: callFields.typeName,
-      createsNewObject,
-    };
-  }
-
   if (callFields.tableName) {
     const namespaceId = resolveNamespaceIdForTable(
       contract,
       callFields.tableName,
       callFields.schemaName,
     );
-    const table = storageTableAt(contract.storage, namespaceId, callFields.tableName);
-    const tableControlPolicy = table?.control;
+    const tableControlPolicy = entityAt<StorageTable>(contract.storage, {
+      namespaceId,
+      entityKind: 'table',
+      entityName: callFields.tableName,
+    })?.control;
     return {
       namespaceId,
       ...ifDefined('explicitNodeControlPolicy', tableControlPolicy),
@@ -170,7 +151,6 @@ export function resolvePostgresCallControlPolicySubject(
 const POSTGRES_ISSUE_CREATION_FACTORY: Readonly<Record<string, string>> = Object.freeze({
   missing_schema: 'createSchema',
   missing_table: 'createTable',
-  type_missing: 'createEnumType',
 });
 
 export function resolvePostgresIssueCreationFactoryName(issue: SchemaIssue): string | undefined {
@@ -201,26 +181,16 @@ export function resolvePostgresIssueControlPolicySubject(
     return { namespaceId: issue.namespaceId, createsNewObject };
   }
 
-  if ('typeName' in issue && issue.typeName) {
-    const namespaceId =
-      'namespaceId' in issue && issue.namespaceId ? issue.namespaceId : UNBOUND_NAMESPACE_ID;
-    const ns = contract.storage.namespaces[namespaceId];
-    const rawEnum = isPostgresSchema(ns) ? ns.entries.type[issue.typeName] : undefined;
-    const controlPolicy = isPostgresEnumStorageEntry(rawEnum) ? rawEnum.control : undefined;
-    return {
-      namespaceId,
-      ...ifDefined('explicitNodeControlPolicy', controlPolicy),
-      typeName: issue.typeName,
-      createsNewObject,
-    };
-  }
-
   if ('table' in issue && issue.table) {
     const namespaceId =
       'namespaceId' in issue && issue.namespaceId
         ? issue.namespaceId
         : resolveNamespaceIdForTable(contract, issue.table, undefined);
-    const table = storageTableAt(contract.storage, namespaceId, issue.table);
+    const table = entityAt<StorageTable>(contract.storage, {
+      namespaceId,
+      entityKind: 'table',
+      entityName: issue.table,
+    });
     return {
       namespaceId,
       ...ifDefined('explicitNodeControlPolicy', table?.control),