@prisma-next/adapter-postgres 0.13.0 → 0.14.0

package/dist/descriptor-meta-DOgMfoqm.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor-meta-DOgMfoqm.mjs","names":[],"sources":["../src/core/descriptor-meta.ts"],"sourcesContent":["import type { CodecControlHooks, ExpandNativeTypeInput } from '@prisma-next/family-sql/control';\nimport {\n  buildOperation,\n  type CodecExpression,\n  type Expression,\n  type TraitExpression,\n  toExpr,\n} from '@prisma-next/sql-relational-core/expression';\nimport {\n  PG_BIT_CODEC_ID,\n  PG_BOOL_CODEC_ID,\n  PG_BYTEA_CODEC_ID,\n  PG_CHAR_CODEC_ID,\n  PG_FLOAT_CODEC_ID,\n  PG_FLOAT4_CODEC_ID,\n  PG_FLOAT8_CODEC_ID,\n  PG_INT_CODEC_ID,\n  PG_INT2_CODEC_ID,\n  PG_INT4_CODEC_ID,\n  PG_INT8_CODEC_ID,\n  PG_INTERVAL_CODEC_ID,\n  PG_JSON_CODEC_ID,\n  PG_JSONB_CODEC_ID,\n  PG_NUMERIC_CODEC_ID,\n  PG_TEXT_CODEC_ID,\n  PG_TIME_CODEC_ID,\n  PG_TIMESTAMP_CODEC_ID,\n  PG_TIMESTAMPTZ_CODEC_ID,\n  PG_TIMETZ_CODEC_ID,\n  PG_UUID_CODEC_ID,\n  PG_VARBIT_CODEC_ID,\n  PG_VARCHAR_CODEC_ID,\n  SQL_CHAR_CODEC_ID,\n  SQL_FLOAT_CODEC_ID,\n  SQL_INT_CODEC_ID,\n  SQL_TEXT_CODEC_ID,\n  SQL_TIMESTAMP_CODEC_ID,\n  SQL_VARCHAR_CODEC_ID,\n} from '@prisma-next/target-postgres/codec-ids';\nimport { postgresCodecRegistry } from '@prisma-next/target-postgres/codecs';\nimport type { QueryOperationTypes } from '../types/operation-types';\n\n// ============================================================================ Helper functions for reducing boilerplate ============================================================================\n\n/** Creates a type import spec for codec types */\nconst codecTypeImport = (named: string) =>\n  ({\n    package: '@prisma-next/target-postgres/codec-types',\n    named,\n    alias: named,\n  }) as const;\n\nfunction isPositiveInteger(value: unknown): value is number {\n  return (\n    typeof value === 'number' && Number.isFinite(value) && Number.isInteger(value) && value > 0\n  );\n}\n\nfunction isNonNegativeInteger(value: unknown): value is number {\n  return (\n    typeof value === 'number' && Number.isFinite(value) && Number.isInteger(value) && value >= 0\n  );\n}\n\nfunction expandLength({ nativeType, typeParams }: ExpandNativeTypeInput): string {\n  if (!typeParams || !('length' in typeParams)) {\n    return nativeType;\n  }\n  const length = typeParams['length'];\n  if (!isPositiveInteger(length)) {\n    throw new Error(\n      `Invalid \"length\" type parameter for \"${nativeType}\": expected a positive integer, got ${JSON.stringify(length)}`,\n    );\n  }\n  return `${nativeType}(${length})`;\n}\n\nfunction expandPrecision({ nativeType, typeParams }: ExpandNativeTypeInput): string {\n  if (!typeParams || !('precision' in typeParams)) {\n    return nativeType;\n  }\n  const precision = typeParams['precision'];\n  if (!isPositiveInteger(precision)) {\n    throw new Error(\n      `Invalid \"precision\" type parameter for \"${nativeType}\": expected a positive integer, got ${JSON.stringify(precision)}`,\n    );\n  }\n  return `${nativeType}(${precision})`;\n}\n\nfunction expandNumeric({ nativeType, typeParams }: ExpandNativeTypeInput): string {\n  const hasPrecision = typeParams && 'precision' in typeParams;\n  const hasScale = typeParams && 'scale' in typeParams;\n\n  if (!hasPrecision && !hasScale) {\n    return nativeType;\n  }\n\n  if (!hasPrecision && hasScale) {\n    throw new Error(\n      `Invalid type parameters for \"${nativeType}\": \"scale\" requires \"precision\" to be specified`,\n    );\n  }\n\n  if (hasPrecision) {\n    const precision = typeParams['precision'];\n    if (!isPositiveInteger(precision)) {\n      throw new Error(\n        `Invalid \"precision\" type parameter for \"${nativeType}\": expected a positive integer, got ${JSON.stringify(precision)}`,\n      );\n    }\n    if (hasScale) {\n      const scale = typeParams['scale'];\n      if (!isNonNegativeInteger(scale)) {\n        throw new Error(\n          `Invalid \"scale\" type parameter for \"${nativeType}\": expected a non-negative integer, got ${JSON.stringify(scale)}`,\n        );\n      }\n      return `${nativeType}(${precision},${scale})`;\n    }\n    return `${nativeType}(${precision})`;\n  }\n\n  return nativeType;\n}\n\nconst lengthHooks: CodecControlHooks = { expandNativeType: expandLength };\nconst precisionHooks: CodecControlHooks = { expandNativeType: expandPrecision };\nconst numericHooks: CodecControlHooks = { expandNativeType: expandNumeric };\nconst identityHooks: CodecControlHooks = { expandNativeType: ({ nativeType }) => nativeType };\n\n// ============================================================================ Descriptor metadata ============================================================================\n\ntype CodecTypesBase = Record<string, { readonly input: unknown; readonly output: unknown }>;\n\nexport function postgresQueryOperations<CT extends CodecTypesBase>(): QueryOperationTypes<CT> {\n  return {\n    ilike: {\n      self: { traits: ['textual'] },\n      impl: (\n        self: TraitExpression<readonly ['textual'], false, CT>,\n        pattern: CodecExpression<'pg/text@1', false, CT>,\n      ): Expression<{ codecId: 'pg/bool@1'; nullable: false }> => {\n        return buildOperation({\n          method: 'ilike',\n          args: [toExpr(self), toExpr(pattern, { codecId: PG_TEXT_CODEC_ID })],\n          returns: { codecId: PG_BOOL_CODEC_ID, nullable: false },\n          lowering: { targetFamily: 'sql', strategy: 'infix', template: '{{self}} ILIKE {{arg0}}' },\n        });\n      },\n    },\n  };\n}\n\nexport const postgresAdapterDescriptorMeta = {\n  kind: 'adapter',\n  familyId: 'sql',\n  targetId: 'postgres',\n  id: 'postgres',\n  version: '0.0.1',\n  capabilities: {\n    postgres: {\n      orderBy: true,\n      limit: true,\n      lateral: true,\n      jsonAgg: true,\n      returning: true,\n      distinctOn: true,\n    },\n    sql: {\n      enums: true,\n      returning: true,\n      defaultInInsert: true,\n      lateral: true,\n    },\n  },\n  types: {\n    codecTypes: {\n      codecDescriptors: Array.from(postgresCodecRegistry.values()),\n      import: {\n        package: '@prisma-next/target-postgres/codec-types',\n        named: 'CodecTypes',\n        alias: 'PgTypes',\n      },\n      typeImports: [\n        {\n          package: '@prisma-next/target-postgres/codec-types',\n          named: 'JsonValue',\n          alias: 'JsonValue',\n        },\n        codecTypeImport('Char'),\n        codecTypeImport('Varchar'),\n        codecTypeImport('Numeric'),\n        codecTypeImport('Bit'),\n        codecTypeImport('VarBit'),\n        codecTypeImport('Timestamp'),\n        codecTypeImport('Timestamptz'),\n        codecTypeImport('Time'),\n        codecTypeImport('Timetz'),\n        codecTypeImport('Interval'),\n      ],\n      controlPlaneHooks: {\n        [SQL_CHAR_CODEC_ID]: lengthHooks,\n        [SQL_VARCHAR_CODEC_ID]: lengthHooks,\n        [SQL_TIMESTAMP_CODEC_ID]: precisionHooks,\n        [PG_CHAR_CODEC_ID]: lengthHooks,\n        [PG_VARCHAR_CODEC_ID]: lengthHooks,\n        [PG_NUMERIC_CODEC_ID]: numericHooks,\n        [PG_BIT_CODEC_ID]: lengthHooks,\n        [PG_VARBIT_CODEC_ID]: lengthHooks,\n        [PG_TIMESTAMP_CODEC_ID]: precisionHooks,\n        [PG_TIMESTAMPTZ_CODEC_ID]: precisionHooks,\n        [PG_TIME_CODEC_ID]: precisionHooks,\n        [PG_TIMETZ_CODEC_ID]: precisionHooks,\n        [PG_INTERVAL_CODEC_ID]: precisionHooks,\n        [PG_JSON_CODEC_ID]: identityHooks,\n        [PG_JSONB_CODEC_ID]: identityHooks,\n        [PG_BYTEA_CODEC_ID]: identityHooks,\n        [PG_UUID_CODEC_ID]: identityHooks,\n      },\n    },\n    storage: [\n      { typeId: PG_TEXT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'text' },\n      { typeId: SQL_TEXT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'text' },\n      { typeId: SQL_CHAR_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'character' },\n      {\n        typeId: SQL_VARCHAR_CODEC_ID,\n        familyId: 'sql',\n        targetId: 'postgres',\n        nativeType: 'character varying',\n      },\n      { typeId: SQL_INT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'int4' },\n      { typeId: SQL_FLOAT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'float8' },\n      {\n        typeId: SQL_TIMESTAMP_CODEC_ID,\n        familyId: 'sql',\n        targetId: 'postgres',\n        nativeType: 'timestamp',\n      },\n      { typeId: PG_CHAR_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'character' },\n      {\n        typeId: PG_VARCHAR_CODEC_ID,\n        familyId: 'sql',\n        targetId: 'postgres',\n        nativeType: 'character varying',\n      },\n      { typeId: PG_INT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'int4' },\n      { typeId: PG_FLOAT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'float8' },\n      { typeId: PG_INT4_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'int4' },\n      { typeId: PG_INT2_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'int2' },\n      { typeId: PG_INT8_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'int8' },\n      { typeId: PG_FLOAT4_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'float4' },\n      { typeId: PG_FLOAT8_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'float8' },\n      { typeId: PG_NUMERIC_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'numeric' },\n      {\n        typeId: PG_TIMESTAMP_CODEC_ID,\n        familyId: 'sql',\n        targetId: 'postgres',\n        nativeType: 'timestamp',\n      },\n      {\n        typeId: PG_TIMESTAMPTZ_CODEC_ID,\n        familyId: 'sql',\n        targetId: 'postgres',\n        nativeType: 'timestamptz',\n      },\n      { typeId: PG_TIME_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'time' },\n      { typeId: PG_TIMETZ_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'timetz' },\n      { typeId: PG_BOOL_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'bool' },\n      { typeId: PG_BIT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'bit' },\n      {\n        typeId: PG_VARBIT_CODEC_ID,\n        familyId: 'sql',\n        targetId: 'postgres',\n        nativeType: 'bit varying',\n      },\n      {\n        typeId: PG_INTERVAL_CODEC_ID,\n        familyId: 'sql',\n        targetId: 'postgres',\n        nativeType: 'interval',\n      },\n      { typeId: PG_JSON_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'json' },\n      { typeId: PG_JSONB_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'jsonb' },\n      { typeId: PG_BYTEA_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'bytea' },\n      { typeId: PG_UUID_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'uuid' },\n    ],\n    queryOperationTypes: {\n      import: {\n        package: '@prisma-next/adapter-postgres/operation-types',\n        named: 'QueryOperationTypes',\n        alias: 'PgAdapterQueryOps',\n      },\n    },\n  },\n} as const;\n"],"mappings":"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"}

package/dist/runtime.d.mts

@@ -1,4 +1,4 @@
-import { c as PostgresContract, l as PostgresLoweredStatement } from "./types-Dv7M8jx8.mjs";
+import { c as PostgresContract, l as PostgresLoweredStatement } from "./types-KXRwRZU8.mjs";
 import { Adapter, AnyQueryAst } from "@prisma-next/sql-relational-core/ast";
 import { SqlRuntimeAdapterDescriptor } from "@prisma-next/sql-runtime";
 import { RuntimeAdapterInstance } from "@prisma-next/framework-components/execution";

package/dist/runtime.mjs

@@ -1,5 +1,5 @@
-import { n as postgresRawCodecInferer, t as createPostgresAdapter } from "./adapter-CAlWA4ug.mjs";
-import { n as postgresQueryOperations, t as postgresAdapterDescriptorMeta } from "./descriptor-meta-NBwpqHS7.mjs";
+import { n as postgresRawCodecInferer, t as createPostgresAdapter } from "./adapter-CwkcdpM_.mjs";
+import { n as postgresQueryOperations, t as postgresAdapterDescriptorMeta } from "./descriptor-meta-DOgMfoqm.mjs";
 import { extractCodecLookup } from "@prisma-next/framework-components/control";
 import { postgresCodecRegistry } from "@prisma-next/target-postgres/codecs";
 import { builtinGeneratorIds } from "@prisma-next/ids";

package/dist/{types-Dv7M8jx8.d.mts → types-KXRwRZU8.d.mts}

@@ -1,6 +1,6 @@
 import { BinaryExpr, ColumnRef, DefaultValueExpr, Direction, LoweredStatement, ParamRef, SelectAst } from "@prisma-next/sql-relational-core/ast";
 import { Contract } from "@prisma-next/contract/types";
-import { CodecLookup } from "@prisma-next/framework-components/codec";
+import { CodecRegistry } from "@prisma-next/framework-components/codec";
 import { SqlStorage, StorageColumn, StorageTable } from "@prisma-next/sql-contract/types";
 
 //#region src/core/types.d.ts
@@ -15,7 +15,7 @@ interface PostgresAdapterOptions {
    * `SqlControlAdapterDescriptor.create(stack)`) supply the assembled stack
    * lookup so extension codecs are visible to the renderer.
    */
-  readonly codecLookup?: CodecLookup;
+  readonly codecLookup?: CodecRegistry;
 }
 type PostgresContract = Contract<SqlStorage> & {
   readonly target: 'postgres';
@@ -28,4 +28,4 @@ interface OrderClause {
 type PostgresLoweredStatement = LoweredStatement;
 //#endregion
 export { OrderClause as a, PostgresContract as c, StorageColumn as d, StorageTable as f, Expr as i, PostgresLoweredStatement as l, ColumnRef as n, ParamRef as o, Direction as r, PostgresAdapterOptions as s, BinaryExpr as t, SelectAst as u };
-//# sourceMappingURL=types-Dv7M8jx8.d.mts.map
+//# sourceMappingURL=types-KXRwRZU8.d.mts.map

package/dist/types-KXRwRZU8.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-KXRwRZU8.d.mts","names":[],"sources":["../src/core/types.ts"],"mappings":";;;;;;UAoBiB,sBAAA;EAAA,SACN,SAAA;EADM;;;;;;;;AAWqB;EAXrB,SAWN,WAAA,GAAc,aAAa;AAAA;AAAA,KAG1B,gBAAA,GAAmB,QAAQ,CAAC,UAAA;EAAA,SAAyB,MAAA;AAAA;AAAA,KAErD,IAAA,GAAO,SAAA,GAAY,QAAA,GAAW,gBAAA;AAAA,UAEzB,WAAA;EAAA,SACN,IAAA,EAAM,SAAA;EAAA,SACN,GAAA,EAAK,SAAS;AAAA;AAAA,KAGb,wBAAA,GAA2B,gBAAgB"}

package/dist/types.d.mts

@@ -1,2 +1,2 @@
-import { a as OrderClause, c as PostgresContract, d as StorageColumn, f as StorageTable, i as Expr, l as PostgresLoweredStatement, n as ColumnRef, o as ParamRef, r as Direction, s as PostgresAdapterOptions, t as BinaryExpr, u as SelectAst } from "./types-Dv7M8jx8.mjs";
+import { a as OrderClause, c as PostgresContract, d as StorageColumn, f as StorageTable, i as Expr, l as PostgresLoweredStatement, n as ColumnRef, o as ParamRef, r as Direction, s as PostgresAdapterOptions, t as BinaryExpr, u as SelectAst } from "./types-KXRwRZU8.mjs";
 export type { BinaryExpr, ColumnRef, Direction, Expr, OrderClause, ParamRef, PostgresAdapterOptions, PostgresContract, PostgresLoweredStatement, SelectAst, StorageColumn, StorageTable };

package/package.json

@@ -1,34 +1,34 @@
 {
   "name": "@prisma-next/adapter-postgres",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "dependencies": {
-    "@prisma-next/contract": "0.13.0",
-    "@prisma-next/contract-authoring": "0.13.0",
-    "@prisma-next/errors": "0.13.0",
-    "@prisma-next/family-sql": "0.13.0",
-    "@prisma-next/framework-components": "0.13.0",
-    "@prisma-next/ids": "0.13.0",
-    "@prisma-next/sql-contract": "0.13.0",
-    "@prisma-next/sql-contract-psl": "0.13.0",
-    "@prisma-next/sql-contract-ts": "0.13.0",
-    "@prisma-next/sql-operations": "0.13.0",
-    "@prisma-next/sql-relational-core": "0.13.0",
-    "@prisma-next/sql-runtime": "0.13.0",
-    "@prisma-next/sql-schema-ir": "0.13.0",
-    "@prisma-next/target-postgres": "0.13.0",
-    "@prisma-next/utils": "0.13.0",
+    "@prisma-next/contract": "0.14.0",
+    "@prisma-next/contract-authoring": "0.14.0",
+    "@prisma-next/errors": "0.14.0",
+    "@prisma-next/family-sql": "0.14.0",
+    "@prisma-next/framework-components": "0.14.0",
+    "@prisma-next/ids": "0.14.0",
+    "@prisma-next/sql-contract": "0.14.0",
+    "@prisma-next/sql-contract-psl": "0.14.0",
+    "@prisma-next/sql-contract-ts": "0.14.0",
+    "@prisma-next/sql-operations": "0.14.0",
+    "@prisma-next/sql-relational-core": "0.14.0",
+    "@prisma-next/sql-runtime": "0.14.0",
+    "@prisma-next/sql-schema-ir": "0.14.0",
+    "@prisma-next/target-postgres": "0.14.0",
+    "@prisma-next/utils": "0.14.0",
     "arktype": "^2.2.0"
   },
   "devDependencies": {
-    "@prisma-next/cli": "0.13.0",
-    "@prisma-next/driver-postgres": "0.13.0",
-    "@prisma-next/migration-tools": "0.13.0",
-    "@prisma-next/test-utils": "0.13.0",
-    "@prisma-next/tsconfig": "0.13.0",
-    "@prisma-next/tsdown": "0.13.0",
+    "@prisma-next/cli": "0.14.0",
+    "@prisma-next/driver-postgres": "0.14.0",
+    "@prisma-next/migration-tools": "0.14.0",
+    "@prisma-next/test-utils": "0.14.0",
+    "@prisma-next/tsconfig": "0.14.0",
+    "@prisma-next/tsdown": "0.14.0",
     "pathe": "^2.0.3",
     "tsdown": "0.22.1",
     "typescript": "5.9.3",

package/src/core/adapter.ts

@@ -1,4 +1,4 @@
-import type { CodecLookup } from '@prisma-next/framework-components/codec';
+import type { CodecRegistry } from '@prisma-next/framework-components/codec';
 import { APP_SPACE_ID } from '@prisma-next/framework-components/control';
 import type {
   Adapter,
@@ -13,7 +13,6 @@ import type { RawCodecInferer } from '@prisma-next/sql-relational-core/expressio
 import type { PostgresDdlNode } from '@prisma-next/target-postgres/ddl';
 import { createPostgresBuiltinCodecLookup } from './codec-lookup';
 import { PostgresControlAdapter } from './control-adapter';
-import { renderLoweredDdl } from './ddl-renderer';
 import { renderLoweredSql } from './sql-renderer';
 import type { PostgresAdapterOptions, PostgresContract, PostgresLoweredStatement } from './types';
 
@@ -42,7 +41,7 @@ class PostgresAdapterImpl
   readonly targetId = 'postgres' as const;
 
   readonly profile: AdapterProfile<'postgres'>;
-  private readonly codecLookup: CodecLookup;
+  private readonly codecLookup: CodecRegistry;
 
   constructor(options?: PostgresAdapterOptions) {
     this.codecLookup = options?.codecLookup ?? createPostgresBuiltinCodecLookup();
@@ -75,7 +74,9 @@ class PostgresAdapterImpl
     context: LowererContext<PostgresContract>,
   ): PostgresLoweredStatement {
     if (isDdlNode(ast)) {
-      return renderLoweredDdl(ast);
+      throw new Error(
+        'lower() does not lower DDL on the runtime adapter — DDL lowering is a control-plane concern handled by the control adapter.',
+      );
     }
     return renderLoweredSql(ast, context.contract, this.codecLookup);
   }

package/src/core/codec-lookup.ts

@@ -1,15 +1,15 @@
-import type { CodecLookup } from '@prisma-next/framework-components/codec';
+import type { CodecRegistry } from '@prisma-next/framework-components/codec';
 import { extractCodecLookup } from '@prisma-next/framework-components/control';
 import { postgresCodecRegistry } from '@prisma-next/target-postgres/codecs';
 
 /**
- * Build a {@link CodecLookup} populated with the Postgres-builtin codec definitions only.
+ * Build a {@link CodecRegistry} populated with the Postgres-builtin codec definitions only.
  *
- * This is the default lookup used by `createPostgresAdapter()` and `new PostgresControlAdapter()` when called without a stack-derived lookup (e.g. from tests, or one-off scripts that don't compose a full stack).
+ * This is the default registry used by `createPostgresAdapter()` and `new PostgresControlAdapter()` when called without a stack-derived registry (e.g. from tests, or one-off scripts that don't compose a full stack).
  *
- * Extension codecs (e.g. `pg/vector@1` from `@prisma-next/extension-pgvector`) are intentionally NOT included here: a bare adapter cannot see extensions. Stack-composed paths (`SqlControlAdapterDescriptor.create(stack)` / `SqlRuntimeAdapterDescriptor.create(stack)`) supply the broader, extension-inclusive lookup at construction time.
+ * Extension codecs (e.g. `pg/vector@1` from `@prisma-next/extension-pgvector`) are intentionally NOT included here: a bare adapter cannot see extensions. Stack-composed paths (`SqlControlAdapterDescriptor.create(stack)` / `SqlRuntimeAdapterDescriptor.create(stack)`) supply the broader, extension-inclusive registry at construction time.
  */
-export function createPostgresBuiltinCodecLookup(): CodecLookup {
+export function createPostgresBuiltinCodecLookup(): CodecRegistry {
   return extractCodecLookup([
     {
       id: 'postgres-builtin-codecs',

package/src/core/control-adapter.ts

@@ -1,8 +1,4 @@
-import type {
-  Contract,
-  ContractMarkerRecord,
-  LedgerEntryRecord,
-} from '@prisma-next/contract/types';
+import type { ContractMarkerRecord, LedgerEntryRecord } from '@prisma-next/contract/types';
 import {
   parseMarkerRowSafely,
   rethrowMarkerReadError,
@@ -10,21 +6,25 @@ import {
 } from '@prisma-next/errors/execution';
 import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';
 import { parseContractMarkerRow } from '@prisma-next/family-sql/verify';
-import type { CodecLookup } from '@prisma-next/framework-components/codec';
+import type { CodecLookup, CodecRegistry } from '@prisma-next/framework-components/codec';
 import { APP_SPACE_ID } from '@prisma-next/framework-components/control';
 import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import { ledgerOriginFromStored } from '@prisma-next/migration-tools/ledger-origin';
-import type {
-  PostgresEnumStorageEntry,
-  SqlControlDriverInstance,
-  SqlStorage,
-} from '@prisma-next/sql-contract/types';
+import { REFERENTIAL_ACTION_SQL } from '@prisma-next/sql-contract/referential-action-sql';
+import type { SqlControlDriverInstance } from '@prisma-next/sql-contract/types';
 import type {
   AnyQueryAst,
+  CodecRef,
+  ContractCodecRegistry,
+  DdlColumn,
   DdlNode,
+  DdlTableConstraint,
+  FunctionColumnDefault,
+  LiteralColumnDefault,
   LoweredStatement,
   LowererContext,
   MarkerReadResult,
+  SqlExecuteRequest,
 } from '@prisma-next/sql-relational-core/ast';
 import { isDdlNode } from '@prisma-next/sql-relational-core/ast';
 import type {
@@ -42,23 +42,20 @@ import {
   buildControlTableBootstrapQueries,
   buildSignMarkerBootstrapQueries,
 } from '@prisma-next/target-postgres/contract-free';
-import type { PostgresDdlNode } from '@prisma-next/target-postgres/ddl';
+import type {
+  AddColumnAction,
+  AlterTableActionVisitor,
+  PostgresAlterTable,
+  PostgresCreateSchema,
+  PostgresCreateTable,
+  PostgresDdlNode,
+} from '@prisma-next/target-postgres/ddl';
 import { parsePostgresDefault } from '@prisma-next/target-postgres/default-normalizer';
-import {
-  createResolveExistingEnumValues,
-  enumStorageCompoundKey,
-  readExistingEnumValues,
-  readPostgresSchemaIrAnnotations,
-} from '@prisma-next/target-postgres/enum-planning';
 import { normalizeSchemaNativeType } from '@prisma-next/target-postgres/native-type-normalizer';
+import { escapeLiteral, quoteIdentifier } from '@prisma-next/target-postgres/sql-utils';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
-import { createPostgresBuiltinCodecLookup } from './codec-lookup';
-import { renderLoweredDdl } from './ddl-renderer';
-import {
-  introspectPostgresEnumTypes,
-  type PostgresEnumStorageTypeAnnotation,
-} from './enum-control-hooks';
+import { encodeControlQueryParams } from './control-codecs';
 import {
   execute,
   infoSchemaTables,
@@ -92,17 +89,10 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
   readonly familyId = 'sql' as const;
   readonly targetId = 'postgres' as const;
 
-  private readonly codecLookup: CodecLookup;
+  private readonly codecRegistry: CodecRegistry;
 
-  /**
-   * @param codecLookup - Codec lookup used by the SQL renderer to resolve
-   *   per-codec metadata at lower-time. Defaults to a Postgres-builtins-only
-   *   lookup when omitted. Stack-aware callers
-   *   (`SqlControlAdapterDescriptor.create(stack)`) supply
-   *   `stack.codecLookup` so extension codecs are visible to the renderer.
-   */
-  constructor(codecLookup?: CodecLookup) {
-    this.codecLookup = codecLookup ?? createPostgresBuiltinCodecLookup();
+  constructor(codecRegistry: CodecRegistry) {
+    this.codecRegistry = codecRegistry;
   }
 
   /**
@@ -118,27 +108,6 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
    */
   readonly normalizeNativeType = normalizeSchemaNativeType;
 
-  /**
-   * Bridges native `PostgresEnumStorageEntry` IR walks against the Postgres
-   * introspection shape (`schema.annotations.pg.storageTypes`). Lets
-   * the family-level schema verifier walk enum types without reaching
-   * into target-specific annotation layouts itself.
-   */
-  readonly resolveExistingEnumValues = (
-    schema: SqlSchemaIR,
-    enumType: PostgresEnumStorageEntry,
-    namespaceId: string,
-  ): readonly string[] | null => {
-    const schemaName =
-      namespaceId === UNBOUND_NAMESPACE_ID
-        ? (readPostgresSchemaIrAnnotations(schema).schema ?? 'public')
-        : namespaceId;
-    return readExistingEnumValues(schema, schemaName, enumType.nativeType);
-  };
-
-  readonly resolveExistingEnumValuesForContract = (contract: Contract<SqlStorage>) =>
-    createResolveExistingEnumValues(contract.storage);
-
   bootstrapControlTableQueries(): readonly DdlNode[] {
     return buildControlTableBootstrapQueries();
   }
@@ -157,9 +126,46 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
    */
   lower(ast: AnyQueryAst | PostgresDdlNode, context: LowererContext<unknown>): LoweredStatement {
     if (isDdlNode(ast)) {
-      return renderLoweredDdl(ast);
+      throw new Error(
+        'lower() cannot lower DDL: DDL default literals require inline codec encoding, which is async. Use lowerToExecuteRequest().',
+      );
+    }
+    return renderLoweredSql(
+      ast,
+      blindCast<PostgresContract, 'caller must supply a matching PostgresContract'>(
+        context.contract,
+      ),
+      this.codecRegistry,
+    );
+  }
+
+  /**
+   * Lower an AST all the way to a driver-ready statement. For DDL nodes,
+   * literal column defaults are formatted as inline SQL with proper quoting and
+   * `::nativeType` cast suffixes. For query ASTs, params are kept as `$N`
+   * placeholders; wire values go in `params`. Does NOT call `this.lower()` —
+   * independent implementation.
+   */
+  async lowerToExecuteRequest(
+    ast: AnyQueryAst | PostgresDdlNode,
+    context?: LowererContext<unknown>,
+  ): Promise<SqlExecuteRequest> {
+    if (isDdlNode(ast)) {
+      return pgRenderDdlExecuteRequest(
+        blindCast<PostgresDdlNode, 'isDdlNode guard'>(ast),
+        this.codecRegistry,
+      );
     }
-    return renderLoweredSql(ast, context.contract as PostgresContract, this.codecLookup);
+    const contract = blindCast<PostgresContract, 'Caller must supply matching contract'>(
+      context?.contract,
+    );
+    const lowered = renderLoweredSql(ast, contract, this.codecRegistry);
+    const codecRegistry = blindCast<
+      ContractCodecRegistry,
+      'framework CodecRegistry: its descriptors materialise SQL codecs; the framework Codec type erases to BaseCodec at this boundary'
+    >(this.codecRegistry);
+    const params = await encodeControlQueryParams(lowered, ast, codecRegistry);
+    return { sql: lowered.sql, params };
   }
 
   /**
@@ -625,19 +631,6 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
       }
     }
 
-    const mergedStorageTypes: Record<string, PostgresEnumStorageTypeAnnotation> = {};
-    for (let i = 0; i < perSchema.length; i++) {
-      const ir = perSchema[i];
-      const pg = blindCast<
-        { storageTypes?: Record<string, PostgresEnumStorageTypeAnnotation> } | undefined,
-        'pg annotation envelope index slot'
-      >(ir?.annotations?.['pg'])?.storageTypes;
-      if (!pg) continue;
-      for (const [key, value] of Object.entries(pg)) {
-        mergedStorageTypes[key] = value;
-      }
-    }
-
     const firstAnnotations = perSchema[0]?.annotations;
     const firstPg =
       blindCast<Record<string, unknown> | undefined, 'pg annotation envelope index slot'>(
@@ -647,13 +640,7 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
       tables: mergedTables,
       ...ifDefined('annotations', {
         ...firstAnnotations,
-        pg: {
-          ...firstPg,
-          ...ifDefined(
-            'storageTypes',
-            Object.keys(mergedStorageTypes).length > 0 ? mergedStorageTypes : undefined,
-          ),
-        },
+        pg: { ...firstPg },
       }),
     };
   }
@@ -1093,20 +1080,22 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
       };
     }
 
-    const rawStorageTypes = await introspectPostgresEnumTypes({ driver, schemaName: schema });
-    const storageTypes: Record<string, PostgresEnumStorageTypeAnnotation> = {};
-    for (const [typeName, annotation] of Object.entries(rawStorageTypes)) {
-      storageTypes[enumStorageCompoundKey(schema, typeName)] = annotation;
-    }
+    const nativeEnumResult = await driver.query<{ typname: string }>(
+      `SELECT t.typname
+         FROM pg_catalog.pg_type t
+         JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+         WHERE t.typtype = 'e'
+           AND n.nspname = $1
+         ORDER BY t.typname`,
+      [schema],
+    );
+    const nativeEnumTypeNames = nativeEnumResult.rows.map((r) => r.typname);
 
     const annotations = {
       pg: {
         schema,
         version: await this.getPostgresVersion(driver),
-        ...ifDefined(
-          'storageTypes',
-          Object.keys(storageTypes).length > 0 ? storageTypes : undefined,
-        ),
+        ...(nativeEnumTypeNames.length > 0 && { nativeEnumTypeNames }),
       },
     };
 
@@ -1368,3 +1357,189 @@ function extractQuotedLiterals(listBody: string): readonly string[] | undefined
   const values = [...listBody.matchAll(pattern)].map((m) => (m[1] ?? '').replace(/''/g, "'"));
   return values.length > 0 ? values : undefined;
 }
+
+// ---------------------------------------------------------------------------
+// pgRenderDdlExecuteRequest — independent DDL walker for lowerToExecuteRequest
+// ---------------------------------------------------------------------------
+
+function pgIsTextLikeNativeType(nativeType: string): boolean {
+  return (
+    nativeType === 'text' ||
+    nativeType === 'varchar' ||
+    nativeType.startsWith('varchar(') ||
+    nativeType === 'character varying' ||
+    nativeType.startsWith('character varying(') ||
+    nativeType === 'char' ||
+    nativeType.startsWith('char(') ||
+    nativeType === 'character' ||
+    nativeType.startsWith('character(')
+  );
+}
+
+function pgInlineLiteral(wire: unknown, nativeType: string): string {
+  if (wire === null) return 'NULL';
+  if (typeof wire === 'boolean') return wire ? 'true' : 'false';
+  if (typeof wire === 'number') {
+    if (!Number.isFinite(wire)) {
+      throw new Error(
+        `pgRenderDdlExecuteRequest: non-finite number wire value ${String(wire)} cannot be emitted as a DEFAULT literal for native type "${nativeType}"`,
+      );
+    }
+    return String(wire);
+  }
+  if (typeof wire === 'bigint') return String(wire);
+  if (wire instanceof Date) {
+    if (Number.isNaN(wire.getTime())) {
+      throw new Error(
+        `pgRenderDdlExecuteRequest: invalid Date value cannot be emitted as a DEFAULT literal for native type "${nativeType}"`,
+      );
+    }
+    const quoted = `'${escapeLiteral(wire.toISOString())}'`;
+    return pgIsTextLikeNativeType(nativeType) ? quoted : `${quoted}::${nativeType}`;
+  }
+  if (typeof wire === 'string') {
+    const quoted = `'${escapeLiteral(wire)}'`;
+    return pgIsTextLikeNativeType(nativeType) ? quoted : `${quoted}::${nativeType}`;
+  }
+  if (wire instanceof Uint8Array) {
+    const hex = Array.from(wire)
+      .map((b) => b.toString(16).padStart(2, '0'))
+      .join('');
+    return `'\\x${hex}'::${nativeType}`;
+  }
+  if (typeof wire === 'object') {
+    const quoted = `'${escapeLiteral(JSON.stringify(wire))}'`;
+    return `${quoted}::${nativeType}`;
+  }
+  throw new Error(
+    `pgRenderDdlExecuteRequest: unexpected wire type "${typeof wire}" for native type "${nativeType}"`,
+  );
+}
+
+async function pgRenderDdlColumnDefault(
+  def: LiteralColumnDefault | FunctionColumnDefault,
+  nativeType: string,
+  codecLookup: CodecLookup,
+  codecRef: CodecRef | undefined,
+): Promise<string> {
+  if (def.kind === 'function') {
+    if (def.expression === 'autoincrement()') return '';
+    return `DEFAULT (${def.expression})`;
+  }
+  if (codecRef !== undefined) {
+    const codec = codecLookup.get(codecRef.codecId);
+    if (codec !== undefined) {
+      const wire = await codec.encode(def.value, {});
+      return `DEFAULT ${pgInlineLiteral(wire, nativeType)}`;
+    }
+  }
+  // Fallback: codec-less literal defaults follow RawSqlLiteral wire-scalar semantics.
+  return `DEFAULT ${pgInlineLiteral(def.value, nativeType)}`;
+}
+
+async function pgRenderDdlColumn(column: DdlColumn, codecLookup: CodecLookup): Promise<string> {
+  const parts = [quoteIdentifier(column.name), column.type];
+  if (column.default) {
+    const clause = await pgRenderDdlColumnDefault(
+      column.default,
+      column.type,
+      codecLookup,
+      column.codecRef,
+    );
+    if (clause.length > 0) parts.push(clause);
+  }
+  if (column.notNull) parts.push('NOT NULL');
+  if (column.primaryKey) parts.push('PRIMARY KEY');
+  return parts.join(' ');
+}
+
+function pgRenderDdlConstraint(constraint: DdlTableConstraint): string {
+  if (constraint.kind === 'primary-key') {
+    const cols = constraint.columns.map(quoteIdentifier).join(', ');
+    if (constraint.name !== undefined) {
+      return `CONSTRAINT ${quoteIdentifier(constraint.name)} PRIMARY KEY (${cols})`;
+    }
+    return `PRIMARY KEY (${cols})`;
+  }
+  if (constraint.kind === 'foreign-key') {
+    const cols = constraint.columns.map(quoteIdentifier).join(', ');
+    const refTable = constraint.refTable.split('.').map(quoteIdentifier).join('.');
+    const refCols = constraint.refColumns.map(quoteIdentifier).join(', ');
+    let sql = `FOREIGN KEY (${cols}) REFERENCES ${refTable} (${refCols})`;
+    if (constraint.onDelete !== undefined) {
+      sql += ` ON DELETE ${REFERENTIAL_ACTION_SQL[constraint.onDelete]}`;
+    }
+    if (constraint.onUpdate !== undefined) {
+      sql += ` ON UPDATE ${REFERENTIAL_ACTION_SQL[constraint.onUpdate]}`;
+    }
+    if (constraint.name !== undefined) {
+      sql = `CONSTRAINT ${quoteIdentifier(constraint.name)} ${sql}`;
+    }
+    return sql;
+  }
+  const cols = constraint.columns.map(quoteIdentifier).join(', ');
+  if (constraint.name !== undefined) {
+    return `CONSTRAINT ${quoteIdentifier(constraint.name)} UNIQUE (${cols})`;
+  }
+  return `UNIQUE (${cols})`;
+}
+
+async function pgRenderCreateTable(
+  node: PostgresCreateTable,
+  codecLookup: CodecLookup,
+): Promise<SqlExecuteRequest> {
+  const ifNotExists = node.ifNotExists ? 'IF NOT EXISTS ' : '';
+  const tableRef = node.schema
+    ? `${quoteIdentifier(node.schema)}.${quoteIdentifier(node.table)}`
+    : quoteIdentifier(node.table);
+  const columnDefs = await Promise.all(
+    node.columns.map((col) => pgRenderDdlColumn(col, codecLookup)),
+  );
+  const constraintDefs =
+    node.constraints !== undefined ? node.constraints.map(pgRenderDdlConstraint) : [];
+  const allDefs = [...columnDefs, ...constraintDefs].join(',\n  ');
+  return {
+    sql: `CREATE TABLE ${ifNotExists}${tableRef} (\n  ${allDefs}\n)`,
+    params: [],
+  };
+}
+
+function pgRenderCreateSchema(node: PostgresCreateSchema): SqlExecuteRequest {
+  const ifNotExists = node.ifNotExists ? 'IF NOT EXISTS ' : '';
+  return {
+    sql: `CREATE SCHEMA ${ifNotExists}${quoteIdentifier(node.schema)}`,
+    params: [],
+  };
+}
+
+async function pgRenderAlterTable(
+  node: PostgresAlterTable,
+  codecLookup: CodecLookup,
+): Promise<SqlExecuteRequest> {
+  const tableRef = node.schema
+    ? `${quoteIdentifier(node.schema)}.${quoteIdentifier(node.table)}`
+    : quoteIdentifier(node.table);
+  const actionVisitor: AlterTableActionVisitor<Promise<string>> = {
+    async addColumn(action: AddColumnAction): Promise<string> {
+      const colFragment = await pgRenderDdlColumn(action.column, codecLookup);
+      return `ADD COLUMN ${colFragment}`;
+    },
+  };
+  const actionSqls = await Promise.all(node.actions.map((a) => a.accept(actionVisitor)));
+  return {
+    sql: `ALTER TABLE ${tableRef} ${actionSqls.join(', ')}`,
+    params: [],
+  };
+}
+
+async function pgRenderDdlExecuteRequest(
+  ast: PostgresDdlNode,
+  codecLookup: CodecLookup,
+): Promise<SqlExecuteRequest> {
+  const visitor = {
+    createTable: (node: PostgresCreateTable) => pgRenderCreateTable(node, codecLookup),
+    createSchema: (node: PostgresCreateSchema) => Promise.resolve(pgRenderCreateSchema(node)),
+    alterTable: (node: PostgresAlterTable) => pgRenderAlterTable(node, codecLookup),
+  };
+  return ast.accept(visitor);
+}

package/src/core/control-codecs.ts

@@ -0,0 +1,25 @@
+import type {
+  AnyQueryAst,
+  ContractCodecRegistry,
+  LoweredStatement,
+} from '@prisma-next/sql-relational-core/ast';
+import {
+  createAstCodecRegistry,
+  deriveParamMetadata,
+  encodeParamsWithMetadata,
+} from '@prisma-next/sql-runtime';
+import { postgresCodecRegistry } from '@prisma-next/target-postgres/codecs';
+
+export const CONTROL_CODECS = createAstCodecRegistry(postgresCodecRegistry);
+
+export async function encodeControlQueryParams(
+  lowered: LoweredStatement,
+  ast: AnyQueryAst,
+  codecs: ContractCodecRegistry = CONTROL_CODECS,
+): Promise<readonly unknown[]> {
+  const values = lowered.params.map((slot) => {
+    if (slot.kind === 'literal') return slot.value;
+    throw new Error(`control query lowered to a bind slot '${slot.name}', which is unsupported`);
+  });
+  return encodeParamsWithMetadata(values, deriveParamMetadata(ast), {}, codecs);
+}