@prisma-next/target-postgres 0.5.0-dev.4 → 0.5.0-dev.41

package/dist/codec-types.d.mts

@@ -1,4 +1,4 @@
-import { r as dataTypes, t as CodecTypes$1 } from "./codecs-D-F2KJqt.mjs";
+import { r as dataTypes, t as CodecTypes$1 } from "./codecs-CE5EUsNM.mjs";
 import { JsonValue } from "@prisma-next/contract/types";
 
 //#region src/exports/codec-types.d.ts

package/dist/codec-types.mjs

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

package/dist/{codecs-D-F2KJqt.d.mts → codecs-CE5EUsNM.d.mts}

@@ -10,9 +10,7 @@ declare const codecs: _prisma_next_sql_relational_core_ast0.CodecDefBuilder<{
   int: Codec<"sql/int@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
   float: Codec<"sql/float@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
   "sql-text": Codec<"sql/text@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
-  "sql-timestamp": Codec<"sql/timestamp@1", readonly ["equality", "order"], string, string, {
-    precision?: number;
-  }, unknown>;
+  "sql-timestamp": Codec<"sql/timestamp@1", readonly ["equality", "order"], Date, Date, Record<string, unknown>, unknown>;
   text: Codec<"pg/text@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
   character: Codec<"pg/char@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
   "character varying": Codec<"pg/varchar@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
@@ -24,8 +22,8 @@ declare const codecs: _prisma_next_sql_relational_core_ast0.CodecDefBuilder<{
   float4: Codec<"pg/float4@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
   float8: Codec<"pg/float8@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
   numeric: Codec<"pg/numeric@1", readonly ["equality", "order", "numeric"], string, string, Record<string, unknown>, unknown>;
-  timestamp: Codec<"pg/timestamp@1", readonly ["equality", "order"], string | Date, string | Date, Record<string, unknown>, unknown>;
-  timestamptz: Codec<"pg/timestamptz@1", readonly ["equality", "order"], string | Date, string | Date, Record<string, unknown>, unknown>;
+  timestamp: Codec<"pg/timestamp@1", readonly ["equality", "order"], Date, Date, Record<string, unknown>, unknown>;
+  timestamptz: Codec<"pg/timestamptz@1", readonly ["equality", "order"], Date, Date, Record<string, unknown>, unknown>;
   time: Codec<"pg/time@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
   timetz: Codec<"pg/timetz@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
   bool: Codec<"pg/bool@1", readonly ["equality", "boolean"], boolean, boolean, Record<string, unknown>, unknown>;
@@ -33,8 +31,16 @@ declare const codecs: _prisma_next_sql_relational_core_ast0.CodecDefBuilder<{
   "bit varying": Codec<"pg/varbit@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
   interval: Codec<"pg/interval@1", readonly ["equality", "order"], string | Record<string, unknown>, string, Record<string, unknown>, unknown>;
   enum: Codec<"pg/enum@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
-  json: Codec<"pg/json@1", readonly [], string, JsonValue, Record<string, unknown>, unknown>;
-} & Record<"jsonb", Codec<"pg/jsonb@1", readonly ["equality"], string, JsonValue, Record<string, unknown>, unknown>>>;
+  json: Codec<"pg/json@1", readonly [], string | number | boolean | {
+    readonly [key: string]: JsonValue;
+  } | readonly JsonValue[] | null, string | number | boolean | {
+    readonly [key: string]: JsonValue;
+  } | readonly JsonValue[] | null, Record<string, unknown>, unknown>;
+} & Record<"jsonb", Codec<"pg/jsonb@1", readonly ["equality"], string | number | boolean | {
+  readonly [key: string]: JsonValue;
+} | readonly JsonValue[] | null, string | number | boolean | {
+  readonly [key: string]: JsonValue;
+} | readonly JsonValue[] | null, Record<string, unknown>, unknown>>>;
 declare const codecDefinitions: {
   readonly char: {
     readonly typeId: "sql/char@1";
@@ -79,12 +85,10 @@ declare const codecDefinitions: {
   readonly "sql-timestamp": {
     readonly typeId: "sql/timestamp@1";
     readonly scalar: "sql-timestamp";
-    readonly codec: Codec<"sql/timestamp@1", readonly ["equality", "order"], string, string, {
-      precision?: number;
-    }, unknown>;
-    readonly input: string;
-    readonly output: string;
-    readonly jsType: string;
+    readonly codec: Codec<"sql/timestamp@1", readonly ["equality", "order"], Date, Date, Record<string, unknown>, unknown>;
+    readonly input: Date;
+    readonly output: Date;
+    readonly jsType: Date;
   };
   readonly text: {
     readonly typeId: "pg/text@1";
@@ -177,18 +181,18 @@ declare const codecDefinitions: {
   readonly timestamp: {
     readonly typeId: "pg/timestamp@1";
     readonly scalar: "timestamp";
-    readonly codec: Codec<"pg/timestamp@1", readonly ["equality", "order"], string | Date, string | Date, Record<string, unknown>, unknown>;
-    readonly input: string | Date;
-    readonly output: string | Date;
-    readonly jsType: string | Date;
+    readonly codec: Codec<"pg/timestamp@1", readonly ["equality", "order"], Date, Date, Record<string, unknown>, unknown>;
+    readonly input: Date;
+    readonly output: Date;
+    readonly jsType: Date;
   };
   readonly timestamptz: {
     readonly typeId: "pg/timestamptz@1";
     readonly scalar: "timestamptz";
-    readonly codec: Codec<"pg/timestamptz@1", readonly ["equality", "order"], string | Date, string | Date, Record<string, unknown>, unknown>;
-    readonly input: string | Date;
-    readonly output: string | Date;
-    readonly jsType: string | Date;
+    readonly codec: Codec<"pg/timestamptz@1", readonly ["equality", "order"], Date, Date, Record<string, unknown>, unknown>;
+    readonly input: Date;
+    readonly output: Date;
+    readonly jsType: Date;
   };
   readonly time: {
     readonly typeId: "pg/time@1";
@@ -249,18 +253,38 @@ declare const codecDefinitions: {
   readonly json: {
     readonly typeId: "pg/json@1";
     readonly scalar: "json";
-    readonly codec: Codec<"pg/json@1", readonly [], string, JsonValue, Record<string, unknown>, unknown>;
-    readonly input: JsonValue;
-    readonly output: JsonValue;
-    readonly jsType: JsonValue;
+    readonly codec: Codec<"pg/json@1", readonly [], string | number | boolean | {
+      readonly [key: string]: JsonValue;
+    } | readonly JsonValue[] | null, string | number | boolean | {
+      readonly [key: string]: JsonValue;
+    } | readonly JsonValue[] | null, Record<string, unknown>, unknown>;
+    readonly input: string | number | boolean | {
+      readonly [key: string]: JsonValue;
+    } | readonly JsonValue[] | null;
+    readonly output: string | number | boolean | {
+      readonly [key: string]: JsonValue;
+    } | readonly JsonValue[] | null;
+    readonly jsType: string | number | boolean | {
+      readonly [key: string]: JsonValue;
+    } | readonly JsonValue[] | null;
   };
   readonly jsonb: {
     readonly typeId: "pg/jsonb@1";
     readonly scalar: "jsonb";
-    readonly codec: Codec<"pg/jsonb@1", readonly ["equality"], string, JsonValue, Record<string, unknown>, unknown>;
-    readonly input: JsonValue;
-    readonly output: JsonValue;
-    readonly jsType: JsonValue;
+    readonly codec: Codec<"pg/jsonb@1", readonly ["equality"], string | number | boolean | {
+      readonly [key: string]: JsonValue;
+    } | readonly JsonValue[] | null, string | number | boolean | {
+      readonly [key: string]: JsonValue;
+    } | readonly JsonValue[] | null, Record<string, unknown>, unknown>;
+    readonly input: string | number | boolean | {
+      readonly [key: string]: JsonValue;
+    } | readonly JsonValue[] | null;
+    readonly output: string | number | boolean | {
+      readonly [key: string]: JsonValue;
+    } | readonly JsonValue[] | null;
+    readonly jsType: string | number | boolean | {
+      readonly [key: string]: JsonValue;
+    } | readonly JsonValue[] | null;
   };
 };
 declare const dataTypes: {
@@ -296,4 +320,4 @@ declare const dataTypes: {
 type CodecTypes = typeof codecs.CodecTypes;
 //#endregion
 export { codecDefinitions as n, dataTypes as r, CodecTypes as t };
-//# sourceMappingURL=codecs-D-F2KJqt.d.mts.map
+//# sourceMappingURL=codecs-CE5EUsNM.d.mts.map

package/dist/codecs-CE5EUsNM.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codecs-CE5EUsNM.d.mts","names":[],"sources":["../src/core/codecs.ts"],"sourcesContent":[],"mappings":";;;;;;cA2kBM,8CAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+BC;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BD,SAAA,KAAA,OAAA,CAAA,aAAA,EAAA,SAAA,CAAA,UAAA,EAAA,OAAA,EAAA,SAAA,CAAA,EAAA,MAAA,EAAA,MAAA,QAAA,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,OAAA,CAAA;IA+BC,SAAA,KAAA,EAA0C,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAC1C,SAA4B,MAAA,EAAA,QAAA;IAE7B,SAAU,KAAA,OAAA,CAAU,aAAO,EAAA,SAAU,CAAA,UAAA,EAAA,OAAA,EAAA,SAAA,CAAA,EAAA,MAAA,EAAA,MAAA,QAAA,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,OAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAFpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAED,UAAA,UAAoB,MAAA,CAAO"}

package/dist/{codecs-BoahtY_Q.mjs → codecs-dzZ_dMpK.mjs}

@@ -3,78 +3,6 @@ import { codec, defineCodecs, sqlCodecDefinitions } from "@prisma-next/sql-relat
 import { ifDefined } from "@prisma-next/utils/defined";
 import { type } from "arktype";
 
-//#region src/core/json-schema-type-expression.ts
-const MAX_DEPTH = 32;
-function isRecord(value) {
-	return typeof value === "object" && value !== null;
-}
-function escapeStringLiteral(str) {
-	return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
-}
-function quotePropertyKey(key) {
-	return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : `'${escapeStringLiteral(key)}'`;
-}
-function renderLiteral(value) {
-	if (typeof value === "string") return `'${escapeStringLiteral(value)}'`;
-	if (typeof value === "number" || typeof value === "boolean") return String(value);
-	if (value === null) return "null";
-	return "unknown";
-}
-function renderUnion(items, depth) {
-	return items.map((item) => render(item, depth)).join(" | ");
-}
-function renderObjectType(schema, depth) {
-	const properties = isRecord(schema["properties"]) ? schema["properties"] : {};
-	const required = Array.isArray(schema["required"]) ? new Set(schema["required"].filter((key) => typeof key === "string")) : /* @__PURE__ */ new Set();
-	const keys = Object.keys(properties).sort((left, right) => left.localeCompare(right));
-	if (keys.length === 0) {
-		const additionalProperties = schema["additionalProperties"];
-		if (additionalProperties === true || additionalProperties === void 0) return "Record<string, unknown>";
-		return `Record<string, ${render(additionalProperties, depth)}>`;
-	}
-	return `{ ${keys.map((key) => {
-		const valueSchema = properties[key];
-		const optionalMarker = required.has(key) ? "" : "?";
-		return `${quotePropertyKey(key)}${optionalMarker}: ${render(valueSchema, depth)}`;
-	}).join("; ")} }`;
-}
-function renderArrayType(schema, depth) {
-	if (Array.isArray(schema["items"])) return `readonly [${schema["items"].map((item) => render(item, depth)).join(", ")}]`;
-	if (schema["items"] !== void 0) {
-		const itemType = render(schema["items"], depth);
-		return itemType.includes(" | ") || itemType.includes(" & ") ? `(${itemType})[]` : `${itemType}[]`;
-	}
-	return "unknown[]";
-}
-function render(schema, depth) {
-	if (depth > MAX_DEPTH || !isRecord(schema)) return "JsonValue";
-	const nextDepth = depth + 1;
-	if ("const" in schema) return renderLiteral(schema["const"]);
-	if (Array.isArray(schema["enum"])) return schema["enum"].map((value) => renderLiteral(value)).join(" | ");
-	if (Array.isArray(schema["oneOf"])) return renderUnion(schema["oneOf"], nextDepth);
-	if (Array.isArray(schema["anyOf"])) return renderUnion(schema["anyOf"], nextDepth);
-	if (Array.isArray(schema["allOf"])) return schema["allOf"].map((item) => render(item, nextDepth)).join(" & ");
-	if (Array.isArray(schema["type"])) return schema["type"].map((item) => render({
-		...schema,
-		type: item
-	}, nextDepth)).join(" | ");
-	switch (schema["type"]) {
-		case "string": return "string";
-		case "number":
-		case "integer": return "number";
-		case "boolean": return "boolean";
-		case "null": return "null";
-		case "array": return renderArrayType(schema, nextDepth);
-		case "object": return renderObjectType(schema, nextDepth);
-		default: break;
-	}
-	return "JsonValue";
-}
-function renderTypeScriptTypeFromJsonSchema(schema) {
-	return render(schema, 0);
-}
-
-//#endregion
 //#region src/core/codecs.ts
 const lengthParamsSchema = type({ length: "number.integer > 0" });
 const numericParamsSchema = type({
@@ -94,13 +22,6 @@ function renderPrecision(typeName, typeParams) {
 	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}>`;
 }
-function renderJsonOutputType(typeParams) {
-	const typeName = typeParams["type"];
-	if (typeof typeName === "string" && typeName.trim().length > 0) return typeName.trim();
-	const schema = typeParams["schemaJson"];
-	if (schema && typeof schema === "object") return renderTypeScriptTypeFromJsonSchema(schema);
-	throw new Error(`renderOutputType: JSON codec typeParams must contain "type" (string) or "schemaJson" (object), got keys: ${Object.keys(typeParams).join(", ")}`);
-}
 function aliasCodec(base, options) {
 	return {
 		id: options.typeId,
@@ -241,16 +162,9 @@ const pgTimestampCodec = codec({
 	typeId: PG_TIMESTAMP_CODEC_ID,
 	targetTypes: ["timestamp"],
 	traits: ["equality", "order"],
-	encode: (value) => {
-		if (value instanceof Date) return value.toISOString();
-		if (typeof value === "string") return value;
-		return String(value);
-	},
-	decode: (wire) => {
-		if (wire instanceof Date) return wire.toISOString();
-		return wire;
-	},
-	encodeJson: (value) => value instanceof Date ? value.toISOString() : value,
+	encode: (value) => value,
+	decode: (wire) => wire,
+	encodeJson: (value) => value.toISOString(),
 	decodeJson: (json) => {
 		if (typeof json !== "string") throw new Error(`Expected ISO date string for pg/timestamp@1, got ${typeof json}`);
 		const date = new Date(json);
@@ -265,16 +179,9 @@ const pgTimestamptzCodec = codec({
 	typeId: PG_TIMESTAMPTZ_CODEC_ID,
 	targetTypes: ["timestamptz"],
 	traits: ["equality", "order"],
-	encode: (value) => {
-		if (value instanceof Date) return value.toISOString();
-		if (typeof value === "string") return value;
-		return String(value);
-	},
-	decode: (wire) => {
-		if (wire instanceof Date) return wire.toISOString();
-		return wire;
-	},
-	encodeJson: (value) => value instanceof Date ? value.toISOString() : value,
+	encode: (value) => value,
+	decode: (wire) => wire,
+	encodeJson: (value) => value.toISOString(),
 	decodeJson: (json) => {
 		if (typeof json !== "string") throw new Error(`Expected ISO date string for pg/timestamptz@1, got ${typeof json}`);
 		const date = new Date(json);
@@ -364,7 +271,6 @@ const pgJsonCodec = codec({
 	traits: [],
 	encode: (value) => JSON.stringify(value),
 	decode: (wire) => typeof wire === "string" ? JSON.parse(wire) : wire,
-	renderOutputType: renderJsonOutputType,
 	meta: { db: { sql: { postgres: { nativeType: "json" } } } }
 });
 const pgJsonbCodec = codec({
@@ -373,7 +279,6 @@ const pgJsonbCodec = codec({
 	traits: ["equality"],
 	encode: (value) => JSON.stringify(value),
 	decode: (wire) => typeof wire === "string" ? JSON.parse(wire) : wire,
-	renderOutputType: renderJsonOutputType,
 	meta: { db: { sql: { postgres: { nativeType: "jsonb" } } } }
 });
 const codecs = defineCodecs().add("char", sqlCharCodec).add("varchar", sqlVarcharCodec).add("int", sqlIntCodec).add("float", sqlFloatCodec).add("sql-text", sqlTextCodec).add("sql-timestamp", sqlTimestampCodec).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);
@@ -382,4 +287,4 @@ const dataTypes = codecs.dataTypes;
 
 //#endregion
 export { dataTypes as n, codecDefinitions as t };
-//# sourceMappingURL=codecs-BoahtY_Q.mjs.map
+//# sourceMappingURL=codecs-dzZ_dMpK.mjs.map

package/dist/codecs-dzZ_dMpK.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codecs-dzZ_dMpK.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 { JsonValue } from '@prisma-next/contract/types';\nimport type { Codec, CodecMeta, CodecTrait } 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 renderLength(typeName: string, typeParams: Record<string, unknown>): string | undefined {\n  const length = typeParams['length'];\n  if (length === undefined) {\n    return undefined;\n  }\n  if (typeof length !== 'number' || !Number.isFinite(length) || !Number.isInteger(length)) {\n    throw new Error(\n      `renderOutputType: expected integer \"length\" in typeParams for ${typeName}, got ${String(length)}`,\n    );\n  }\n  return `${typeName}<${length}>`;\n}\n\nfunction renderPrecision(typeName: string, typeParams: Record<string, unknown>): string {\n  const precision = typeParams['precision'];\n  if (precision === undefined) {\n    return typeName;\n  }\n  if (\n    typeof precision !== 'number' ||\n    !Number.isFinite(precision) ||\n    !Number.isInteger(precision)\n  ) {\n    throw new Error(\n      `renderOutputType: expected integer \"precision\" in typeParams for ${typeName}, got ${String(precision)}`,\n    );\n  }\n  return `${typeName}<${precision}>`;\n}\n\n// Phase C: postgres' raw json/jsonb codecs no longer carry a\n// `renderOutputType` slot — the schema-typed JSON surface that drove\n// `typeParams: { schemaJson, type? }` retired in favor of the per-library\n// extension package (`@prisma-next/extension-arktype-json`). Untyped\n// json/jsonb columns have no typeParams; the framework emit path falls\n// through to the generic `CodecTypes['pg/jsonb@1']['output']` accessor\n// (which resolves to `JsonValue` via the codec-types map).\n\nfunction aliasCodec<\n  Id extends string,\n  TTraits extends readonly CodecTrait[],\n  TWire,\n  TJs,\n  TParams,\n  THelper,\n>(\n  base: Codec<string, TTraits, TWire, TJs, TParams, THelper>,\n  options: {\n    readonly typeId: Id;\n    readonly targetTypes: readonly string[];\n    readonly meta?: CodecMeta;\n  },\n): Codec<Id, TTraits, 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    ...ifDefined('traits', base.traits),\n    ...ifDefined('renderOutputType', base.renderOutputType),\n    decode: base.decode,\n    encodeJson: base.encodeJson,\n    decodeJson: base.decodeJson,\n  } as Codec<Id, TTraits, TWire, TJs, TParams, THelper>;\n}\n\nconst sqlCharCodec = sqlCodecDefinitions.char.codec;\nconst sqlVarcharCodec = sqlCodecDefinitions.varchar.codec;\nconst sqlIntCodec = sqlCodecDefinitions.int.codec;\nconst sqlFloatCodec = sqlCodecDefinitions.float.codec;\nconst sqlTextCodec = sqlCodecDefinitions.text.codec;\nconst sqlTimestampCodec = sqlCodecDefinitions.timestamp.codec;\n\n// Create individual codec instances\nconst pgTextCodec = codec({\n  typeId: PG_TEXT_CODEC_ID,\n  targetTypes: ['text'],\n  traits: ['equality', 'order', 'textual'],\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({\n  typeId: PG_INT4_CODEC_ID,\n  targetTypes: ['int4'],\n  traits: ['equality', 'order', 'numeric'],\n  encode: (value: number): number => value,\n  decode: (wire: number): number => wire,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'integer',\n        },\n      },\n    },\n  },\n});\n\nconst pgNumericCodec = codec<\n  typeof PG_NUMERIC_CODEC_ID,\n  readonly ['equality', 'order', 'numeric'],\n  string,\n  string\n>({\n  typeId: PG_NUMERIC_CODEC_ID,\n  targetTypes: ['numeric', 'decimal'],\n  traits: ['equality', 'order', 'numeric'],\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  renderOutputType: (typeParams) => {\n    const precision = typeParams['precision'];\n    if (precision === undefined) return undefined;\n    if (\n      typeof precision !== 'number' ||\n      !Number.isFinite(precision) ||\n      !Number.isInteger(precision)\n    ) {\n      throw new Error(\n        `renderOutputType: expected integer \"precision\" in typeParams for Numeric, got ${String(precision)}`,\n      );\n    }\n    const scale = typeParams['scale'];\n    return typeof scale === 'number' ? `Numeric<${precision}, ${scale}>` : `Numeric<${precision}>`;\n  },\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'numeric',\n        },\n      },\n    },\n  },\n});\n\nconst pgInt2Codec = codec({\n  typeId: PG_INT2_CODEC_ID,\n  targetTypes: ['int2'],\n  traits: ['equality', 'order', 'numeric'],\n  encode: (value: number): number => value,\n  decode: (wire: number): number => wire,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'smallint',\n        },\n      },\n    },\n  },\n});\n\nconst pgInt8Codec = codec({\n  typeId: PG_INT8_CODEC_ID,\n  targetTypes: ['int8'],\n  traits: ['equality', 'order', 'numeric'],\n  encode: (value: number): number => value,\n  decode: (wire: number): number => wire,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'bigint',\n        },\n      },\n    },\n  },\n});\n\nconst pgFloat4Codec = codec({\n  typeId: PG_FLOAT4_CODEC_ID,\n  targetTypes: ['float4'],\n  traits: ['equality', 'order', 'numeric'],\n  encode: (value: number): number => value,\n  decode: (wire: number): number => wire,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'real',\n        },\n      },\n    },\n  },\n});\n\nconst pgFloat8Codec = codec({\n  typeId: PG_FLOAT8_CODEC_ID,\n  targetTypes: ['float8'],\n  traits: ['equality', 'order', 'numeric'],\n  encode: (value: number): number => value,\n  decode: (wire: number): number => wire,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'double precision',\n        },\n      },\n    },\n  },\n});\n\nconst pgTimestampCodec = codec<\n  typeof PG_TIMESTAMP_CODEC_ID,\n  readonly ['equality', 'order'],\n  Date,\n  Date\n>({\n  typeId: PG_TIMESTAMP_CODEC_ID,\n  targetTypes: ['timestamp'],\n  traits: ['equality', 'order'],\n  encode: (value: Date): Date => value,\n  decode: (wire: Date): Date => wire,\n  encodeJson: (value: Date) => value.toISOString(),\n  decodeJson: (json) => {\n    if (typeof json !== 'string') {\n      throw new Error(`Expected ISO date string for pg/timestamp@1, got ${typeof json}`);\n    }\n    const date = new Date(json);\n    if (Number.isNaN(date.getTime())) {\n      throw new Error(`Invalid ISO date string for pg/timestamp@1: ${json}`);\n    }\n    return date;\n  },\n  paramsSchema: precisionParamsSchema,\n  renderOutputType: (typeParams) => renderPrecision('Timestamp', typeParams),\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'timestamp without time zone',\n        },\n      },\n    },\n  },\n});\n\nconst pgTimestamptzCodec = codec<\n  typeof PG_TIMESTAMPTZ_CODEC_ID,\n  readonly ['equality', 'order'],\n  Date,\n  Date\n>({\n  typeId: PG_TIMESTAMPTZ_CODEC_ID,\n  targetTypes: ['timestamptz'],\n  traits: ['equality', 'order'],\n  encode: (value: Date): Date => value,\n  decode: (wire: Date): Date => wire,\n  encodeJson: (value: Date) => value.toISOString(),\n  decodeJson: (json) => {\n    if (typeof json !== 'string') {\n      throw new Error(`Expected ISO date string for pg/timestamptz@1, got ${typeof json}`);\n    }\n    const date = new Date(json);\n    if (Number.isNaN(date.getTime())) {\n      throw new Error(`Invalid ISO date string for pg/timestamptz@1: ${json}`);\n    }\n    return date;\n  },\n  paramsSchema: precisionParamsSchema,\n  renderOutputType: (typeParams) => renderPrecision('Timestamptz', typeParams),\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, readonly ['equality', 'order'], string, string>({\n  typeId: PG_TIME_CODEC_ID,\n  targetTypes: ['time'],\n  traits: ['equality', 'order'],\n  encode: (value: string): string => value,\n  decode: (wire: string): string => wire,\n  paramsSchema: precisionParamsSchema,\n  renderOutputType: (typeParams) => renderPrecision('Time', typeParams),\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'time',\n        },\n      },\n    },\n  },\n});\n\nconst pgTimetzCodec = codec<\n  typeof PG_TIMETZ_CODEC_ID,\n  readonly ['equality', 'order'],\n  string,\n  string\n>({\n  typeId: PG_TIMETZ_CODEC_ID,\n  targetTypes: ['timetz'],\n  traits: ['equality', 'order'],\n  encode: (value: string): string => value,\n  decode: (wire: string): string => wire,\n  paramsSchema: precisionParamsSchema,\n  renderOutputType: (typeParams) => renderPrecision('Timetz', typeParams),\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'timetz',\n        },\n      },\n    },\n  },\n});\n\nconst pgBoolCodec = codec({\n  typeId: PG_BOOL_CODEC_ID,\n  targetTypes: ['bool'],\n  traits: ['equality', 'boolean'],\n  encode: (value: boolean): boolean => value,\n  decode: (wire: boolean): boolean => 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, readonly ['equality', 'order'], string, string>({\n  typeId: PG_BIT_CODEC_ID,\n  targetTypes: ['bit'],\n  traits: ['equality', 'order'],\n  encode: (value: string): string => value,\n  decode: (wire: string): string => wire,\n  paramsSchema: lengthParamsSchema,\n  renderOutputType: (typeParams) => renderLength('Bit', typeParams),\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'bit',\n        },\n      },\n    },\n  },\n});\n\nconst pgVarbitCodec = codec<\n  typeof PG_VARBIT_CODEC_ID,\n  readonly ['equality', 'order'],\n  string,\n  string\n>({\n  typeId: PG_VARBIT_CODEC_ID,\n  targetTypes: ['bit varying'],\n  traits: ['equality', 'order'],\n  encode: (value: string): string => value,\n  decode: (wire: string): string => wire,\n  paramsSchema: lengthParamsSchema,\n  renderOutputType: (typeParams) => renderLength('VarBit', typeParams),\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'bit varying',\n        },\n      },\n    },\n  },\n});\n\nconst pgEnumCodec = codec({\n  typeId: PG_ENUM_CODEC_ID,\n  targetTypes: ['enum'],\n  traits: ['equality', 'order'],\n  encode: (value: string): string => value,\n  decode: (wire: string): string => wire,\n  renderOutputType: (typeParams) => {\n    const values = typeParams['values'];\n    if (!Array.isArray(values)) {\n      throw new Error(\n        `renderOutputType: expected array \"values\" in typeParams for enum, got ${typeof values}`,\n      );\n    }\n    return values\n      .map((value) => `'${String(value).replace(/\\\\/g, '\\\\\\\\').replace(/'/g, \"\\\\'\")}'`)\n      .join(' | ');\n  },\n});\n\nconst pgIntervalCodec = codec<\n  typeof PG_INTERVAL_CODEC_ID,\n  readonly ['equality', 'order'],\n  string | Record<string, unknown>,\n  string\n>({\n  typeId: PG_INTERVAL_CODEC_ID,\n  targetTypes: ['interval'],\n  traits: ['equality', 'order'],\n  encode: (value: string): string => value,\n  decode: (wire: string | Record<string, unknown>): string => {\n    if (typeof wire === 'string') return wire;\n    return JSON.stringify(wire);\n  },\n  paramsSchema: precisionParamsSchema,\n  renderOutputType: (typeParams) => renderPrecision('Interval', typeParams),\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'interval',\n        },\n      },\n    },\n  },\n});\n\nconst pgJsonCodec = codec({\n  typeId: PG_JSON_CODEC_ID,\n  targetTypes: ['json'],\n  traits: [],\n  encode: (value: string | JsonValue): string => JSON.stringify(value),\n  decode: (wire: string | JsonValue): JsonValue =>\n    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({\n  typeId: PG_JSONB_CODEC_ID,\n  targetTypes: ['jsonb'],\n  traits: ['equality'],\n  encode: (value: string | JsonValue): string => JSON.stringify(value),\n  decode: (wire: string | JsonValue): JsonValue =>\n    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('sql-text', sqlTextCodec)\n  .add('sql-timestamp', sqlTimestampCodec)\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\nexport type CodecTypes = typeof codecs.CodecTypes;\n"],"mappings":"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"}

package/dist/codecs.d.mts

@@ -1,2 +1,2 @@
-import { n as codecDefinitions, r as dataTypes, t as CodecTypes } from "./codecs-D-F2KJqt.mjs";
+import { n as codecDefinitions, r as dataTypes, t as CodecTypes } from "./codecs-CE5EUsNM.mjs";
 export { type CodecTypes, codecDefinitions, dataTypes };

package/dist/codecs.mjs

@@ -1,3 +1,3 @@
-import { n as dataTypes, t as codecDefinitions } from "./codecs-BoahtY_Q.mjs";
+import { n as dataTypes, t as codecDefinitions } from "./codecs-dzZ_dMpK.mjs";
 
 export { codecDefinitions, dataTypes };

package/dist/control.mjs

@@ -3,13 +3,12 @@ import { t as parsePostgresDefault } from "./default-normalizer-DNOpRoOF.mjs";
 import { t as normalizeSchemaNativeType } from "./native-type-normalizer-CInai_oY.mjs";
 import { o as renderDefaultLiteral } from "./planner-ddl-builders-Dxvw1LHw.mjs";
 import "./issue-planner-CFjB0_oO.mjs";
-import { t as createPostgresMigrationPlanner } from "./planner-CLUvVhUN.mjs";
-import { a as ensurePrismaContractSchemaStatement, i as ensureMarkerTableStatement, n as buildWriteMarkerStatements, r as ensureLedgerTableStatement, t as buildLedgerInsertStatement } from "./statement-builders-BPnmt6wx.mjs";
+import { t as createPostgresMigrationPlanner } from "./planner-B4ZSLHRI.mjs";
+import { a as ensurePrismaContractSchemaStatement, i as ensureMarkerTableStatement, n as buildMergeMarkerStatements, r as ensureLedgerTableStatement, t as buildLedgerInsertStatement } from "./statement-builders-CHqCtSfe.mjs";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { contractToSchemaIR, extractCodecControlHooks, runnerFailure, runnerSuccess } from "@prisma-next/family-sql/control";
 import { verifySqlSchema } from "@prisma-next/family-sql/schema-verify";
 import { ok, okVoid } from "@prisma-next/utils/result";
-import { readMarker } from "@prisma-next/family-sql/verify";
 import { SqlQueryError } from "@prisma-next/sql-errors";
 
 //#region src/core/migrations/runner.ts
@@ -54,10 +53,12 @@ var PostgresMigrationRunner = class {
 		try {
 			await this.acquireLock(driver, lockKey);
 			await this.ensureControlTables(driver);
-			const existingMarker = await readMarker(driver);
+			const existingMarker = await this.family.readMarker({ driver });
 			const markerCheck = this.ensureMarkerCompatibility(existingMarker, options.plan);
 			if (!markerCheck.ok) return markerCheck;
-			const skipOperations = this.markerMatchesDestination(existingMarker, options.plan) && options.plan.origin != null;
+			const markerAtDestination = this.markerMatchesDestination(existingMarker, options.plan);
+			const isSelfEdge = options.plan.origin?.storageHash === options.plan.destination.storageHash;
+			const skipOperations = markerAtDestination && options.plan.origin != null && !isSelfEdge;
 			let applyValue;
 			if (skipOperations) applyValue = {
 				operationsExecuted: 0,
@@ -86,8 +87,13 @@ var PostgresMigrationRunner = class {
 				why: "The resulting database schema does not satisfy the destination contract.",
 				meta: { issues: schemaVerifyResult.schema.issues }
 			});
-			await this.upsertMarker(driver, options, existingMarker);
-			await this.recordLedgerEntry(driver, options, existingMarker, applyValue.executedOperations);
+			const incomingInvariants = options.plan.providedInvariants;
+			const existingInvariants = new Set(existingMarker?.invariants ?? []);
+			const incomingIsSubsetOfExisting = incomingInvariants.every((id) => existingInvariants.has(id));
+			if (!(isSelfEdge && applyValue.operationsExecuted === 0 && incomingIsSubsetOfExisting)) {
+				await this.upsertMarker(driver, options, existingMarker);
+				await this.recordLedgerEntry(driver, options, existingMarker, applyValue.executedOperations);
+			}
 			await this.commitTransaction(driver);
 			committed = true;
 			return runnerSuccess({
@@ -308,12 +314,14 @@ var PostgresMigrationRunner = class {
 		return okVoid();
 	}
 	async upsertMarker(driver, options, existingMarker) {
-		const writeStatements = buildWriteMarkerStatements({
+		const incomingInvariants = options.plan.providedInvariants;
+		const writeStatements = buildMergeMarkerStatements({
 			storageHash: options.plan.destination.storageHash,
 			profileHash: options.plan.destination.profileHash ?? options.destinationContract.profileHash ?? options.plan.destination.storageHash,
 			contractJson: options.destinationContract,
 			canonicalVersion: null,
-			meta: {}
+			meta: {},
+			invariants: incomingInvariants
 		});
 		const statement = existingMarker ? writeStatements.update : writeStatements.insert;
 		await this.executeStatement(driver, statement);