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

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,16 @@
 import type { CodecControlHooks, ExpandNativeTypeInput } from '@prisma-next/family-sql/control';
 import type { SqlOperationDescriptor } from '@prisma-next/sql-operations';
+import {
+  buildOperation,
+  type CodecExpression,
+  type Expression,
+  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,
@@ -128,17 +136,28 @@ const identityHooks: CodecControlHooks = { expandNativeType: ({ nativeType }) =>
 // 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 }> =>
+        buildOperation({
+          method: 'ilike',
+          args: [toExpr(self), toExpr(pattern, PG_TEXT_CODEC_ID)],
+          returns: { codecId: PG_BOOL_CODEC_ID, nullable: false },
+          lowering: { targetFamily: 'sql', strategy: 'infix', template: '{{self}} ILIKE {{arg0}}' },
+        }),
+    },
+  ];
+}
 
 export const postgresAdapterDescriptorMeta = {
   kind: 'adapter',
@@ -202,6 +221,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 +287,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,
@@ -20,50 +22,97 @@ import {
   type ParamRef,
   type ProjectionItem,
   type SelectAst,
+  type Codec as SqlCodec,
   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}`;
+  }
+  // SQL codecs extend the framework `Codec` base with an optional
+  // `meta: CodecMeta`; the framework `CodecLookup.get` returns the base type,
+  // so we narrow to `SqlCodec` to read `meta`. Every codec actually
+  // registered into a SQL codec lookup conforms to `SqlCodec`.
+  const codec = codecLookup.get(codecId) as SqlCodec | undefined;
+  if (codec === 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.",
+    );
+  }
+  const nativeType = codec.meta?.db?.sql?.postgres?.nativeType;
+  if (nativeType !== undefined && !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}`;
+/**
+ * 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;
 }
 
-type ParamIndexMap = Map<ParamRef, number>;
-
 /**
  * Render a SQL query AST to a Postgres-flavored `{ sql, params }` payload.
  *
@@ -74,32 +123,30 @@ type ParamIndexMap = Map<ParamRef, number>;
 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 +218,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,
@@ -457,11 +525,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 {
@@ -660,7 +728,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 +761,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 +771,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' };

package/src/exports/column-types.ts

@@ -10,6 +10,7 @@ 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 +30,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 +149,19 @@ 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 +172,29 @@ 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';