@prisma-next/adapter-postgres 0.16.0-dev.33 → 0.16.0-dev.34

package/src/core/sql-renderer.ts

@@ -1,5 +1,5 @@
 import type { JsonValue } from '@prisma-next/contract/types';
-import type { CodecLookup } from '@prisma-next/framework-components/codec';
+import type { CodecRef } from '@prisma-next/framework-components/codec';
 import { runtimeError } from '@prisma-next/framework-components/runtime';
 import {
   type AggregateExpr,
@@ -37,6 +37,7 @@ import {
   type UpdateAst,
   type WindowFuncExpr,
 } from '@prisma-next/sql-relational-core/ast';
+import type { PostgresCodecDescriptorRegistry } from '@prisma-next/target-postgres/codec-descriptor';
 import { isPgEnumParams } from '@prisma-next/target-postgres/codecs';
 import {
   escapeLiteral,
@@ -49,11 +50,11 @@ import { adapterError } from './adapter-errors';
 import type { PostgresContract } from './types';
 
 /**
- * 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.
+ * Postgres native types whose unknown-OID parameter inference is reliable in arbitrary expression positions. Parameters bound to a descriptor whose `nativeTypeFor` result 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).
  *
- * 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.
+ * Spellings match the target descriptors' `nativeTypeFor` results, not the `udt_name` abbreviations that ADR 205 used as illustrative shorthand. The registry-based cast policy compares against these strings directly.
  */
 const POSTGRES_INFERRABLE_NATIVE_TYPES: ReadonlySet<string> = new Set([
   // Numeric
@@ -84,23 +85,19 @@ const POSTGRES_INFERRABLE_NATIVE_TYPES: ReadonlySet<string> = new Set([
 function renderTypedParam(
   index: number,
   codecId: string | undefined,
-  codecLookup: CodecLookup,
+  codecDescriptorRegistry: PostgresCodecDescriptorRegistry,
   many?: boolean,
   typeParams?: JsonValue,
 ): string {
   if (codecId === undefined) {
     return `$${index}`;
   }
-  const meta = codecLookup.metaFor(codecId, typeParams);
-  const isRegistered =
-    codecLookup.get(codecId) !== undefined ||
-    meta !== undefined ||
-    codecLookup.targetTypesFor(codecId) !== undefined;
-  if (!isRegistered) {
+  const descriptor = codecDescriptorRegistry.descriptorFor(codecId);
+  if (descriptor === undefined) {
     throw adapterError(
       'RUNTIME.PARAM_REF_MISSING_CODEC',
       `Postgres lowering: ParamRef carries codecId "${codecId}" but the ` +
-        'assembled codec lookup has no entry for it. This usually indicates ' +
+        'validated PostgreSQL codec registry 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. `extensions: [pgvectorRuntime]`), ' +
         'or use the codec directly from `@prisma-next/target-postgres/codecs` ' +
@@ -108,42 +105,22 @@ function renderTypedParam(
       { meta: { codecId } },
     );
   }
-  // `typeParams` above already resolved a parameterized codec's per-instance
-  // meta (e.g. a native enum's type name) ahead of its static fallback.
-  //
-  // 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`, so
-  // navigate that path defensively and string-check the leaf.
-  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') {
-    const arraySuffix = many ? '[]' : '';
-    // A `typeParams.typeName` marks a named database type (e.g. a native
-    // enum): cast to its quoted, schema-qualified identifier so Postgres does
-    // not case-fold it (`$1::HoldType` would resolve as `holdtype`). Mirrors
-    // the DDL-side policy in `buildColumnTypeSql`. Builtin spellings
-    // (`double precision`, `jsonb`, …) stay verbatim — quoting them would
-    // turn them into (nonexistent) user-type lookups.
-    if (isPgEnumParams(typeParams)) {
-      return `$${index}::${quoteQualifiedName(nativeType)}${arraySuffix}`;
-    }
-    if (!POSTGRES_INFERRABLE_NATIVE_TYPES.has(nativeType)) {
-      return `$${index}::${nativeType}${arraySuffix}`;
-    }
-    if (many) {
-      return `$${index}::${nativeType}${arraySuffix}`;
-    }
+  const ref: CodecRef = {
+    codecId,
+    ...ifDefined('many', many),
+    ...ifDefined('typeParams', typeParams),
+  };
+  const nativeType = descriptor.nativeTypeFor(ref);
+  const arraySuffix = many ? '[]' : '';
+  if (isPgEnumParams(typeParams)) {
+    return `$${index}::${quoteQualifiedName(nativeType)}${arraySuffix}`;
+  }
+  if (!POSTGRES_INFERRABLE_NATIVE_TYPES.has(nativeType) || many) {
+    return `$${index}::${nativeType}${arraySuffix}`;
   }
   return `$${index}`;
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null;
-}
-
 function unreachableKind(value: never): string {
   const candidate: unknown = value;
   if (
@@ -158,11 +135,11 @@ function unreachableKind(value: never): string {
 }
 
 /**
- * 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.
+ * Per-render carrier threaded through every helper. Bundles the param-index map (for `$N` numbering) and the assembled-stack target descriptor registry (for cast policy at the `renderTypedParam` chokepoint). Carrying both on a single value keeps helper signatures stable.
  */
 interface ParamIndexMap {
   readonly indexMap: Map<AnyParamRef, number>;
-  readonly codecLookup: CodecLookup;
+  readonly codecDescriptorRegistry: PostgresCodecDescriptorRegistry;
 }
 
 /**
@@ -173,7 +150,7 @@ interface ParamIndexMap {
 export function renderLoweredSql(
   ast: AnyQueryAst,
   contract: PostgresContract,
-  codecLookup: CodecLookup,
+  codecDescriptorRegistry: PostgresCodecDescriptorRegistry,
 ): { readonly sql: string; readonly params: readonly LoweredParam[] } {
   const orderedRefs = collectOrderedParamRefs(ast);
   const indexMap = new Map<AnyParamRef, number>();
@@ -183,7 +160,7 @@ export function renderLoweredSql(
       ? { kind: 'bind', name: ref.name }
       : { kind: 'literal', value: ref.value };
   });
-  const pim: ParamIndexMap = { indexMap, codecLookup };
+  const pim: ParamIndexMap = { indexMap, codecDescriptorRegistry };
 
   const node = ast;
   let sql: string;
@@ -841,7 +818,7 @@ function renderParamRef(ref: AnyParamRef, pim: ParamIndexMap): string {
     return renderTypedParam(
       index,
       ref.codec.codecId,
-      pim.codecLookup,
+      pim.codecDescriptorRegistry,
       ref.codec.many,
       ref.codec.typeParams,
     );
@@ -858,7 +835,7 @@ function renderParamRef(ref: AnyParamRef, pim: ParamIndexMap): string {
   return renderTypedParam(
     index,
     ref.codec.codecId,
-    pim.codecLookup,
+    pim.codecDescriptorRegistry,
     ref.codec.many,
     ref.codec.typeParams,
   );

package/src/core/types.ts

@@ -16,19 +16,21 @@ import type {
   SelectAst,
   UpdateAst,
 } from '@prisma-next/sql-relational-core/ast';
+import type {
+  AnyPostgresCodecDescriptor,
+  PostgresCodecDescriptorRegistry,
+} from '@prisma-next/target-postgres/codec-descriptor';
+
+export type PostgresCodecRegistry = CodecRegistry & PostgresCodecDescriptorRegistry;
 
 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.
+   * Custom PostgreSQL codec descriptors contributed alongside the built-ins.
+   * The complete descriptor set is validated at construction and becomes the
+   * single source for both codec materialization and target-specific lowering.
    */
-  readonly codecLookup?: CodecRegistry;
+  readonly codecDescriptors?: readonly AnyPostgresCodecDescriptor[];
 }
 
 export type { PostgresContract } from '@prisma-next/target-postgres/types';

package/src/exports/control.ts

@@ -5,6 +5,7 @@ import {
   qualifyName,
   quoteIdentifier,
 } from '@prisma-next/target-postgres/sql-utils';
+import { assemblePostgresCodecRegistry } from '../core/codec-lookup';
 import { PostgresControlAdapter } from '../core/control-adapter';
 import {
   createPostgresDefaultFunctionRegistry,
@@ -21,7 +22,13 @@ const postgresAdapterDescriptor: SqlControlAdapterDescriptor<'postgres'> = {
     generatorDescriptors: createPostgresMutationDefaultGeneratorDescriptors(),
   },
   create(stack): SqlControlAdapter<'postgres'> {
-    return new PostgresControlAdapter(stack.codecLookup);
+    const components = [
+      stack.target,
+      ...(stack.adapter === undefined ? [] : [stack.adapter]),
+      ...stack.extensions,
+    ];
+    const codecRegistry = assemblePostgresCodecRegistry(components);
+    return new PostgresControlAdapter(codecRegistry);
   },
 };
 
@@ -29,6 +36,9 @@ export default postgresAdapterDescriptor;
 
 export { parsePostgresDefault } from '@prisma-next/target-postgres/default-normalizer';
 export { normalizeSchemaNativeType } from '@prisma-next/target-postgres/native-type-normalizer';
-export { createPostgresBuiltinCodecLookup } from '../core/codec-lookup';
+export {
+  createPostgresBuiltinCodecLookup,
+  createPostgresCodecRegistryWithBuiltins,
+} from '../core/codec-lookup';
 export { PostgresControlAdapter } from '../core/control-adapter';
 export { escapeLiteral, qualifyName, quoteIdentifier };

package/src/exports/runtime.ts

@@ -1,13 +1,13 @@
 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 } 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, postgresRawCodecInferer } from '../core/adapter';
+import { createPostgresAdapterWithCodecRegistry, postgresRawCodecInferer } from '../core/adapter';
+import { assemblePostgresCodecRegistry } from '../core/codec-lookup';
 import { postgresAdapterDescriptorMeta, postgresQueryOperations } from '../core/descriptor-meta';
 import type { PostgresContract, PostgresLoweredStatement } from '../core/types';
 
@@ -37,11 +37,9 @@ const postgresRuntimeAdapterDescriptor: SqlRuntimeAdapterDescriptor<'postgres',
     mutationDefaultGenerators: createPostgresMutationDefaultGenerators,
     rawCodecInferer: postgresRawCodecInferer,
     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 components = [stack.target, stack.adapter, ...stack.extensions];
-      const codecLookup = extractCodecLookup(components);
-      return createPostgresAdapter({ codecLookup });
+      const codecRegistry = assemblePostgresCodecRegistry(components);
+      return createPostgresAdapterWithCodecRegistry(codecRegistry);
     },
   };
 

package/src/exports/types.ts

@@ -6,6 +6,7 @@ export type {
   OrderClause,
   ParamRef,
   PostgresAdapterOptions,
+  PostgresCodecRegistry,
   PostgresContract,
   PostgresLoweredStatement,
   SelectAst,

package/dist/adapter-CZfCp5TH.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"adapter-CZfCp5TH.mjs","names":[],"sources":["../src/core/adapter.ts"],"sourcesContent":["import type { CodecRegistry } from '@prisma-next/framework-components/codec';\nimport { APP_SPACE_ID } from '@prisma-next/framework-components/control';\nimport type {\n  Adapter,\n  AdapterProfile,\n  AnyQueryAst,\n  LowererContext,\n  RawSqlLiteral,\n  SqlQueryable,\n} from '@prisma-next/sql-relational-core/ast';\nimport { isDdlNode } from '@prisma-next/sql-relational-core/ast';\nimport type { RawCodecInferer } from '@prisma-next/sql-relational-core/expression';\nimport type { PostgresDdlNode } from '@prisma-next/target-postgres/ddl';\nimport { adapterError } from './adapter-errors';\nimport { createPostgresBuiltinCodecLookup } from './codec-lookup';\nimport { PostgresControlAdapter } from './control-adapter';\nimport { renderLoweredSql } from './sql-renderer';\nimport type { PostgresAdapterOptions, PostgresContract, PostgresLoweredStatement } from './types';\n\nconst defaultCapabilities = Object.freeze({\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    scalarList: true,\n  },\n});\n\nclass PostgresAdapterImpl\n  implements Adapter<AnyQueryAst, PostgresContract, PostgresLoweredStatement>\n{\n  // These fields make the adapter instance structurally compatible with RuntimeAdapterInstance<'sql', 'postgres'> without introducing a runtime-plane dependency.\n  readonly familyId = 'sql' as const;\n  readonly targetId = 'postgres' as const;\n\n  readonly profile: AdapterProfile<'postgres'>;\n  private readonly codecLookup: CodecRegistry;\n\n  constructor(options?: PostgresAdapterOptions) {\n    this.codecLookup = options?.codecLookup ?? createPostgresBuiltinCodecLookup();\n    const controlAdapter = new PostgresControlAdapter(this.codecLookup);\n    this.profile = Object.freeze({\n      id: options?.profileId ?? 'postgres/default@1',\n      target: 'postgres',\n      capabilities: defaultCapabilities,\n      readMarker: (queryable: SqlQueryable) =>\n        controlAdapter.readMarkerDiscriminated(\n          {\n            familyId: 'sql',\n            targetId: 'postgres',\n            query: async <Row = Record<string, unknown>>(\n              sql: string,\n              params?: readonly unknown[],\n            ) => {\n              const result = await queryable.query<Row>(sql, params);\n              return { rows: [...result.rows] };\n            },\n            close: async () => {},\n          },\n          APP_SPACE_ID,\n        ),\n    });\n  }\n\n  lower(\n    ast: AnyQueryAst | PostgresDdlNode,\n    context: LowererContext<PostgresContract>,\n  ): PostgresLoweredStatement {\n    if (isDdlNode(ast)) {\n      throw adapterError(\n        'RUNTIME.DDL_UNSUPPORTED',\n        'lower() does not lower DDL on the runtime adapter — DDL lowering is a control-plane concern handled by the control adapter.',\n        { meta: { surface: 'runtime-adapter' } },\n      );\n    }\n    return renderLoweredSql(ast, context.contract, this.codecLookup);\n  }\n}\n\n/** Codec-id lookup for bare-literal interpolations used by `fns.raw` on a postgres client. Contributed as the descriptor's static `rawCodecInferer` slot. */\nexport const postgresRawCodecInferer: RawCodecInferer = {\n  inferCodec(value: RawSqlLiteral): string {\n    switch (typeof value) {\n      case 'number':\n        return Number.isSafeInteger(value) && value % 1 === 0 ? 'pg/int4' : 'pg/float8';\n      case 'bigint':\n        return 'pg/int8';\n      case 'string':\n        return 'pg/text';\n      case 'boolean':\n        return 'pg/bool';\n      case 'object':\n        if (value instanceof Uint8Array) return 'pg/bytea';\n    }\n    throw adapterError(\n      'RUNTIME.RAW_SQL_UNSUPPORTED_INTERPOLATION',\n      'unsupported JS value type for raw-SQL interpolation: wrap this value in `param(...)` with an explicit codec',\n      { meta: { valueType: typeof value } },\n    );\n  },\n};\n\nexport function createPostgresAdapter(options?: PostgresAdapterOptions) {\n  return Object.freeze(new PostgresAdapterImpl(options));\n}\n"],"mappings":";;;;AAmBA,MAAM,sBAAsB,OAAO,OAAO;CACxC,UAAU;EACR,SAAS;EACT,OAAO;EACP,SAAS;EACT,SAAS;EACT,WAAW;EACX,YAAY;CACd;CACA,KAAK;EACH,OAAO;EACP,WAAW;EACX,iBAAiB;EACjB,SAAS;EACT,YAAY;CACd;AACF,CAAC;AAED,IAAM,sBAAN,MAEA;CAEE,WAAoB;CACpB,WAAoB;CAEpB;CACA;CAEA,YAAY,SAAkC;EAC5C,KAAK,cAAc,SAAS,eAAe,iCAAiC;EAC5E,MAAM,iBAAiB,IAAI,uBAAuB,KAAK,WAAW;EAClE,KAAK,UAAU,OAAO,OAAO;GAC3B,IAAI,SAAS,aAAa;GAC1B,QAAQ;GACR,cAAc;GACd,aAAa,cACX,eAAe,wBACb;IACE,UAAU;IACV,UAAU;IACV,OAAO,OACL,KACA,WACG;KAEH,OAAO,EAAE,MAAM,CAAC,IAAG,MADE,UAAU,MAAW,KAAK,MAAM,EAAA,CAC3B,IAAI,EAAE;IAClC;IACA,OAAO,YAAY,CAAC;GACtB,GACA,YACF;EACJ,CAAC;CACH;CAEA,MACE,KACA,SAC0B;EAC1B,IAAI,UAAU,GAAG,GACf,MAAM,aACJ,2BACA,+HACA,EAAE,MAAM,EAAE,SAAS,kBAAkB,EAAE,CACzC;EAEF,OAAO,iBAAiB,KAAK,QAAQ,UAAU,KAAK,WAAW;CACjE;AACF;;AAGA,MAAa,0BAA2C,EACtD,WAAW,OAA8B;CACvC,QAAQ,OAAO,OAAf;EACE,KAAK,UACH,OAAO,OAAO,cAAc,KAAK,KAAK,QAAQ,MAAM,IAAI,YAAY;EACtE,KAAK,UACH,OAAO;EACT,KAAK,UACH,OAAO;EACT,KAAK,WACH,OAAO;EACT,KAAK,UACH,IAAI,iBAAiB,YAAY,OAAO;CAC5C;CACA,MAAM,aACJ,6CACA,+GACA,EAAE,MAAM,EAAE,WAAW,OAAO,MAAM,EAAE,CACtC;AACF,EACF;AAEA,SAAgB,sBAAsB,SAAkC;CACtE,OAAO,OAAO,OAAO,IAAI,oBAAoB,OAAO,CAAC;AACvD"}