@prisma/orm-target-postgres 8.0.0-rc.14-dev.29 → 8.0.0-rc.14-dev.30

package/dist/data-types-DzUVlWeo-CBMHoFoH.mjs

@@ -0,0 +1,366 @@
+import { b as pgIntervalCanonical, r as canonicalUuid, s as fitsFloat4, u as pgByteaCanonical } from "./codec-helpers-BKrVHgYc-DFnb5u9l.mjs";
+import { r as quoteIdentifier } from "./sql-utils-BMXJi06b-CAQOplfq.mjs";
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
+import { assembleDataTypes, isNonFiniteText } from "@prisma/orm-framework/components/codec";
+import { numeralText, sqlDataType } from "@prisma/orm-family-sql/contract/data-type";
+import { canonicalDateTime, integerTextCanonicalForm } from "@prisma/orm-family-sql/contract/data-type-support";
+import { type } from "arktype";
+//#region ../../../3-targets/3-targets/postgres/dist/data-types-DzUVlWeo.mjs
+/** A cast between two types that store the same shape: the value is already the form this type stores. */
+const unchanged = (value) => value;
+function wrongShape(value, expected) {
+	throw structuredError("CONTRACT.CAST_REFUSED", `Expected ${expected}, got ${JSON.stringify(value)}.`, {
+		why: "A cast reads the canonical form of the type it takes values of.",
+		fix: "Hand the cast a value in the shape its source type stores."
+	});
+}
+/** A whole number as the digit text `int8` and `numeric` store. */
+const asNumeralText = (value) => typeof value === "number" ? numeralText(value) : wrongShape(value, "a number");
+/**
+* A number as the floating-point types store it: a JSON number, or one of the three words, which
+* those types keep as text. A magnitude past what a double holds is refused rather than rounded to
+* a word: the database refuses it too, and storing `Infinity` would make a written number
+* indistinguishable from a written `Infinity`.
+*/
+const asFloat = (value) => {
+	if (typeof value === "number") return value;
+	if (typeof value !== "string") return wrongShape(value, "a number or numeral text");
+	if (isNonFiniteText(value)) return value;
+	const converted = Number(value);
+	if (Number.isFinite(converted)) return converted;
+	throw structuredError("CONTRACT.CAST_REFUSED", `${value} is out of range: no double holds a number that large.`, {
+		why: "The floating-point types store a double, which holds magnitudes up to about 1.8e308.",
+		fix: "Use a number a double holds, or a numeric column."
+	});
+};
+const written = (text) => ({
+	text,
+	written: true
+});
+const catalog = (text) => ({
+	text,
+	catalog: true
+});
+const writtenAndCatalog = (text) => ({
+	text,
+	written: true,
+	catalog: true
+});
+const claimsOnly = (text) => ({ text });
+/** The precision and scale of `numeric`. PostgreSQL 15 and later take a negative scale and one above the precision. */
+const pgNumericParams = type({
+	"precision?": "number.integer >= 1 & number.integer <= 1000",
+	"scale?": "number.integer >= -1000 & number.integer <= 1000"
+}).narrow((params, ctx) => params.scale === void 0 || params.precision !== void 0 || ctx.reject({
+	path: ["scale"],
+	message: "scale requires a precision"
+}));
+/** The length of `char` and `varchar`. */
+const pgCharacterLengthParams = type({ "length?": "number.integer >= 1 & number.integer <= 10485760" });
+/** The length of `bit` and `bit varying`. */
+const pgBitLengthParams = type({ "length?": "number.integer >= 1 & number.integer <= 83886080" });
+/** The fractional-second precision of the time, timestamp and interval types. */
+const pgPrecisionParams = type({ "precision?": "number.integer >= 0 & number.integer <= 6" });
+const pgEnumParams = type({ typeName: "string > 0" });
+/** A type with no parameters that is written and reported by its own name. */
+const namedOnly = (id, name, casts = {}) => sqlDataType(id, {
+	texts: [writtenAndCatalog(name)],
+	casts
+});
+const withDefaultLength = (params) => params.length === void 0 ? {
+	...params,
+	length: 1
+} : params;
+const pgText = namedOnly("pg/text", "text");
+const pgTextArray = sqlDataType("pg/text-array", {});
+/** The enum's `typeName`: its name in `public` or with no schema, its schema-qualified name elsewhere. */
+function qualifiedEnumName(reported) {
+	const name = reported.name ?? "";
+	return reported.schema === void 0 || reported.schema === "public" ? name : `${reported.schema}.${name}`;
+}
+const pgEnum = sqlDataType("pg/enum", {
+	params: pgEnumParams,
+	claimsKind: "enum",
+	render: ({ typeName }) => {
+		const dot = typeName.indexOf(".");
+		return dot === -1 ? quoteIdentifier(typeName) : `${quoteIdentifier(typeName.slice(0, dot))}.${quoteIdentifier(typeName.slice(dot + 1))}`;
+	},
+	fromReported: (reported) => ({ typeName: qualifiedEnumName(reported) })
+});
+const pgInt2 = sqlDataType("pg/int2", { texts: [written("int2"), catalog("smallint")] });
+const pgBool = sqlDataType("pg/bool", { texts: [written("bool"), catalog("boolean")] });
+const pgJson = namedOnly("pg/json", "json");
+const pgTsquery = namedOnly("pg/tsquery", "tsquery");
+const pgInt4 = sqlDataType("pg/int4", {
+	texts: [
+		written("int4"),
+		catalog("integer"),
+		claimsOnly("int")
+	],
+	casts: { [pgInt2.id]: unchanged }
+});
+const pgInt8 = sqlDataType("pg/int8", {
+	texts: [written("int8"), catalog("bigint")],
+	toCanonicalForm: integerTextCanonicalForm,
+	casts: {
+		[pgInt2.id]: asNumeralText,
+		[pgInt4.id]: asNumeralText
+	}
+});
+const pgNumeric = sqlDataType("pg/numeric", {
+	params: pgNumericParams,
+	texts: [
+		writtenAndCatalog("numeric"),
+		written("numeric({precision})"),
+		writtenAndCatalog("numeric({precision},{scale})"),
+		claimsOnly("decimal"),
+		claimsOnly("decimal({precision})"),
+		claimsOnly("decimal({precision},{scale})")
+	],
+	normalize: (params) => params.precision !== void 0 && params.scale === void 0 ? {
+		...params,
+		scale: 0
+	} : params,
+	casts: {
+		[pgInt2.id]: asNumeralText,
+		[pgInt4.id]: asNumeralText,
+		[pgInt8.id]: unchanged
+	}
+});
+/** `float4` stores a single-precision float, so a magnitude past about 3.4e38, or one it would round to 0, does not fit. */
+const asFloat4 = (value) => {
+	const converted = asFloat(value);
+	if (typeof converted !== "number" || fitsFloat4(converted)) return converted;
+	throw structuredError("CONTRACT.CAST_REFUSED", `${converted} is out of range: float4 holds a nonzero magnitude from about 1.4e-45 to 3.4e38.`, {
+		why: "float4 stores a single-precision float, which overflows past about 3.4e38 and rounds a magnitude below about 1.4e-45 to 0.",
+		fix: "Use a number float4 holds, or a float8 or numeric column."
+	});
+};
+const floatCastsOf = (cast) => ({
+	[pgInt2.id]: cast,
+	[pgInt4.id]: cast,
+	[pgInt8.id]: cast,
+	[pgNumeric.id]: cast
+});
+const pgFloat4 = sqlDataType("pg/float4", {
+	texts: [written("float4"), catalog("real")],
+	casts: floatCastsOf(asFloat4)
+});
+const pgFloat8 = sqlDataType("pg/float8", {
+	texts: [
+		written("float8"),
+		catalog("double precision"),
+		claimsOnly("float")
+	],
+	casts: floatCastsOf(asFloat)
+});
+const pgJsonb = namedOnly("pg/jsonb", "jsonb", { [pgJson.id]: unchanged });
+const fromText = { [pgText.id]: unchanged };
+const pgChar = sqlDataType("pg/char", {
+	params: pgCharacterLengthParams,
+	texts: [
+		written("character"),
+		writtenAndCatalog("character({length})"),
+		claimsOnly("char"),
+		claimsOnly("char({length})")
+	],
+	normalize: withDefaultLength,
+	casts: fromText
+});
+const pgVarchar = sqlDataType("pg/varchar", {
+	params: pgCharacterLengthParams,
+	texts: [
+		writtenAndCatalog("character varying"),
+		writtenAndCatalog("character varying({length})"),
+		claimsOnly("varchar"),
+		claimsOnly("varchar({length})")
+	],
+	casts: fromText
+});
+/** Text in any form PostgreSQL reads as a UUID, written the way PostgreSQL writes it, so the contract holds the value the database reports. */
+const asUuid = (value) => {
+	if (typeof value !== "string") return wrongShape(value, "text");
+	const uuid = canonicalUuid(value);
+	if (uuid !== void 0) return uuid;
+	throw structuredError("CONTRACT.CAST_REFUSED", `${JSON.stringify(value)} is not a UUID: PostgreSQL reads 32 hexadecimal digits, with a hyphen after any group of four and optionally in braces.`, {
+		why: "A uuid column takes only text PostgreSQL reads as a UUID.",
+		fix: "Write a UUID such as a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11."
+	});
+};
+const pgUuid = sqlDataType("pg/uuid", {
+	texts: [writtenAndCatalog("uuid")],
+	casts: { [pgText.id]: asUuid }
+});
+const pgInet = namedOnly("pg/inet", "inet", fromText);
+const pgBit = sqlDataType("pg/bit", {
+	params: pgBitLengthParams,
+	texts: [written("bit"), writtenAndCatalog("bit({length})")],
+	normalize: withDefaultLength,
+	casts: fromText
+});
+const pgVarbit = sqlDataType("pg/varbit", {
+	params: pgBitLengthParams,
+	texts: [
+		writtenAndCatalog("bit varying"),
+		writtenAndCatalog("bit varying({length})"),
+		claimsOnly("varbit"),
+		claimsOnly("varbit({length})")
+	],
+	casts: fromText
+});
+const POSTGRES_YEAR = /^(\d{4,6})(-.*?)( BC)?$/;
+/**
+* Text PostgreSQL prints, in ISO 8601. A year with a ` BC` suffix becomes the ISO year, one higher
+* than its negative, so 1 BC is 0000 and 44 BC is -000043. A year of five or six digits becomes a
+* signed six-digit year. 0 BC does not exist, so it stays as written and the reader refuses it.
+*/
+function isoFromPostgresText(text) {
+	const match = POSTGRES_YEAR.exec(text);
+	if (match === null) return text;
+	const [, digits = "", rest = "", bc] = match;
+	const year = Number(digits);
+	if (bc !== void 0) {
+		if (year === 0) return text;
+		const astronomical = 1 - year;
+		return astronomical === 0 ? `0000${rest}` : `-${String(-astronomical).padStart(6, "0")}${rest}`;
+	}
+	return digits.length > 4 ? `+${String(year).padStart(6, "0")}${rest}` : text;
+}
+const INFINITIES = /* @__PURE__ */ new Set(["infinity", "-infinity"]);
+/**
+* The canonical form of a date or time type (ADR 254), from ISO 8601 or the text PostgreSQL prints.
+* `infinity` and `-infinity` are values of the types that hold them.
+*/
+function postgresDateTime(options, holdsInfinity) {
+	return (text) => holdsInfinity && INFINITIES.has(text) ? text : canonicalDateTime(isoFromPostgresText(text), options, text);
+}
+/**
+* Each range is what PostgreSQL and every codec of the type hold: PostgreSQL starts at 4714-11-24
+* BC, and the `Temporal` and `Date` codecs end at +275760-09-13.
+*/
+const pgDateCanonical = postgresDateTime({
+	shape: "date",
+	dataTypeId: "pg/date",
+	range: {
+		earliest: "-004713-11-24",
+		latest: "+275760-09-13"
+	}
+}, true);
+const pgTimeCanonical = postgresDateTime({
+	shape: "time",
+	dataTypeId: "pg/time"
+}, false);
+const pgTimetzCanonical = postgresDateTime({
+	shape: "timeWithOffset",
+	dataTypeId: "pg/timetz",
+	maxOffsetHours: 15
+}, false);
+const pgTimestampCanonical = postgresDateTime({
+	shape: "dateTime",
+	dataTypeId: "pg/timestamp",
+	range: {
+		earliest: "-004713-11-24T00:00:00",
+		latest: "+275760-09-13T23:59:59.999999"
+	}
+}, true);
+const pgTimestamptzCanonical = postgresDateTime({
+	shape: "instant",
+	dataTypeId: "pg/timestamptz",
+	range: {
+		earliest: "-004713-11-24T00:00:00Z",
+		latest: "+275760-09-13T00:00:00Z"
+	}
+}, true);
+/** The canonical-form function of a type whose values are written as text. */
+const canonicalFromText = (canonical) => (value) => typeof value === "string" ? canonical(value) : wrongShape(value, "text");
+/** A type whose canonical form reads text: that canonical form, and the same function as its cast from text. */
+function typeCanonicalFromText(id, canonical, spec) {
+	const toCanonicalForm = canonicalFromText(canonical);
+	return sqlDataType(id, {
+		...spec,
+		toCanonicalForm,
+		casts: { [pgText.id]: toCanonicalForm }
+	});
+}
+const pgTimetz = typeCanonicalFromText("pg/timetz", pgTimetzCanonical, {
+	params: pgPrecisionParams,
+	texts: [
+		written("timetz"),
+		written("timetz({precision})"),
+		catalog("time with time zone"),
+		catalog("time({precision}) with time zone")
+	]
+});
+const pgInterval = typeCanonicalFromText("pg/interval", pgIntervalCanonical, {
+	params: pgPrecisionParams,
+	texts: [writtenAndCatalog("interval"), writtenAndCatalog("interval({precision})")]
+});
+const pgBytea = typeCanonicalFromText("pg/bytea", pgByteaCanonical, { texts: [writtenAndCatalog("bytea")] });
+const pgDate = typeCanonicalFromText("pg/date", pgDateCanonical, { texts: [writtenAndCatalog("date")] });
+const pgTime = typeCanonicalFromText("pg/time", pgTimeCanonical, {
+	params: pgPrecisionParams,
+	texts: [
+		written("time"),
+		written("time({precision})"),
+		catalog("time without time zone"),
+		catalog("time({precision}) without time zone")
+	]
+});
+const pgTimestamp = typeCanonicalFromText("pg/timestamp", pgTimestampCanonical, {
+	params: pgPrecisionParams,
+	texts: [
+		written("timestamp"),
+		written("timestamp({precision})"),
+		catalog("timestamp without time zone"),
+		catalog("timestamp({precision}) without time zone")
+	]
+});
+const pgTimestamptz = typeCanonicalFromText("pg/timestamptz", pgTimestamptzCanonical, {
+	params: pgPrecisionParams,
+	texts: [
+		written("timestamptz"),
+		written("timestamptz({precision})"),
+		catalog("timestamp with time zone"),
+		catalog("timestamp({precision}) with time zone")
+	]
+});
+/** Every data type this target registers. */
+const postgresDataTypes = [
+	pgText,
+	pgTextArray,
+	pgEnum,
+	pgInt2,
+	pgBool,
+	pgJson,
+	pgTsquery,
+	pgInt4,
+	pgInt8,
+	pgNumeric,
+	pgFloat4,
+	pgFloat8,
+	pgJsonb,
+	pgChar,
+	pgVarchar,
+	pgUuid,
+	pgInet,
+	pgBit,
+	pgVarbit,
+	pgTimetz,
+	pgInterval,
+	pgBytea,
+	pgDate,
+	pgTime,
+	pgTimestamp,
+	pgTimestamptz
+];
+/** A lookup of the data types this target registers. */
+function createPostgresBuiltinDataTypeLookup() {
+	return assembleDataTypes([{
+		id: "postgres",
+		dataTypes: postgresDataTypes
+	}]).lookup;
+}
+//#endregion
+export { pgTimestamptz as A, pgPrecisionParams as C, pgTimeCanonical as D, pgTime as E, pgUuid as F, pgVarbit as I, pgVarchar as L, pgTimetz as M, pgTimetzCanonical as N, pgTimestamp as O, pgTsquery as P, postgresDataTypes as R, pgNumericParams as S, pgTextArray as T, pgInt8 as _, pgBytea as a, pgJsonb as b, pgDate as c, pgEnumParams as d, pgFloat4 as f, pgInt4 as g, pgInt2 as h, pgBool as i, pgTimestamptzCanonical as j, pgTimestampCanonical as k, pgDateCanonical as l, pgInet as m, pgBit as n, pgChar as o, pgFloat8 as p, pgBitLengthParams as r, pgCharacterLengthParams as s, createPostgresBuiltinDataTypeLookup as t, pgEnum as u, pgInterval as v, pgText as w, pgNumeric as x, pgJson as y };
+
+//# sourceMappingURL=data-types-DzUVlWeo-CBMHoFoH.mjs.map

package/dist/data-types-DzUVlWeo-CBMHoFoH.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-types-DzUVlWeo-CBMHoFoH.mjs","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/data-types-DzUVlWeo.mjs"],"sourcesContent":["import { b as pgIntervalCanonical, r as canonicalUuid, s as fitsFloat4, u as pgByteaCanonical } from \"./codec-helpers-BKrVHgYc.mjs\";\nimport { r as quoteIdentifier } from \"./sql-utils-BMXJi06b.mjs\";\nimport { numeralText, sqlDataType } from \"@internal/sql-contract/data-type\";\nimport { canonicalDateTime, integerTextCanonicalForm } from \"@internal/sql-contract/data-type-support\";\nimport { structuredError } from \"@internal/utils/structured-error\";\nimport { assembleDataTypes, isNonFiniteText } from \"@internal/framework-components/codec\";\nimport { type } from \"arktype\";\n//#region src/core/data-types.ts\n/** A cast between two types that store the same shape: the value is already the form this type stores. */\nconst unchanged = (value) => value;\nfunction wrongShape(value, expected) {\n\tthrow structuredError(\"CONTRACT.CAST_REFUSED\", `Expected ${expected}, got ${JSON.stringify(value)}.`, {\n\t\twhy: \"A cast reads the canonical form of the type it takes values of.\",\n\t\tfix: \"Hand the cast a value in the shape its source type stores.\"\n\t});\n}\n/** A whole number as the digit text `int8` and `numeric` store. */\nconst asNumeralText = (value) => typeof value === \"number\" ? numeralText(value) : wrongShape(value, \"a number\");\n/**\n* A number as the floating-point types store it: a JSON number, or one of the three words, which\n* those types keep as text. A magnitude past what a double holds is refused rather than rounded to\n* a word: the database refuses it too, and storing `Infinity` would make a written number\n* indistinguishable from a written `Infinity`.\n*/\nconst asFloat = (value) => {\n\tif (typeof value === \"number\") return value;\n\tif (typeof value !== \"string\") return wrongShape(value, \"a number or numeral text\");\n\tif (isNonFiniteText(value)) return value;\n\tconst converted = Number(value);\n\tif (Number.isFinite(converted)) return converted;\n\tthrow structuredError(\"CONTRACT.CAST_REFUSED\", `${value} is out of range: no double holds a number that large.`, {\n\t\twhy: \"The floating-point types store a double, which holds magnitudes up to about 1.8e308.\",\n\t\tfix: \"Use a number a double holds, or a numeric column.\"\n\t});\n};\nconst written = (text) => ({\n\ttext,\n\twritten: true\n});\nconst catalog = (text) => ({\n\ttext,\n\tcatalog: true\n});\nconst writtenAndCatalog = (text) => ({\n\ttext,\n\twritten: true,\n\tcatalog: true\n});\nconst claimsOnly = (text) => ({ text });\n/** The precision and scale of `numeric`. PostgreSQL 15 and later take a negative scale and one above the precision. */\nconst pgNumericParams = type({\n\t\"precision?\": \"number.integer >= 1 & number.integer <= 1000\",\n\t\"scale?\": \"number.integer >= -1000 & number.integer <= 1000\"\n}).narrow((params, ctx) => params.scale === void 0 || params.precision !== void 0 || ctx.reject({\n\tpath: [\"scale\"],\n\tmessage: \"scale requires a precision\"\n}));\n/** The length of `char` and `varchar`. */\nconst pgCharacterLengthParams = type({ \"length?\": \"number.integer >= 1 & number.integer <= 10485760\" });\n/** The length of `bit` and `bit varying`. */\nconst pgBitLengthParams = type({ \"length?\": \"number.integer >= 1 & number.integer <= 83886080\" });\n/** The fractional-second precision of the time, timestamp and interval types. */\nconst pgPrecisionParams = type({ \"precision?\": \"number.integer >= 0 & number.integer <= 6\" });\nconst pgEnumParams = type({ typeName: \"string > 0\" });\n/** A type with no parameters that is written and reported by its own name. */\nconst namedOnly = (id, name, casts = {}) => sqlDataType(id, {\n\ttexts: [writtenAndCatalog(name)],\n\tcasts\n});\nconst withDefaultLength = (params) => params.length === void 0 ? {\n\t...params,\n\tlength: 1\n} : params;\nconst pgText = namedOnly(\"pg/text\", \"text\");\nconst pgTextArray = sqlDataType(\"pg/text-array\", {});\n/** The enum's `typeName`: its name in `public` or with no schema, its schema-qualified name elsewhere. */\nfunction qualifiedEnumName(reported) {\n\tconst name = reported.name ?? \"\";\n\treturn reported.schema === void 0 || reported.schema === \"public\" ? name : `${reported.schema}.${name}`;\n}\nconst pgEnum = sqlDataType(\"pg/enum\", {\n\tparams: pgEnumParams,\n\tclaimsKind: \"enum\",\n\trender: ({ typeName }) => {\n\t\tconst dot = typeName.indexOf(\".\");\n\t\treturn dot === -1 ? quoteIdentifier(typeName) : `${quoteIdentifier(typeName.slice(0, dot))}.${quoteIdentifier(typeName.slice(dot + 1))}`;\n\t},\n\tfromReported: (reported) => ({ typeName: qualifiedEnumName(reported) })\n});\nconst pgInt2 = sqlDataType(\"pg/int2\", { texts: [written(\"int2\"), catalog(\"smallint\")] });\nconst pgBool = sqlDataType(\"pg/bool\", { texts: [written(\"bool\"), catalog(\"boolean\")] });\nconst pgJson = namedOnly(\"pg/json\", \"json\");\nconst pgTsquery = namedOnly(\"pg/tsquery\", \"tsquery\");\nconst pgInt4 = sqlDataType(\"pg/int4\", {\n\ttexts: [\n\t\twritten(\"int4\"),\n\t\tcatalog(\"integer\"),\n\t\tclaimsOnly(\"int\")\n\t],\n\tcasts: { [pgInt2.id]: unchanged }\n});\nconst pgInt8 = sqlDataType(\"pg/int8\", {\n\ttexts: [written(\"int8\"), catalog(\"bigint\")],\n\ttoCanonicalForm: integerTextCanonicalForm,\n\tcasts: {\n\t\t[pgInt2.id]: asNumeralText,\n\t\t[pgInt4.id]: asNumeralText\n\t}\n});\nconst pgNumeric = sqlDataType(\"pg/numeric\", {\n\tparams: pgNumericParams,\n\ttexts: [\n\t\twrittenAndCatalog(\"numeric\"),\n\t\twritten(\"numeric({precision})\"),\n\t\twrittenAndCatalog(\"numeric({precision},{scale})\"),\n\t\tclaimsOnly(\"decimal\"),\n\t\tclaimsOnly(\"decimal({precision})\"),\n\t\tclaimsOnly(\"decimal({precision},{scale})\")\n\t],\n\tnormalize: (params) => params.precision !== void 0 && params.scale === void 0 ? {\n\t\t...params,\n\t\tscale: 0\n\t} : params,\n\tcasts: {\n\t\t[pgInt2.id]: asNumeralText,\n\t\t[pgInt4.id]: asNumeralText,\n\t\t[pgInt8.id]: unchanged\n\t}\n});\n/** `float4` stores a single-precision float, so a magnitude past about 3.4e38, or one it would round to 0, does not fit. */\nconst asFloat4 = (value) => {\n\tconst converted = asFloat(value);\n\tif (typeof converted !== \"number\" || fitsFloat4(converted)) return converted;\n\tthrow structuredError(\"CONTRACT.CAST_REFUSED\", `${converted} is out of range: float4 holds a nonzero magnitude from about 1.4e-45 to 3.4e38.`, {\n\t\twhy: \"float4 stores a single-precision float, which overflows past about 3.4e38 and rounds a magnitude below about 1.4e-45 to 0.\",\n\t\tfix: \"Use a number float4 holds, or a float8 or numeric column.\"\n\t});\n};\nconst floatCastsOf = (cast) => ({\n\t[pgInt2.id]: cast,\n\t[pgInt4.id]: cast,\n\t[pgInt8.id]: cast,\n\t[pgNumeric.id]: cast\n});\nconst pgFloat4 = sqlDataType(\"pg/float4\", {\n\ttexts: [written(\"float4\"), catalog(\"real\")],\n\tcasts: floatCastsOf(asFloat4)\n});\nconst pgFloat8 = sqlDataType(\"pg/float8\", {\n\ttexts: [\n\t\twritten(\"float8\"),\n\t\tcatalog(\"double precision\"),\n\t\tclaimsOnly(\"float\")\n\t],\n\tcasts: floatCastsOf(asFloat)\n});\nconst pgJsonb = namedOnly(\"pg/jsonb\", \"jsonb\", { [pgJson.id]: unchanged });\nconst fromText = { [pgText.id]: unchanged };\nconst pgChar = sqlDataType(\"pg/char\", {\n\tparams: pgCharacterLengthParams,\n\ttexts: [\n\t\twritten(\"character\"),\n\t\twrittenAndCatalog(\"character({length})\"),\n\t\tclaimsOnly(\"char\"),\n\t\tclaimsOnly(\"char({length})\")\n\t],\n\tnormalize: withDefaultLength,\n\tcasts: fromText\n});\nconst pgVarchar = sqlDataType(\"pg/varchar\", {\n\tparams: pgCharacterLengthParams,\n\ttexts: [\n\t\twrittenAndCatalog(\"character varying\"),\n\t\twrittenAndCatalog(\"character varying({length})\"),\n\t\tclaimsOnly(\"varchar\"),\n\t\tclaimsOnly(\"varchar({length})\")\n\t],\n\tcasts: fromText\n});\n/** Text in any form PostgreSQL reads as a UUID, written the way PostgreSQL writes it, so the contract holds the value the database reports. */\nconst asUuid = (value) => {\n\tif (typeof value !== \"string\") return wrongShape(value, \"text\");\n\tconst uuid = canonicalUuid(value);\n\tif (uuid !== void 0) return uuid;\n\tthrow structuredError(\"CONTRACT.CAST_REFUSED\", `${JSON.stringify(value)} is not a UUID: PostgreSQL reads 32 hexadecimal digits, with a hyphen after any group of four and optionally in braces.`, {\n\t\twhy: \"A uuid column takes only text PostgreSQL reads as a UUID.\",\n\t\tfix: \"Write a UUID such as a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11.\"\n\t});\n};\nconst pgUuid = sqlDataType(\"pg/uuid\", {\n\ttexts: [writtenAndCatalog(\"uuid\")],\n\tcasts: { [pgText.id]: asUuid }\n});\nconst pgInet = namedOnly(\"pg/inet\", \"inet\", fromText);\nconst pgBit = sqlDataType(\"pg/bit\", {\n\tparams: pgBitLengthParams,\n\ttexts: [written(\"bit\"), writtenAndCatalog(\"bit({length})\")],\n\tnormalize: withDefaultLength,\n\tcasts: fromText\n});\nconst pgVarbit = sqlDataType(\"pg/varbit\", {\n\tparams: pgBitLengthParams,\n\ttexts: [\n\t\twrittenAndCatalog(\"bit varying\"),\n\t\twrittenAndCatalog(\"bit varying({length})\"),\n\t\tclaimsOnly(\"varbit\"),\n\t\tclaimsOnly(\"varbit({length})\")\n\t],\n\tcasts: fromText\n});\nconst POSTGRES_YEAR = /^(\\d{4,6})(-.*?)( BC)?$/;\n/**\n* Text PostgreSQL prints, in ISO 8601. A year with a ` BC` suffix becomes the ISO year, one higher\n* than its negative, so 1 BC is 0000 and 44 BC is -000043. A year of five or six digits becomes a\n* signed six-digit year. 0 BC does not exist, so it stays as written and the reader refuses it.\n*/\nfunction isoFromPostgresText(text) {\n\tconst match = POSTGRES_YEAR.exec(text);\n\tif (match === null) return text;\n\tconst [, digits = \"\", rest = \"\", bc] = match;\n\tconst year = Number(digits);\n\tif (bc !== void 0) {\n\t\tif (year === 0) return text;\n\t\tconst astronomical = 1 - year;\n\t\treturn astronomical === 0 ? `0000${rest}` : `-${String(-astronomical).padStart(6, \"0\")}${rest}`;\n\t}\n\treturn digits.length > 4 ? `+${String(year).padStart(6, \"0\")}${rest}` : text;\n}\nconst INFINITIES = /* @__PURE__ */ new Set([\"infinity\", \"-infinity\"]);\n/**\n* The canonical form of a date or time type (ADR 254), from ISO 8601 or the text PostgreSQL prints.\n* `infinity` and `-infinity` are values of the types that hold them.\n*/\nfunction postgresDateTime(options, holdsInfinity) {\n\treturn (text) => holdsInfinity && INFINITIES.has(text) ? text : canonicalDateTime(isoFromPostgresText(text), options, text);\n}\n/**\n* Each range is what PostgreSQL and every codec of the type hold: PostgreSQL starts at 4714-11-24\n* BC, and the `Temporal` and `Date` codecs end at +275760-09-13.\n*/\nconst pgDateCanonical = postgresDateTime({\n\tshape: \"date\",\n\tdataTypeId: \"pg/date\",\n\trange: {\n\t\tearliest: \"-004713-11-24\",\n\t\tlatest: \"+275760-09-13\"\n\t}\n}, true);\nconst pgTimeCanonical = postgresDateTime({\n\tshape: \"time\",\n\tdataTypeId: \"pg/time\"\n}, false);\nconst pgTimetzCanonical = postgresDateTime({\n\tshape: \"timeWithOffset\",\n\tdataTypeId: \"pg/timetz\",\n\tmaxOffsetHours: 15\n}, false);\nconst pgTimestampCanonical = postgresDateTime({\n\tshape: \"dateTime\",\n\tdataTypeId: \"pg/timestamp\",\n\trange: {\n\t\tearliest: \"-004713-11-24T00:00:00\",\n\t\tlatest: \"+275760-09-13T23:59:59.999999\"\n\t}\n}, true);\nconst pgTimestamptzCanonical = postgresDateTime({\n\tshape: \"instant\",\n\tdataTypeId: \"pg/timestamptz\",\n\trange: {\n\t\tearliest: \"-004713-11-24T00:00:00Z\",\n\t\tlatest: \"+275760-09-13T00:00:00Z\"\n\t}\n}, true);\n/** The canonical-form function of a type whose values are written as text. */\nconst canonicalFromText = (canonical) => (value) => typeof value === \"string\" ? canonical(value) : wrongShape(value, \"text\");\n/** A type whose canonical form reads text: that canonical form, and the same function as its cast from text. */\nfunction typeCanonicalFromText(id, canonical, spec) {\n\tconst toCanonicalForm = canonicalFromText(canonical);\n\treturn sqlDataType(id, {\n\t\t...spec,\n\t\ttoCanonicalForm,\n\t\tcasts: { [pgText.id]: toCanonicalForm }\n\t});\n}\nconst pgTimetz = typeCanonicalFromText(\"pg/timetz\", pgTimetzCanonical, {\n\tparams: pgPrecisionParams,\n\ttexts: [\n\t\twritten(\"timetz\"),\n\t\twritten(\"timetz({precision})\"),\n\t\tcatalog(\"time with time zone\"),\n\t\tcatalog(\"time({precision}) with time zone\")\n\t]\n});\nconst pgInterval = typeCanonicalFromText(\"pg/interval\", pgIntervalCanonical, {\n\tparams: pgPrecisionParams,\n\ttexts: [writtenAndCatalog(\"interval\"), writtenAndCatalog(\"interval({precision})\")]\n});\nconst pgBytea = typeCanonicalFromText(\"pg/bytea\", pgByteaCanonical, { texts: [writtenAndCatalog(\"bytea\")] });\nconst pgDate = typeCanonicalFromText(\"pg/date\", pgDateCanonical, { texts: [writtenAndCatalog(\"date\")] });\nconst pgTime = typeCanonicalFromText(\"pg/time\", pgTimeCanonical, {\n\tparams: pgPrecisionParams,\n\ttexts: [\n\t\twritten(\"time\"),\n\t\twritten(\"time({precision})\"),\n\t\tcatalog(\"time without time zone\"),\n\t\tcatalog(\"time({precision}) without time zone\")\n\t]\n});\nconst pgTimestamp = typeCanonicalFromText(\"pg/timestamp\", pgTimestampCanonical, {\n\tparams: pgPrecisionParams,\n\ttexts: [\n\t\twritten(\"timestamp\"),\n\t\twritten(\"timestamp({precision})\"),\n\t\tcatalog(\"timestamp without time zone\"),\n\t\tcatalog(\"timestamp({precision}) without time zone\")\n\t]\n});\nconst pgTimestamptz = typeCanonicalFromText(\"pg/timestamptz\", pgTimestamptzCanonical, {\n\tparams: pgPrecisionParams,\n\ttexts: [\n\t\twritten(\"timestamptz\"),\n\t\twritten(\"timestamptz({precision})\"),\n\t\tcatalog(\"timestamp with time zone\"),\n\t\tcatalog(\"timestamp({precision}) with time zone\")\n\t]\n});\n/** Every data type this target registers. */\nconst postgresDataTypes = [\n\tpgText,\n\tpgTextArray,\n\tpgEnum,\n\tpgInt2,\n\tpgBool,\n\tpgJson,\n\tpgTsquery,\n\tpgInt4,\n\tpgInt8,\n\tpgNumeric,\n\tpgFloat4,\n\tpgFloat8,\n\tpgJsonb,\n\tpgChar,\n\tpgVarchar,\n\tpgUuid,\n\tpgInet,\n\tpgBit,\n\tpgVarbit,\n\tpgTimetz,\n\tpgInterval,\n\tpgBytea,\n\tpgDate,\n\tpgTime,\n\tpgTimestamp,\n\tpgTimestamptz\n];\n/** A lookup of the data types this target registers. */\nfunction createPostgresBuiltinDataTypeLookup() {\n\treturn assembleDataTypes([{\n\t\tid: \"postgres\",\n\t\tdataTypes: postgresDataTypes\n\t}]).lookup;\n}\n//#endregion\nexport { pgTimestamptz as A, pgPrecisionParams as C, pgTimeCanonical as D, pgTime as E, pgUuid as F, pgVarbit as I, pgVarchar as L, pgTimetz as M, pgTimetzCanonical as N, pgTimestamp as O, pgTsquery as P, postgresDataTypes as R, pgNumericParams as S, pgTextArray as T, pgInt8 as _, pgBytea as a, pgJsonb as b, pgDate as c, pgEnumParams as d, pgFloat4 as f, pgInt4 as g, pgInt2 as h, pgBool as i, pgTimestamptzCanonical as j, pgTimestampCanonical as k, pgDateCanonical as l, pgInet as m, pgBit as n, pgChar as o, pgFloat8 as p, pgBitLengthParams as r, pgCharacterLengthParams as s, createPostgresBuiltinDataTypeLookup as t, pgEnum as u, pgInterval as v, pgText as w, pgNumeric as x, pgJson as y };\n\n//# sourceMappingURL=data-types-DzUVlWeo.mjs.map"],"mappings":"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"}

package/dist/data-types-E1wms1_i.d.mts

@@ -0,0 +1,96 @@
+import { DataType, DataTypeLookup } from "@prisma/orm-framework/components/codec";
+import { DataTypeAuthoringEntry } from "@prisma/orm-framework/components/authoring";
+//#region ../../../3-targets/3-targets/postgres/dist/data-types.d.mts
+//#region src/core/data-type-entries.d.ts
+declare function postgresDataTypeEntries(): Readonly<Record<string, DataTypeAuthoringEntry>>;
+//#endregion
+//#region src/core/data-types.d.ts
+/** The precision and scale of `numeric`. PostgreSQL 15 and later take a negative scale and one above the precision. */
+declare const pgNumericParams: import("arktype/internal/variants/object.ts").ObjectType<{
+  precision?: number;
+  scale?: number;
+}, {}>;
+/** The length of `char` and `varchar`. */
+declare const pgCharacterLengthParams: import("arktype/internal/variants/object.ts").ObjectType<{
+  length?: number;
+}, {}>;
+/** The length of `bit` and `bit varying`. */
+declare const pgBitLengthParams: import("arktype/internal/variants/object.ts").ObjectType<{
+  length?: number;
+}, {}>;
+/** The fractional-second precision of the time, timestamp and interval types. */
+declare const pgPrecisionParams: import("arktype/internal/variants/object.ts").ObjectType<{
+  precision?: number;
+}, {}>;
+declare const pgEnumParams: import("arktype/internal/variants/object.ts").ObjectType<{
+  typeName: string;
+}, {}>;
+declare const pgText: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<Readonly<Record<string, unknown>>>;
+declare const pgTextArray: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<Readonly<Record<string, unknown>>>;
+declare const pgEnum: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<{
+  typeName: string;
+}>;
+declare const pgInt2: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<Readonly<Record<string, unknown>>>;
+declare const pgBool: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<Readonly<Record<string, unknown>>>;
+declare const pgJson: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<Readonly<Record<string, unknown>>>;
+declare const pgTsquery: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<Readonly<Record<string, unknown>>>;
+declare const pgInt4: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<Readonly<Record<string, unknown>>>;
+declare const pgInt8: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<Readonly<Record<string, unknown>>>;
+declare const pgNumeric: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<{
+  precision?: number;
+  scale?: number;
+}>;
+declare const pgFloat4: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<Readonly<Record<string, unknown>>>;
+declare const pgFloat8: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<Readonly<Record<string, unknown>>>;
+declare const pgJsonb: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<Readonly<Record<string, unknown>>>;
+declare const pgChar: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<{
+  length?: number;
+}>;
+declare const pgVarchar: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<{
+  length?: number;
+}>;
+declare const pgUuid: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<Readonly<Record<string, unknown>>>;
+declare const pgInet: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<Readonly<Record<string, unknown>>>;
+declare const pgBit: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<{
+  length?: number;
+}>;
+declare const pgVarbit: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<{
+  length?: number;
+}>;
+/**
+ * Each range is what PostgreSQL and every codec of the type hold: PostgreSQL starts at 4714-11-24
+ * BC, and the `Temporal` and `Date` codecs end at +275760-09-13.
+ */
+declare const pgDateCanonical: (text: string) => string;
+declare const pgTimeCanonical: (text: string) => string;
+declare const pgTimetzCanonical: (text: string) => string;
+declare const pgTimestampCanonical: (text: string) => string;
+declare const pgTimestamptzCanonical: (text: string) => string;
+declare const pgTimetz: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<{
+  precision?: number;
+}>;
+declare const pgInterval: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<{
+  precision?: number;
+}>;
+declare const pgBytea: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<{
+  precision?: number;
+}>;
+declare const pgDate: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<{
+  precision?: number;
+}>;
+declare const pgTime: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<{
+  precision?: number;
+}>;
+declare const pgTimestamp: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<{
+  precision?: number;
+}>;
+declare const pgTimestamptz: import("@prisma/orm-family-sql/contract/data-type").SqlDataType<{
+  precision?: number;
+}>;
+/** Every data type this target registers. */
+declare const postgresDataTypes: readonly DataType[];
+/** A lookup of the data types this target registers. */
+declare function createPostgresBuiltinDataTypeLookup(): DataTypeLookup;
+//#endregion
+export { pgTimestamptz as A, pgPrecisionParams as C, pgTimeCanonical as D, pgTime as E, pgUuid as F, pgVarbit as I, pgVarchar as L, pgTimetz as M, pgTimetzCanonical as N, pgTimestamp as O, pgTsquery as P, postgresDataTypeEntries as R, pgNumericParams as S, pgTextArray as T, pgInt8 as _, pgBytea as a, pgJsonb as b, pgDate as c, pgEnumParams as d, pgFloat4 as f, pgInt4 as g, pgInt2 as h, pgBool as i, pgTimestamptzCanonical as j, pgTimestampCanonical as k, pgDateCanonical as l, pgInet as m, pgBit as n, pgChar as o, pgFloat8 as p, pgBitLengthParams as r, pgCharacterLengthParams as s, createPostgresBuiltinDataTypeLookup as t, pgEnum as u, pgInterval as v, pgText as w, pgNumeric as x, pgJson as y, postgresDataTypes as z };
+//# sourceMappingURL=data-types-E1wms1_i.d.mts.map

package/dist/data-types-E1wms1_i.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-types-E1wms1_i.d.mts","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/data-types.d.mts"],"mappings":";;;;iBAGiB,2BAA2B,SAAS,eAAe;;;;cAItD,+DAA+D;EAC3E;EACA;;;cAGY,uEAAuE;EACnF;;;cAGY,iEAAiE;EAC7E;;;cAGY,iEAAiE;EAC7E;;cAEY,4DAA4D;EACxE;;cAEY,mDAAmD,YAAY,SAAS;cACxE,wDAAwD,YAAY,SAAS;cAC7E,mDAAmD;EAC/D;;cAEY,mDAAmD,YAAY,SAAS;cACxE,mDAAmD,YAAY,SAAS;cACxE,mDAAmD,YAAY,SAAS;cACxE,sDAAsD,YAAY,SAAS;cAC3E,mDAAmD,YAAY,SAAS;cACxE,mDAAmD,YAAY,SAAS;cACxE,sDAAsD;EAClE;EACA;;cAEY,qDAAqD,YAAY,SAAS;cAC1E,qDAAqD,YAAY,SAAS;cAC1E,oDAAoD,YAAY,SAAS;cACzE,mDAAmD;EAC/D;;cAEY,sDAAsD;EAClE;;cAEY,mDAAmD,YAAY,SAAS;cACxE,mDAAmD,YAAY,SAAS;cACxE,kDAAkD;EAC9D;;cAEY,qDAAqD;EACjE;;;;;;cAMY,kBAAkB;cAClB,kBAAkB;cAClB,oBAAoB;cACpB,uBAAuB;cACvB,yBAAyB;cACzB,qDAAqD;EACjE;;cAEY,uDAAuD;EACnE;;cAEY,oDAAoD;EAChE;;cAEY,mDAAmD;EAC/D;;cAEY,mDAAmD;EAC/D;;cAEY,wDAAwD;EACpE;;cAEY,0DAA0D;EACtE;;;cAGY,4BAA4B;;iBAEzB,uCAAuC"}

package/dist/{ddl-BQFDVert-CcDdETee.mjs → ddl-BzsT_-qY-Cdzm0YIK.mjs}

@@ -1,10 +1,10 @@
 import { S as PG_TEXT_CODEC_ID } from "./codec-ids-Cb0yO-IS--e0P2rfI.mjs";
-import { h as postgresCreateNamespace, l as PostgresTableSource } from "./postgres-schema-C8slJGZo-CFGUyJPt.mjs";
+import { h as postgresCreateNamespace, l as PostgresTableSource } from "./postgres-schema-DXd0mebY-CExd_GcQ.mjs";
 import { a as PostgresAlterTable, c as PostgresCreateSchema, f as PostgresDisableRowLevelSecurity, h as PostgresDropType, i as PostgresAlterPolicyRename, l as PostgresCreateTable, m as PostgresDropPolicy, n as DropDefaultAction, o as PostgresCreateIndex, p as PostgresDropIndex, r as PostgresAlterIndexRename, s as PostgresCreatePolicy, t as AddColumnAction, u as PostgresCreateType } from "./nodes-Bm2a7z6e-BXTXyzZv.mjs";
 import { opaqueSql } from "@prisma/orm-family-sql/relational-core/ast";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { cfExpr, cfTable, exprSelect } from "@prisma/orm-family-sql/relational-core/contract-free";
-//#region ../../../3-targets/3-targets/postgres/dist/ddl-BQFDVert.mjs
+//#region ../../../3-targets/3-targets/postgres/dist/ddl-BzsT_-qY.mjs
 /**
 * `to_regclass($1)` with the qualified table name bound as a text parameter.
 * Thin vocabulary wrapper over the core `cfExpr.fn` helper — the target
@@ -404,4 +404,4 @@ function disableRowLevelSecurity(options) {
 //#endregion
 export { toRegclass as A, nativeEnumValueExistsAst as C, tableExistsAst as D, rlsPolicyExistsAst as E, tableIsEmptyAst as O, nativeEnumTypeExistsAst as S, rlsEnabledAst as T, dropIndex as _, columnDefaultAst as a, extensionExistsAst as b, columnTypeAst as c, createPolicy as d, createSchema as f, dropDefaultAction as g, disableRowLevelSecurity as h, alterTable as i, tablePrimaryKeyAst as k, constraintExistsAst as l, createType as m, alterIndexRename as n, columnExistsAst as o, createTable as p, alterPolicyRename as r, columnNullabilityAst as s, addColumnAction as t, createIndex as u, dropPolicy as v, noNullValuesAst as w, indexExistsAst as x, dropType as y };
 
-//# sourceMappingURL=ddl-BQFDVert-CcDdETee.mjs.map
+//# sourceMappingURL=ddl-BzsT_-qY-Cdzm0YIK.mjs.map