@prisma-next/adapter-postgres 0.3.0-dev.11 → 0.3.0-dev.113

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,MAAA,CAAoB,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,MAAA;EAahB,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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"}

package/dist/control.d.mts

@@ -0,0 +1,77 @@
+import { SqlControlAdapterDescriptor } from "@prisma-next/family-sql/control";
+import { ColumnDefault } from "@prisma-next/contract/types";
+
+//#region src/core/sql-utils.d.ts
+
+/**
+ * Shared SQL utility functions for the Postgres adapter.
+ *
+ * These functions handle safe SQL identifier and literal escaping
+ * with security validations to prevent injection and encoding issues.
+ */
+/**
+ * Error thrown when an invalid SQL identifier or literal is detected.
+ * Boundary layers map this to structured envelopes.
+ */
+declare class SqlEscapeError extends Error {
+  readonly value: string;
+  readonly kind: 'identifier' | 'literal';
+  constructor(message: string, value: string, kind: 'identifier' | 'literal');
+}
+/**
+ * Validates and quotes a PostgreSQL identifier (table, column, type, schema names).
+ *
+ * Security validations:
+ * - Rejects null bytes which could cause truncation or unexpected behavior
+ * - Rejects empty identifiers
+ * - Warns on identifiers exceeding PostgreSQL's 63-character limit
+ *
+ * @throws {SqlEscapeError} If the identifier contains null bytes or is empty
+ */
+declare function quoteIdentifier(identifier: string): string;
+/**
+ * Escapes a string literal for safe use in SQL statements.
+ *
+ * Security validations:
+ * - Rejects null bytes which could cause truncation or unexpected behavior
+ *
+ * Note: This assumes PostgreSQL's `standard_conforming_strings` is ON (default since PG 9.1).
+ * Backslashes are treated as literal characters, not escape sequences.
+ *
+ * @throws {SqlEscapeError} If the value contains null bytes
+ */
+declare function escapeLiteral(value: string): string;
+/**
+ * Builds a qualified name (schema.object) with proper quoting.
+ */
+declare function qualifyName(schemaName: string, objectName: string): string;
+//#endregion
+//#region src/core/default-normalizer.d.ts
+/**
+ * Parses a raw Postgres column default expression into a normalized ColumnDefault.
+ * This enables semantic comparison between contract defaults and introspected schema defaults.
+ *
+ * Used by the migration diff layer to normalize raw database defaults during comparison,
+ * keeping the introspection layer focused on faithful data capture.
+ *
+ * @param rawDefault - Raw default expression from information_schema.columns.column_default
+ * @param nativeType - Native column type, used for type-aware parsing (bigint tagging, JSON detection)
+ * @returns Normalized ColumnDefault or undefined if the expression cannot be parsed
+ */
+declare function parsePostgresDefault(rawDefault: string, nativeType?: string): ColumnDefault | undefined;
+//#endregion
+//#region src/core/control-adapter.d.ts
+
+/**
+ * Normalizes a Postgres schema native type to its canonical form for comparison.
+ *
+ * Uses a pre-computed lookup map for simple prefix replacements (O(1))
+ * and handles complex temporal type normalization separately.
+ */
+declare function normalizeSchemaNativeType(nativeType: string): string;
+//#endregion
+//#region src/exports/control.d.ts
+declare const postgresAdapterDescriptor: SqlControlAdapterDescriptor<'postgres'>;
+//#endregion
+export { SqlEscapeError, postgresAdapterDescriptor as default, escapeLiteral, normalizeSchemaNativeType, parsePostgresDefault, qualifyName, quoteIdentifier };
+//# sourceMappingURL=control.d.mts.map

package/dist/control.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.d.mts","names":[],"sources":["../src/core/sql-utils.ts","../src/core/default-normalizer.ts","../src/core/control-adapter.ts","../src/exports/control.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAWA;AA0BA;AAiCA;AAcA;;;cAzEa,cAAA,SAAuB,KAAA;ECuDpB,SAAA,KAAA,EAAA,MAAA;;;;AC0ZhB;;;;ACndgG;;;;;;iBH4BhF,eAAA;;;;;;;;;;;;iBAiCA,aAAA;;;;iBAcA,WAAA;;;;;;AAzEhB;AA0BA;AAiCA;AAcA;;;;AClBA;iBAAgB,oBAAA,2CAGb;;;;;;;;;;iBCuZa,yBAAA;;;cCjdV,2BAA2B"}