@prisma-next/adapter-postgres 0.5.0-dev.6 → 0.5.0-dev.61

package/src/core/codec-lookup.ts

@@ -0,0 +1,19 @@
+import type { CodecLookup } 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.
+ *
+ * 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).
+ *
+ * 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.
+ */
+export function createPostgresBuiltinCodecLookup(): CodecLookup {
+  return extractCodecLookup([
+    {
+      id: 'postgres-builtin-codecs',
+      types: { codecTypes: { codecDescriptors: Array.from(postgresCodecRegistry.values()) } },
+    },
+  ]);
+}

package/src/core/control-adapter.ts

@@ -1,4 +1,7 @@
+import type { ContractMarkerRecord } from '@prisma-next/contract/types';
 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 { ControlDriverInstance } from '@prisma-next/framework-components/control';
 import type {
   AnyQueryAst,
@@ -19,6 +22,7 @@ import type {
 import { parsePostgresDefault } from '@prisma-next/target-postgres/default-normalizer';
 import { normalizeSchemaNativeType } from '@prisma-next/target-postgres/native-type-normalizer';
 import { ifDefined } from '@prisma-next/utils/defined';
+import { createPostgresBuiltinCodecLookup } from './codec-lookup';
 import { pgEnumControlHooks } from './enum-control-hooks';
 import { renderLoweredSql } from './sql-renderer';
 import type { PostgresContract } from './types';
@@ -31,6 +35,19 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
   readonly familyId = 'sql' as const;
   readonly targetId = 'postgres' as const;
 
+  private readonly codecLookup: CodecLookup;
+
+  /**
+   * @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();
+  }
+
   /**
    * Target-specific normalizer for raw Postgres default expressions.
    * Used by schema verification to normalize raw defaults before comparison.
@@ -53,7 +70,57 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
    * without instantiating the runtime adapter.
    */
   lower(ast: AnyQueryAst, context: LowererContext<unknown>): LoweredStatement {
-    return renderLoweredSql(ast, context.contract as PostgresContract);
+    return renderLoweredSql(ast, context.contract as PostgresContract, this.codecLookup);
+  }
+
+  /**
+   * Reads the contract marker from `prisma_contract.marker`. Probes
+   * `information_schema.tables` first so a fresh database (where the
+   * `prisma_contract` schema doesn't yet exist) returns `null` instead of a
+   * "relation does not exist" error — some Postgres wire-protocol clients
+   * (e.g. PGlite's TCP proxy) don't fully recover from extended-protocol
+   * parse errors, so we probe before reading.
+   */
+  async readMarker(
+    driver: ControlDriverInstance<'sql', 'postgres'>,
+  ): Promise<ContractMarkerRecord | null> {
+    const exists = await driver.query(
+      `select 1
+       from information_schema.tables
+       where table_schema = $1 and table_name = $2`,
+      ['prisma_contract', 'marker'],
+    );
+    if (exists.rows.length === 0) {
+      return null;
+    }
+
+    const result = await driver.query<{
+      core_hash: string;
+      profile_hash: string;
+      contract_json: unknown | null;
+      canonical_version: number | null;
+      updated_at: Date | string;
+      app_tag: string | null;
+      meta: unknown | null;
+      invariants: readonly string[];
+    }>(
+      `select
+         core_hash,
+         profile_hash,
+         contract_json,
+         canonical_version,
+         updated_at,
+         app_tag,
+         meta,
+         invariants
+       from prisma_contract.marker
+       where id = $1`,
+      [1],
+    );
+
+    const row = result.rows[0];
+    if (!row) return null;
+    return parseContractMarkerRow(row);
   }
 
   /**

package/src/core/control-mutation-defaults.ts

@@ -1,4 +1,5 @@
 import type { ExecutionMutationDefaultValue } from '@prisma-next/contract/types';
+import { timestampNowControlDescriptor } from '@prisma-next/family-sql/control';
 import type {
   ControlMutationDefaultEntry,
   DefaultFunctionLoweringContext,
@@ -301,25 +302,30 @@ export function createPostgresDefaultFunctionRegistry(): ReadonlyMap<
 }
 
 export function createPostgresMutationDefaultGeneratorDescriptors(): readonly MutationDefaultGeneratorDescriptor[] {
-  return builtinGeneratorRegistryMetadata.map(({ id, applicableCodecIds }) => ({
-    id,
-    applicableCodecIds,
-    resolveGeneratedColumnDescriptor: ({ generated }) => {
-      if (generated.kind !== 'generator' || generated.id !== id) {
-        return undefined;
-      }
-      const descriptor = resolveBuiltinGeneratedColumnDescriptor({
+  return [
+    ...builtinGeneratorRegistryMetadata.map(
+      ({ id, applicableCodecIds }): MutationDefaultGeneratorDescriptor => ({
         id,
-        ...(generated.params ? { params: generated.params } : {}),
-      });
-      return {
-        codecId: descriptor.type.codecId,
-        nativeType: descriptor.type.nativeType,
-        ...(descriptor.type.typeRef ? { typeRef: descriptor.type.typeRef } : {}),
-        ...(descriptor.typeParams ? { typeParams: descriptor.typeParams } : {}),
-      };
-    },
-  }));
+        applicableCodecIds,
+        resolveGeneratedColumnDescriptor: ({ generated }) => {
+          if (generated.kind !== 'generator' || generated.id !== id) {
+            return undefined;
+          }
+          const descriptor = resolveBuiltinGeneratedColumnDescriptor({
+            id,
+            ...(generated.params ? { params: generated.params } : {}),
+          });
+          return {
+            codecId: descriptor.type.codecId,
+            nativeType: descriptor.type.nativeType,
+            ...(descriptor.type.typeRef ? { typeRef: descriptor.type.typeRef } : {}),
+            ...(descriptor.typeParams ? { typeParams: descriptor.typeParams } : {}),
+          };
+        },
+      }),
+    ),
+    timestampNowControlDescriptor(),
+  ];
 }
 
 export function createPostgresScalarTypeDescriptors(): ReadonlyMap<string, string> {

package/src/core/descriptor-meta.ts

@@ -1,8 +1,17 @@
 import type { CodecControlHooks, ExpandNativeTypeInput } from '@prisma-next/family-sql/control';
 import type { SqlOperationDescriptor } from '@prisma-next/sql-operations';
+import {
+  buildOperation,
+  type CodecExpression,
+  type Expression,
+  refsOf,
+  type TraitExpression,
+  toExpr,
+} from '@prisma-next/sql-relational-core/expression';
 import {
   PG_BIT_CODEC_ID,
   PG_BOOL_CODEC_ID,
+  PG_BYTEA_CODEC_ID,
   PG_CHAR_CODEC_ID,
   PG_ENUM_CODEC_ID,
   PG_FLOAT_CODEC_ID,
@@ -30,12 +39,10 @@ import {
   SQL_TIMESTAMP_CODEC_ID,
   SQL_VARCHAR_CODEC_ID,
 } from '@prisma-next/target-postgres/codec-ids';
-import { codecDefinitions } from '@prisma-next/target-postgres/codecs';
+import { postgresCodecRegistry } from '@prisma-next/target-postgres/codecs';
 import { pgEnumControlHooks } from './enum-control-hooks';
 
-// ============================================================================
-// Helper functions for reducing boilerplate
-// ============================================================================
+// ============================================================================ Helper functions for reducing boilerplate ============================================================================
 
 /** Creates a type import spec for codec types */
 const codecTypeImport = (named: string) =>
@@ -124,21 +131,32 @@ const precisionHooks: CodecControlHooks = { expandNativeType: expandPrecision };
 const numericHooks: CodecControlHooks = { expandNativeType: expandNumeric };
 const identityHooks: CodecControlHooks = { expandNativeType: ({ nativeType }) => nativeType };
 
-// ============================================================================
-// Descriptor metadata
-// ============================================================================
+// ============================================================================ Descriptor metadata ============================================================================
 
-export const postgresQueryOperations: readonly SqlOperationDescriptor[] = [
-  {
-    method: 'ilike',
-    args: [
-      { traits: ['textual'], nullable: false },
-      { codecId: PG_TEXT_CODEC_ID, nullable: false },
-    ],
-    returns: { codecId: PG_BOOL_CODEC_ID, nullable: false },
-    lowering: { targetFamily: 'sql', strategy: 'infix', template: '{{self}} ILIKE {{arg0}}' },
-  },
-];
+type CodecTypesBase = Record<string, { readonly input: unknown; readonly output: unknown }>;
+
+export function postgresQueryOperations<
+  CT extends CodecTypesBase,
+>(): readonly SqlOperationDescriptor[] {
+  return [
+    {
+      method: 'ilike',
+      self: { traits: ['textual'] },
+      impl: (
+        self: TraitExpression<readonly ['textual'], false, CT>,
+        pattern: CodecExpression<'pg/text@1', false, CT>,
+      ): Expression<{ codecId: 'pg/bool@1'; nullable: false }> => {
+        const selfRefs = refsOf(self);
+        return buildOperation({
+          method: 'ilike',
+          args: [toExpr(self), toExpr(pattern, PG_TEXT_CODEC_ID, selfRefs)],
+          returns: { codecId: PG_BOOL_CODEC_ID, nullable: false },
+          lowering: { targetFamily: 'sql', strategy: 'infix', template: '{{self}} ILIKE {{arg0}}' },
+        });
+      },
+    },
+  ];
+}
 
 export const postgresAdapterDescriptorMeta = {
   kind: 'adapter',
@@ -162,7 +180,7 @@ export const postgresAdapterDescriptorMeta = {
   },
   types: {
     codecTypes: {
-      codecInstances: Object.values(codecDefinitions).map((def) => def.codec),
+      codecDescriptors: Array.from(postgresCodecRegistry.values()),
       import: {
         package: '@prisma-next/target-postgres/codec-types',
         named: 'CodecTypes',
@@ -202,6 +220,7 @@ export const postgresAdapterDescriptorMeta = {
         [PG_ENUM_CODEC_ID]: pgEnumControlHooks,
         [PG_JSON_CODEC_ID]: identityHooks,
         [PG_JSONB_CODEC_ID]: identityHooks,
+        [PG_BYTEA_CODEC_ID]: identityHooks,
       },
     },
     storage: [
@@ -267,6 +286,7 @@ export const postgresAdapterDescriptorMeta = {
       },
       { typeId: PG_JSON_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'json' },
       { typeId: PG_JSONB_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'jsonb' },
+      { typeId: PG_BYTEA_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'bytea' },
     ],
     queryOperationTypes: {
       import: {

package/src/core/sql-renderer.ts

@@ -1,3 +1,4 @@
+import type { CodecLookup } from '@prisma-next/framework-components/codec';
 import {
   type AggregateExpr,
   type AnyExpression,
@@ -5,6 +6,7 @@ import {
   type AnyQueryAst,
   type BinaryExpr,
   type ColumnRef,
+  collectOrderedParamRefs,
   type DeleteAst,
   type InsertAst,
   type InsertValue,
@@ -23,83 +25,116 @@ import {
   type SubqueryExpr,
   type UpdateAst,
 } from '@prisma-next/sql-relational-core/ast';
-import { PG_JSON_CODEC_ID, PG_JSONB_CODEC_ID } from '@prisma-next/target-postgres/codec-ids';
 import { escapeLiteral, quoteIdentifier } from '@prisma-next/target-postgres/sql-utils';
 import type { PostgresContract } from './types';
 
-// Mirrors `VECTOR_CODEC_ID` in `@prisma-next/extension-pgvector/core/constants`.
-// Duplicated here rather than imported because the canonical export is not
-// part of the extension's public subpath surface, and `@prisma-next/adapter-postgres`
-// does not (and should not) take a runtime dependency on the extension package
-// just for one constant. The whole `getCodecParamCast` switch is slated for
-// removal under TML-2310 ("Move SQL param-cast metadata onto codec descriptors"),
-// at which point this and the JSON/JSONB IDs below also disappear.
-const VECTOR_CODEC_ID = 'pg/vector@1' as const;
-
 /**
- * Map a codec ID to its `::cast` suffix, if Postgres requires one for
- * parameterized values (e.g. `$1::vector`, `$1::jsonb`).
+ * Postgres native types whose unknown-OID parameter inference is reliable in arbitrary expression positions. Parameters bound to a codec whose `meta.db.sql.postgres.nativeType` falls in this set are emitted as plain `$N`; everything else (including `json`, `jsonb`, extension types like `vector`, and unknown user types) is emitted as `$N::<nativeType>` so the planner picks an unambiguous overload.
+ *
+ * `json` / `jsonb` are intentionally excluded despite being Postgres builtins: their operator overloads make context inference unreliable in expression positions (e.g. `$1 -> 'key'` is ambiguous between the two).
  *
- * NOTE: hardcoded codec IDs here are a known wart, tracked separately by
- * TML-2310 ("Move SQL param-cast metadata onto codec descriptors").
- * Until that lands the cast lives on the renderer rather than the codec.
+ * Spellings match the on-disk `meta.db.sql.postgres.nativeType` values in `@prisma-next/target-postgres`'s codec definitions, not the `udt_name` abbreviations that ADR 205 used as illustrative shorthand. The lookup-based cast policy compares against these strings directly.
  */
-function getCodecParamCast(codecId: string | undefined): string | undefined {
-  if (codecId === VECTOR_CODEC_ID) {
-    return 'vector';
-  }
-  if (codecId === PG_JSON_CODEC_ID) {
-    return 'json';
-  }
-  if (codecId === PG_JSONB_CODEC_ID) {
-    return 'jsonb';
-  }
-  return undefined;
+const POSTGRES_INFERRABLE_NATIVE_TYPES: ReadonlySet<string> = new Set([
+  // Numeric
+  'integer',
+  'smallint',
+  'bigint',
+  'real',
+  'double precision',
+  'numeric',
+  // Boolean
+  'boolean',
+  // Strings
+  'text',
+  'character',
+  'character varying',
+  // Temporal
+  'timestamp',
+  'timestamp without time zone',
+  'timestamp with time zone',
+  'time',
+  'timetz',
+  'interval',
+  // Bit strings
+  'bit',
+  'bit varying',
+]);
+
+function renderTypedParam(
+  index: number,
+  codecId: string | undefined,
+  codecLookup: CodecLookup,
+): string {
+  if (codecId === undefined) {
+    return `$${index}`;
+  }
+  if (codecLookup.get(codecId) === undefined) {
+    throw new Error(
+      `Postgres lowering: ParamRef carries codecId "${codecId}" but the ` +
+        'assembled codec lookup has no entry for it. This usually indicates ' +
+        'a missing extension pack in the runtime stack — register the pack ' +
+        'that contributes this codec (e.g. `extensionPacks: [pgvectorRuntime]`), ' +
+        'or use the codec directly from `@prisma-next/target-postgres/codecs` ' +
+        "if it's a builtin.",
+    );
+  }
+  // The framework `CodecLookup.metaFor` returns the family-agnostic `CodecMeta` whose `db` is `Record<string, unknown>`. The SQL family populates a narrower shape with `db.sql.<dialect>.nativeType: string`; navigate that path defensively and string-check the leaf.
+  const meta = codecLookup.metaFor(codecId);
+  const dbRecord = meta?.db;
+  const sqlBlock = isRecord(dbRecord) ? dbRecord['sql'] : undefined;
+  const dialectBlock = isRecord(sqlBlock) ? sqlBlock['postgres'] : undefined;
+  const nativeType = isRecord(dialectBlock) ? dialectBlock['nativeType'] : undefined;
+  if (typeof nativeType === 'string' && !POSTGRES_INFERRABLE_NATIVE_TYPES.has(nativeType)) {
+    return `$${index}::${nativeType}`;
+  }
+  return `$${index}`;
 }
 
-function renderTypedParam(index: number, codecId: string | undefined): string {
-  const cast = getCodecParamCast(codecId);
-  return cast ? `$${index}::${cast}` : `$${index}`;
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
 }
 
-type ParamIndexMap = Map<ParamRef, number>;
+/**
+ * Per-render carrier threaded through every helper. Bundles the param-index map (for `$N` numbering) and the assembled-stack `codecLookup` (for cast policy at the `renderTypedParam` chokepoint). Carrying both on a single value keeps helper signatures stable.
+ */
+interface ParamIndexMap {
+  readonly indexMap: Map<ParamRef, number>;
+  readonly codecLookup: CodecLookup;
+}
 
 /**
  * Render a SQL query AST to a Postgres-flavored `{ sql, params }` payload.
  *
- * Shared between the runtime (`PostgresAdapterImpl.lower`) and control
- * (`PostgresControlAdapter.lower`) entrypoints so emit-time and run-time
- * paths produce byte-identical output for the same AST.
+ * Shared between the runtime (`PostgresAdapterImpl.lower`) and control (`PostgresControlAdapter.lower`) entrypoints so emit-time and run-time paths produce byte-identical output for the same AST.
  */
 export function renderLoweredSql(
   ast: AnyQueryAst,
   contract: PostgresContract,
+  codecLookup: CodecLookup,
 ): { readonly sql: string; readonly params: readonly unknown[] } {
-  const collectedParamRefs = ast.collectParamRefs();
-  const paramIndexMap: ParamIndexMap = new Map();
-  const params: unknown[] = [];
-  for (const ref of collectedParamRefs) {
-    if (paramIndexMap.has(ref)) {
-      continue;
-    }
-    paramIndexMap.set(ref, params.length + 1);
-    params.push(ref.value);
-  }
+  const orderedRefs = collectOrderedParamRefs(ast);
+  const indexMap = new Map<ParamRef, number>();
+  const params: unknown[] = orderedRefs.map((ref, i) => {
+    indexMap.set(ref, i + 1);
+    return ref.value;
+  });
+  const pim: ParamIndexMap = { indexMap, codecLookup };
 
   const node = ast;
   let sql: string;
   switch (node.kind) {
     case 'select':
-      sql = renderSelect(node, contract, paramIndexMap);
+      sql = renderSelect(node, contract, pim);
       break;
     case 'insert':
-      sql = renderInsert(node, contract, paramIndexMap);
+      sql = renderInsert(node, contract, pim);
       break;
     case 'update':
-      sql = renderUpdate(node, contract, paramIndexMap);
+      sql = renderUpdate(node, contract, pim);
       break;
     case 'delete':
-      sql = renderDelete(node, contract, paramIndexMap);
+      sql = renderDelete(node, contract, pim);
       break;
     // v8 ignore next 4
     default:
@@ -171,6 +206,27 @@ function renderProjection(
     .join(', ');
 }
 
+function renderReturning(
+  items: ReadonlyArray<ProjectionItem>,
+  contract: PostgresContract,
+  pim: ParamIndexMap,
+): string {
+  return items
+    .map((item) => {
+      if (item.expr.kind === 'column-ref') {
+        const rendered = renderColumn(item.expr);
+        return item.expr.column === item.alias
+          ? rendered
+          : `${rendered} AS ${quoteIdentifier(item.alias)}`;
+      }
+      if (item.expr.kind === 'literal') {
+        return `${renderLiteral(item.expr)} AS ${quoteIdentifier(item.alias)}`;
+      }
+      return `${renderExpr(item.expr, contract, pim)} AS ${quoteIdentifier(item.alias)}`;
+    })
+    .join(', ');
+}
+
 function renderDistinctPrefix(
   distinct: true | undefined,
   distinctOn: ReadonlyArray<AnyExpression> | undefined,
@@ -241,15 +297,9 @@ function renderNullCheck(
 }
 
 /**
- * Atomic expression kinds whose rendered SQL is already self-delimited
- * (a column reference, parameter, literal, function call, aggregate, etc.)
- * and therefore does not need surrounding parentheses when used as the
- * left operand of a postfix predicate like `IS NULL` or `IS NOT NULL`,
- * or as either operand of a binary infix operator.
+ * Atomic expression kinds whose rendered SQL is already self-delimited (a column reference, parameter, literal, function call, aggregate, etc.) and therefore does not need surrounding parentheses when used as the left operand of a postfix predicate like `IS NULL` or `IS NOT NULL`, or as either operand of a binary infix operator.
  *
- * Anything not in this set is treated as composite (binary, AND/OR/NOT,
- * EXISTS, nested IS NULL, subqueries, operation templates) and gets
- * wrapped to preserve grouping.
+ * Anything not in this set is treated as composite (binary, AND/OR/NOT, EXISTS, nested IS NULL, subqueries, operation templates) and gets wrapped to preserve grouping.
  */
 function isAtomicExpressionKind(kind: AnyExpression['kind']): boolean {
   switch (kind) {
@@ -457,11 +507,11 @@ function renderExpr(expr: AnyExpression, contract: PostgresContract, pim: ParamI
 }
 
 function renderParamRef(ref: ParamRef, pim: ParamIndexMap): string {
-  const index = pim.get(ref);
+  const index = pim.indexMap.get(ref);
   if (index === undefined) {
     throw new Error('ParamRef not found in index map');
   }
-  return renderTypedParam(index, ref.codecId);
+  return renderTypedParam(index, ref.codecId, pim.codecLookup);
 }
 
 function renderLiteral(expr: LiteralExpr): string {
@@ -503,12 +553,7 @@ function renderOperation(
     return renderExpr(arg, contract, pim);
   });
 
-  // Resolve `{{self}}` and `{{argN}}` from the original template in a single
-  // pass. Doing this with sequential `String.prototype.replace` calls is
-  // unsafe: a substituted fragment can itself contain text that matches a
-  // later token (e.g. an arg literal containing the substring `{{arg1}}`),
-  // and the next iteration would corrupt it. A single regex callback never
-  // re-scans already-substituted output.
+  // Resolve `{{self}}` and `{{argN}}` from the original template in a single pass. Doing this with sequential `String.prototype.replace` calls is unsafe: a substituted fragment can itself contain text that matches a later token (e.g. an arg literal containing the substring `{{arg1}}`), and the next iteration would corrupt it. A single regex callback never re-scans already-substituted output.
   return expr.lowering.template.replace(
     /\{\{self\}\}|\{\{arg(\d+)\}\}/g,
     (token, argIndex: string | undefined) => {
@@ -660,7 +705,7 @@ function renderInsert(ast: InsertAst, contract: PostgresContract, pim: ParamInde
       })()
     : '';
   const returningClause = ast.returning?.length
-    ? ` RETURNING ${ast.returning.map((col) => `${quoteIdentifier(col.table)}.${quoteIdentifier(col.column)}`).join(', ')}`
+    ? ` RETURNING ${renderReturning(ast.returning, contract, pim)}`
     : '';
 
   return `${insertClause}${onConflictClause}${returningClause}`;
@@ -693,7 +738,7 @@ function renderUpdate(ast: UpdateAst, contract: PostgresContract, pim: ParamInde
 
   const whereClause = ast.where ? ` WHERE ${renderWhere(ast.where, contract, pim)}` : '';
   const returningClause = ast.returning?.length
-    ? ` RETURNING ${ast.returning.map((col) => `${quoteIdentifier(col.table)}.${quoteIdentifier(col.column)}`).join(', ')}`
+    ? ` RETURNING ${renderReturning(ast.returning, contract, pim)}`
     : '';
 
   return `UPDATE ${table} SET ${setClauses.join(', ')}${whereClause}${returningClause}`;
@@ -703,7 +748,7 @@ function renderDelete(ast: DeleteAst, contract: PostgresContract, pim: ParamInde
   const table = quoteIdentifier(ast.table.name);
   const whereClause = ast.where ? ` WHERE ${renderWhere(ast.where, contract, pim)}` : '';
   const returningClause = ast.returning?.length
-    ? ` RETURNING ${ast.returning.map((col) => `${quoteIdentifier(col.table)}.${quoteIdentifier(col.column)}`).join(', ')}`
+    ? ` RETURNING ${renderReturning(ast.returning, contract, pim)}`
     : '';
 
   return `DELETE FROM ${table}${whereClause}${returningClause}`;

package/src/core/types.ts

@@ -1,4 +1,5 @@
 import type { Contract } from '@prisma-next/contract/types';
+import type { CodecLookup } from '@prisma-next/framework-components/codec';
 import type { SqlStorage, StorageColumn, StorageTable } from '@prisma-next/sql-contract/types';
 import type {
   AnyQueryAst,
@@ -19,6 +20,16 @@ import type {
 
 export interface PostgresAdapterOptions {
   readonly profileId?: string;
+  /**
+   * Codec lookup used by the SQL renderer to resolve per-codec metadata at
+   * lower-time. Defaults to a Postgres-builtins-only lookup when omitted —
+   * see {@link createPostgresBuiltinCodecLookup} in `./codec-lookup`.
+   *
+   * Stack-aware callers (`SqlRuntimeAdapterDescriptor.create(stack)` /
+   * `SqlControlAdapterDescriptor.create(stack)`) supply the assembled stack
+   * lookup so extension codecs are visible to the renderer.
+   */
+  readonly codecLookup?: CodecLookup;
 }
 
 export type PostgresContract = Contract<SqlStorage> & { readonly target: 'postgres' };