@prisma-next/adapter-postgres 0.5.0-dev.4 → 0.5.0-dev.42

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,
@@ -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

@@ -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,
@@ -164,68 +158,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';

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';
@@ -8,15 +9,9 @@ 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 { 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
@@ -31,20 +26,6 @@ function createPostgresCodecRegistry(): CodecRegistry {
   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,
@@ -55,34 +36,40 @@ function createPostgresMutationDefaultGenerators() {
   }));
 }
 
-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>
->;
+/**
+ * Phase C of codec-registry-unification: the postgres adapter retains
+ * only static raw-JSON / raw-JSONB column descriptors. Schema-typed JSON
+ * columns ship from per-library extension packages now —
+ * `@prisma-next/extension-arktype-json` for arktype, future zod / valibot
+ * extensions when each lands. The previously-shipped
+ * `parameterizedCodecDescriptors` for `pg/json@1` / `pg/jsonb@1` retired
+ * with the schema-typed surface; the unified descriptor map auto-lifts
+ * the raw json/jsonb codecs from `codecs:` via the synthesis bridge for
+ * codec-id-keyed metadata reads.
+ */
+const parameterizedCodecDescriptors: ReadonlyArray<RuntimeParameterizedCodecDescriptor> = [];
 
 const postgresRuntimeAdapterDescriptor: SqlRuntimeAdapterDescriptor<'postgres', SqlRuntimeAdapter> =
   {
     ...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"}