@prisma-next/adapter-postgres 0.3.0-dev.33 → 0.3.0-dev.36

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

@@ -0,0 +1 @@
+{"version":3,"file":"codec-types.d.mts","names":[],"sources":["../src/core/codecs.ts","../src/exports/codec-types.ts"],"sourcesContent":[],"mappings":";;;;;KAqFY,SAAA;0BAKkB;aACjB;cA8WP,8CAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8BC;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAGD,YAAA,UAAoB,MAAA,CAAO;;;;;;;;;;;;KCtdlC,kBAAA;;;;;;;KAQA,iCAAiC;;;;;;;;;;+BAO5B,qBAEF,YACJ;KAEQ,UAAA,GAAa;wBACD;;wBACyC;eACnD,MACL,4BAA4B;;yBAEZ;;wBACwC;eACnD,MACL,4BAA4B;;;KAOhC,yBAAyB,2BAA2B,2BAClC,QAAQ,MAAM;KAGhC,4BAA4B,2BAA2B,gBAAgB;KAEhE,yBAAyB;gBAA8B;;KACvD,4BAA4B;mBAAiC;;KAC7D,sEAAsE;sBAC5D;kBACJ;;KAEN,wBAAwB;eAA6B;CDqYrD,CAAA;AA8BC,KClaD,MDka6B,CAAA,UAAA,MAAA,CAAA,GClaF,aDkaE,CAAA;EAG7B,cAAA,ECra2D,CDqajD;;KCpaV,sDAAsD;wBAC1C;AA9DsD,CAAA,CAAA;AAmBzE,KA6CO,WA7CP,CAAA,UAA2B,MAAA,GAAA,SAAA,GAAA,SAAA,CAAA,GA6CoC,aA7CpC,CAAA;EAAM,sBAAA,EA8CZ,CA9CY;CAO5B,CAAA;AAEF,KAuCI,IAvCJ,CAAA,UAAA,MAAA,GAAA,SAAA,GAAA,SAAA,CAAA,GAuCqD,aAvCrD,CAAA;EACJ,eAAA,EAsC0F,CAtC1F;CAAS,CAAA;AAED,KAqCA,MArCU,CAAA,UAAA,MAAA,GAAA,SAAA,GAAA,SAAA,CAAA,GAqCyC,aArCzC,CAAA;EAAG,iBAAA,EAsCJ,CAtCI;CACD,CAAA;AACyC,KAsCrD,QAtCqD,CAAA,UAAA,MAAA,GAAA,SAAA,GAAA,SAAA,CAAA,GAsCA,aAtCA,CAAA;EACnD,mBAAA,EAsCS,CAtCT;CACuB,CAAA"}

package/dist/codec-types.mjs

@@ -0,0 +1,3 @@
+import { n as dataTypes } from "./codecs-DcC1nPzh.mjs";
+
+export { dataTypes };

package/dist/codecs-DcC1nPzh.mjs

@@ -0,0 +1,206 @@
+import { S as PG_VARCHAR_CODEC_ID, _ as PG_TIMESTAMPTZ_CODEC_ID, a as PG_FLOAT4_CODEC_ID, b as PG_TIME_CODEC_ID, c as PG_INT2_CODEC_ID, d as PG_INTERVAL_CODEC_ID, f as PG_INT_CODEC_ID, g as PG_TEXT_CODEC_ID, h as PG_NUMERIC_CODEC_ID, i as PG_ENUM_CODEC_ID, l as PG_INT4_CODEC_ID, m as PG_JSON_CODEC_ID, n as PG_BOOL_CODEC_ID, o as PG_FLOAT8_CODEC_ID, p as PG_JSONB_CODEC_ID, r as PG_CHAR_CODEC_ID, s as PG_FLOAT_CODEC_ID, t as PG_BIT_CODEC_ID, u as PG_INT8_CODEC_ID, v as PG_TIMESTAMP_CODEC_ID, x as PG_VARBIT_CODEC_ID, y as PG_TIMETZ_CODEC_ID } from "./codec-ids-Bsm9c7ns.mjs";
+import { codec, defineCodecs, sqlCodecDefinitions } from "@prisma-next/sql-relational-core/ast";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { type } from "arktype";
+
+//#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" });
+function aliasCodec(base, options) {
+	return {
+		id: options.typeId,
+		targetTypes: options.targetTypes,
+		...ifDefined("meta", options.meta),
+		...ifDefined("paramsSchema", base.paramsSchema),
+		...ifDefined("init", base.init),
+		...ifDefined("encode", base.encode),
+		decode: base.decode
+	};
+}
+const sqlCharCodec = sqlCodecDefinitions.char.codec;
+const sqlVarcharCodec = sqlCodecDefinitions.varchar.codec;
+const sqlIntCodec = sqlCodecDefinitions.int.codec;
+const sqlFloatCodec = sqlCodecDefinitions.float.codec;
+const pgTextCodec = codec({
+	typeId: PG_TEXT_CODEC_ID,
+	targetTypes: ["text"],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	meta: { db: { sql: { postgres: { nativeType: "text" } } } }
+});
+const pgCharCodec = aliasCodec(sqlCharCodec, {
+	typeId: PG_CHAR_CODEC_ID,
+	targetTypes: ["character"],
+	meta: { db: { sql: { postgres: { nativeType: "character" } } } }
+});
+const pgVarcharCodec = aliasCodec(sqlVarcharCodec, {
+	typeId: PG_VARCHAR_CODEC_ID,
+	targetTypes: ["character varying"],
+	meta: { db: { sql: { postgres: { nativeType: "character varying" } } } }
+});
+const pgIntCodec = aliasCodec(sqlIntCodec, {
+	typeId: PG_INT_CODEC_ID,
+	targetTypes: ["int4"],
+	meta: { db: { sql: { postgres: { nativeType: "integer" } } } }
+});
+const pgFloatCodec = aliasCodec(sqlFloatCodec, {
+	typeId: PG_FLOAT_CODEC_ID,
+	targetTypes: ["float8"],
+	meta: { db: { sql: { postgres: { nativeType: "double precision" } } } }
+});
+const pgInt4Codec = codec({
+	typeId: PG_INT4_CODEC_ID,
+	targetTypes: ["int4"],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	meta: { db: { sql: { postgres: { nativeType: "integer" } } } }
+});
+const pgNumericCodec = codec({
+	typeId: PG_NUMERIC_CODEC_ID,
+	targetTypes: ["numeric", "decimal"],
+	encode: (value) => value,
+	decode: (wire) => {
+		if (typeof wire === "number") return String(wire);
+		return wire;
+	},
+	paramsSchema: numericParamsSchema,
+	meta: { db: { sql: { postgres: { nativeType: "numeric" } } } }
+});
+const pgInt2Codec = codec({
+	typeId: PG_INT2_CODEC_ID,
+	targetTypes: ["int2"],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	meta: { db: { sql: { postgres: { nativeType: "smallint" } } } }
+});
+const pgInt8Codec = codec({
+	typeId: PG_INT8_CODEC_ID,
+	targetTypes: ["int8"],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	meta: { db: { sql: { postgres: { nativeType: "bigint" } } } }
+});
+const pgFloat4Codec = codec({
+	typeId: PG_FLOAT4_CODEC_ID,
+	targetTypes: ["float4"],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	meta: { db: { sql: { postgres: { nativeType: "real" } } } }
+});
+const pgFloat8Codec = codec({
+	typeId: PG_FLOAT8_CODEC_ID,
+	targetTypes: ["float8"],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	meta: { db: { sql: { postgres: { nativeType: "double precision" } } } }
+});
+const pgTimestampCodec = codec({
+	typeId: PG_TIMESTAMP_CODEC_ID,
+	targetTypes: ["timestamp"],
+	encode: (value) => {
+		if (value instanceof Date) return value.toISOString();
+		if (typeof value === "string") return value;
+		return String(value);
+	},
+	decode: (wire) => {
+		if (typeof wire === "string") return wire;
+		if (wire instanceof Date) return wire.toISOString();
+		return String(wire);
+	},
+	paramsSchema: precisionParamsSchema,
+	meta: { db: { sql: { postgres: { nativeType: "timestamp without time zone" } } } }
+});
+const pgTimestamptzCodec = codec({
+	typeId: PG_TIMESTAMPTZ_CODEC_ID,
+	targetTypes: ["timestamptz"],
+	encode: (value) => {
+		if (value instanceof Date) return value.toISOString();
+		if (typeof value === "string") return value;
+		return String(value);
+	},
+	decode: (wire) => {
+		if (typeof wire === "string") return wire;
+		if (wire instanceof Date) return wire.toISOString();
+		return String(wire);
+	},
+	paramsSchema: precisionParamsSchema,
+	meta: { db: { sql: { postgres: { nativeType: "timestamp with time zone" } } } }
+});
+const pgTimeCodec = codec({
+	typeId: PG_TIME_CODEC_ID,
+	targetTypes: ["time"],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	paramsSchema: precisionParamsSchema,
+	meta: { db: { sql: { postgres: { nativeType: "time" } } } }
+});
+const pgTimetzCodec = codec({
+	typeId: PG_TIMETZ_CODEC_ID,
+	targetTypes: ["timetz"],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	paramsSchema: precisionParamsSchema,
+	meta: { db: { sql: { postgres: { nativeType: "timetz" } } } }
+});
+const pgBoolCodec = codec({
+	typeId: PG_BOOL_CODEC_ID,
+	targetTypes: ["bool"],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	meta: { db: { sql: { postgres: { nativeType: "boolean" } } } }
+});
+const pgBitCodec = codec({
+	typeId: PG_BIT_CODEC_ID,
+	targetTypes: ["bit"],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	paramsSchema: lengthParamsSchema,
+	meta: { db: { sql: { postgres: { nativeType: "bit" } } } }
+});
+const pgVarbitCodec = codec({
+	typeId: PG_VARBIT_CODEC_ID,
+	targetTypes: ["bit varying"],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	paramsSchema: lengthParamsSchema,
+	meta: { db: { sql: { postgres: { nativeType: "bit varying" } } } }
+});
+const pgEnumCodec = codec({
+	typeId: PG_ENUM_CODEC_ID,
+	targetTypes: ["enum"],
+	encode: (value) => value,
+	decode: (wire) => wire
+});
+const pgIntervalCodec = codec({
+	typeId: PG_INTERVAL_CODEC_ID,
+	targetTypes: ["interval"],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	paramsSchema: precisionParamsSchema,
+	meta: { db: { sql: { postgres: { nativeType: "interval" } } } }
+});
+const pgJsonCodec = codec({
+	typeId: PG_JSON_CODEC_ID,
+	targetTypes: ["json"],
+	encode: (value) => JSON.stringify(value),
+	decode: (wire) => typeof wire === "string" ? JSON.parse(wire) : wire,
+	meta: { db: { sql: { postgres: { nativeType: "json" } } } }
+});
+const pgJsonbCodec = codec({
+	typeId: PG_JSONB_CODEC_ID,
+	targetTypes: ["jsonb"],
+	encode: (value) => JSON.stringify(value),
+	decode: (wire) => typeof wire === "string" ? JSON.parse(wire) : wire,
+	meta: { db: { sql: { postgres: { nativeType: "jsonb" } } } }
+});
+const codecs = defineCodecs().add("char", sqlCharCodec).add("varchar", sqlVarcharCodec).add("int", sqlIntCodec).add("float", sqlFloatCodec).add("text", pgTextCodec).add("character", pgCharCodec).add("character varying", pgVarcharCodec).add("integer", pgIntCodec).add("double precision", pgFloatCodec).add("int4", pgInt4Codec).add("int2", pgInt2Codec).add("int8", pgInt8Codec).add("float4", pgFloat4Codec).add("float8", pgFloat8Codec).add("numeric", pgNumericCodec).add("timestamp", pgTimestampCodec).add("timestamptz", pgTimestamptzCodec).add("time", pgTimeCodec).add("timetz", pgTimetzCodec).add("bool", pgBoolCodec).add("bit", pgBitCodec).add("bit varying", pgVarbitCodec).add("interval", pgIntervalCodec).add("enum", pgEnumCodec).add("json", pgJsonCodec).add("jsonb", pgJsonbCodec);
+const codecDefinitions = codecs.codecDefinitions;
+const dataTypes = codecs.dataTypes;
+
+//#endregion
+export { dataTypes as n, codecDefinitions as t };
+//# sourceMappingURL=codecs-DcC1nPzh.mjs.map

package/dist/codecs-DcC1nPzh.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codecs-DcC1nPzh.mjs","names":["arktype"],"sources":["../src/core/codecs.ts"],"sourcesContent":["/**\n * Unified codec definitions for Postgres adapter.\n *\n * This file contains a single source of truth for all codec information:\n * - Scalar names\n * - Type IDs\n * - Codec implementations (runtime)\n * - Type information (compile-time)\n *\n * This structure is used both at runtime (to populate the registry) and\n * at compile time (to derive CodecTypes).\n */\n\nimport type { Codec, CodecMeta } from '@prisma-next/sql-relational-core/ast';\nimport { codec, defineCodecs, sqlCodecDefinitions } from '@prisma-next/sql-relational-core/ast';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { type as arktype } from 'arktype';\nimport {\n  PG_BIT_CODEC_ID,\n  PG_BOOL_CODEC_ID,\n  PG_CHAR_CODEC_ID,\n  PG_ENUM_CODEC_ID,\n  PG_FLOAT_CODEC_ID,\n  PG_FLOAT4_CODEC_ID,\n  PG_FLOAT8_CODEC_ID,\n  PG_INT_CODEC_ID,\n  PG_INT2_CODEC_ID,\n  PG_INT4_CODEC_ID,\n  PG_INT8_CODEC_ID,\n  PG_INTERVAL_CODEC_ID,\n  PG_JSON_CODEC_ID,\n  PG_JSONB_CODEC_ID,\n  PG_NUMERIC_CODEC_ID,\n  PG_TEXT_CODEC_ID,\n  PG_TIME_CODEC_ID,\n  PG_TIMESTAMP_CODEC_ID,\n  PG_TIMESTAMPTZ_CODEC_ID,\n  PG_TIMETZ_CODEC_ID,\n  PG_VARBIT_CODEC_ID,\n  PG_VARCHAR_CODEC_ID,\n} from './codec-ids';\n\nconst lengthParamsSchema = arktype({\n  length: 'number.integer > 0',\n});\n\nconst numericParamsSchema = arktype({\n  precision: 'number.integer > 0 & number.integer <= 1000',\n  'scale?': 'number.integer >= 0',\n});\n\nconst precisionParamsSchema = arktype({\n  'precision?': 'number.integer >= 0 & number.integer <= 6',\n});\n\nfunction aliasCodec<\n  Id extends string,\n  TWire,\n  TJs,\n  TParams = Record<string, unknown>,\n  THelper = unknown,\n>(\n  base: Codec<string, TWire, TJs, TParams, THelper>,\n  options: {\n    readonly typeId: Id;\n    readonly targetTypes: readonly string[];\n    readonly meta?: CodecMeta;\n  },\n): Codec<Id, TWire, TJs, TParams, THelper> {\n  return {\n    id: options.typeId,\n    targetTypes: options.targetTypes,\n    ...ifDefined('meta', options.meta),\n    ...ifDefined('paramsSchema', base.paramsSchema),\n    ...ifDefined('init', base.init),\n    ...ifDefined('encode', base.encode),\n    decode: base.decode,\n  };\n}\n\nconst sqlCharCodec = sqlCodecDefinitions.char.codec;\nconst sqlVarcharCodec = sqlCodecDefinitions.varchar.codec;\nconst sqlIntCodec = sqlCodecDefinitions.int.codec;\nconst sqlFloatCodec = sqlCodecDefinitions.float.codec;\n\nexport type JsonValue =\n  | string\n  | number\n  | boolean\n  | null\n  | { readonly [key: string]: JsonValue }\n  | readonly JsonValue[];\n\n// Create individual codec instances\nconst pgTextCodec = codec({\n  typeId: PG_TEXT_CODEC_ID,\n  targetTypes: ['text'],\n  encode: (value: string): string => value,\n  decode: (wire: string): string => wire,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'text',\n        },\n      },\n    },\n  },\n});\n\nconst pgCharCodec = aliasCodec(sqlCharCodec, {\n  typeId: PG_CHAR_CODEC_ID,\n  targetTypes: ['character'],\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'character',\n        },\n      },\n    },\n  },\n});\n\nconst pgVarcharCodec = aliasCodec(sqlVarcharCodec, {\n  typeId: PG_VARCHAR_CODEC_ID,\n  targetTypes: ['character varying'],\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'character varying',\n        },\n      },\n    },\n  },\n});\n\nconst pgIntCodec = aliasCodec(sqlIntCodec, {\n  typeId: PG_INT_CODEC_ID,\n  targetTypes: ['int4'],\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'integer',\n        },\n      },\n    },\n  },\n});\n\nconst pgFloatCodec = aliasCodec(sqlFloatCodec, {\n  typeId: PG_FLOAT_CODEC_ID,\n  targetTypes: ['float8'],\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'double precision',\n        },\n      },\n    },\n  },\n});\n\nconst pgInt4Codec = codec<typeof PG_INT4_CODEC_ID, number, number>({\n  typeId: PG_INT4_CODEC_ID,\n  targetTypes: ['int4'],\n  encode: (value) => value,\n  decode: (wire) => wire,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'integer',\n        },\n      },\n    },\n  },\n});\n\nconst pgNumericCodec = codec<typeof PG_NUMERIC_CODEC_ID, string, string>({\n  typeId: PG_NUMERIC_CODEC_ID,\n  targetTypes: ['numeric', 'decimal'],\n  encode: (value: string): string => value,\n  decode: (wire: string | number): string => {\n    if (typeof wire === 'number') return String(wire);\n    return wire;\n  },\n  paramsSchema: numericParamsSchema,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'numeric',\n        },\n      },\n    },\n  },\n});\n\nconst pgInt2Codec = codec<typeof PG_INT2_CODEC_ID, number, number>({\n  typeId: PG_INT2_CODEC_ID,\n  targetTypes: ['int2'],\n  encode: (value) => value,\n  decode: (wire) => wire,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'smallint',\n        },\n      },\n    },\n  },\n});\n\nconst pgInt8Codec = codec<typeof PG_INT8_CODEC_ID, number, number>({\n  typeId: PG_INT8_CODEC_ID,\n  targetTypes: ['int8'],\n  encode: (value) => value,\n  decode: (wire) => wire,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'bigint',\n        },\n      },\n    },\n  },\n});\n\nconst pgFloat4Codec = codec<typeof PG_FLOAT4_CODEC_ID, number, number>({\n  typeId: PG_FLOAT4_CODEC_ID,\n  targetTypes: ['float4'],\n  encode: (value) => value,\n  decode: (wire) => wire,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'real',\n        },\n      },\n    },\n  },\n});\n\nconst pgFloat8Codec = codec<typeof PG_FLOAT8_CODEC_ID, number, number>({\n  typeId: PG_FLOAT8_CODEC_ID,\n  targetTypes: ['float8'],\n  encode: (value) => value,\n  decode: (wire) => wire,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'double precision',\n        },\n      },\n    },\n  },\n});\n\nconst pgTimestampCodec = codec<typeof PG_TIMESTAMP_CODEC_ID, string | Date, string>({\n  typeId: PG_TIMESTAMP_CODEC_ID,\n  targetTypes: ['timestamp'],\n  encode: (value: string | Date): string => {\n    if (value instanceof Date) return value.toISOString();\n    if (typeof value === 'string') return value;\n    return String(value);\n  },\n  decode: (wire: string | Date): string => {\n    if (typeof wire === 'string') return wire;\n    if (wire instanceof Date) return wire.toISOString();\n    return String(wire);\n  },\n  paramsSchema: precisionParamsSchema,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'timestamp without time zone',\n        },\n      },\n    },\n  },\n});\n\nconst pgTimestamptzCodec = codec<typeof PG_TIMESTAMPTZ_CODEC_ID, string | Date, string>({\n  typeId: PG_TIMESTAMPTZ_CODEC_ID,\n  targetTypes: ['timestamptz'],\n  encode: (value: string | Date): string => {\n    if (value instanceof Date) return value.toISOString();\n    if (typeof value === 'string') return value;\n    return String(value);\n  },\n  decode: (wire: string | Date): string => {\n    if (typeof wire === 'string') return wire;\n    if (wire instanceof Date) return wire.toISOString();\n    return String(wire);\n  },\n  paramsSchema: precisionParamsSchema,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'timestamp with time zone',\n        },\n      },\n    },\n  },\n});\n\nconst pgTimeCodec = codec<typeof PG_TIME_CODEC_ID, string, string>({\n  typeId: PG_TIME_CODEC_ID,\n  targetTypes: ['time'],\n  encode: (value: string): string => value,\n  decode: (wire: string): string => wire,\n  paramsSchema: precisionParamsSchema,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'time',\n        },\n      },\n    },\n  },\n});\n\nconst pgTimetzCodec = codec<typeof PG_TIMETZ_CODEC_ID, string, string>({\n  typeId: PG_TIMETZ_CODEC_ID,\n  targetTypes: ['timetz'],\n  encode: (value: string): string => value,\n  decode: (wire: string): string => wire,\n  paramsSchema: precisionParamsSchema,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'timetz',\n        },\n      },\n    },\n  },\n});\n\nconst pgBoolCodec = codec<typeof PG_BOOL_CODEC_ID, boolean, boolean>({\n  typeId: PG_BOOL_CODEC_ID,\n  targetTypes: ['bool'],\n  encode: (value) => value,\n  decode: (wire) => wire,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'boolean',\n        },\n      },\n    },\n  },\n});\n\nconst pgBitCodec = codec<typeof PG_BIT_CODEC_ID, string, string>({\n  typeId: PG_BIT_CODEC_ID,\n  targetTypes: ['bit'],\n  encode: (value: string): string => value,\n  decode: (wire: string): string => wire,\n  paramsSchema: lengthParamsSchema,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'bit',\n        },\n      },\n    },\n  },\n});\n\nconst pgVarbitCodec = codec<typeof PG_VARBIT_CODEC_ID, string, string>({\n  typeId: PG_VARBIT_CODEC_ID,\n  targetTypes: ['bit varying'],\n  encode: (value: string): string => value,\n  decode: (wire: string): string => wire,\n  paramsSchema: lengthParamsSchema,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'bit varying',\n        },\n      },\n    },\n  },\n});\n\nconst pgEnumCodec = codec<typeof PG_ENUM_CODEC_ID, string, string>({\n  typeId: PG_ENUM_CODEC_ID,\n  targetTypes: ['enum'],\n  encode: (value) => value,\n  decode: (wire) => wire,\n});\n\nconst pgIntervalCodec = codec<typeof PG_INTERVAL_CODEC_ID, string, string>({\n  typeId: PG_INTERVAL_CODEC_ID,\n  targetTypes: ['interval'],\n  encode: (value: string): string => value,\n  decode: (wire: string): string => wire,\n  paramsSchema: precisionParamsSchema,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'interval',\n        },\n      },\n    },\n  },\n});\n\nconst pgJsonCodec = codec<typeof PG_JSON_CODEC_ID, string | JsonValue, JsonValue>({\n  typeId: PG_JSON_CODEC_ID,\n  targetTypes: ['json'],\n  encode: (value) => JSON.stringify(value),\n  decode: (wire) => (typeof wire === 'string' ? JSON.parse(wire) : wire),\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'json',\n        },\n      },\n    },\n  },\n});\n\nconst pgJsonbCodec = codec<typeof PG_JSONB_CODEC_ID, string | JsonValue, JsonValue>({\n  typeId: PG_JSONB_CODEC_ID,\n  targetTypes: ['jsonb'],\n  encode: (value) => JSON.stringify(value),\n  decode: (wire) => (typeof wire === 'string' ? JSON.parse(wire) : wire),\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'jsonb',\n        },\n      },\n    },\n  },\n});\n\n// Build codec definitions using the builder DSL\nconst codecs = defineCodecs()\n  .add('char', sqlCharCodec)\n  .add('varchar', sqlVarcharCodec)\n  .add('int', sqlIntCodec)\n  .add('float', sqlFloatCodec)\n  .add('text', pgTextCodec)\n  .add('character', pgCharCodec)\n  .add('character varying', pgVarcharCodec)\n  .add('integer', pgIntCodec)\n  .add('double precision', pgFloatCodec)\n  .add('int4', pgInt4Codec)\n  .add('int2', pgInt2Codec)\n  .add('int8', pgInt8Codec)\n  .add('float4', pgFloat4Codec)\n  .add('float8', pgFloat8Codec)\n  .add('numeric', pgNumericCodec)\n  .add('timestamp', pgTimestampCodec)\n  .add('timestamptz', pgTimestamptzCodec)\n  .add('time', pgTimeCodec)\n  .add('timetz', pgTimetzCodec)\n  .add('bool', pgBoolCodec)\n  .add('bit', pgBitCodec)\n  .add('bit varying', pgVarbitCodec)\n  .add('interval', pgIntervalCodec)\n  .add('enum', pgEnumCodec)\n  .add('json', pgJsonCodec)\n  .add('jsonb', pgJsonbCodec);\n\n// Export derived structures directly from codecs builder\nexport const codecDefinitions = codecs.codecDefinitions;\nexport const dataTypes = codecs.dataTypes;\n\n// Export types derived from codecs builder\nexport type CodecTypes = typeof codecs.CodecTypes;\n"],"mappings":"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"}

package/dist/column-types.d.mts

@@ -0,0 +1,110 @@
+import { StorageTypeInstance } from "@prisma-next/sql-contract/types";
+import { ColumnTypeDescriptor } from "@prisma-next/contract-authoring";
+
+//#region src/core/standard-schema.d.ts
+type StandardSchemaJsonSchemaField = {
+  readonly output?: unknown;
+};
+/**
+ * Runtime view of the Standard Schema protocol.
+ * Reads `~standard.jsonSchema.output` for the serializable JSON Schema representation,
+ * and `.expression` for an optional TypeScript type expression string (Arktype-specific).
+ *
+ * This differs from the compile-time `StandardSchemaLike` in `codec-types.ts`, which reads
+ * `~standard.types.output` for TypeScript type narrowing in contract.d.ts.
+ */
+type StandardSchemaLike = {
+  readonly '~standard'?: {
+    readonly version?: number;
+    readonly jsonSchema?: StandardSchemaJsonSchemaField;
+  };
+  readonly expression?: unknown;
+};
+//#endregion
+//#region src/exports/column-types.d.ts
+declare const textColumn: ColumnTypeDescriptor;
+declare function charColumn(length: number): ColumnTypeDescriptor & {
+  readonly typeParams: {
+    readonly length: number;
+  };
+};
+declare function varcharColumn(length: number): ColumnTypeDescriptor & {
+  readonly typeParams: {
+    readonly length: number;
+  };
+};
+declare const int4Column: ColumnTypeDescriptor;
+declare const int2Column: ColumnTypeDescriptor;
+declare const int8Column: ColumnTypeDescriptor;
+declare const float4Column: ColumnTypeDescriptor;
+declare const float8Column: ColumnTypeDescriptor;
+declare function numericColumn(precision: number, scale?: number): ColumnTypeDescriptor & {
+  readonly typeParams: {
+    readonly precision: number;
+    readonly scale?: number;
+  };
+};
+declare const timestampColumn: ColumnTypeDescriptor;
+declare const timestamptzColumn: ColumnTypeDescriptor;
+declare function timeColumn(precision?: number): ColumnTypeDescriptor & {
+  readonly typeParams?: {
+    readonly precision: number;
+  };
+};
+declare function timetzColumn(precision?: number): ColumnTypeDescriptor & {
+  readonly typeParams?: {
+    readonly precision: number;
+  };
+};
+declare const boolColumn: ColumnTypeDescriptor;
+declare function bitColumn(length: number): ColumnTypeDescriptor & {
+  readonly typeParams: {
+    readonly length: number;
+  };
+};
+declare function varbitColumn(length: number): ColumnTypeDescriptor & {
+  readonly typeParams: {
+    readonly length: number;
+  };
+};
+declare function intervalColumn(precision?: number): ColumnTypeDescriptor & {
+  readonly typeParams?: {
+    readonly precision: number;
+  };
+};
+declare const jsonColumn: ColumnTypeDescriptor;
+declare const jsonbColumn: ColumnTypeDescriptor;
+type JsonSchemaTypeParams = {
+  readonly schemaJson: Record<string, unknown>;
+  readonly type?: string;
+};
+/**
+ * Typed column descriptor for JSON/JSONB columns with Standard Schema.
+ *
+ * `typeParams.schemaJson` carries the runtime JSON Schema payload (serializable record)
+ * used by the emitter to render TypeScript type expressions in contract.d.ts.
+ *
+ * `typeParams.schema` is a phantom-only key: at runtime it does not exist, but at the
+ * type level it preserves the original `TSchema` so that `ResolveStandardSchemaOutput<P>`
+ * in codec-types.ts can resolve the output type via `~standard.types.output` or `.infer`.
+ */
+type TypedColumnDescriptor<TSchema extends StandardSchemaLike> = ColumnTypeDescriptor & {
+  readonly typeParams: JsonSchemaTypeParams & {
+    readonly schema: TSchema;
+  };
+};
+declare function json(): ColumnTypeDescriptor;
+declare function json<TSchema extends StandardSchemaLike>(schema: TSchema): TypedColumnDescriptor<TSchema>;
+declare function jsonb(): ColumnTypeDescriptor;
+declare function jsonb<TSchema extends StandardSchemaLike>(schema: TSchema): TypedColumnDescriptor<TSchema>;
+declare function enumType<const Values extends readonly string[]>(name: string, values: Values): StorageTypeInstance & {
+  readonly typeParams: {
+    readonly values: Values;
+  };
+};
+declare function enumColumn<TypeName extends string>(typeName: TypeName, nativeType: string): ColumnTypeDescriptor & {
+  readonly typeRef: TypeName;
+};
+//#endregion
+export { bitColumn, boolColumn, charColumn, enumColumn, enumType, float4Column, float8Column, int2Column, int4Column, int8Column, intervalColumn, json, jsonColumn, jsonb, jsonbColumn, numericColumn, textColumn, timeColumn, timestampColumn, timestamptzColumn, timetzColumn, varbitColumn, varcharColumn };
+//# sourceMappingURL=column-types.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"column-types.d.mts","names":[],"sources":["../src/core/standard-schema.ts","../src/exports/column-types.ts"],"sourcesContent":[],"mappings":";;;;KAEK,6BAAA;;;AAFsB;AAc3B;;;;ACwBA;AAKA;AAUA;AAUa,KDjDD,kBAAA,GCiDa;EAKZ,SAAA,WAGH,CAAA,EAAA;IAEG,SAGH,OAAA,CAAA,EAAA,MAHe;IAKZ,SAAA,UAGH,CAAA,EDhEgB,6BCgEhB;EAEG,CAAA;EAKG,SAAA,UAAa,CAAA,EAAA,OAG1B;AAUH,CAAA;;;AA/Da,cAAA,UAAY,EAAA,oBAGf;AAEM,iBAAA,UAAA,CAA4B,MAAA,EAAA,MAAoB,CAAA,EAApB,oBAAoB,GAAA;EAUhD,SAAA,UAAa,EAAA;IAUhB,SAGH,MAAA,EAAA,MAHe;EAKZ,CAAA;AAKb,CAAA;AAKa,iBAzBG,aAAA,CAyBW,MAAA,EAAA,MAGjB,CAAA,EA5BqC,oBA4BrC,GAAA;EAEG,SAAA,UAGH,EAAA;IAEM,SAAA,MAAa,EAAA,MAG1B;EAUU,CAAA;AAKb,CAAA;AAKgB,cAhDH,UAgDmC,EAhDvB,oBAgD2C;AAUpD,cArDH,UAqDqC,EArDzB,oBAqD6C;AAUzD,cA1DA,UA0DY,EA1DA,oBA6Df;AAEM,cA1DH,YA0D8B,EA1DhB,oBA0DoC;AAU/C,cA/DH,YA+DiC,EA/DnB,oBA+DuC;AAUlD,iBApEA,aAAA,CAoEoC,SAAA,EAAA,MAAoB,EAAA,KAAA,CAAA,EAAA,MAAA,CAAA,EAjErE,oBAiEqE,GAAA;EAU3D,SAAA,UAGH,EAAA;IAEG,SAAA,SAGH,EAAA,MAHgB;IAKrB,SAAA,KAAA,CAAA,EAAA,MAAoB;EA6BpB,CAAA;CAAsC;AAAsB,cAxGpD,eAwGoD,EAxGnC,oBAwGmC;AAC1C,cApGV,iBAoGU,EApGS,oBAoGT;AAA0C,iBA/FjD,UAAA,CA+FiD,SAAA,CAAA,EAAA,MAAA,CAAA,EA/FjB,oBA+FiB,GAAA;EAAO,SAAA,UAAA,CAAA,EAAA;IAkCxD,SAAI,SAAI,EAAA,MAAA;EACR,CAAA;CAAqB;AAC3B,iBAzHM,YAAA,CAyHN,SAAA,CAAA,EAAA,MAAA,CAAA,EAzHwC,oBAyHxC,GAAA;EACe,SAAA,UAAA,CAAA,EAAA;IAAtB,SAAA,SAAA,EAAA,MAAA;EAAqB,CAAA;AAKxB,CAAA;AACgB,cAtHH,UAsHQ,EAtHI,oBAsHJ;AAAiB,iBAjHtB,SAAA,CAiHsB,MAAA,EAAA,MAAA,CAAA,EAjHK,oBAiHL,GAAA;EAC5B,SAAA,UAAA,EAAA;IACe,SAAA,MAAA,EAAA,MAAA;EAAtB,CAAA;CAAqB;AAKR,iBA9GA,YAAA,CA8GQ,MAAA,EAAA,MAAA,CAAA,EA9GsB,oBA8GtB,GAAA;EAEd,SAAA,UAAA,EAAA;IACP,SAAA,MAAA,EAAA,MAAA;EAAgE,CAAA;CAAM;AAQzD,iBA/GA,cAAA,CA+GU,SAAA,CAAA,EAAA,MAAA,CAAA,EA/G0B,oBA+G1B,GAAA;EACd,SAAA,UAAA,CAAA,EAAA;IAET,SAAA,SAAA,EAAA,MAAA;EAA2C,CAAA;CAAQ;cAxGzC,YAAY;cAKZ,aAAa;KAKrB,oBAAA;uBACkB;;;;;;;;;;;;;KA4BlB,sCAAsC,sBAAsB;uBAC1C;qBAA0C;;;iBAkCjD,IAAA,CAAA,GAAQ;iBACR,qBAAqB,4BAC3B,UACP,sBAAsB;iBAKT,KAAA,CAAA,GAAS;iBACT,sBAAsB,4BAC5B,UACP,sBAAsB;iBAKT,uEAEN,SACP;;qBAAgE;;;iBAQnD,8CACJ,+BAET;oBAA2C"}

package/dist/column-types.mjs

@@ -0,0 +1,180 @@
+import { C as SQL_CHAR_CODEC_ID, E as SQL_VARCHAR_CODEC_ID, _ as PG_TIMESTAMPTZ_CODEC_ID, a as PG_FLOAT4_CODEC_ID, b as PG_TIME_CODEC_ID, c as PG_INT2_CODEC_ID, d as PG_INTERVAL_CODEC_ID, g as PG_TEXT_CODEC_ID, h as PG_NUMERIC_CODEC_ID, i as PG_ENUM_CODEC_ID, l as PG_INT4_CODEC_ID, m as PG_JSON_CODEC_ID, n as PG_BOOL_CODEC_ID, o as PG_FLOAT8_CODEC_ID, p as PG_JSONB_CODEC_ID, t as PG_BIT_CODEC_ID, u as PG_INT8_CODEC_ID, v as PG_TIMESTAMP_CODEC_ID, x as PG_VARBIT_CODEC_ID, y as PG_TIMETZ_CODEC_ID } from "./codec-ids-Bsm9c7ns.mjs";
+
+//#region src/core/standard-schema.ts
+function isObjectLike(value) {
+	return (typeof value === "object" || typeof value === "function") && value !== null;
+}
+function resolveOutputJsonSchemaField(schema) {
+	const jsonSchema = schema["~standard"]?.jsonSchema;
+	if (!jsonSchema) return;
+	if (typeof jsonSchema.output === "function") return jsonSchema.output({ target: "draft-07" });
+	return jsonSchema.output;
+}
+function extractStandardSchemaOutputJsonSchema(schema) {
+	const outputSchema = resolveOutputJsonSchemaField(schema);
+	if (!isObjectLike(outputSchema)) return;
+	return outputSchema;
+}
+function extractStandardSchemaTypeExpression(schema) {
+	const expression = schema.expression;
+	if (typeof expression !== "string") return;
+	const trimmedExpression = expression.trim();
+	if (trimmedExpression.length === 0) return;
+	return trimmedExpression;
+}
+function isStandardSchemaLike(value) {
+	return isObjectLike(value) && isObjectLike(value["~standard"]);
+}
+
+//#endregion
+//#region src/exports/column-types.ts
+const textColumn = {
+	codecId: PG_TEXT_CODEC_ID,
+	nativeType: "text"
+};
+function charColumn(length) {
+	return {
+		codecId: SQL_CHAR_CODEC_ID,
+		nativeType: "character",
+		typeParams: { length }
+	};
+}
+function varcharColumn(length) {
+	return {
+		codecId: SQL_VARCHAR_CODEC_ID,
+		nativeType: "character varying",
+		typeParams: { length }
+	};
+}
+const int4Column = {
+	codecId: PG_INT4_CODEC_ID,
+	nativeType: "int4"
+};
+const int2Column = {
+	codecId: PG_INT2_CODEC_ID,
+	nativeType: "int2"
+};
+const int8Column = {
+	codecId: PG_INT8_CODEC_ID,
+	nativeType: "int8"
+};
+const float4Column = {
+	codecId: PG_FLOAT4_CODEC_ID,
+	nativeType: "float4"
+};
+const float8Column = {
+	codecId: PG_FLOAT8_CODEC_ID,
+	nativeType: "float8"
+};
+function numericColumn(precision, scale) {
+	return {
+		codecId: PG_NUMERIC_CODEC_ID,
+		nativeType: "numeric",
+		typeParams: scale === void 0 ? { precision } : {
+			precision,
+			scale
+		}
+	};
+}
+const timestampColumn = {
+	codecId: PG_TIMESTAMP_CODEC_ID,
+	nativeType: "timestamp"
+};
+const timestamptzColumn = {
+	codecId: PG_TIMESTAMPTZ_CODEC_ID,
+	nativeType: "timestamptz"
+};
+function timeColumn(precision) {
+	return {
+		codecId: PG_TIME_CODEC_ID,
+		nativeType: "time",
+		...precision === void 0 ? {} : { typeParams: { precision } }
+	};
+}
+function timetzColumn(precision) {
+	return {
+		codecId: PG_TIMETZ_CODEC_ID,
+		nativeType: "timetz",
+		...precision === void 0 ? {} : { typeParams: { precision } }
+	};
+}
+const boolColumn = {
+	codecId: PG_BOOL_CODEC_ID,
+	nativeType: "bool"
+};
+function bitColumn(length) {
+	return {
+		codecId: PG_BIT_CODEC_ID,
+		nativeType: "bit",
+		typeParams: { length }
+	};
+}
+function varbitColumn(length) {
+	return {
+		codecId: PG_VARBIT_CODEC_ID,
+		nativeType: "bit varying",
+		typeParams: { length }
+	};
+}
+function intervalColumn(precision) {
+	return {
+		codecId: PG_INTERVAL_CODEC_ID,
+		nativeType: "interval",
+		...precision === void 0 ? {} : { typeParams: { precision } }
+	};
+}
+const jsonColumn = {
+	codecId: PG_JSON_CODEC_ID,
+	nativeType: "json"
+};
+const jsonbColumn = {
+	codecId: PG_JSONB_CODEC_ID,
+	nativeType: "jsonb"
+};
+function createJsonTypeParams(schema) {
+	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, nativeType, staticDescriptor) {
+	return (schema) => {
+		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);
+function json(schema) {
+	return _json(schema);
+}
+function jsonb(schema) {
+	return _jsonb(schema);
+}
+function enumType(name, values) {
+	return {
+		codecId: PG_ENUM_CODEC_ID,
+		nativeType: name,
+		typeParams: { values }
+	};
+}
+function enumColumn(typeName, nativeType) {
+	return {
+		codecId: PG_ENUM_CODEC_ID,
+		nativeType,
+		typeRef: typeName
+	};
+}
+
+//#endregion
+export { bitColumn, boolColumn, charColumn, enumColumn, enumType, float4Column, float8Column, int2Column, int4Column, int8Column, intervalColumn, json, jsonColumn, jsonb, jsonbColumn, numericColumn, textColumn, timeColumn, timestampColumn, timestamptzColumn, timetzColumn, varbitColumn, varcharColumn };
+//# sourceMappingURL=column-types.mjs.map

package/dist/column-types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"column-types.mjs","names":["textColumn: ColumnTypeDescriptor","int4Column: ColumnTypeDescriptor","int2Column: ColumnTypeDescriptor","int8Column: ColumnTypeDescriptor","float4Column: ColumnTypeDescriptor","float8Column: ColumnTypeDescriptor","timestampColumn: ColumnTypeDescriptor","timestamptzColumn: ColumnTypeDescriptor","boolColumn: ColumnTypeDescriptor","jsonColumn: ColumnTypeDescriptor","jsonbColumn: ColumnTypeDescriptor"],"sources":["../src/core/standard-schema.ts","../src/exports/column-types.ts"],"sourcesContent":["type UnknownRecord = Record<string, unknown>;\n\ntype StandardSchemaJsonSchemaField = {\n  readonly output?: unknown;\n};\n\n/**\n * Runtime view of the Standard Schema protocol.\n * Reads `~standard.jsonSchema.output` for the serializable JSON Schema representation,\n * and `.expression` for an optional TypeScript type expression string (Arktype-specific).\n *\n * This differs from the compile-time `StandardSchemaLike` in `codec-types.ts`, which reads\n * `~standard.types.output` for TypeScript type narrowing in contract.d.ts.\n */\nexport type StandardSchemaLike = {\n  readonly '~standard'?: {\n    readonly version?: number;\n    readonly jsonSchema?: StandardSchemaJsonSchemaField;\n  };\n  readonly expression?: unknown;\n};\n\nfunction isObjectLike(value: unknown): value is UnknownRecord {\n  return (typeof value === 'object' || typeof value === 'function') && value !== null;\n}\n\nfunction resolveOutputJsonSchemaField(schema: StandardSchemaLike): unknown {\n  const jsonSchema = schema['~standard']?.jsonSchema;\n  if (!jsonSchema) {\n    return undefined;\n  }\n\n  if (typeof jsonSchema.output === 'function') {\n    return jsonSchema.output({\n      target: 'draft-07',\n    });\n  }\n\n  return jsonSchema.output;\n}\n\nexport function extractStandardSchemaOutputJsonSchema(\n  schema: StandardSchemaLike,\n): UnknownRecord | undefined {\n  const outputSchema = resolveOutputJsonSchemaField(schema);\n  if (!isObjectLike(outputSchema)) {\n    return undefined;\n  }\n\n  return outputSchema;\n}\n\nexport function extractStandardSchemaTypeExpression(\n  schema: StandardSchemaLike,\n): string | undefined {\n  const expression = schema.expression;\n  if (typeof expression !== 'string') {\n    return undefined;\n  }\n\n  const trimmedExpression = expression.trim();\n  if (trimmedExpression.length === 0) {\n    return undefined;\n  }\n\n  return trimmedExpression;\n}\n\nexport function isStandardSchemaLike(value: unknown): value is StandardSchemaLike {\n  return isObjectLike(value) && isObjectLike((value as StandardSchemaLike)['~standard']);\n}\n","/**\n * Column type descriptors for Postgres adapter.\n *\n * These descriptors provide both codecId and nativeType for use in contract authoring.\n * They are derived from the same source of truth as codec definitions and manifests.\n */\n\nimport type { ColumnTypeDescriptor } from '@prisma-next/contract-authoring';\nimport type { StorageTypeInstance } from '@prisma-next/sql-contract/types';\nimport {\n  PG_BIT_CODEC_ID,\n  PG_BOOL_CODEC_ID,\n  PG_ENUM_CODEC_ID,\n  PG_FLOAT4_CODEC_ID,\n  PG_FLOAT8_CODEC_ID,\n  PG_INT2_CODEC_ID,\n  PG_INT4_CODEC_ID,\n  PG_INT8_CODEC_ID,\n  PG_INTERVAL_CODEC_ID,\n  PG_JSON_CODEC_ID,\n  PG_JSONB_CODEC_ID,\n  PG_NUMERIC_CODEC_ID,\n  PG_TEXT_CODEC_ID,\n  PG_TIME_CODEC_ID,\n  PG_TIMESTAMP_CODEC_ID,\n  PG_TIMESTAMPTZ_CODEC_ID,\n  PG_TIMETZ_CODEC_ID,\n  PG_VARBIT_CODEC_ID,\n  SQL_CHAR_CODEC_ID,\n  SQL_VARCHAR_CODEC_ID,\n} from '../core/codec-ids';\nimport {\n  extractStandardSchemaOutputJsonSchema,\n  extractStandardSchemaTypeExpression,\n  isStandardSchemaLike,\n  type StandardSchemaLike,\n} from '../core/standard-schema';\n\nexport const textColumn: ColumnTypeDescriptor = {\n  codecId: PG_TEXT_CODEC_ID,\n  nativeType: 'text',\n} as const;\n\nexport function charColumn(length: number): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly length: number };\n} {\n  return {\n    codecId: SQL_CHAR_CODEC_ID,\n    nativeType: 'character',\n    typeParams: { length },\n  } as const;\n}\n\nexport function varcharColumn(length: number): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly length: number };\n} {\n  return {\n    codecId: SQL_VARCHAR_CODEC_ID,\n    nativeType: 'character varying',\n    typeParams: { length },\n  } as const;\n}\n\nexport const int4Column: ColumnTypeDescriptor = {\n  codecId: PG_INT4_CODEC_ID,\n  nativeType: 'int4',\n} as const;\n\nexport const int2Column: ColumnTypeDescriptor = {\n  codecId: PG_INT2_CODEC_ID,\n  nativeType: 'int2',\n} as const;\n\nexport const int8Column: ColumnTypeDescriptor = {\n  codecId: PG_INT8_CODEC_ID,\n  nativeType: 'int8',\n} as const;\n\nexport const float4Column: ColumnTypeDescriptor = {\n  codecId: PG_FLOAT4_CODEC_ID,\n  nativeType: 'float4',\n} as const;\n\nexport const float8Column: ColumnTypeDescriptor = {\n  codecId: PG_FLOAT8_CODEC_ID,\n  nativeType: 'float8',\n} as const;\n\nexport function numericColumn(\n  precision: number,\n  scale?: number,\n): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly precision: number; readonly scale?: number };\n} {\n  return {\n    codecId: PG_NUMERIC_CODEC_ID,\n    nativeType: 'numeric',\n    typeParams: scale === undefined ? { precision } : { precision, scale },\n  } as const;\n}\n\nexport const timestampColumn: ColumnTypeDescriptor = {\n  codecId: PG_TIMESTAMP_CODEC_ID,\n  nativeType: 'timestamp',\n} as const;\n\nexport const timestamptzColumn: ColumnTypeDescriptor = {\n  codecId: PG_TIMESTAMPTZ_CODEC_ID,\n  nativeType: 'timestamptz',\n} as const;\n\nexport function timeColumn(precision?: number): ColumnTypeDescriptor & {\n  readonly typeParams?: { readonly precision: number };\n} {\n  return {\n    codecId: PG_TIME_CODEC_ID,\n    nativeType: 'time',\n    ...(precision === undefined ? {} : { typeParams: { precision } }),\n  } as const;\n}\n\nexport function timetzColumn(precision?: number): ColumnTypeDescriptor & {\n  readonly typeParams?: { readonly precision: number };\n} {\n  return {\n    codecId: PG_TIMETZ_CODEC_ID,\n    nativeType: 'timetz',\n    ...(precision === undefined ? {} : { typeParams: { precision } }),\n  } as const;\n}\n\nexport const boolColumn: ColumnTypeDescriptor = {\n  codecId: PG_BOOL_CODEC_ID,\n  nativeType: 'bool',\n} as const;\n\nexport function bitColumn(length: number): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly length: number };\n} {\n  return {\n    codecId: PG_BIT_CODEC_ID,\n    nativeType: 'bit',\n    typeParams: { length },\n  } as const;\n}\n\nexport function varbitColumn(length: number): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly length: number };\n} {\n  return {\n    codecId: PG_VARBIT_CODEC_ID,\n    nativeType: 'bit varying',\n    typeParams: { length },\n  } as const;\n}\n\nexport function intervalColumn(precision?: number): ColumnTypeDescriptor & {\n  readonly typeParams?: { readonly precision: number };\n} {\n  return {\n    codecId: PG_INTERVAL_CODEC_ID,\n    nativeType: 'interval',\n    ...(precision === undefined ? {} : { typeParams: { precision } }),\n  } as const;\n}\n\nexport const jsonColumn: ColumnTypeDescriptor = {\n  codecId: PG_JSON_CODEC_ID,\n  nativeType: 'json',\n} as const;\n\nexport const jsonbColumn: ColumnTypeDescriptor = {\n  codecId: PG_JSONB_CODEC_ID,\n  nativeType: 'jsonb',\n} as const;\n\ntype JsonSchemaTypeParams = {\n  readonly schemaJson: Record<string, unknown>;\n  readonly type?: string;\n};\n\nfunction createJsonTypeParams(schema: StandardSchemaLike): JsonSchemaTypeParams {\n  const outputSchema = extractStandardSchemaOutputJsonSchema(schema);\n  if (!outputSchema) {\n    throw new Error('JSON schema must expose ~standard.jsonSchema.output()');\n  }\n\n  const expression = extractStandardSchemaTypeExpression(schema);\n  if (expression) {\n    return { schemaJson: outputSchema, type: expression };\n  }\n\n  return { schemaJson: outputSchema };\n}\n\n/**\n * Typed column descriptor for JSON/JSONB columns with Standard Schema.\n *\n * `typeParams.schemaJson` carries the runtime JSON Schema payload (serializable record)\n * used by the emitter to render TypeScript type expressions in contract.d.ts.\n *\n * `typeParams.schema` is a phantom-only key: at runtime it does not exist, but at the\n * type level it preserves the original `TSchema` so that `ResolveStandardSchemaOutput<P>`\n * in codec-types.ts can resolve the output type via `~standard.types.output` or `.infer`.\n */\ntype TypedColumnDescriptor<TSchema extends StandardSchemaLike> = ColumnTypeDescriptor & {\n  readonly typeParams: JsonSchemaTypeParams & { readonly schema: TSchema };\n};\n\nfunction createJsonColumnFactory(\n  codecId: string,\n  nativeType: string,\n  staticDescriptor: ColumnTypeDescriptor,\n) {\n  return <TSchema extends StandardSchemaLike>(schema?: TSchema): ColumnTypeDescriptor => {\n    if (!schema) {\n      return staticDescriptor;\n    }\n\n    if (!isStandardSchemaLike(schema)) {\n      throw new Error(`${nativeType}(schema) expects a Standard Schema value`);\n    }\n\n    return {\n      codecId,\n      nativeType,\n      // At runtime, typeParams only contains { schemaJson, type? }.\n      // The `schema` key exists only at the type level (phantom) so that\n      // `ResolveStandardSchemaOutput<P>` in codec-types.ts can resolve the\n      // schema's output type via `~standard.types.output` or `.infer`.\n      typeParams: createJsonTypeParams(schema) as JsonSchemaTypeParams & {\n        readonly schema: TSchema;\n      },\n    };\n  };\n}\n\nconst _json = createJsonColumnFactory(PG_JSON_CODEC_ID, 'json', jsonColumn);\nconst _jsonb = createJsonColumnFactory(PG_JSONB_CODEC_ID, 'jsonb', jsonbColumn);\n\nexport function json(): ColumnTypeDescriptor;\nexport function json<TSchema extends StandardSchemaLike>(\n  schema: TSchema,\n): TypedColumnDescriptor<TSchema>;\nexport function json<TSchema extends StandardSchemaLike>(schema?: TSchema): ColumnTypeDescriptor {\n  return _json(schema);\n}\n\nexport function jsonb(): ColumnTypeDescriptor;\nexport function jsonb<TSchema extends StandardSchemaLike>(\n  schema: TSchema,\n): TypedColumnDescriptor<TSchema>;\nexport function jsonb<TSchema extends StandardSchemaLike>(schema?: TSchema): ColumnTypeDescriptor {\n  return _jsonb(schema);\n}\n\nexport function enumType<const Values extends readonly string[]>(\n  name: string,\n  values: Values,\n): StorageTypeInstance & { readonly typeParams: { readonly values: Values } } {\n  return {\n    codecId: PG_ENUM_CODEC_ID,\n    nativeType: name,\n    typeParams: { values },\n  } as const;\n}\n\nexport function enumColumn<TypeName extends string>(\n  typeName: TypeName,\n  nativeType: string,\n): ColumnTypeDescriptor & { readonly typeRef: TypeName } {\n  return {\n    codecId: PG_ENUM_CODEC_ID,\n    nativeType,\n    typeRef: typeName,\n  };\n}\n"],"mappings":"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"}