@prisma-next/target-postgres 0.5.0-dev.60 → 0.5.0-dev.62

package/dist/codecs.mjs

@@ -1,4 +1,743 @@
-import "./codec-ids-ckQX9Kcg.mjs";
-import { n as dataTypes, t as codecDefinitions } from "./codecs-D0oXyJIH.mjs";
+import { C as PG_VARCHAR_CODEC_ID, S as PG_VARBIT_CODEC_ID, _ as PG_TEXT_CODEC_ID, a as PG_ENUM_CODEC_ID, b as PG_TIMETZ_CODEC_ID, c as PG_FLOAT_CODEC_ID, d as PG_INT8_CODEC_ID, f as PG_INTERVAL_CODEC_ID, g as PG_NUMERIC_CODEC_ID, h as PG_JSON_CODEC_ID, i as PG_CHAR_CODEC_ID, l as PG_INT2_CODEC_ID, m as PG_JSONB_CODEC_ID, n as PG_BOOL_CODEC_ID, o as PG_FLOAT4_CODEC_ID, p as PG_INT_CODEC_ID, r as PG_BYTEA_CODEC_ID, s as PG_FLOAT8_CODEC_ID, t as PG_BIT_CODEC_ID, u as PG_INT4_CODEC_ID, v as PG_TIMESTAMPTZ_CODEC_ID, x as PG_TIME_CODEC_ID, y as PG_TIMESTAMP_CODEC_ID } from "./codec-ids-ckQX9Kcg.mjs";
+import { SqlCharCodec, SqlFloatCodec, SqlIntCodec, SqlVarcharCodec, sqlCharDescriptor, sqlFloatDescriptor, sqlIntDescriptor, sqlTextDescriptor, sqlTimestampDescriptor, sqlVarcharDescriptor } from "@prisma-next/sql-relational-core/ast";
+import { CodecDescriptorImpl, CodecImpl, column, voidParamsSchema } from "@prisma-next/framework-components/codec";
+import { type } from "arktype";
+import { buildCodecDescriptorRegistry } from "@prisma-next/sql-relational-core/codec-descriptor-registry";
 
-export { codecDefinitions, dataTypes };
+//#region src/core/codec-helpers.ts
+function renderLength(typeName, typeParams) {
+	const length = typeParams["length"];
+	if (length === void 0) return;
+	if (typeof length !== "number" || !Number.isFinite(length) || !Number.isInteger(length)) throw new Error(`renderOutputType: expected integer "length" in typeParams for ${typeName}, got ${String(length)}`);
+	return `${typeName}<${length}>`;
+}
+function renderPrecision(typeName, typeParams) {
+	const precision = typeParams["precision"];
+	if (precision === void 0) return typeName;
+	if (typeof precision !== "number" || !Number.isFinite(precision) || !Number.isInteger(precision)) throw new Error(`renderOutputType: expected integer "precision" in typeParams for ${typeName}, got ${String(precision)}`);
+	return `${typeName}<${precision}>`;
+}
+const pgNumericDecode = (wire) => {
+	if (typeof wire === "number") return String(wire);
+	return wire;
+};
+const pgNumericRenderOutputType = (typeParams) => {
+	const precision = typeParams.precision;
+	if (precision === void 0) return void 0;
+	if (typeof precision !== "number" || !Number.isFinite(precision) || !Number.isInteger(precision)) throw new Error(`renderOutputType: expected integer "precision" in typeParams for Numeric, got ${String(precision)}`);
+	const scale = typeParams.scale;
+	if (scale === void 0) return `Numeric<${precision}>`;
+	if (typeof scale !== "number" || !Number.isFinite(scale) || !Number.isInteger(scale)) throw new Error(`renderOutputType: expected integer "scale" in typeParams for Numeric, got ${String(scale)}`);
+	return `Numeric<${precision}, ${scale}>`;
+};
+const ISO_8601_UTC = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?Z$/;
+const pgTimestampEncodeJson = (value) => value.toISOString();
+const pgTimestampDecodeJson = (json) => {
+	if (typeof json !== "string") throw new Error(`Expected ISO date string for pg/timestamp@1, got ${typeof json}`);
+	if (!ISO_8601_UTC.test(json)) throw new Error(`Invalid ISO date string for pg/timestamp@1: ${json}`);
+	const date = new Date(json);
+	if (Number.isNaN(date.getTime())) throw new Error(`Invalid ISO date string for pg/timestamp@1: ${json}`);
+	return date;
+};
+const pgTimestamptzEncodeJson = (value) => value.toISOString();
+const pgTimestamptzDecodeJson = (json) => {
+	if (typeof json !== "string") throw new Error(`Expected ISO date string for pg/timestamptz@1, got ${typeof json}`);
+	if (!ISO_8601_UTC.test(json)) throw new Error(`Invalid ISO date string for pg/timestamptz@1: ${json}`);
+	const date = new Date(json);
+	if (Number.isNaN(date.getTime())) throw new Error(`Invalid ISO date string for pg/timestamptz@1: ${json}`);
+	return date;
+};
+const pgIntervalDecode = (wire) => {
+	if (typeof wire === "string") return wire;
+	return JSON.stringify(wire);
+};
+const pgEnumRenderOutputType = (typeParams) => {
+	const values = typeParams.values;
+	if (!Array.isArray(values)) throw new Error(`renderOutputType: expected array "values" in typeParams for enum, got ${typeof values}`);
+	if (!values.every((v) => typeof v === "string")) throw new Error(`renderOutputType: expected string[] "values" in typeParams for enum`);
+	return values.map((value) => `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`).join(" | ");
+};
+const pgJsonEncode = (value) => JSON.stringify(value);
+const pgJsonDecode = (wire) => typeof wire === "string" ? JSON.parse(wire) : wire;
+const pgJsonbEncode = (value) => JSON.stringify(value);
+const pgJsonbDecode = (wire) => typeof wire === "string" ? JSON.parse(wire) : wire;
+
+//#endregion
+//#region src/core/codecs.ts
+const lengthParamsSchema = type({ "length?": "number.integer > 0" });
+const numericParamsSchema = type({
+	precision: "number.integer > 0 & number.integer <= 1000",
+	"scale?": "number.integer >= 0"
+});
+const precisionParamsSchema = type({ "precision?": "number.integer >= 0 & number.integer <= 6" });
+const PG_TEXT_META = { db: { sql: { postgres: { nativeType: "text" } } } };
+const PG_INT4_META = { db: { sql: { postgres: { nativeType: "integer" } } } };
+const PG_INT2_META = { db: { sql: { postgres: { nativeType: "smallint" } } } };
+const PG_INT8_META = { db: { sql: { postgres: { nativeType: "bigint" } } } };
+const PG_FLOAT4_META = { db: { sql: { postgres: { nativeType: "real" } } } };
+const PG_FLOAT8_META = { db: { sql: { postgres: { nativeType: "double precision" } } } };
+const PG_NUMERIC_META = { db: { sql: { postgres: { nativeType: "numeric" } } } };
+const PG_TIMESTAMP_META = { db: { sql: { postgres: { nativeType: "timestamp without time zone" } } } };
+const PG_TIMESTAMPTZ_META = { db: { sql: { postgres: { nativeType: "timestamp with time zone" } } } };
+const PG_TIME_META = { db: { sql: { postgres: { nativeType: "time" } } } };
+const PG_TIMETZ_META = { db: { sql: { postgres: { nativeType: "timetz" } } } };
+const PG_BOOL_META = { db: { sql: { postgres: { nativeType: "boolean" } } } };
+const PG_BIT_META = { db: { sql: { postgres: { nativeType: "bit" } } } };
+const PG_VARBIT_META = { db: { sql: { postgres: { nativeType: "bit varying" } } } };
+const PG_BYTEA_META = { db: { sql: { postgres: { nativeType: "bytea" } } } };
+const PG_INTERVAL_META = { db: { sql: { postgres: { nativeType: "interval" } } } };
+const PG_JSON_META = { db: { sql: { postgres: { nativeType: "json" } } } };
+const PG_JSONB_META = { db: { sql: { postgres: { nativeType: "jsonb" } } } };
+var PgTextCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgTextDescriptor = class extends CodecDescriptorImpl {
+	codecId = PG_TEXT_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"textual"
+	];
+	targetTypes = ["text"];
+	meta = PG_TEXT_META;
+	paramsSchema = voidParamsSchema;
+	factory() {
+		return () => new PgTextCodec(this);
+	}
+};
+const pgTextDescriptor = new PgTextDescriptor();
+const pgTextColumn = () => column(pgTextDescriptor.factory(), pgTextDescriptor.codecId, void 0, "text");
+var PgInt4Codec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgInt4Descriptor = class extends CodecDescriptorImpl {
+	codecId = PG_INT4_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"numeric"
+	];
+	targetTypes = ["int4"];
+	meta = PG_INT4_META;
+	paramsSchema = voidParamsSchema;
+	factory() {
+		return () => new PgInt4Codec(this);
+	}
+};
+const pgInt4Descriptor = new PgInt4Descriptor();
+const pgInt4Column = () => column(pgInt4Descriptor.factory(), pgInt4Descriptor.codecId, void 0, "int4");
+var PgInt2Codec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgInt2Descriptor = class extends CodecDescriptorImpl {
+	codecId = PG_INT2_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"numeric"
+	];
+	targetTypes = ["int2"];
+	meta = PG_INT2_META;
+	paramsSchema = voidParamsSchema;
+	factory() {
+		return () => new PgInt2Codec(this);
+	}
+};
+const pgInt2Descriptor = new PgInt2Descriptor();
+const pgInt2Column = () => column(pgInt2Descriptor.factory(), pgInt2Descriptor.codecId, void 0, "int2");
+var PgInt8Codec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgInt8Descriptor = class extends CodecDescriptorImpl {
+	codecId = PG_INT8_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"numeric"
+	];
+	targetTypes = ["int8"];
+	meta = PG_INT8_META;
+	paramsSchema = voidParamsSchema;
+	factory() {
+		return () => new PgInt8Codec(this);
+	}
+};
+const pgInt8Descriptor = new PgInt8Descriptor();
+const pgInt8Column = () => column(pgInt8Descriptor.factory(), pgInt8Descriptor.codecId, void 0, "int8");
+var PgFloat4Codec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgFloat4Descriptor = class extends CodecDescriptorImpl {
+	codecId = PG_FLOAT4_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"numeric"
+	];
+	targetTypes = ["float4"];
+	meta = PG_FLOAT4_META;
+	paramsSchema = voidParamsSchema;
+	factory() {
+		return () => new PgFloat4Codec(this);
+	}
+};
+const pgFloat4Descriptor = new PgFloat4Descriptor();
+const pgFloat4Column = () => column(pgFloat4Descriptor.factory(), pgFloat4Descriptor.codecId, void 0, "float4");
+var PgFloat8Codec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgFloat8Descriptor = class extends CodecDescriptorImpl {
+	codecId = PG_FLOAT8_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"numeric"
+	];
+	targetTypes = ["float8"];
+	meta = PG_FLOAT8_META;
+	paramsSchema = voidParamsSchema;
+	factory() {
+		return () => new PgFloat8Codec(this);
+	}
+};
+const pgFloat8Descriptor = new PgFloat8Descriptor();
+const pgFloat8Column = () => column(pgFloat8Descriptor.factory(), pgFloat8Descriptor.codecId, void 0, "float8");
+var PgBoolCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgBoolDescriptor = class extends CodecDescriptorImpl {
+	codecId = PG_BOOL_CODEC_ID;
+	traits = ["equality", "boolean"];
+	targetTypes = ["bool"];
+	meta = PG_BOOL_META;
+	paramsSchema = voidParamsSchema;
+	factory() {
+		return () => new PgBoolCodec(this);
+	}
+};
+const pgBoolDescriptor = new PgBoolDescriptor();
+const pgBoolColumn = () => column(pgBoolDescriptor.factory(), pgBoolDescriptor.codecId, void 0, "bool");
+var PgNumericCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return pgNumericDecode(wire);
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgNumericDescriptor = class extends CodecDescriptorImpl {
+	codecId = PG_NUMERIC_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"numeric"
+	];
+	targetTypes = ["numeric", "decimal"];
+	meta = PG_NUMERIC_META;
+	paramsSchema = numericParamsSchema;
+	renderOutputType(params) {
+		return pgNumericRenderOutputType(params);
+	}
+	factory(_params) {
+		return () => new PgNumericCodec(this);
+	}
+};
+const pgNumericDescriptor = new PgNumericDescriptor();
+const pgNumericColumn = (params) => column(pgNumericDescriptor.factory(params), pgNumericDescriptor.codecId, params, "numeric");
+var PgTimestampCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return pgTimestampEncodeJson(value);
+	}
+	decodeJson(json) {
+		return pgTimestampDecodeJson(json);
+	}
+};
+var PgTimestampDescriptor = class extends CodecDescriptorImpl {
+	codecId = PG_TIMESTAMP_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = ["timestamp"];
+	meta = PG_TIMESTAMP_META;
+	paramsSchema = precisionParamsSchema;
+	renderOutputType(params) {
+		return renderPrecision("Timestamp", params);
+	}
+	factory(_params) {
+		return () => new PgTimestampCodec(this);
+	}
+};
+const pgTimestampDescriptor = new PgTimestampDescriptor();
+const pgTimestampColumn = (params = {}) => column(pgTimestampDescriptor.factory(params), pgTimestampDescriptor.codecId, params, "timestamp");
+var PgTimestamptzCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return pgTimestamptzEncodeJson(value);
+	}
+	decodeJson(json) {
+		return pgTimestamptzDecodeJson(json);
+	}
+};
+var PgTimestamptzDescriptor = class extends CodecDescriptorImpl {
+	codecId = PG_TIMESTAMPTZ_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = ["timestamptz"];
+	meta = PG_TIMESTAMPTZ_META;
+	paramsSchema = precisionParamsSchema;
+	renderOutputType(params) {
+		return renderPrecision("Timestamptz", params);
+	}
+	factory(_params) {
+		return () => new PgTimestamptzCodec(this);
+	}
+};
+const pgTimestamptzDescriptor = new PgTimestamptzDescriptor();
+const pgTimestamptzColumn = (params = {}) => column(pgTimestamptzDescriptor.factory(params), pgTimestamptzDescriptor.codecId, params, "timestamptz");
+var PgTimeCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgTimeDescriptor = class extends CodecDescriptorImpl {
+	codecId = PG_TIME_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = ["time"];
+	meta = PG_TIME_META;
+	paramsSchema = precisionParamsSchema;
+	renderOutputType(params) {
+		return renderPrecision("Time", params);
+	}
+	factory(_params) {
+		return () => new PgTimeCodec(this);
+	}
+};
+const pgTimeDescriptor = new PgTimeDescriptor();
+const pgTimeColumn = (params = {}) => column(pgTimeDescriptor.factory(params), pgTimeDescriptor.codecId, params, "time");
+var PgTimetzCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgTimetzDescriptor = class extends CodecDescriptorImpl {
+	codecId = PG_TIMETZ_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = ["timetz"];
+	meta = PG_TIMETZ_META;
+	paramsSchema = precisionParamsSchema;
+	renderOutputType(params) {
+		return renderPrecision("Timetz", params);
+	}
+	factory(_params) {
+		return () => new PgTimetzCodec(this);
+	}
+};
+const pgTimetzDescriptor = new PgTimetzDescriptor();
+const pgTimetzColumn = (params = {}) => column(pgTimetzDescriptor.factory(params), pgTimetzDescriptor.codecId, params, "timetz");
+var PgBitCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgBitDescriptor = class extends CodecDescriptorImpl {
+	codecId = PG_BIT_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = ["bit"];
+	meta = PG_BIT_META;
+	paramsSchema = lengthParamsSchema;
+	renderOutputType(params) {
+		return renderLength("Bit", params);
+	}
+	factory(_params) {
+		return () => new PgBitCodec(this);
+	}
+};
+const pgBitDescriptor = new PgBitDescriptor();
+const pgBitColumn = (params = {}) => column(pgBitDescriptor.factory(params), pgBitDescriptor.codecId, params, "bit");
+var PgVarbitCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgVarbitDescriptor = class extends CodecDescriptorImpl {
+	codecId = PG_VARBIT_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = ["bit varying"];
+	meta = PG_VARBIT_META;
+	paramsSchema = lengthParamsSchema;
+	renderOutputType(params) {
+		return renderLength("VarBit", params);
+	}
+	factory(_params) {
+		return () => new PgVarbitCodec(this);
+	}
+};
+const pgVarbitDescriptor = new PgVarbitDescriptor();
+const pgVarbitColumn = (params = {}) => column(pgVarbitDescriptor.factory(params), pgVarbitDescriptor.codecId, params, "bit varying");
+var PgByteaCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire instanceof Uint8Array && wire.constructor === Uint8Array ? wire : new Uint8Array(wire.buffer, wire.byteOffset, wire.byteLength);
+	}
+	encodeJson(value) {
+		return Buffer.from(value).toString("base64");
+	}
+	decodeJson(json) {
+		if (typeof json !== "string") throw new Error(`Expected base64 string for pg/bytea@1, got ${typeof json}`);
+		const decoded = Buffer.from(json, "base64");
+		if (decoded.toString("base64") !== json) throw new Error(`Invalid base64 string for pg/bytea@1 (length: ${json.length})`);
+		return new Uint8Array(decoded);
+	}
+};
+var PgByteaDescriptor = class extends CodecDescriptorImpl {
+	codecId = PG_BYTEA_CODEC_ID;
+	traits = ["equality"];
+	targetTypes = ["bytea"];
+	meta = PG_BYTEA_META;
+	paramsSchema = voidParamsSchema;
+	factory() {
+		return () => new PgByteaCodec(this);
+	}
+};
+const pgByteaDescriptor = new PgByteaDescriptor();
+var PgIntervalCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return pgIntervalDecode(wire);
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgIntervalDescriptor = class extends CodecDescriptorImpl {
+	codecId = PG_INTERVAL_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = ["interval"];
+	meta = PG_INTERVAL_META;
+	paramsSchema = precisionParamsSchema;
+	renderOutputType(params) {
+		return renderPrecision("Interval", params);
+	}
+	factory(_params) {
+		return () => new PgIntervalCodec(this);
+	}
+};
+const pgIntervalDescriptor = new PgIntervalDescriptor();
+const pgIntervalColumn = (params = {}) => column(pgIntervalDescriptor.factory(params), pgIntervalDescriptor.codecId, params, "interval");
+const enumParamsSchema = type({ "values?": "string[]" });
+var PgEnumCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgEnumDescriptor = class extends CodecDescriptorImpl {
+	codecId = PG_ENUM_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = ["enum"];
+	paramsSchema = enumParamsSchema;
+	renderOutputType(params) {
+		return pgEnumRenderOutputType(params);
+	}
+	factory(_params) {
+		return () => new PgEnumCodec(this);
+	}
+};
+const pgEnumDescriptor = new PgEnumDescriptor();
+const pgEnumColumn = (params = {}) => column(pgEnumDescriptor.factory(params), pgEnumDescriptor.codecId, params, "enum");
+var PgJsonCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return pgJsonEncode(value);
+	}
+	async decode(wire, _ctx) {
+		return pgJsonDecode(wire);
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgJsonDescriptor = class extends CodecDescriptorImpl {
+	codecId = PG_JSON_CODEC_ID;
+	traits = [];
+	targetTypes = ["json"];
+	meta = PG_JSON_META;
+	paramsSchema = voidParamsSchema;
+	factory() {
+		return () => new PgJsonCodec(this);
+	}
+};
+const pgJsonDescriptor = new PgJsonDescriptor();
+const pgJsonColumn = () => column(pgJsonDescriptor.factory(), pgJsonDescriptor.codecId, void 0, "json");
+var PgJsonbCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return pgJsonbEncode(value);
+	}
+	async decode(wire, _ctx) {
+		return pgJsonbDecode(wire);
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var PgJsonbDescriptor = class extends CodecDescriptorImpl {
+	codecId = PG_JSONB_CODEC_ID;
+	traits = ["equality"];
+	targetTypes = ["jsonb"];
+	meta = PG_JSONB_META;
+	paramsSchema = voidParamsSchema;
+	factory() {
+		return () => new PgJsonbCodec(this);
+	}
+};
+const pgJsonbDescriptor = new PgJsonbDescriptor();
+const pgJsonbColumn = () => column(pgJsonbDescriptor.factory(), pgJsonbDescriptor.codecId, void 0, "jsonb");
+const PG_CHAR_META = { db: { sql: { postgres: { nativeType: "character" } } } };
+const PG_VARCHAR_META = { db: { sql: { postgres: { nativeType: "character varying" } } } };
+const PG_INT_META = { db: { sql: { postgres: { nativeType: "integer" } } } };
+const PG_FLOAT_META = { db: { sql: { postgres: { nativeType: "double precision" } } } };
+var PgCharDescriptor = class extends CodecDescriptorImpl {
+	codecId = PG_CHAR_CODEC_ID;
+	targetTypes = ["character"];
+	meta = PG_CHAR_META;
+	traits = sqlCharDescriptor.traits;
+	paramsSchema = sqlCharDescriptor.paramsSchema;
+	renderOutputType(params) {
+		return sqlCharDescriptor.renderOutputType(params);
+	}
+	factory(_params) {
+		return () => new SqlCharCodec(this);
+	}
+};
+const pgCharDescriptor = new PgCharDescriptor();
+const pgCharColumn = (params = {}) => column(pgCharDescriptor.factory(params), pgCharDescriptor.codecId, params, "character");
+var PgVarcharDescriptor = class extends CodecDescriptorImpl {
+	codecId = PG_VARCHAR_CODEC_ID;
+	targetTypes = ["character varying"];
+	meta = PG_VARCHAR_META;
+	traits = sqlVarcharDescriptor.traits;
+	paramsSchema = sqlVarcharDescriptor.paramsSchema;
+	renderOutputType(params) {
+		return sqlVarcharDescriptor.renderOutputType(params);
+	}
+	factory(_params) {
+		return () => new SqlVarcharCodec(this);
+	}
+};
+const pgVarcharDescriptor = new PgVarcharDescriptor();
+const pgVarcharColumn = (params = {}) => column(pgVarcharDescriptor.factory(params), pgVarcharDescriptor.codecId, params, "character varying");
+var PgIntDescriptor = class extends CodecDescriptorImpl {
+	codecId = PG_INT_CODEC_ID;
+	targetTypes = ["int4"];
+	meta = PG_INT_META;
+	traits = sqlIntDescriptor.traits;
+	paramsSchema = sqlIntDescriptor.paramsSchema;
+	factory() {
+		return () => new SqlIntCodec(this);
+	}
+};
+const pgIntDescriptor = new PgIntDescriptor();
+const pgIntColumn = () => column(pgIntDescriptor.factory(), pgIntDescriptor.codecId, void 0, "int4");
+var PgFloatDescriptor = class extends CodecDescriptorImpl {
+	codecId = PG_FLOAT_CODEC_ID;
+	targetTypes = ["float8"];
+	meta = PG_FLOAT_META;
+	traits = sqlFloatDescriptor.traits;
+	paramsSchema = sqlFloatDescriptor.paramsSchema;
+	factory() {
+		return () => new SqlFloatCodec(this);
+	}
+};
+const pgFloatDescriptor = new PgFloatDescriptor();
+const pgFloatColumn = () => column(pgFloatDescriptor.factory(), pgFloatDescriptor.codecId, void 0, "float8");
+const codecDescriptors = [
+	sqlCharDescriptor,
+	sqlVarcharDescriptor,
+	sqlIntDescriptor,
+	sqlFloatDescriptor,
+	sqlTextDescriptor,
+	sqlTimestampDescriptor,
+	pgTextDescriptor,
+	pgCharDescriptor,
+	pgVarcharDescriptor,
+	pgIntDescriptor,
+	pgFloatDescriptor,
+	pgInt4Descriptor,
+	pgInt2Descriptor,
+	pgInt8Descriptor,
+	pgFloat4Descriptor,
+	pgFloat8Descriptor,
+	pgNumericDescriptor,
+	pgTimestampDescriptor,
+	pgTimestamptzDescriptor,
+	pgTimeDescriptor,
+	pgTimetzDescriptor,
+	pgBoolDescriptor,
+	pgBitDescriptor,
+	pgVarbitDescriptor,
+	pgByteaDescriptor,
+	pgIntervalDescriptor,
+	pgEnumDescriptor,
+	pgJsonDescriptor,
+	pgJsonbDescriptor
+];
+
+//#endregion
+//#region src/core/registry.ts
+/**
+* Registry of every codec descriptor shipped by `@prisma-next/target-postgres`.
+*
+* Public consumer surface for the postgres codec set: the postgres adapter and any other consumer that needs to enumerate or look up a postgres codec by id consumes this rather than the raw descriptor array. See ADR 208.
+*/
+const postgresCodecRegistry = buildCodecDescriptorRegistry(codecDescriptors);
+
+//#endregion
+export { pgBitColumn, pgBoolColumn, pgCharColumn, pgEnumColumn, pgFloat4Column, pgFloat8Column, pgFloatColumn, pgInt2Column, pgInt4Column, pgInt8Column, pgIntColumn, pgIntervalColumn, pgJsonColumn, pgJsonbColumn, pgNumericColumn, pgTextColumn, pgTimeColumn, pgTimestampColumn, pgTimestamptzColumn, pgTimetzColumn, pgVarbitColumn, pgVarcharColumn, postgresCodecRegistry };
+//# sourceMappingURL=codecs.mjs.map