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

package/dist/runtime.mjs

@@ -1,95 +1,54 @@
-import { t as createPostgresAdapter } from "./adapter-hNElNHo4.mjs";
-import { n as postgresQueryOperations, t as postgresAdapterDescriptorMeta } from "./descriptor-meta-RTDzyrae.mjs";
+import { t as createPostgresAdapter } from "./adapter-_L4wXA4O.mjs";
+import { n as postgresQueryOperations, t as postgresAdapterDescriptorMeta } from "./descriptor-meta-CpEka_0t.mjs";
 import { createCodecRegistry } from "@prisma-next/sql-relational-core/ast";
 import { codecDefinitions } from "@prisma-next/target-postgres/codecs";
-import { PG_JSONB_CODEC_ID, PG_JSON_CODEC_ID } from "@prisma-next/target-postgres/codec-ids";
 import { builtinGeneratorIds } from "@prisma-next/ids";
+import { timestampNowRuntimeGenerator } from "@prisma-next/family-sql/runtime";
+import { extractCodecLookup } from "@prisma-next/framework-components/control";
 import { generateId } from "@prisma-next/ids/runtime";
-import { type } from "arktype";
-import Ajv from "ajv";
 
-//#region src/core/json-schema-validator.ts
-/**
-* Shared Ajv instance for all JSON Schema validators.
-* Reusing a single instance avoids ~50-100KB memory overhead per compiled schema.
-*/
-let sharedAjv;
-function getSharedAjv() {
-	if (!sharedAjv) sharedAjv = new Ajv({
-		allErrors: false,
-		strict: false
-	});
-	return sharedAjv;
-}
-/**
-* Compiles a JSON Schema object into a reusable validate function using Ajv.
-*
-* The returned function validates a value against the schema and returns
-* a structured result with error details on failure.
-*
-* Uses a shared Ajv instance and fail-fast mode (`allErrors: false`)
-* to minimize memory and CPU overhead.
-*
-* @param schema - A JSON Schema object (draft-07 compatible)
-* @returns A validate function
-*/
-function compileJsonSchemaValidator(schema) {
-	const validate = getSharedAjv().compile(schema);
-	return (value) => {
-		if (validate(value)) return { valid: true };
-		return {
-			valid: false,
-			errors: validate.errors.map((err) => ({
-				path: err.instancePath || "/",
-				message: err.message ?? "unknown validation error",
-				keyword: err.keyword
-			}))
-		};
-	};
-}
-
-//#endregion
 //#region src/exports/runtime.ts
 function createPostgresCodecRegistry() {
 	const registry = createCodecRegistry();
 	for (const definition of Object.values(codecDefinitions)) registry.register(definition.codec);
 	return registry;
 }
-const jsonTypeParamsSchema = type({
-	schemaJson: "object",
-	"type?": "string"
-});
 function createPostgresMutationDefaultGenerators() {
-	return builtinGeneratorIds.map((id) => ({
+	return [...builtinGeneratorIds.map((id) => ({
 		id,
 		generate: (params) => {
 			return generateId(params ? {
 				id,
 				params
 			} : { id });
-		}
-	}));
-}
-function initJsonCodecHelper(params) {
-	return { validate: compileJsonSchemaValidator(params.schemaJson) };
+		},
+		stability: "field"
+	})), timestampNowRuntimeGenerator()];
 }
-const parameterizedCodecDescriptors = [{
-	codecId: PG_JSON_CODEC_ID,
-	paramsSchema: jsonTypeParamsSchema,
-	init: initJsonCodecHelper
-}, {
-	codecId: PG_JSONB_CODEC_ID,
-	paramsSchema: jsonTypeParamsSchema,
-	init: initJsonCodecHelper
-}];
+/**
+* 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 = [];
 const postgresRuntimeAdapterDescriptor = {
 	...postgresAdapterDescriptorMeta,
 	codecs: createPostgresCodecRegistry,
 	parameterizedCodecs: () => parameterizedCodecDescriptors,
-	queryOperations: () => postgresQueryOperations,
+	queryOperations: () => postgresQueryOperations(),
 	mutationDefaultGenerators: createPostgresMutationDefaultGenerators,
-	create(_stack) {
-		return createPostgresAdapter();
+	create(stack) {
+		return createPostgresAdapter({ codecLookup: extractCodecLookup([
+			stack.target,
+			stack.adapter,
+			...stack.extensionPacks
+		]) });
 	}
 };
 var runtime_default = postgresRuntimeAdapterDescriptor;

package/dist/runtime.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.mjs","names":["sharedAjv: Ajv | undefined","arktype","postgresRuntimeAdapterDescriptor: SqlRuntimeAdapterDescriptor<'postgres', SqlRuntimeAdapter>"],"sources":["../src/core/json-schema-validator.ts","../src/exports/runtime.ts"],"sourcesContent":["import type {\n  JsonSchemaValidateFn,\n  JsonSchemaValidationError,\n  JsonSchemaValidationResult,\n} from '@prisma-next/sql-relational-core/query-lane-context';\nimport Ajv from 'ajv';\n\nexport type { JsonSchemaValidateFn, JsonSchemaValidationError, JsonSchemaValidationResult };\n\n/**\n * Shared Ajv instance for all JSON Schema validators.\n * Reusing a single instance avoids ~50-100KB memory overhead per compiled schema.\n */\nlet sharedAjv: Ajv | undefined;\n\nfunction getSharedAjv(): Ajv {\n  if (!sharedAjv) {\n    sharedAjv = new Ajv({ allErrors: false, strict: false });\n  }\n  return sharedAjv;\n}\n\n/**\n * Compiles a JSON Schema object into a reusable validate function using Ajv.\n *\n * The returned function validates a value against the schema and returns\n * a structured result with error details on failure.\n *\n * Uses a shared Ajv instance and fail-fast mode (`allErrors: false`)\n * to minimize memory and CPU overhead.\n *\n * @param schema - A JSON Schema object (draft-07 compatible)\n * @returns A validate function\n */\nexport function compileJsonSchemaValidator(schema: Record<string, unknown>): JsonSchemaValidateFn {\n  const ajv = getSharedAjv();\n  const validate = ajv.compile(schema);\n\n  return (value: unknown): JsonSchemaValidationResult => {\n    const valid = validate(value);\n    if (valid) {\n      return { valid: true };\n    }\n\n    // biome-ignore lint/style/noNonNullAssertion: Ajv guarantees `errors` is populated whenever `validate(...)` returns false.\n    const errors: JsonSchemaValidationError[] = validate.errors!.map((err) => ({\n      path: err.instancePath || '/',\n      message: err.message ?? 'unknown validation error',\n      keyword: err.keyword,\n    }));\n\n    return { valid: false, errors };\n  };\n}\n","import type { GeneratedValueSpec } from '@prisma-next/contract/types';\nimport type { RuntimeAdapterInstance } from '@prisma-next/framework-components/execution';\nimport { builtinGeneratorIds } from '@prisma-next/ids';\nimport { generateId } from '@prisma-next/ids/runtime';\nimport type { Adapter, AnyQueryAst, CodecRegistry } from '@prisma-next/sql-relational-core/ast';\nimport { createCodecRegistry } from '@prisma-next/sql-relational-core/ast';\nimport type {\n  RuntimeParameterizedCodecDescriptor,\n  SqlRuntimeAdapterDescriptor,\n} from '@prisma-next/sql-runtime';\nimport { PG_JSON_CODEC_ID, PG_JSONB_CODEC_ID } from '@prisma-next/target-postgres/codec-ids';\nimport { codecDefinitions } from '@prisma-next/target-postgres/codecs';\nimport { type as arktype } from 'arktype';\nimport { createPostgresAdapter } from '../core/adapter';\nimport { postgresAdapterDescriptorMeta, postgresQueryOperations } from '../core/descriptor-meta';\nimport {\n  compileJsonSchemaValidator,\n  type JsonSchemaValidateFn,\n} from '../core/json-schema-validator';\nimport type { PostgresContract, PostgresLoweredStatement } from '../core/types';\n\nexport interface SqlRuntimeAdapter\n  extends RuntimeAdapterInstance<'sql', 'postgres'>,\n    Adapter<AnyQueryAst, PostgresContract, PostgresLoweredStatement> {}\n\nfunction createPostgresCodecRegistry(): CodecRegistry {\n  const registry = createCodecRegistry();\n  for (const definition of Object.values(codecDefinitions)) {\n    registry.register(definition.codec);\n  }\n  return registry;\n}\n\nconst jsonTypeParamsSchema = arktype({\n  schemaJson: 'object',\n  'type?': 'string',\n});\n\n/** The inferred type params shape from the arktype schema. */\ntype JsonTypeParams = typeof jsonTypeParamsSchema.infer;\n\n/**\n * Helper returned by the JSON/JSONB `init` hook.\n * Contains a compiled JSON Schema validate function for runtime conformance checks.\n */\nexport type JsonCodecHelper = { readonly validate: JsonSchemaValidateFn };\n\nfunction createPostgresMutationDefaultGenerators() {\n  return builtinGeneratorIds.map((id) => ({\n    id,\n    generate: (params?: Record<string, unknown>) => {\n      const spec: GeneratedValueSpec = params ? { id, params } : { id };\n      return generateId(spec);\n    },\n  }));\n}\n\nfunction initJsonCodecHelper(params: JsonTypeParams): JsonCodecHelper {\n  return { validate: compileJsonSchemaValidator(params.schemaJson as Record<string, unknown>) };\n}\n\nconst parameterizedCodecDescriptors = [\n  {\n    codecId: PG_JSON_CODEC_ID,\n    paramsSchema: jsonTypeParamsSchema,\n    init: initJsonCodecHelper,\n  },\n  {\n    codecId: PG_JSONB_CODEC_ID,\n    paramsSchema: jsonTypeParamsSchema,\n    init: initJsonCodecHelper,\n  },\n] as const satisfies ReadonlyArray<\n  RuntimeParameterizedCodecDescriptor<JsonTypeParams, JsonCodecHelper>\n>;\n\nconst postgresRuntimeAdapterDescriptor: SqlRuntimeAdapterDescriptor<'postgres', SqlRuntimeAdapter> =\n  {\n    ...postgresAdapterDescriptorMeta,\n    codecs: createPostgresCodecRegistry,\n    parameterizedCodecs: () => parameterizedCodecDescriptors,\n    queryOperations: () => postgresQueryOperations,\n    mutationDefaultGenerators: createPostgresMutationDefaultGenerators,\n    create(_stack): SqlRuntimeAdapter {\n      return createPostgresAdapter();\n    },\n  };\n\nexport default postgresRuntimeAdapterDescriptor;\n"],"mappings":";;;;;;;;;;;;;;;AAaA,IAAIA;AAEJ,SAAS,eAAoB;AAC3B,KAAI,CAAC,UACH,aAAY,IAAI,IAAI;EAAE,WAAW;EAAO,QAAQ;EAAO,CAAC;AAE1D,QAAO;;;;;;;;;;;;;;AAeT,SAAgB,2BAA2B,QAAuD;CAEhG,MAAM,WADM,cAAc,CACL,QAAQ,OAAO;AAEpC,SAAQ,UAA+C;AAErD,MADc,SAAS,MAAM,CAE3B,QAAO,EAAE,OAAO,MAAM;AAUxB,SAAO;GAAE,OAAO;GAAO,QANqB,SAAS,OAAQ,KAAK,SAAS;IACzE,MAAM,IAAI,gBAAgB;IAC1B,SAAS,IAAI,WAAW;IACxB,SAAS,IAAI;IACd,EAAE;GAE4B;;;;;;AC1BnC,SAAS,8BAA6C;CACpD,MAAM,WAAW,qBAAqB;AACtC,MAAK,MAAM,cAAc,OAAO,OAAO,iBAAiB,CACtD,UAAS,SAAS,WAAW,MAAM;AAErC,QAAO;;AAGT,MAAM,uBAAuBC,KAAQ;CACnC,YAAY;CACZ,SAAS;CACV,CAAC;AAWF,SAAS,0CAA0C;AACjD,QAAO,oBAAoB,KAAK,QAAQ;EACtC;EACA,WAAW,WAAqC;AAE9C,UAAO,WAD0B,SAAS;IAAE;IAAI;IAAQ,GAAG,EAAE,IAAI,CAC1C;;EAE1B,EAAE;;AAGL,SAAS,oBAAoB,QAAyC;AACpE,QAAO,EAAE,UAAU,2BAA2B,OAAO,WAAsC,EAAE;;AAG/F,MAAM,gCAAgC,CACpC;CACE,SAAS;CACT,cAAc;CACd,MAAM;CACP,EACD;CACE,SAAS;CACT,cAAc;CACd,MAAM;CACP,CACF;AAID,MAAMC,mCACJ;CACE,GAAG;CACH,QAAQ;CACR,2BAA2B;CAC3B,uBAAuB;CACvB,2BAA2B;CAC3B,OAAO,QAA2B;AAChC,SAAO,uBAAuB;;CAEjC;AAEH,sBAAe"}
+{"version":3,"file":"runtime.mjs","names":["parameterizedCodecDescriptors: ReadonlyArray<RuntimeParameterizedCodecDescriptor>","postgresRuntimeAdapterDescriptor: SqlRuntimeAdapterDescriptor<'postgres', SqlRuntimeAdapter>"],"sources":["../src/exports/runtime.ts"],"sourcesContent":["import type { GeneratedValueSpec } from '@prisma-next/contract/types';\nimport { timestampNowRuntimeGenerator } from '@prisma-next/family-sql/runtime';\nimport { extractCodecLookup } from '@prisma-next/framework-components/control';\nimport type { RuntimeAdapterInstance } from '@prisma-next/framework-components/execution';\nimport { builtinGeneratorIds } from '@prisma-next/ids';\nimport { generateId } from '@prisma-next/ids/runtime';\nimport type { Adapter, AnyQueryAst, CodecRegistry } from '@prisma-next/sql-relational-core/ast';\nimport { createCodecRegistry } from '@prisma-next/sql-relational-core/ast';\nimport type {\n  RuntimeParameterizedCodecDescriptor,\n  SqlRuntimeAdapterDescriptor,\n} from '@prisma-next/sql-runtime';\nimport { codecDefinitions } from '@prisma-next/target-postgres/codecs';\nimport { createPostgresAdapter } from '../core/adapter';\nimport { postgresAdapterDescriptorMeta, postgresQueryOperations } from '../core/descriptor-meta';\nimport type { PostgresContract, PostgresLoweredStatement } from '../core/types';\n\nexport interface SqlRuntimeAdapter\n  extends RuntimeAdapterInstance<'sql', 'postgres'>,\n    Adapter<AnyQueryAst, PostgresContract, PostgresLoweredStatement> {}\n\nfunction createPostgresCodecRegistry(): CodecRegistry {\n  const registry = createCodecRegistry();\n  for (const definition of Object.values(codecDefinitions)) {\n    registry.register(definition.codec);\n  }\n  return registry;\n}\n\nfunction createPostgresMutationDefaultGenerators() {\n  return [\n    ...builtinGeneratorIds.map((id) => ({\n      id,\n      generate: (params?: Record<string, unknown>) => {\n        const spec: GeneratedValueSpec = params ? { id, params } : { id };\n        return generateId(spec);\n      },\n      stability: 'field' as const,\n    })),\n    timestampNowRuntimeGenerator(),\n  ];\n}\n\n/**\n * Phase C of codec-registry-unification: the postgres adapter retains\n * only static raw-JSON / raw-JSONB column descriptors. Schema-typed JSON\n * columns ship from per-library extension packages now —\n * `@prisma-next/extension-arktype-json` for arktype, future zod / valibot\n * extensions when each lands. The previously-shipped\n * `parameterizedCodecDescriptors` for `pg/json@1` / `pg/jsonb@1` retired\n * with the schema-typed surface; the unified descriptor map auto-lifts\n * the raw json/jsonb codecs from `codecs:` via the synthesis bridge for\n * codec-id-keyed metadata reads.\n */\nconst parameterizedCodecDescriptors: ReadonlyArray<RuntimeParameterizedCodecDescriptor> = [];\n\nconst postgresRuntimeAdapterDescriptor: SqlRuntimeAdapterDescriptor<'postgres', SqlRuntimeAdapter> =\n  {\n    ...postgresAdapterDescriptorMeta,\n    codecs: createPostgresCodecRegistry,\n    parameterizedCodecs: () => parameterizedCodecDescriptors,\n    queryOperations: () => postgresQueryOperations(),\n    mutationDefaultGenerators: createPostgresMutationDefaultGenerators,\n    create(stack): SqlRuntimeAdapter {\n      // The runtime `ExecutionStack` does not (yet) carry a pre-assembled\n      // `codecLookup` field the way the control `ControlStack` does, so we\n      // derive an equivalent lookup here from the stack's component metadata\n      // (target + adapter + extension packs) using the same assembly helper\n      // that `createControlStack` uses. This keeps the renderer fed with the\n      // same codec set on both planes — including extension-contributed\n      // codecs like `pg/vector@1` from `@prisma-next/extension-pgvector`.\n      const codecLookup = extractCodecLookup([\n        stack.target,\n        stack.adapter,\n        ...stack.extensionPacks,\n      ]);\n      return createPostgresAdapter({ codecLookup });\n    },\n  };\n\nexport default postgresRuntimeAdapterDescriptor;\n"],"mappings":";;;;;;;;;;AAqBA,SAAS,8BAA6C;CACpD,MAAM,WAAW,qBAAqB;AACtC,MAAK,MAAM,cAAc,OAAO,OAAO,iBAAiB,CACtD,UAAS,SAAS,WAAW,MAAM;AAErC,QAAO;;AAGT,SAAS,0CAA0C;AACjD,QAAO,CACL,GAAG,oBAAoB,KAAK,QAAQ;EAClC;EACA,WAAW,WAAqC;AAE9C,UAAO,WAD0B,SAAS;IAAE;IAAI;IAAQ,GAAG,EAAE,IAAI,CAC1C;;EAEzB,WAAW;EACZ,EAAE,EACH,8BAA8B,CAC/B;;;;;;;;;;;;;AAcH,MAAMA,gCAAoF,EAAE;AAE5F,MAAMC,mCACJ;CACE,GAAG;CACH,QAAQ;CACR,2BAA2B;CAC3B,uBAAuB,yBAAyB;CAChD,2BAA2B;CAC3B,OAAO,OAA0B;AAa/B,SAAO,sBAAsB,EAAE,aALX,mBAAmB;GACrC,MAAM;GACN,MAAM;GACN,GAAG,MAAM;GACV,CAAC,EAC0C,CAAC;;CAEhD;AAEH,sBAAe"}

package/dist/{sql-renderer-pEaSP82_.mjs → sql-renderer-DLwYpnxz.mjs}

@@ -1,25 +1,74 @@
-import { LiteralExpr } from "@prisma-next/sql-relational-core/ast";
-import { PG_JSONB_CODEC_ID, PG_JSON_CODEC_ID } from "@prisma-next/target-postgres/codec-ids";
+import { LiteralExpr, collectOrderedParamRefs } from "@prisma-next/sql-relational-core/ast";
+import { codecDefinitions } from "@prisma-next/target-postgres/codecs";
 import { escapeLiteral, quoteIdentifier } from "@prisma-next/target-postgres/sql-utils";
 
-//#region src/core/sql-renderer.ts
-const VECTOR_CODEC_ID = "pg/vector@1";
+//#region src/core/codec-lookup.ts
 /**
-* Map a codec ID to its `::cast` suffix, if Postgres requires one for
-* parameterized values (e.g. `$1::vector`, `$1::jsonb`).
+* 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).
 *
-* 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.
+* 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.
 */
-function getCodecParamCast(codecId) {
-	if (codecId === VECTOR_CODEC_ID) return "vector";
-	if (codecId === PG_JSON_CODEC_ID) return "json";
-	if (codecId === PG_JSONB_CODEC_ID) return "jsonb";
+function createPostgresBuiltinCodecLookup() {
+	const byId = /* @__PURE__ */ new Map();
+	for (const definition of Object.values(codecDefinitions)) byId.set(definition.codec.id, definition.codec);
+	return { get: (id) => byId.get(id) };
 }
-function renderTypedParam(index, codecId) {
-	const cast = getCodecParamCast(codecId);
-	return cast ? `$${index}::${cast}` : `$${index}`;
+
+//#endregion
+//#region src/core/sql-renderer.ts
+/**
+* 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).
+*
+* 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.
+*/
+const POSTGRES_INFERRABLE_NATIVE_TYPES = new Set([
+	"integer",
+	"smallint",
+	"bigint",
+	"real",
+	"double precision",
+	"numeric",
+	"boolean",
+	"text",
+	"character",
+	"character varying",
+	"timestamp",
+	"timestamp without time zone",
+	"timestamp with time zone",
+	"time",
+	"timetz",
+	"interval",
+	"bit",
+	"bit varying"
+]);
+function renderTypedParam(index, codecId, codecLookup) {
+	if (codecId === void 0) return `$${index}`;
+	const codec = codecLookup.get(codecId);
+	if (codec === void 0) 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 !== void 0 && !POSTGRES_INFERRABLE_NATIVE_TYPES.has(nativeType)) return `$${index}::${nativeType}`;
+	return `$${index}`;
 }
 /**
 * Render a SQL query AST to a Postgres-flavored `{ sql, params }` payload.
@@ -28,29 +77,31 @@ function renderTypedParam(index, codecId) {
 * (`PostgresControlAdapter.lower`) entrypoints so emit-time and run-time
 * paths produce byte-identical output for the same AST.
 */
-function renderLoweredSql(ast, contract) {
-	const collectedParamRefs = ast.collectParamRefs();
-	const paramIndexMap = /* @__PURE__ */ new Map();
-	const params = [];
-	for (const ref of collectedParamRefs) {
-		if (paramIndexMap.has(ref)) continue;
-		paramIndexMap.set(ref, params.length + 1);
-		params.push(ref.value);
-	}
+function renderLoweredSql(ast, contract, codecLookup) {
+	const orderedRefs = collectOrderedParamRefs(ast);
+	const indexMap = /* @__PURE__ */ new Map();
+	const params = orderedRefs.map((ref, i) => {
+		indexMap.set(ref, i + 1);
+		return ref.value;
+	});
+	const pim = {
+		indexMap,
+		codecLookup
+	};
 	const node = ast;
 	let sql;
 	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;
 		default: throw new Error(`Unsupported AST node kind: ${node.kind}`);
 	}
@@ -81,6 +132,16 @@ function renderProjection(projection, contract, pim) {
 		return `${renderExpr(item.expr, contract, pim)} AS ${alias}`;
 	}).join(", ");
 }
+function renderReturning(items, contract, pim) {
+	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, distinctOn, contract, pim) {
 	if (distinctOn && distinctOn.length > 0) return `DISTINCT ON (${distinctOn.map((expr) => renderExpr(expr, contract, pim)).join(", ")}) `;
 	if (distinct) return "DISTINCT ";
@@ -243,9 +304,9 @@ function renderExpr(expr, contract, pim) {
 	}
 }
 function renderParamRef(ref, pim) {
-	const index = pim.get(ref);
+	const index = pim.indexMap.get(ref);
 	if (index === void 0) throw new Error("ParamRef not found in index map");
-	return renderTypedParam(index, ref.codecId);
+	return renderTypedParam(index, ref.codecId, pim.codecLookup);
 }
 function renderLiteral(expr) {
 	if (typeof expr.value === "string") return `'${escapeLiteral(expr.value)}'`;
@@ -337,7 +398,7 @@ function renderInsert(ast, contract, pim) {
 			}
 			default: throw new Error(`Unsupported onConflict action: ${action.kind}`);
 		}
-	})() : ""}${ast.returning?.length ? ` RETURNING ${ast.returning.map((col) => `${quoteIdentifier(col.table)}.${quoteIdentifier(col.column)}`).join(", ")}` : ""}`;
+	})() : ""}${ast.returning?.length ? ` RETURNING ${renderReturning(ast.returning, contract, pim)}` : ""}`;
 }
 function renderUpdate(ast, contract, pim) {
 	const table = quoteIdentifier(ast.table.name);
@@ -358,13 +419,13 @@ function renderUpdate(ast, contract, pim) {
 		return `${column} = ${value}`;
 	});
 	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(", ")}` : "";
+	const returningClause = ast.returning?.length ? ` RETURNING ${renderReturning(ast.returning, contract, pim)}` : "";
 	return `UPDATE ${table} SET ${setClauses.join(", ")}${whereClause}${returningClause}`;
 }
 function renderDelete(ast, contract, pim) {
-	return `DELETE FROM ${quoteIdentifier(ast.table.name)}${ast.where ? ` WHERE ${renderWhere(ast.where, contract, pim)}` : ""}${ast.returning?.length ? ` RETURNING ${ast.returning.map((col) => `${quoteIdentifier(col.table)}.${quoteIdentifier(col.column)}`).join(", ")}` : ""}`;
+	return `DELETE FROM ${quoteIdentifier(ast.table.name)}${ast.where ? ` WHERE ${renderWhere(ast.where, contract, pim)}` : ""}${ast.returning?.length ? ` RETURNING ${renderReturning(ast.returning, contract, pim)}` : ""}`;
 }
 
 //#endregion
-export { renderLoweredSql as t };
-//# sourceMappingURL=sql-renderer-pEaSP82_.mjs.map
+export { createPostgresBuiltinCodecLookup as n, renderLoweredSql as t };
+//# sourceMappingURL=sql-renderer-DLwYpnxz.mjs.map

package/dist/sql-renderer-DLwYpnxz.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-renderer-DLwYpnxz.mjs","names":["POSTGRES_INFERRABLE_NATIVE_TYPES: ReadonlySet<string>","params: unknown[]","pim: ParamIndexMap","sql: string","right: string","orderedColumns: string[]","value: string"],"sources":["../src/core/codec-lookup.ts","../src/core/sql-renderer.ts"],"sourcesContent":["import type { Codec, CodecLookup } from '@prisma-next/framework-components/codec';\nimport { codecDefinitions } from '@prisma-next/target-postgres/codecs';\n\n/**\n * Build a {@link CodecLookup} populated with the Postgres-builtin codec\n * definitions only.\n *\n * This is the default lookup used by `createPostgresAdapter()` and\n * `new PostgresControlAdapter()` when called without a stack-derived lookup\n * (e.g. from tests, or one-off scripts that don't compose a full stack).\n *\n * Extension codecs (e.g. `pg/vector@1` from `@prisma-next/extension-pgvector`)\n * are intentionally NOT included here: a bare adapter cannot see extensions.\n * Stack-composed paths (`SqlControlAdapterDescriptor.create(stack)` /\n * `SqlRuntimeAdapterDescriptor.create(stack)`) supply the broader,\n * extension-inclusive lookup at construction time.\n */\nexport function createPostgresBuiltinCodecLookup(): CodecLookup {\n  const byId = new Map<string, Codec>();\n  for (const definition of Object.values(codecDefinitions)) {\n    byId.set(definition.codec.id, definition.codec);\n  }\n  return { get: (id) => byId.get(id) };\n}\n","import type { CodecLookup } from '@prisma-next/framework-components/codec';\nimport {\n  type AggregateExpr,\n  type AnyExpression,\n  type AnyFromSource,\n  type AnyQueryAst,\n  type BinaryExpr,\n  type ColumnRef,\n  collectOrderedParamRefs,\n  type DeleteAst,\n  type InsertAst,\n  type InsertValue,\n  type JoinAst,\n  type JoinOnExpr,\n  type JsonArrayAggExpr,\n  type JsonObjectExpr,\n  type ListExpression,\n  LiteralExpr,\n  type NullCheckExpr,\n  type OperationExpr,\n  type OrderByItem,\n  type ParamRef,\n  type ProjectionItem,\n  type SelectAst,\n  type Codec as SqlCodec,\n  type SubqueryExpr,\n  type UpdateAst,\n} from '@prisma-next/sql-relational-core/ast';\nimport { escapeLiteral, quoteIdentifier } from '@prisma-next/target-postgres/sql-utils';\nimport type { PostgresContract } from './types';\n\n/**\n * Postgres native types whose unknown-OID parameter inference is reliable in\n * arbitrary expression positions. Parameters bound to a codec whose\n * `meta.db.sql.postgres.nativeType` falls in this set are emitted as plain\n * `$N`; everything else (including `json`, `jsonb`, extension types like\n * `vector`, and unknown user types) is emitted as `$N::<nativeType>` so the\n * planner picks an unambiguous overload.\n *\n * `json` / `jsonb` are intentionally excluded despite being Postgres builtins:\n * their operator overloads make context inference unreliable in expression\n * positions (e.g. `$1 -> 'key'` is ambiguous between the two).\n *\n * Spellings match the on-disk `meta.db.sql.postgres.nativeType` values in\n * `@prisma-next/target-postgres`'s codec definitions, not the `udt_name`\n * abbreviations that ADR 205 used as illustrative shorthand. The lookup-based\n * cast policy compares against these strings directly.\n */\nconst POSTGRES_INFERRABLE_NATIVE_TYPES: ReadonlySet<string> = new Set([\n  // Numeric\n  'integer',\n  'smallint',\n  'bigint',\n  'real',\n  'double precision',\n  'numeric',\n  // Boolean\n  'boolean',\n  // Strings\n  'text',\n  'character',\n  'character varying',\n  // Temporal\n  'timestamp',\n  'timestamp without time zone',\n  'timestamp with time zone',\n  'time',\n  'timetz',\n  'interval',\n  // Bit strings\n  'bit',\n  'bit varying',\n]);\n\nfunction renderTypedParam(\n  index: number,\n  codecId: string | undefined,\n  codecLookup: CodecLookup,\n): string {\n  if (codecId === undefined) {\n    return `$${index}`;\n  }\n  // SQL codecs extend the framework `Codec` base with an optional\n  // `meta: CodecMeta`; the framework `CodecLookup.get` returns the base type,\n  // so we narrow to `SqlCodec` to read `meta`. Every codec actually\n  // registered into a SQL codec lookup conforms to `SqlCodec`.\n  const codec = codecLookup.get(codecId) as SqlCodec | undefined;\n  if (codec === undefined) {\n    throw new Error(\n      `Postgres lowering: ParamRef carries codecId \"${codecId}\" but the ` +\n        'assembled codec lookup has no entry for it. This usually indicates ' +\n        'a missing extension pack in the runtime stack — register the pack ' +\n        'that contributes this codec (e.g. `extensionPacks: [pgvectorRuntime]`), ' +\n        'or use the codec directly from `@prisma-next/target-postgres/codecs` ' +\n        \"if it's a builtin.\",\n    );\n  }\n  const nativeType = codec.meta?.db?.sql?.postgres?.nativeType;\n  if (nativeType !== undefined && !POSTGRES_INFERRABLE_NATIVE_TYPES.has(nativeType)) {\n    return `$${index}::${nativeType}`;\n  }\n  return `$${index}`;\n}\n\n/**\n * Per-render carrier threaded through every helper. Bundles the param-index\n * map (for `$N` numbering) and the assembled-stack `codecLookup` (for\n * cast policy at the `renderTypedParam` chokepoint). Carrying both on a\n * single value keeps helper signatures stable.\n */\ninterface ParamIndexMap {\n  readonly indexMap: Map<ParamRef, number>;\n  readonly codecLookup: CodecLookup;\n}\n\n/**\n * Render a SQL query AST to a Postgres-flavored `{ sql, params }` payload.\n *\n * Shared between the runtime (`PostgresAdapterImpl.lower`) and control\n * (`PostgresControlAdapter.lower`) entrypoints so emit-time and run-time\n * paths produce byte-identical output for the same AST.\n */\nexport function renderLoweredSql(\n  ast: AnyQueryAst,\n  contract: PostgresContract,\n  codecLookup: CodecLookup,\n): { readonly sql: string; readonly params: readonly unknown[] } {\n  const orderedRefs = collectOrderedParamRefs(ast);\n  const indexMap = new Map<ParamRef, number>();\n  const params: unknown[] = orderedRefs.map((ref, i) => {\n    indexMap.set(ref, i + 1);\n    return ref.value;\n  });\n  const pim: ParamIndexMap = { indexMap, codecLookup };\n\n  const node = ast;\n  let sql: string;\n  switch (node.kind) {\n    case 'select':\n      sql = renderSelect(node, contract, pim);\n      break;\n    case 'insert':\n      sql = renderInsert(node, contract, pim);\n      break;\n    case 'update':\n      sql = renderUpdate(node, contract, pim);\n      break;\n    case 'delete':\n      sql = renderDelete(node, contract, pim);\n      break;\n    // v8 ignore next 4\n    default:\n      throw new Error(\n        `Unsupported AST node kind: ${(node satisfies never as { kind: string }).kind}`,\n      );\n  }\n\n  return Object.freeze({ sql, params: Object.freeze(params) });\n}\n\nfunction renderSelect(ast: SelectAst, contract: PostgresContract, pim: ParamIndexMap): string {\n  const selectClause = `SELECT ${renderDistinctPrefix(ast.distinct, ast.distinctOn, contract, pim)}${renderProjection(\n    ast.projection,\n    contract,\n    pim,\n  )}`;\n  const fromClause = `FROM ${renderSource(ast.from, contract, pim)}`;\n\n  const joinsClause = ast.joins?.length\n    ? ast.joins.map((join) => renderJoin(join, contract, pim)).join(' ')\n    : '';\n\n  const whereClause = ast.where ? `WHERE ${renderWhere(ast.where, contract, pim)}` : '';\n  const groupByClause = ast.groupBy?.length\n    ? `GROUP BY ${ast.groupBy.map((expr) => renderExpr(expr, contract, pim)).join(', ')}`\n    : '';\n  const havingClause = ast.having ? `HAVING ${renderWhere(ast.having, contract, pim)}` : '';\n  const orderClause = ast.orderBy?.length\n    ? `ORDER BY ${ast.orderBy\n        .map((order) => {\n          const expr = renderExpr(order.expr, contract, pim);\n          return `${expr} ${order.dir.toUpperCase()}`;\n        })\n        .join(', ')}`\n    : '';\n  const limitClause = typeof ast.limit === 'number' ? `LIMIT ${ast.limit}` : '';\n  const offsetClause = typeof ast.offset === 'number' ? `OFFSET ${ast.offset}` : '';\n\n  const clauses = [\n    selectClause,\n    fromClause,\n    joinsClause,\n    whereClause,\n    groupByClause,\n    havingClause,\n    orderClause,\n    limitClause,\n    offsetClause,\n  ]\n    .filter((part) => part.length > 0)\n    .join(' ');\n  return clauses.trim();\n}\n\nfunction renderProjection(\n  projection: ReadonlyArray<ProjectionItem>,\n  contract: PostgresContract,\n  pim: ParamIndexMap,\n): string {\n  return projection\n    .map((item) => {\n      const alias = quoteIdentifier(item.alias);\n      if (item.expr.kind === 'literal') {\n        return `${renderLiteral(item.expr)} AS ${alias}`;\n      }\n      return `${renderExpr(item.expr, contract, pim)} AS ${alias}`;\n    })\n    .join(', ');\n}\n\nfunction renderReturning(\n  items: ReadonlyArray<ProjectionItem>,\n  contract: PostgresContract,\n  pim: ParamIndexMap,\n): string {\n  return items\n    .map((item) => {\n      if (item.expr.kind === 'column-ref') {\n        const rendered = renderColumn(item.expr);\n        return item.expr.column === item.alias\n          ? rendered\n          : `${rendered} AS ${quoteIdentifier(item.alias)}`;\n      }\n      if (item.expr.kind === 'literal') {\n        return `${renderLiteral(item.expr)} AS ${quoteIdentifier(item.alias)}`;\n      }\n      return `${renderExpr(item.expr, contract, pim)} AS ${quoteIdentifier(item.alias)}`;\n    })\n    .join(', ');\n}\n\nfunction renderDistinctPrefix(\n  distinct: true | undefined,\n  distinctOn: ReadonlyArray<AnyExpression> | undefined,\n  contract: PostgresContract,\n  pim: ParamIndexMap,\n): string {\n  if (distinctOn && distinctOn.length > 0) {\n    const rendered = distinctOn.map((expr) => renderExpr(expr, contract, pim)).join(', ');\n    return `DISTINCT ON (${rendered}) `;\n  }\n  if (distinct) {\n    return 'DISTINCT ';\n  }\n  return '';\n}\n\nfunction renderSource(\n  source: AnyFromSource,\n  contract: PostgresContract,\n  pim: ParamIndexMap,\n): string {\n  const node = source;\n  switch (node.kind) {\n    case 'table-source': {\n      const table = quoteIdentifier(node.name);\n      if (!node.alias) {\n        return table;\n      }\n      return `${table} AS ${quoteIdentifier(node.alias)}`;\n    }\n    case 'derived-table-source':\n      return `(${renderSelect(node.query, contract, pim)}) AS ${quoteIdentifier(node.alias)}`;\n    // v8 ignore next 4\n    default:\n      throw new Error(\n        `Unsupported source node kind: ${(node satisfies never as { kind: string }).kind}`,\n      );\n  }\n}\n\nfunction assertScalarSubquery(query: SelectAst): void {\n  if (query.projection.length !== 1) {\n    throw new Error('Subquery expressions must project exactly one column');\n  }\n}\n\nfunction renderSubqueryExpr(\n  expr: SubqueryExpr,\n  contract: PostgresContract,\n  pim: ParamIndexMap,\n): string {\n  assertScalarSubquery(expr.query);\n  return `(${renderSelect(expr.query, contract, pim)})`;\n}\n\nfunction renderWhere(expr: AnyExpression, contract: PostgresContract, pim: ParamIndexMap): string {\n  return renderExpr(expr, contract, pim);\n}\n\nfunction renderNullCheck(\n  expr: NullCheckExpr,\n  contract: PostgresContract,\n  pim: ParamIndexMap,\n): string {\n  const rendered = renderExpr(expr.expr, contract, pim);\n  const renderedExpr = isAtomicExpressionKind(expr.expr.kind) ? rendered : `(${rendered})`;\n  return expr.isNull ? `${renderedExpr} IS NULL` : `${renderedExpr} IS NOT NULL`;\n}\n\n/**\n * Atomic expression kinds whose rendered SQL is already self-delimited\n * (a column reference, parameter, literal, function call, aggregate, etc.)\n * and therefore does not need surrounding parentheses when used as the\n * left operand of a postfix predicate like `IS NULL` or `IS NOT NULL`,\n * or as either operand of a binary infix operator.\n *\n * Anything not in this set is treated as composite (binary, AND/OR/NOT,\n * EXISTS, nested IS NULL, subqueries, operation templates) and gets\n * wrapped to preserve grouping.\n */\nfunction isAtomicExpressionKind(kind: AnyExpression['kind']): boolean {\n  switch (kind) {\n    case 'column-ref':\n    case 'identifier-ref':\n    case 'param-ref':\n    case 'literal':\n    case 'aggregate':\n    case 'json-object':\n    case 'json-array-agg':\n    case 'list':\n      return true;\n    case 'subquery':\n    case 'operation':\n    case 'binary':\n    case 'and':\n    case 'or':\n    case 'exists':\n    case 'null-check':\n    case 'not':\n      return false;\n  }\n}\n\nfunction renderBinary(expr: BinaryExpr, contract: PostgresContract, pim: ParamIndexMap): string {\n  if (expr.right.kind === 'list' && expr.right.values.length === 0) {\n    if (expr.op === 'in') {\n      return 'FALSE';\n    }\n    if (expr.op === 'notIn') {\n      return 'TRUE';\n    }\n  }\n\n  const leftExpr = expr.left;\n  const left = renderExpr(leftExpr, contract, pim);\n  const leftRendered =\n    leftExpr.kind === 'operation' || leftExpr.kind === 'subquery' ? `(${left})` : left;\n\n  const rightNode = expr.right;\n  let right: string;\n  switch (rightNode.kind) {\n    case 'list':\n      right = renderListLiteral(rightNode, contract, pim);\n      break;\n    case 'literal':\n      right = renderLiteral(rightNode);\n      break;\n    case 'column-ref':\n      right = renderColumn(rightNode);\n      break;\n    case 'param-ref':\n      right = renderParamRef(rightNode, pim);\n      break;\n    default:\n      right = renderExpr(rightNode, contract, pim);\n      break;\n  }\n\n  const operatorMap: Record<BinaryExpr['op'], string> = {\n    eq: '=',\n    neq: '!=',\n    gt: '>',\n    lt: '<',\n    gte: '>=',\n    lte: '<=',\n    like: 'LIKE',\n    in: 'IN',\n    notIn: 'NOT IN',\n  };\n\n  return `${leftRendered} ${operatorMap[expr.op]} ${right}`;\n}\n\nfunction renderListLiteral(\n  expr: ListExpression,\n  contract: PostgresContract,\n  pim: ParamIndexMap,\n): string {\n  if (expr.values.length === 0) {\n    return '(NULL)';\n  }\n  const values = expr.values\n    .map((v) => {\n      if (v.kind === 'param-ref') return renderParamRef(v, pim);\n      if (v.kind === 'literal') return renderLiteral(v);\n      return renderExpr(v, contract, pim);\n    })\n    .join(', ');\n  return `(${values})`;\n}\n\nfunction renderColumn(ref: ColumnRef): string {\n  if (ref.table === 'excluded') {\n    return `excluded.${quoteIdentifier(ref.column)}`;\n  }\n  return `${quoteIdentifier(ref.table)}.${quoteIdentifier(ref.column)}`;\n}\n\nfunction renderAggregateExpr(\n  expr: AggregateExpr,\n  contract: PostgresContract,\n  pim: ParamIndexMap,\n): string {\n  const fn = expr.fn.toUpperCase();\n  if (!expr.expr) {\n    return `${fn}(*)`;\n  }\n  return `${fn}(${renderExpr(expr.expr, contract, pim)})`;\n}\n\nfunction renderJsonObjectExpr(\n  expr: JsonObjectExpr,\n  contract: PostgresContract,\n  pim: ParamIndexMap,\n): string {\n  const args = expr.entries\n    .flatMap((entry): [string, string] => {\n      const key = `'${escapeLiteral(entry.key)}'`;\n      if (entry.value.kind === 'literal') {\n        return [key, renderLiteral(entry.value)];\n      }\n      return [key, renderExpr(entry.value, contract, pim)];\n    })\n    .join(', ');\n  return `json_build_object(${args})`;\n}\n\nfunction renderOrderByItems(\n  items: ReadonlyArray<OrderByItem>,\n  contract: PostgresContract,\n  pim: ParamIndexMap,\n): string {\n  return items\n    .map((item) => `${renderExpr(item.expr, contract, pim)} ${item.dir.toUpperCase()}`)\n    .join(', ');\n}\n\nfunction renderJsonArrayAggExpr(\n  expr: JsonArrayAggExpr,\n  contract: PostgresContract,\n  pim: ParamIndexMap,\n): string {\n  const aggregateOrderBy =\n    expr.orderBy && expr.orderBy.length > 0\n      ? ` ORDER BY ${renderOrderByItems(expr.orderBy, contract, pim)}`\n      : '';\n  const aggregated = `json_agg(${renderExpr(expr.expr, contract, pim)}${aggregateOrderBy})`;\n  if (expr.onEmpty === 'emptyArray') {\n    return `coalesce(${aggregated}, json_build_array())`;\n  }\n  return aggregated;\n}\n\nfunction renderExpr(expr: AnyExpression, contract: PostgresContract, pim: ParamIndexMap): string {\n  const node = expr;\n  switch (node.kind) {\n    case 'column-ref':\n      return renderColumn(node);\n    case 'identifier-ref':\n      return quoteIdentifier(node.name);\n    case 'operation':\n      return renderOperation(node, contract, pim);\n    case 'subquery':\n      return renderSubqueryExpr(node, contract, pim);\n    case 'aggregate':\n      return renderAggregateExpr(node, contract, pim);\n    case 'json-object':\n      return renderJsonObjectExpr(node, contract, pim);\n    case 'json-array-agg':\n      return renderJsonArrayAggExpr(node, contract, pim);\n    case 'binary':\n      return renderBinary(node, contract, pim);\n    case 'and':\n      if (node.exprs.length === 0) {\n        return 'TRUE';\n      }\n      return `(${node.exprs.map((part) => renderExpr(part, contract, pim)).join(' AND ')})`;\n    case 'or':\n      if (node.exprs.length === 0) {\n        return 'FALSE';\n      }\n      return `(${node.exprs.map((part) => renderExpr(part, contract, pim)).join(' OR ')})`;\n    case 'exists': {\n      const notKeyword = node.notExists ? 'NOT ' : '';\n      const subquery = renderSelect(node.subquery, contract, pim);\n      return `${notKeyword}EXISTS (${subquery})`;\n    }\n    case 'null-check':\n      return renderNullCheck(node, contract, pim);\n    case 'not':\n      return `NOT (${renderExpr(node.expr, contract, pim)})`;\n    case 'param-ref':\n      return renderParamRef(node, pim);\n    case 'literal':\n      return renderLiteral(node);\n    case 'list':\n      return renderListLiteral(node, contract, pim);\n    // v8 ignore next 4\n    default:\n      throw new Error(\n        `Unsupported expression node kind: ${(node satisfies never as { kind: string }).kind}`,\n      );\n  }\n}\n\nfunction renderParamRef(ref: ParamRef, pim: ParamIndexMap): string {\n  const index = pim.indexMap.get(ref);\n  if (index === undefined) {\n    throw new Error('ParamRef not found in index map');\n  }\n  return renderTypedParam(index, ref.codecId, pim.codecLookup);\n}\n\nfunction renderLiteral(expr: LiteralExpr): string {\n  if (typeof expr.value === 'string') {\n    return `'${escapeLiteral(expr.value)}'`;\n  }\n  if (typeof expr.value === 'number' || typeof expr.value === 'boolean') {\n    return String(expr.value);\n  }\n  if (typeof expr.value === 'bigint') {\n    return String(expr.value);\n  }\n  if (expr.value === null) {\n    return 'NULL';\n  }\n  if (expr.value === undefined) {\n    return 'NULL';\n  }\n  if (expr.value instanceof Date) {\n    return `'${escapeLiteral(expr.value.toISOString())}'`;\n  }\n  if (Array.isArray(expr.value)) {\n    return `ARRAY[${expr.value.map((v: unknown) => renderLiteral(new LiteralExpr(v))).join(', ')}]`;\n  }\n  const json = JSON.stringify(expr.value);\n  if (json === undefined) {\n    return 'NULL';\n  }\n  return `'${escapeLiteral(json)}'`;\n}\n\nfunction renderOperation(\n  expr: OperationExpr,\n  contract: PostgresContract,\n  pim: ParamIndexMap,\n): string {\n  const self = renderExpr(expr.self, contract, pim);\n  const args = expr.args.map((arg) => {\n    return renderExpr(arg, contract, pim);\n  });\n\n  // Resolve `{{self}}` and `{{argN}}` from the original template in a single\n  // pass. Doing this with sequential `String.prototype.replace` calls is\n  // unsafe: a substituted fragment can itself contain text that matches a\n  // later token (e.g. an arg literal containing the substring `{{arg1}}`),\n  // and the next iteration would corrupt it. A single regex callback never\n  // re-scans already-substituted output.\n  return expr.lowering.template.replace(\n    /\\{\\{self\\}\\}|\\{\\{arg(\\d+)\\}\\}/g,\n    (token, argIndex: string | undefined) => {\n      if (token === '{{self}}') {\n        return self;\n      }\n      const arg = args[Number(argIndex)];\n      if (arg === undefined) {\n        throw new Error(\n          `Operation lowering template for \"${expr.method}\" referenced missing argument {{arg${argIndex}}}; template has ${args.length} arg(s)`,\n        );\n      }\n      return arg;\n    },\n  );\n}\n\nfunction renderJoin(join: JoinAst, contract: PostgresContract, pim: ParamIndexMap): string {\n  const joinType = join.joinType.toUpperCase();\n  const lateral = join.lateral ? 'LATERAL ' : '';\n  const source = renderSource(join.source, contract, pim);\n  const onClause = renderJoinOn(join.on, contract, pim);\n  return `${joinType} JOIN ${lateral}${source} ON ${onClause}`;\n}\n\nfunction renderJoinOn(on: JoinOnExpr, contract: PostgresContract, pim: ParamIndexMap): string {\n  if (on.kind === 'eq-col-join-on') {\n    const left = renderColumn(on.left);\n    const right = renderColumn(on.right);\n    return `${left} = ${right}`;\n  }\n  return renderWhere(on, contract, pim);\n}\n\nfunction getInsertColumnOrder(\n  rows: ReadonlyArray<Record<string, InsertValue>>,\n  contract: PostgresContract,\n  tableName: string,\n): string[] {\n  const orderedColumns: string[] = [];\n  const seenColumns = new Set<string>();\n\n  for (const row of rows) {\n    for (const column of Object.keys(row)) {\n      if (seenColumns.has(column)) {\n        continue;\n      }\n      seenColumns.add(column);\n      orderedColumns.push(column);\n    }\n  }\n\n  if (orderedColumns.length > 0) {\n    return orderedColumns;\n  }\n\n  const table = contract.storage.tables[tableName];\n  if (!table) {\n    throw new Error(`INSERT target table not found in contract storage: ${tableName}`);\n  }\n  return Object.keys(table.columns);\n}\n\nfunction renderInsertValue(value: InsertValue | undefined, pim: ParamIndexMap): string {\n  if (!value || value.kind === 'default-value') {\n    return 'DEFAULT';\n  }\n\n  switch (value.kind) {\n    case 'param-ref':\n      return renderParamRef(value, pim);\n    case 'column-ref':\n      return renderColumn(value);\n    // v8 ignore next 4\n    default:\n      throw new Error(\n        `Unsupported value node in INSERT: ${(value satisfies never as { kind: string }).kind}`,\n      );\n  }\n}\n\nfunction renderInsert(ast: InsertAst, contract: PostgresContract, pim: ParamIndexMap): string {\n  const table = quoteIdentifier(ast.table.name);\n  const rows = ast.rows;\n  if (rows.length === 0) {\n    throw new Error('INSERT requires at least one row');\n  }\n  const hasExplicitValues = rows.some((row) => Object.keys(row).length > 0);\n  const insertClause = (() => {\n    if (!hasExplicitValues) {\n      if (rows.length === 1) {\n        return `INSERT INTO ${table} DEFAULT VALUES`;\n      }\n\n      const defaultColumns = getInsertColumnOrder(rows, contract, ast.table.name);\n      if (defaultColumns.length === 0) {\n        return `INSERT INTO ${table} VALUES ${rows.map(() => '()').join(', ')}`;\n      }\n\n      const quotedColumns = defaultColumns.map((column) => quoteIdentifier(column));\n      const defaultRow = `(${defaultColumns.map(() => 'DEFAULT').join(', ')})`;\n      return `INSERT INTO ${table} (${quotedColumns.join(', ')}) VALUES ${rows\n        .map(() => defaultRow)\n        .join(', ')}`;\n    }\n\n    const columnOrder = getInsertColumnOrder(rows, contract, ast.table.name);\n    const columns = columnOrder.map((column) => quoteIdentifier(column));\n    const values = rows\n      .map((row) => {\n        const renderedRow = columnOrder.map((column) => renderInsertValue(row[column], pim));\n        return `(${renderedRow.join(', ')})`;\n      })\n      .join(', ');\n\n    return `INSERT INTO ${table} (${columns.join(', ')}) VALUES ${values}`;\n  })();\n  const onConflictClause = ast.onConflict\n    ? (() => {\n        const conflictColumns = ast.onConflict.columns.map((col) => quoteIdentifier(col.column));\n        if (conflictColumns.length === 0) {\n          throw new Error('INSERT onConflict requires at least one conflict column');\n        }\n\n        const action = ast.onConflict.action;\n        switch (action.kind) {\n          case 'do-nothing':\n            return ` ON CONFLICT (${conflictColumns.join(', ')}) DO NOTHING`;\n          case 'do-update-set': {\n            const updateEntries = Object.entries(action.set);\n            if (updateEntries.length === 0) {\n              throw new Error('INSERT onConflict do-update-set requires at least one assignment');\n            }\n            const updates = updateEntries.map(([colName, value]) => {\n              const target = quoteIdentifier(colName);\n              if (value.kind === 'param-ref') {\n                return `${target} = ${renderParamRef(value, pim)}`;\n              }\n              return `${target} = ${renderColumn(value)}`;\n            });\n            return ` ON CONFLICT (${conflictColumns.join(', ')}) DO UPDATE SET ${updates.join(', ')}`;\n          }\n          // v8 ignore next 4\n          default:\n            throw new Error(\n              `Unsupported onConflict action: ${(action satisfies never as { kind: string }).kind}`,\n            );\n        }\n      })()\n    : '';\n  const returningClause = ast.returning?.length\n    ? ` RETURNING ${renderReturning(ast.returning, contract, pim)}`\n    : '';\n\n  return `${insertClause}${onConflictClause}${returningClause}`;\n}\n\nfunction renderUpdate(ast: UpdateAst, contract: PostgresContract, pim: ParamIndexMap): string {\n  const table = quoteIdentifier(ast.table.name);\n  const setEntries = Object.entries(ast.set);\n  if (setEntries.length === 0) {\n    throw new Error('UPDATE requires at least one SET assignment');\n  }\n  const setClauses = setEntries.map(([col, val]) => {\n    const column = quoteIdentifier(col);\n    let value: string;\n    switch (val.kind) {\n      case 'param-ref':\n        value = renderParamRef(val, pim);\n        break;\n      case 'column-ref':\n        value = renderColumn(val);\n        break;\n      // v8 ignore next 4\n      default:\n        throw new Error(\n          `Unsupported value node in UPDATE: ${(val satisfies never as { kind: string }).kind}`,\n        );\n    }\n    return `${column} = ${value}`;\n  });\n\n  const whereClause = ast.where ? ` WHERE ${renderWhere(ast.where, contract, pim)}` : '';\n  const returningClause = ast.returning?.length\n    ? ` RETURNING ${renderReturning(ast.returning, contract, pim)}`\n    : '';\n\n  return `UPDATE ${table} SET ${setClauses.join(', ')}${whereClause}${returningClause}`;\n}\n\nfunction renderDelete(ast: DeleteAst, contract: PostgresContract, pim: ParamIndexMap): string {\n  const table = quoteIdentifier(ast.table.name);\n  const whereClause = ast.where ? ` WHERE ${renderWhere(ast.where, contract, pim)}` : '';\n  const returningClause = ast.returning?.length\n    ? ` RETURNING ${renderReturning(ast.returning, contract, pim)}`\n    : '';\n\n  return `DELETE FROM ${table}${whereClause}${returningClause}`;\n}\n"],"mappings":"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"}

package/dist/{types-CfRPdAk8.d.mts → types-tLtmYqCO.d.mts}

@@ -1,10 +1,21 @@
 import { BinaryExpr, ColumnRef, DefaultValueExpr, Direction, LoweredStatement, ParamRef, SelectAst } from "@prisma-next/sql-relational-core/ast";
 import { Contract } from "@prisma-next/contract/types";
+import { CodecLookup } from "@prisma-next/framework-components/codec";
 import { SqlStorage, StorageColumn, StorageTable } from "@prisma-next/sql-contract/types";
 
 //#region src/core/types.d.ts
 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;
 }
 type PostgresContract = Contract<SqlStorage> & {
   readonly target: 'postgres';
@@ -17,4 +28,4 @@ interface OrderClause {
 type PostgresLoweredStatement = LoweredStatement;
 //#endregion
 export { OrderClause as a, PostgresContract as c, StorageColumn as d, StorageTable as f, Expr as i, PostgresLoweredStatement as l, ColumnRef as n, ParamRef as o, Direction as r, PostgresAdapterOptions as s, BinaryExpr as t, SelectAst as u };
-//# sourceMappingURL=types-CfRPdAk8.d.mts.map
+//# sourceMappingURL=types-tLtmYqCO.d.mts.map

package/dist/types-tLtmYqCO.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-tLtmYqCO.d.mts","names":[],"sources":["../src/core/types.ts"],"sourcesContent":[],"mappings":";;;;;;UAoBiB,sBAAA;;EAAA;AAcjB;AAEA;;;;;AAEA;AAKA;yBAZyB;;KAGb,gBAAA,GAAmB,SAAS;;;KAE5B,IAAA,GAAO,YAAY,WAAW;UAEzB,WAAA;iBACA;gBACD;;KAGJ,wBAAA,GAA2B"}

package/dist/types.d.mts

@@ -1,2 +1,2 @@
-import { a as OrderClause, c as PostgresContract, d as StorageColumn, f as StorageTable, i as Expr, l as PostgresLoweredStatement, n as ColumnRef, o as ParamRef, r as Direction, s as PostgresAdapterOptions, t as BinaryExpr, u as SelectAst } from "./types-CfRPdAk8.mjs";
+import { a as OrderClause, c as PostgresContract, d as StorageColumn, f as StorageTable, i as Expr, l as PostgresLoweredStatement, n as ColumnRef, o as ParamRef, r as Direction, s as PostgresAdapterOptions, t as BinaryExpr, u as SelectAst } from "./types-tLtmYqCO.mjs";
 export { type BinaryExpr, type ColumnRef, type Direction, type Expr, type OrderClause, type ParamRef, type PostgresAdapterOptions, type PostgresContract, type PostgresLoweredStatement, type SelectAst, type StorageColumn, type StorageTable };

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@prisma-next/adapter-postgres",
-  "version": "0.5.0-dev.6",
+  "version": "0.5.0-dev.60",
+  "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "files": [
@@ -8,34 +9,33 @@
     "src"
   ],
   "dependencies": {
-    "ajv": "^8.18.0",
     "arktype": "^2.0.0",
-    "@prisma-next/contract": "0.5.0-dev.6",
-    "@prisma-next/family-sql": "0.5.0-dev.6",
-    "@prisma-next/ids": "0.5.0-dev.6",
-    "@prisma-next/framework-components": "0.5.0-dev.6",
-    "@prisma-next/contract-authoring": "0.5.0-dev.6",
-    "@prisma-next/sql-contract": "0.5.0-dev.6",
-    "@prisma-next/sql-operations": "0.5.0-dev.6",
-    "@prisma-next/sql-runtime": "0.5.0-dev.6",
-    "@prisma-next/sql-schema-ir": "0.5.0-dev.6",
-    "@prisma-next/utils": "0.5.0-dev.6",
-    "@prisma-next/target-postgres": "0.5.0-dev.6",
-    "@prisma-next/sql-contract-psl": "0.5.0-dev.6",
-    "@prisma-next/sql-contract-ts": "0.5.0-dev.6",
-    "@prisma-next/sql-relational-core": "0.5.0-dev.6"
+    "@prisma-next/contract": "0.5.0-dev.60",
+    "@prisma-next/contract-authoring": "0.5.0-dev.60",
+    "@prisma-next/framework-components": "0.5.0-dev.60",
+    "@prisma-next/sql-contract": "0.5.0-dev.60",
+    "@prisma-next/sql-contract-ts": "0.5.0-dev.60",
+    "@prisma-next/family-sql": "0.5.0-dev.60",
+    "@prisma-next/sql-operations": "0.5.0-dev.60",
+    "@prisma-next/sql-runtime": "0.5.0-dev.60",
+    "@prisma-next/sql-relational-core": "0.5.0-dev.60",
+    "@prisma-next/sql-schema-ir": "0.5.0-dev.60",
+    "@prisma-next/ids": "0.5.0-dev.60",
+    "@prisma-next/target-postgres": "0.5.0-dev.60",
+    "@prisma-next/utils": "0.5.0-dev.60",
+    "@prisma-next/sql-contract-psl": "0.5.0-dev.60"
   },
   "devDependencies": {
     "pathe": "^2.0.3",
     "tsdown": "0.18.4",
     "typescript": "5.9.3",
     "vitest": "4.0.17",
-    "@prisma-next/cli": "0.5.0-dev.6",
-    "@prisma-next/errors": "0.5.0-dev.6",
-    "@prisma-next/driver-postgres": "0.5.0-dev.6",
-    "@prisma-next/extension-pgvector": "0.5.0-dev.6",
-    "@prisma-next/tsconfig": "0.0.0",
+    "@prisma-next/cli": "0.5.0-dev.60",
+    "@prisma-next/errors": "0.5.0-dev.60",
+    "@prisma-next/driver-postgres": "0.5.0-dev.60",
+    "@prisma-next/extension-pgvector": "0.5.0-dev.60",
     "@prisma-next/test-utils": "0.0.1",
+    "@prisma-next/tsconfig": "0.0.0",
     "@prisma-next/tsdown": "0.0.0"
   },
   "exports": {

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) };
+}