@prisma-next/adapter-postgres 0.5.0-dev.9 → 0.5.1

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,
@@ -19,87 +21,124 @@ import {
   type OrderByItem,
   type ParamRef,
   type ProjectionItem,
+  type RawSqlExpr,
   type SelectAst,
   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;
+    case 'raw-sql':
+      sql = renderRawSql(node, contract, pim);
       break;
     // v8 ignore next 4
     default:
@@ -171,6 +210,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 +301,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 +511,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 +557,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 +709,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 +742,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,8 +752,22 @@ 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}`;
 }
+
+function renderRawSql(ast: RawSqlExpr, contract: PostgresContract, pim: ParamIndexMap): string {
+  const out: string[] = [];
+  for (let i = 0; i < ast.fragments.length; i++) {
+    out.push(ast.fragments[i] ?? '');
+    if (i < ast.args.length) {
+      const arg = ast.args[i];
+      if (arg !== undefined) {
+        out.push(renderExpr(arg, contract, pim));
+      }
+    }
+  }
+  return out.join('');
+}

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' };

package/src/exports/column-types.ts

@@ -1,15 +1,15 @@
 /**
  * Column type descriptors for Postgres adapter.
  *
- * These descriptors provide both codecId and nativeType for use in contract authoring.
- * They are derived from the same source of truth as codec definitions and manifests.
+ * These descriptors provide both codecId and nativeType for use in contract authoring. They are derived from the same source of truth as codec definitions and manifests.
  */
 
-import type { ColumnTypeDescriptor } from '@prisma-next/contract-authoring';
+import type { ColumnTypeDescriptor } from '@prisma-next/framework-components/codec';
 import type { StorageTypeInstance } from '@prisma-next/sql-contract/types';
 import {
   PG_BIT_CODEC_ID,
   PG_BOOL_CODEC_ID,
+  PG_BYTEA_CODEC_ID,
   PG_ENUM_CODEC_ID,
   PG_FLOAT4_CODEC_ID,
   PG_FLOAT8_CODEC_ID,
@@ -29,12 +29,6 @@ import {
   SQL_CHAR_CODEC_ID,
   SQL_VARCHAR_CODEC_ID,
 } from '@prisma-next/target-postgres/codec-ids';
-import {
-  extractStandardSchemaOutputJsonSchema,
-  extractStandardSchemaTypeExpression,
-  isStandardSchemaLike,
-  type StandardSchemaLike,
-} from '../core/standard-schema';
 
 export const textColumn = {
   codecId: PG_TEXT_CODEC_ID,
@@ -154,6 +148,16 @@ export function varbitColumn(length: number): ColumnTypeDescriptor & {
   } as const;
 }
 
+/**
+ * Postgres `bytea` column descriptor — variable-length binary string.
+ *
+ * Round-trips as `Uint8Array` on the JS side. The pg wire-protocol text encoding (`\x` followed by hex-encoded bytes, canonical for Postgres ≥ 9.0) and binary encoding are both handled by the underlying driver; the codec only normalizes the JS-side representation to a plain `Uint8Array` view.
+ */
+export const byteaColumn = {
+  codecId: PG_BYTEA_CODEC_ID,
+  nativeType: 'bytea',
+} as const satisfies ColumnTypeDescriptor;
+
 export function intervalColumn(precision?: number): ColumnTypeDescriptor & {
   readonly typeParams?: { readonly precision: number };
 } {
@@ -164,68 +168,24 @@ export function intervalColumn(precision?: number): ColumnTypeDescriptor & {
   } as const;
 }
 
+/**
+ * Postgres `json` column descriptor — untyped raw JSON.
+ *
+ * For schema-typed JSON columns, use the per-library extension package (`@prisma-next/extension-arktype-json` ships `arktypeJson(schema)` for arktype). The schema-accepting `json(schema)` / `jsonb(schema)` overloads previously shipped from this module retired in Phase C of the codec-registry-unification project — see spec § AC-7.
+ */
 export const jsonColumn = {
   codecId: PG_JSON_CODEC_ID,
   nativeType: 'json',
 } as const satisfies ColumnTypeDescriptor;
 
+/**
+ * Postgres `jsonb` column descriptor — untyped raw JSONB. Same retirement note as {@link jsonColumn}.
+ */
 export const jsonbColumn = {
   codecId: PG_JSONB_CODEC_ID,
   nativeType: 'jsonb',
 } as const satisfies ColumnTypeDescriptor;
 
-type JsonSchemaTypeParams = {
-  readonly schemaJson: Record<string, unknown>;
-  readonly type?: string;
-};
-
-function createJsonTypeParams(schema: StandardSchemaLike): JsonSchemaTypeParams {
-  const outputSchema = extractStandardSchemaOutputJsonSchema(schema);
-  if (!outputSchema) {
-    throw new Error('JSON schema must expose ~standard.jsonSchema.output()');
-  }
-
-  const expression = extractStandardSchemaTypeExpression(schema);
-  if (expression) {
-    return { schemaJson: outputSchema, type: expression };
-  }
-
-  return { schemaJson: outputSchema };
-}
-
-function createJsonColumnFactory(
-  codecId: string,
-  nativeType: string,
-  staticDescriptor: ColumnTypeDescriptor,
-) {
-  return (schema?: StandardSchemaLike): ColumnTypeDescriptor => {
-    if (!schema) {
-      return staticDescriptor;
-    }
-
-    if (!isStandardSchemaLike(schema)) {
-      throw new Error(`${nativeType}(schema) expects a Standard Schema value`);
-    }
-
-    return {
-      codecId,
-      nativeType,
-      typeParams: createJsonTypeParams(schema),
-    };
-  };
-}
-
-const _json = createJsonColumnFactory(PG_JSON_CODEC_ID, 'json', jsonColumn);
-const _jsonb = createJsonColumnFactory(PG_JSONB_CODEC_ID, 'jsonb', jsonbColumn);
-
-export function json(schema?: StandardSchemaLike): ColumnTypeDescriptor {
-  return _json(schema);
-}
-
-export function jsonb(schema?: StandardSchemaLike): ColumnTypeDescriptor {
-  return _jsonb(schema);
-}
-
 export function enumType<const Values extends readonly string[]>(
   name: string,
   values: Values,

package/src/exports/control.ts

@@ -21,8 +21,8 @@ const postgresAdapterDescriptor: SqlControlAdapterDescriptor<'postgres'> = {
     defaultFunctionRegistry: createPostgresDefaultFunctionRegistry(),
     generatorDescriptors: createPostgresMutationDefaultGeneratorDescriptors(),
   },
-  create(_stack): SqlControlAdapter<'postgres'> {
-    return new PostgresControlAdapter();
+  create(stack): SqlControlAdapter<'postgres'> {
+    return new PostgresControlAdapter(stack.codecLookup);
   },
 };
 
@@ -31,3 +31,4 @@ export default postgresAdapterDescriptor;
 export { parsePostgresDefault } from '@prisma-next/target-postgres/default-normalizer';
 export { normalizeSchemaNativeType } from '@prisma-next/target-postgres/native-type-normalizer';
 export { escapeLiteral, qualifyName, quoteIdentifier, SqlEscapeError };
+export { PostgresControlAdapter } from '../core/control-adapter';

package/src/exports/runtime.ts

@@ -1,88 +1,49 @@
 import type { GeneratedValueSpec } from '@prisma-next/contract/types';
+import { timestampNowRuntimeGenerator } from '@prisma-next/family-sql/runtime';
+import { extractCodecLookup } from '@prisma-next/framework-components/control';
 import type { RuntimeAdapterInstance } from '@prisma-next/framework-components/execution';
 import { builtinGeneratorIds } from '@prisma-next/ids';
 import { generateId } from '@prisma-next/ids/runtime';
-import type { Adapter, AnyQueryAst, CodecRegistry } from '@prisma-next/sql-relational-core/ast';
-import { createCodecRegistry } from '@prisma-next/sql-relational-core/ast';
-import type {
-  RuntimeParameterizedCodecDescriptor,
-  SqlRuntimeAdapterDescriptor,
-} from '@prisma-next/sql-runtime';
-import { PG_JSON_CODEC_ID, PG_JSONB_CODEC_ID } from '@prisma-next/target-postgres/codec-ids';
-import { codecDefinitions } from '@prisma-next/target-postgres/codecs';
-import { type as arktype } from 'arktype';
+import type { Adapter, AnyQueryAst } from '@prisma-next/sql-relational-core/ast';
+import type { SqlRuntimeAdapterDescriptor } from '@prisma-next/sql-runtime';
+import { postgresCodecRegistry } from '@prisma-next/target-postgres/codecs';
 import { createPostgresAdapter } from '../core/adapter';
 import { postgresAdapterDescriptorMeta, postgresQueryOperations } from '../core/descriptor-meta';
-import {
-  compileJsonSchemaValidator,
-  type JsonSchemaValidateFn,
-} from '../core/json-schema-validator';
 import type { PostgresContract, PostgresLoweredStatement } from '../core/types';
 
 export interface SqlRuntimeAdapter
   extends RuntimeAdapterInstance<'sql', 'postgres'>,
     Adapter<AnyQueryAst, PostgresContract, PostgresLoweredStatement> {}
 
-function createPostgresCodecRegistry(): CodecRegistry {
-  const registry = createCodecRegistry();
-  for (const definition of Object.values(codecDefinitions)) {
-    registry.register(definition.codec);
-  }
-  return registry;
-}
-
-const jsonTypeParamsSchema = arktype({
-  schemaJson: 'object',
-  'type?': 'string',
-});
-
-/** The inferred type params shape from the arktype schema. */
-type JsonTypeParams = typeof jsonTypeParamsSchema.infer;
-
-/**
- * Helper returned by the JSON/JSONB `init` hook.
- * Contains a compiled JSON Schema validate function for runtime conformance checks.
- */
-export type JsonCodecHelper = { readonly validate: JsonSchemaValidateFn };
-
 function createPostgresMutationDefaultGenerators() {
-  return builtinGeneratorIds.map((id) => ({
-    id,
-    generate: (params?: Record<string, unknown>) => {
-      const spec: GeneratedValueSpec = params ? { id, params } : { id };
-      return generateId(spec);
-    },
-  }));
+  return [
+    ...builtinGeneratorIds.map((id) => ({
+      id,
+      generate: (params?: Record<string, unknown>) => {
+        const spec: GeneratedValueSpec = params ? { id, params } : { id };
+        return generateId(spec);
+      },
+      stability: 'field' as const,
+    })),
+    timestampNowRuntimeGenerator(),
+  ];
 }
 
-function initJsonCodecHelper(params: JsonTypeParams): JsonCodecHelper {
-  return { validate: compileJsonSchemaValidator(params.schemaJson as Record<string, unknown>) };
-}
-
-const parameterizedCodecDescriptors = [
-  {
-    codecId: PG_JSON_CODEC_ID,
-    paramsSchema: jsonTypeParamsSchema,
-    init: initJsonCodecHelper,
-  },
-  {
-    codecId: PG_JSONB_CODEC_ID,
-    paramsSchema: jsonTypeParamsSchema,
-    init: initJsonCodecHelper,
-  },
-] as const satisfies ReadonlyArray<
-  RuntimeParameterizedCodecDescriptor<JsonTypeParams, JsonCodecHelper>
->;
-
 const postgresRuntimeAdapterDescriptor: SqlRuntimeAdapterDescriptor<'postgres', SqlRuntimeAdapter> =
   {
     ...postgresAdapterDescriptorMeta,
-    codecs: createPostgresCodecRegistry,
-    parameterizedCodecs: () => parameterizedCodecDescriptors,
-    queryOperations: () => postgresQueryOperations,
+    codecs: () => Array.from(postgresCodecRegistry.values()),
+    queryOperations: () => postgresQueryOperations(),
     mutationDefaultGenerators: createPostgresMutationDefaultGenerators,
-    create(_stack): SqlRuntimeAdapter {
-      return createPostgresAdapter();
+    create(stack): SqlRuntimeAdapter {
+      // The runtime `ExecutionStack` does not (yet) carry a pre-assembled `codecLookup` field the way the control `ControlStack` does, so we derive an equivalent lookup here from the stack's component metadata (target + adapter + extension packs) using the same assembly helper that `createControlStack` uses. This keeps the renderer fed with the same codec set on both planes — including extension-contributed codecs like
+      // `pg/vector@1` from `@prisma-next/extension-pgvector`.
+      const codecLookup = extractCodecLookup([
+        stack.target,
+        stack.adapter,
+        ...stack.extensionPacks,
+      ]);
+      return createPostgresAdapter({ codecLookup });
     },
   };
 

package/src/types/operation-types.ts

@@ -1,11 +1,21 @@
 import type { SqlQueryOperationTypes } from '@prisma-next/sql-contract/types';
+import type {
+  CodecExpression,
+  Expression,
+  TraitExpression,
+} from '@prisma-next/sql-relational-core/expression';
 
-export type QueryOperationTypes = SqlQueryOperationTypes<{
-  readonly ilike: {
-    readonly args: readonly [
-      { readonly traits: readonly ['textual']; readonly nullable: false },
-      { readonly codecId: 'pg/text@1'; readonly nullable: false },
-    ];
-    readonly returns: { readonly codecId: 'pg/bool@1'; readonly nullable: false };
-  };
-}>;
+type CodecTypesBase = Record<string, { readonly input: unknown; readonly output: unknown }>;
+
+export type QueryOperationTypes<CT extends CodecTypesBase> = SqlQueryOperationTypes<
+  CT,
+  {
+    readonly ilike: {
+      readonly self: { readonly traits: readonly ['textual'] };
+      readonly impl: (
+        self: TraitExpression<readonly ['textual'], false, CT>,
+        pattern: CodecExpression<'pg/text@1', false, CT>,
+      ) => Expression<{ codecId: 'pg/bool@1'; nullable: false }>;
+    };
+  }
+>;

package/dist/adapter-hNElNHo4.mjs

@@ -1,60 +0,0 @@
-import { t as renderLoweredSql } from "./sql-renderer-pEaSP82_.mjs";
-import { createCodecRegistry } from "@prisma-next/sql-relational-core/ast";
-import { codecDefinitions } from "@prisma-next/target-postgres/codecs";
-import { ifDefined } from "@prisma-next/utils/defined";
-
-//#region src/core/adapter.ts
-const defaultCapabilities = Object.freeze({
-	postgres: {
-		orderBy: true,
-		limit: true,
-		lateral: true,
-		jsonAgg: true,
-		returning: true
-	},
-	sql: {
-		enums: true,
-		returning: true,
-		defaultInInsert: true
-	}
-});
-const parameterizedCodecs = Object.values(codecDefinitions).map((definition) => definition.codec).filter((codec) => codec.paramsSchema !== void 0).map((codec) => Object.freeze({
-	codecId: codec.id,
-	paramsSchema: codec.paramsSchema,
-	...ifDefined("init", codec.init)
-}));
-var PostgresAdapterImpl = class {
-	familyId = "sql";
-	targetId = "postgres";
-	profile;
-	codecRegistry = (() => {
-		const registry = createCodecRegistry();
-		for (const definition of Object.values(codecDefinitions)) registry.register(definition.codec);
-		return registry;
-	})();
-	constructor(options) {
-		this.profile = Object.freeze({
-			id: options?.profileId ?? "postgres/default@1",
-			target: "postgres",
-			capabilities: defaultCapabilities,
-			codecs: () => this.codecRegistry,
-			readMarkerStatement: () => ({
-				sql: "select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta from prisma_contract.marker where id = $1",
-				params: [1]
-			})
-		});
-	}
-	parameterizedCodecs() {
-		return parameterizedCodecs;
-	}
-	lower(ast, context) {
-		return renderLoweredSql(ast, context.contract);
-	}
-};
-function createPostgresAdapter(options) {
-	return Object.freeze(new PostgresAdapterImpl(options));
-}
-
-//#endregion
-export { createPostgresAdapter as t };
-//# sourceMappingURL=adapter-hNElNHo4.mjs.map