@prisma-next/adapter-postgres 0.5.0-dev.2 → 0.5.0-dev.21

package/src/core/adapter.ts

@@ -1,3 +1,4 @@
+import type { CodecLookup } from '@prisma-next/framework-components/codec';
 import {
   type Adapter,
   type AdapterProfile,
@@ -6,8 +7,10 @@ import {
   createCodecRegistry,
   type LowererContext,
 } from '@prisma-next/sql-relational-core/ast';
+import { parseContractMarkerRow } from '@prisma-next/sql-runtime';
 import { codecDefinitions } from '@prisma-next/target-postgres/codecs';
 import { ifDefined } from '@prisma-next/utils/defined';
+import { createPostgresBuiltinCodecLookup } from './codec-lookup';
 import { renderLoweredSql } from './sql-renderer';
 import type { PostgresAdapterOptions, PostgresContract, PostgresLoweredStatement } from './types';
 
@@ -58,17 +61,22 @@ class PostgresAdapterImpl
     }
     return registry;
   })();
+  private readonly codecLookup: CodecLookup;
 
   constructor(options?: PostgresAdapterOptions) {
+    this.codecLookup = options?.codecLookup ?? createPostgresBuiltinCodecLookup();
     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',
+        sql: 'select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta, invariants from prisma_contract.marker where id = $1',
         params: [1],
       }),
+      // Postgres' driver hydrates `text[]` columns as native JS arrays, so
+      // the row is already in the shape the shared parser expects.
+      parseMarkerRow: (row: unknown) => parseContractMarkerRow(row),
     });
   }
 
@@ -77,7 +85,7 @@ class PostgresAdapterImpl
   }
 
   lower(ast: AnyQueryAst, context: LowererContext<PostgresContract>): PostgresLoweredStatement {
-    return renderLoweredSql(ast, context.contract);
+    return renderLoweredSql(ast, context.contract, this.codecLookup);
   }
 }
 

package/src/core/codec-lookup.ts

@@ -0,0 +1,24 @@
+import type { Codec, CodecLookup } from '@prisma-next/framework-components/codec';
+import { codecDefinitions } 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 {
+  const byId = new Map<string, Codec>();
+  for (const definition of Object.values(codecDefinitions)) {
+    byId.set(definition.codec.id, definition.codec);
+  }
+  return { get: (id) => byId.get(id) };
+}

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/descriptor-meta.ts

@@ -1,5 +1,12 @@
 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,
@@ -128,17 +135,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',

package/src/core/sql-renderer.ts

@@ -1,3 +1,4 @@
+import type { CodecLookup } from '@prisma-next/framework-components/codec';
 import {
   type AggregateExpr,
   type AnyExpression,
@@ -20,50 +21,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 +122,34 @@ 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 indexMap = new Map<ParamRef, number>();
   const params: unknown[] = [];
   for (const ref of collectedParamRefs) {
-    if (paramIndexMap.has(ref)) {
+    if (indexMap.has(ref)) {
       continue;
     }
-    paramIndexMap.set(ref, params.length + 1);
+    indexMap.set(ref, params.length + 1);
     params.push(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:
@@ -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 {

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/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,4 +1,5 @@
 import type { GeneratedValueSpec } from '@prisma-next/contract/types';
+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';
@@ -79,10 +80,22 @@ const postgresRuntimeAdapterDescriptor: SqlRuntimeAdapterDescriptor<'postgres',
     ...postgresAdapterDescriptorMeta,
     codecs: createPostgresCodecRegistry,
     parameterizedCodecs: () => parameterizedCodecDescriptors,
-    queryOperations: () => postgresQueryOperations,
+    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.map

@@ -1 +0,0 @@
-{"version":3,"file":"adapter-hNElNHo4.mjs","names":["parameterizedCodecs: ReadonlyArray<CodecParamsDescriptor>"],"sources":["../src/core/adapter.ts"],"sourcesContent":["import {\n  type Adapter,\n  type AdapterProfile,\n  type AnyQueryAst,\n  type CodecParamsDescriptor,\n  createCodecRegistry,\n  type LowererContext,\n} from '@prisma-next/sql-relational-core/ast';\nimport { codecDefinitions } from '@prisma-next/target-postgres/codecs';\nimport { ifDefined } from '@prisma-next/utils/defined';\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  },\n  sql: {\n    enums: true,\n    returning: true,\n    defaultInInsert: true,\n  },\n});\n\ntype AdapterCodec = (typeof codecDefinitions)[keyof typeof codecDefinitions]['codec'];\ntype ParameterizedCodec = AdapterCodec & {\n  readonly paramsSchema: NonNullable<AdapterCodec['paramsSchema']>;\n};\n\nconst parameterizedCodecs: ReadonlyArray<CodecParamsDescriptor> = Object.values(codecDefinitions)\n  .map((definition) => definition.codec)\n  .filter((codec): codec is ParameterizedCodec => codec.paramsSchema !== undefined)\n  .map((codec) =>\n    Object.freeze({\n      codecId: codec.id,\n      paramsSchema: codec.paramsSchema,\n      ...ifDefined('init', codec.init),\n    }),\n  );\n\nclass PostgresAdapterImpl\n  implements Adapter<AnyQueryAst, PostgresContract, PostgresLoweredStatement>\n{\n  // These fields make the adapter instance structurally compatible with\n  // 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 codecRegistry = (() => {\n    const registry = createCodecRegistry();\n    for (const definition of Object.values(codecDefinitions)) {\n      registry.register(definition.codec);\n    }\n    return registry;\n  })();\n\n  constructor(options?: PostgresAdapterOptions) {\n    this.profile = Object.freeze({\n      id: options?.profileId ?? 'postgres/default@1',\n      target: 'postgres',\n      capabilities: defaultCapabilities,\n      codecs: () => this.codecRegistry,\n      readMarkerStatement: () => ({\n        sql: 'select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta from prisma_contract.marker where id = $1',\n        params: [1],\n      }),\n    });\n  }\n\n  parameterizedCodecs(): ReadonlyArray<CodecParamsDescriptor> {\n    return parameterizedCodecs;\n  }\n\n  lower(ast: AnyQueryAst, context: LowererContext<PostgresContract>): PostgresLoweredStatement {\n    return renderLoweredSql(ast, context.contract);\n  }\n}\n\nexport function createPostgresAdapter(options?: PostgresAdapterOptions) {\n  return Object.freeze(new PostgresAdapterImpl(options));\n}\n"],"mappings":";;;;;;AAaA,MAAM,sBAAsB,OAAO,OAAO;CACxC,UAAU;EACR,SAAS;EACT,OAAO;EACP,SAAS;EACT,SAAS;EACT,WAAW;EACZ;CACD,KAAK;EACH,OAAO;EACP,WAAW;EACX,iBAAiB;EAClB;CACF,CAAC;AAOF,MAAMA,sBAA4D,OAAO,OAAO,iBAAiB,CAC9F,KAAK,eAAe,WAAW,MAAM,CACrC,QAAQ,UAAuC,MAAM,iBAAiB,OAAU,CAChF,KAAK,UACJ,OAAO,OAAO;CACZ,SAAS,MAAM;CACf,cAAc,MAAM;CACpB,GAAG,UAAU,QAAQ,MAAM,KAAK;CACjC,CAAC,CACH;AAEH,IAAM,sBAAN,MAEA;CAGE,AAAS,WAAW;CACpB,AAAS,WAAW;CAEpB,AAAS;CACT,AAAiB,uBAAuB;EACtC,MAAM,WAAW,qBAAqB;AACtC,OAAK,MAAM,cAAc,OAAO,OAAO,iBAAiB,CACtD,UAAS,SAAS,WAAW,MAAM;AAErC,SAAO;KACL;CAEJ,YAAY,SAAkC;AAC5C,OAAK,UAAU,OAAO,OAAO;GAC3B,IAAI,SAAS,aAAa;GAC1B,QAAQ;GACR,cAAc;GACd,cAAc,KAAK;GACnB,4BAA4B;IAC1B,KAAK;IACL,QAAQ,CAAC,EAAE;IACZ;GACF,CAAC;;CAGJ,sBAA4D;AAC1D,SAAO;;CAGT,MAAM,KAAkB,SAAqE;AAC3F,SAAO,iBAAiB,KAAK,QAAQ,SAAS;;;AAIlD,SAAgB,sBAAsB,SAAkC;AACtE,QAAO,OAAO,OAAO,IAAI,oBAAoB,QAAQ,CAAC"}