@prisma/orm-target-mysql 8.0.0-rc.22-dev.11 → 8.0.0-rc.22-dev.12

package/dist/codecs-BfiB79-5.mjs

@@ -0,0 +1,750 @@
+import { a as mysqlCodec, n as buildMysqlCodecDescriptorRegistry, r as identityJsonProjection, t as MysqlCodecDescriptor } from "./codec-descriptor-3xp1XvVH-yVLnNzZ8.mjs";
+import { a as MYSQL_DATE_STRING_CODEC_ID, c as MYSQL_ENUM_CODEC_ID, d as MYSQL_TIMESTAMP_DATE_CODEC_ID, f as MYSQL_TIMESTAMP_STRING_CODEC_ID, h as MYSQL_TIME_TEMPORAL_CODEC_ID, i as MYSQL_DATETIME_TEMPORAL_CODEC_ID, l as MYSQL_INT_CODEC_ID, m as MYSQL_TIME_STRING_CODEC_ID, n as MYSQL_DATETIME_CODEC_ID, o as MYSQL_DATE_TEMPORAL_CODEC_ID, p as MYSQL_TIMESTAMP_TEMPORAL_CODEC_ID, r as MYSQL_DATETIME_STRING_CODEC_ID, s as MYSQL_DURATION_STRING_CODEC_ID, t as MYSQL_BIGINT_CODEC_ID, u as MYSQL_TEXT_CODEC_ID } from "./codec-ids-CrR9Xi7r-CarpqbNM.mjs";
+import { c as mysqlQueryNotYetSupported, n as errorDateTimeUnwritable, o as errorTemporalWrongType, r as errorTemporalNonIsoCalendar, s as mysqlError, t as errorDateTimeUnreadable } from "./errors-Cng94tYg-D02Eud2d.mjs";
+import { C as mysqlTimestampText, S as mysqlTimestamp, _ as mysqlInt, b as mysqlTime, c as mysqlDateText, d as mysqlDatetimeText, f as mysqlDuration, g as mysqlEnumParams, h as mysqlEnum, i as mysqlChar, l as mysqlDatetime, m as mysqlDurationText, p as mysqlDurationParams, r as mysqlBigint, s as mysqlDate, u as mysqlDatetimeParams, v as mysqlText, w as mysqlVarchar, x as mysqlTimeText } from "./data-types-DOaaPS93-DBkMJyh1.mjs";
+import { t as requireTemporal } from "./require-temporal-DeDQhbTn-Bxc65WbA.mjs";
+import { CodecImpl, dateTimeStoredText, decimalTextBigintLiteral, refuseJsonValue, renderTsLiteral } from "@prisma/orm-framework/components/codec";
+import { CastExpr, SqlCharCodec, SqlRawCodec, SqlVarcharCodec, sqlCharDescriptor, sqlRawDescriptor, sqlVarcharDescriptor } from "@prisma/orm-family-sql/relational-core/ast";
+import { sqlRawDataType } from "@prisma/orm-family-sql/contract/data-type";
+import { hasDigitsBelow, hasDigitsBelowAMillisecond, isValidDate } from "@prisma/orm-framework/type-implementations/date";
+import { describeValue, temporalFromText, temporalToText, withoutUtcDesignator } from "@prisma/orm-framework/type-implementations/temporal-text";
+import { extractCodecLookup } from "@prisma/orm-framework/components/control";
+import { buildCodecDescriptorRegistry } from "@prisma/orm-family-sql/relational-core/codec-descriptor-registry";
+//#region ../../../3-targets/mysql/1-target/dist/codecs.mjs
+function messageOf(cause) {
+	return cause instanceof Error ? cause.message : String(cause);
+}
+/** The text MySQL reads for a stored date and time, `2024-01-02 03:04:05.5`. */
+function mysqlWireText(stored) {
+	return stored.replace("T", " ");
+}
+/** The UTC date and time without an offset that ISO 8601 text with a UTC offset names, in the form `stored` writes. Throws when the text names no instant, or one `stored` refuses. */
+function utcDateTimeOfInstantText(codecId, text, stored) {
+	return stored(withoutUtcDesignator(dateTimeStoredText(text, {
+		shape: "instant",
+		ownerId: codecId
+	})));
+}
+/** The stored form `stored` writes for a value an application wrote; a value it refuses is refused as `RUNTIME.ENCODE_FAILED`. */
+function storedTextForWrite(codecId, value, stored) {
+	if (typeof value !== "string") throw errorDateTimeUnwritable({
+		codecId,
+		received: describeValue(value),
+		detail: "It writes ISO 8601 text."
+	});
+	try {
+		return stored(value);
+	} catch (cause) {
+		throw errorDateTimeUnwritable({
+			codecId,
+			received: JSON.stringify(value),
+			detail: messageOf(cause),
+			cause
+		});
+	}
+}
+/** The stored form of the text MySQL returned for a row, as `stored` reads it; text `stored` refuses is refused as `RUNTIME.DECODE_FAILED`. */
+function storedTextFromWire(codecId, wire, stored) {
+	if (typeof wire !== "string") throw errorDateTimeUnreadable({
+		codecId,
+		value: String(wire),
+		detail: `MySQL returned ${describeValue(wire)}, not text.`
+	});
+	try {
+		return stored(wire);
+	} catch (cause) {
+		throw errorDateTimeUnreadable({
+			codecId,
+			value: wire,
+			detail: messageOf(cause),
+			cause
+		});
+	}
+}
+/** The Temporal value that stored text names, read with `parse`. */
+function temporalFromStoredText(identity, text, parse) {
+	const read = temporalFromText(requireTemporal({
+		codecId: identity.codecId,
+		operation: "decode"
+	}), text, parse);
+	if (read.kind === "unreadable") throw errorDateTimeUnreadable({
+		codecId: identity.codecId,
+		value: text,
+		detail: `${identity.temporalTag} cannot hold it: ${read.detail}. Use ${identity.stringType} to read the column as text.`,
+		cause: read.cause
+	});
+	return read.value;
+}
+/** The stored form of a Temporal value, as `stored` writes its ISO text. A value of another kind, in a calendar other than ISO 8601, or with digits below a microsecond, which MySQL does not hold, is refused. */
+function storedTextOfTemporal(identity, value, stored) {
+	const encoded = temporalToText(value, identity.temporalTag);
+	switch (encoded.kind) {
+		case "wrong-type": throw errorTemporalWrongType(identity.codecId, identity.temporalTag, identity.stringType, encoded.received);
+		case "non-iso-calendar": throw errorTemporalNonIsoCalendar(identity.codecId, encoded.calendarId);
+		case "text":
+			if (hasDigitsBelow(encoded.text, 6)) throw errorDateTimeUnwritable({
+				codecId: identity.codecId,
+				received: `the ${identity.temporalTag} ${encoded.text}`,
+				detail: "It has digits below a microsecond, and MySQL holds microseconds at most. Round it first, as in value.round({ smallestUnit: 'microsecond', roundingMode: 'trunc' })."
+			});
+			return storedTextForWrite(identity.codecId, encoded.text, stored);
+	}
+}
+const WIRE_DATE_TIME = /^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2}(?:\.\d+)?)$/;
+/** The instant the text MySQL sends for a `datetime` or a `timestamp` names in UTC: every session runs in UTC, so the text holds no time zone of its own. */
+function dateOfWireText(codecId, wire) {
+	const match = WIRE_DATE_TIME.exec(wire);
+	const date = match === null ? void 0 : /* @__PURE__ */ new Date(`${match[1]}T${match[2]}Z`);
+	if (date === void 0 || !isValidDate(date)) throw mysqlError("RUNTIME.DECODE_FAILED", `${codecId} wire value must be a date and time as MySQL prints it`, { meta: {
+		codecId,
+		received: String(wire)
+	} });
+	return date;
+}
+/** The text MySQL reads for a `Date` in UTC, with millisecond digits. An Invalid Date, and an instant `stored` refuses, are refused. */
+function wireTextOfDate(codecId, value, stored) {
+	if (!isValidDate(value)) throw mysqlError("RUNTIME.ENCODE_FAILED", `${codecId} value must be a valid Date`, { meta: {
+		codecId,
+		received: String(value)
+	} });
+	const text = value.toISOString();
+	storedTextForWrite(codecId, text, (instant) => utcDateTimeOfInstantText(codecId, instant, stored));
+	return mysqlWireText(withoutUtcDesignator(text));
+}
+/** The fraction digits a column with `params` holds: its `precision`, or 0, which MySQL holds when none is written. */
+function precisionOf(params) {
+	const precision = params["precision"];
+	return typeof precision === "number" ? precision : 0;
+}
+/** `stored`, a contract value of a column with `params`; a value with more fraction digits than the column holds, which MySQL would round, is refused. */
+function storedWithinPrecision(codecId, stored, params) {
+	const precision = precisionOf(params);
+	if (!hasDigitsBelow(stored, precision)) return stored;
+	return refuseJsonValue(codecId, `a value with at most ${precision} ${precision === 1 ? "fraction digit" : "fraction digits"} of a second, which precision ${precision} holds without rounding`, stored);
+}
+/** Wire text with its fraction cut to the digits the column's `precision` holds: MySQL rounds a value to its column, which could carry it to the next second, day or past the column's range. A codec reference that names no precision, as a raw parameter writes, describes no column, so its value is written whole. */
+function roundedDownToPrecision(text, params) {
+	const precision = params["precision"];
+	if (typeof precision !== "number") return text;
+	return text.replace(/\.(\d+)$/, (_fraction, digits) => precision === 0 ? "" : `.${digits.slice(0, precision)}`);
+}
+/** The stored form of an instant written as ISO 8601 text with a UTC offset: its UTC date and time, in the form `stored` writes. */
+const instantIn = (codecId, stored) => (text) => utcDateTimeOfInstantText(codecId, text, stored);
+/** Reads the text MySQL returns for a row in any year: a column's range is refused on write only. */
+const anyYear = (ownerId, shape) => (text) => dateTimeStoredText(text, {
+	shape,
+	ownerId
+});
+const datetimeRow = anyYear(mysqlDatetime.id, "dateTime");
+const timestampRow = anyYear(mysqlTimestamp.id, "dateTime");
+const dateRow = anyYear(mysqlDate.id, "date");
+const DATETIME_TEMPORAL = {
+	codecId: MYSQL_DATETIME_TEMPORAL_CODEC_ID,
+	temporalTag: "Temporal.Instant",
+	stringType: "DatetimeString"
+};
+const TIMESTAMP_TEMPORAL = {
+	codecId: MYSQL_TIMESTAMP_TEMPORAL_CODEC_ID,
+	temporalTag: "Temporal.Instant",
+	stringType: "TimestampString"
+};
+const DATE_TEMPORAL = {
+	codecId: MYSQL_DATE_TEMPORAL_CODEC_ID,
+	temporalTag: "Temporal.PlainDate",
+	stringType: "DateString"
+};
+const TIME_TEMPORAL = {
+	codecId: MYSQL_TIME_TEMPORAL_CODEC_ID,
+	temporalTag: "Temporal.PlainTime",
+	stringType: "TimeString"
+};
+const instantOf = (identity, stored) => temporalFromStoredText(identity, `${stored}Z`, (temporal, text) => temporal.Instant.from(text));
+/** A MySQL `timestamp` as a JavaScript `Date`, read and written in UTC. */
+var MysqlTimestampDateCodec = class extends CodecImpl {
+	async toWire(value, _ctx) {
+		return roundedDownToPrecision(wireTextOfDate(this.id, value, mysqlTimestampText), this.dataTypeParams);
+	}
+	async fromWire(wire, _ctx) {
+		return dateOfWireText(this.id, wire);
+	}
+	fromDataTypeValue(value) {
+		const stored = storedWithinPrecision(this.id, value.value, this.dataTypeParams);
+		if (hasDigitsBelowAMillisecond(stored)) return refuseJsonValue(this.id, `a timestamp with no digits below a millisecond, which a Date drops: ${JSON.stringify(value.value)} has them`, value.value);
+		return /* @__PURE__ */ new Date(`${stored}Z`);
+	}
+	toDataTypeValue(input) {
+		return this.dataTypeValueOf(input.toISOString().replace("Z", ""));
+	}
+};
+var MysqlTimestampDateDescriptor = class extends MysqlCodecDescriptor {
+	dataType = mysqlTimestamp.id;
+	codecId = MYSQL_TIMESTAMP_DATE_CODEC_ID;
+	traits = ["equality", "order"];
+	paramsSchema = mysqlDatetimeParams;
+	jsonProjection(expression) {
+		return identityJsonProjection(expression);
+	}
+	factory(params) {
+		return () => new MysqlTimestampDateCodec(this, mysqlTimestamp, params);
+	}
+};
+const mysqlTimestampDateDescriptor = new MysqlTimestampDateDescriptor();
+/** An instant read as `Temporal.Instant` from a `datetime` that holds it in UTC. */
+var MysqlDatetimeTemporalCodec = class extends CodecImpl {
+	async toWire(value, _ctx) {
+		return roundedDownToPrecision(mysqlWireText(this.stored(value)), this.dataTypeParams);
+	}
+	async fromWire(wire, _ctx) {
+		return instantOf(DATETIME_TEMPORAL, storedTextFromWire(this.id, wire, datetimeRow));
+	}
+	fromDataTypeValue(value) {
+		return instantOf(DATETIME_TEMPORAL, storedWithinPrecision(this.id, value.value, this.dataTypeParams));
+	}
+	toDataTypeValue(input) {
+		return this.dataTypeValueOf(this.stored(input));
+	}
+	stored(value) {
+		return storedTextOfTemporal(DATETIME_TEMPORAL, value, instantIn(this.id, mysqlDatetimeText));
+	}
+};
+var MysqlDatetimeTemporalDescriptor = class extends MysqlCodecDescriptor {
+	dataType = mysqlDatetime.id;
+	codecId = MYSQL_DATETIME_TEMPORAL_CODEC_ID;
+	traits = ["equality", "order"];
+	paramsSchema = mysqlDatetimeParams;
+	jsonProjection(expression) {
+		return identityJsonProjection(expression);
+	}
+	factory(params) {
+		return () => new MysqlDatetimeTemporalCodec(this, mysqlDatetime, params);
+	}
+};
+const mysqlDatetimeTemporalDescriptor = new MysqlDatetimeTemporalDescriptor();
+/** An instant read as `Temporal.Instant` from a `timestamp`. */
+var MysqlTimestampTemporalCodec = class extends CodecImpl {
+	async toWire(value, _ctx) {
+		return roundedDownToPrecision(mysqlWireText(this.stored(value)), this.dataTypeParams);
+	}
+	async fromWire(wire, _ctx) {
+		return instantOf(TIMESTAMP_TEMPORAL, storedTextFromWire(this.id, wire, timestampRow));
+	}
+	fromDataTypeValue(value) {
+		return instantOf(TIMESTAMP_TEMPORAL, storedWithinPrecision(this.id, value.value, this.dataTypeParams));
+	}
+	toDataTypeValue(input) {
+		return this.dataTypeValueOf(this.stored(input));
+	}
+	stored(value) {
+		return storedTextOfTemporal(TIMESTAMP_TEMPORAL, value, instantIn(this.id, mysqlTimestampText));
+	}
+};
+var MysqlTimestampTemporalDescriptor = class extends MysqlCodecDescriptor {
+	dataType = mysqlTimestamp.id;
+	codecId = MYSQL_TIMESTAMP_TEMPORAL_CODEC_ID;
+	traits = ["equality", "order"];
+	paramsSchema = mysqlDatetimeParams;
+	jsonProjection(expression) {
+		return identityJsonProjection(expression);
+	}
+	factory(params) {
+		return () => new MysqlTimestampTemporalCodec(this, mysqlTimestamp, params);
+	}
+};
+const mysqlTimestampTemporalDescriptor = new MysqlTimestampTemporalDescriptor();
+/** The literal of the instant text a string codec reads from a stored date and time, which has no offset. */
+function renderInstantTextLiteral(value) {
+	return typeof value === "string" ? renderTsLiteral(`${value}Z`) : void 0;
+}
+/** An instant read as ISO 8601 text in UTC, `2024-01-01T00:00:00.5Z`, from a `datetime`. A write takes ISO 8601 text with any UTC offset. */
+var MysqlDatetimeStringCodec = class extends CodecImpl {
+	async toWire(value, _ctx) {
+		return roundedDownToPrecision(mysqlWireText(storedTextForWrite(this.id, value, instantIn(this.id, mysqlDatetimeText))), this.dataTypeParams);
+	}
+	async fromWire(wire, _ctx) {
+		return `${storedTextFromWire(this.id, wire, datetimeRow)}Z`;
+	}
+	fromDataTypeValue(value) {
+		return `${storedWithinPrecision(this.id, value.value, this.dataTypeParams)}Z`;
+	}
+	toDataTypeValue(input) {
+		return this.dataTypeValueOf(instantIn(this.id, mysqlDatetimeText)(input));
+	}
+};
+var MysqlDatetimeStringDescriptor = class extends MysqlCodecDescriptor {
+	dataType = mysqlDatetime.id;
+	codecId = MYSQL_DATETIME_STRING_CODEC_ID;
+	traits = ["equality", "order"];
+	paramsSchema = mysqlDatetimeParams;
+	renderValueLiteral(value) {
+		return renderInstantTextLiteral(value);
+	}
+	jsonProjection(expression) {
+		return identityJsonProjection(expression);
+	}
+	factory(params) {
+		return () => new MysqlDatetimeStringCodec(this, mysqlDatetime, params);
+	}
+};
+const mysqlDatetimeStringDescriptor = new MysqlDatetimeStringDescriptor();
+/** An instant read as ISO 8601 text in UTC, `2024-01-01T00:00:00.5Z`, from a `timestamp`. A write takes ISO 8601 text with any UTC offset. */
+var MysqlTimestampStringCodec = class extends CodecImpl {
+	async toWire(value, _ctx) {
+		return roundedDownToPrecision(mysqlWireText(storedTextForWrite(this.id, value, instantIn(this.id, mysqlTimestampText))), this.dataTypeParams);
+	}
+	async fromWire(wire, _ctx) {
+		return `${storedTextFromWire(this.id, wire, timestampRow)}Z`;
+	}
+	fromDataTypeValue(value) {
+		return `${storedWithinPrecision(this.id, value.value, this.dataTypeParams)}Z`;
+	}
+	toDataTypeValue(input) {
+		return this.dataTypeValueOf(instantIn(this.id, mysqlTimestampText)(input));
+	}
+};
+var MysqlTimestampStringDescriptor = class extends MysqlCodecDescriptor {
+	dataType = mysqlTimestamp.id;
+	codecId = MYSQL_TIMESTAMP_STRING_CODEC_ID;
+	traits = ["equality", "order"];
+	paramsSchema = mysqlDatetimeParams;
+	renderValueLiteral(value) {
+		return renderInstantTextLiteral(value);
+	}
+	jsonProjection(expression) {
+		return identityJsonProjection(expression);
+	}
+	factory(params) {
+		return () => new MysqlTimestampStringCodec(this, mysqlTimestamp, params);
+	}
+};
+const mysqlTimestampStringDescriptor = new MysqlTimestampStringDescriptor();
+/** A calendar date read as ISO 8601 text, `2024-02-29`. */
+var MysqlDateStringCodec = class extends CodecImpl {
+	async toWire(value, _ctx) {
+		return storedTextForWrite(this.id, value, mysqlDateText);
+	}
+	async fromWire(wire, _ctx) {
+		return storedTextFromWire(this.id, wire, dateRow);
+	}
+	fromDataTypeValue(value) {
+		return value.value;
+	}
+	toDataTypeValue(input) {
+		return this.storedDataTypeValueOf(input);
+	}
+};
+var MysqlDateStringDescriptor = class extends MysqlCodecDescriptor {
+	dataType = mysqlDate.id;
+	codecId = MYSQL_DATE_STRING_CODEC_ID;
+	traits = ["equality", "order"];
+	paramsSchema = void 0;
+	renderValueLiteral(value) {
+		return renderTsLiteral(value);
+	}
+	jsonProjection(expression) {
+		return identityJsonProjection(expression);
+	}
+	factory() {
+		return () => new MysqlDateStringCodec(this, mysqlDate);
+	}
+};
+const mysqlDateStringDescriptor = new MysqlDateStringDescriptor();
+/** A calendar date read as `Temporal.PlainDate`. */
+var MysqlDateTemporalCodec = class extends CodecImpl {
+	async toWire(value, _ctx) {
+		return storedTextOfTemporal(DATE_TEMPORAL, value, mysqlDateText);
+	}
+	async fromWire(wire, _ctx) {
+		return this.plainDateOf(storedTextFromWire(this.id, wire, dateRow));
+	}
+	fromDataTypeValue(value) {
+		return this.plainDateOf(value.value);
+	}
+	toDataTypeValue(input) {
+		return this.dataTypeValueOf(storedTextOfTemporal(DATE_TEMPORAL, input, mysqlDateText));
+	}
+	plainDateOf(stored) {
+		return temporalFromStoredText(DATE_TEMPORAL, stored, (temporal, text) => temporal.PlainDate.from(text));
+	}
+};
+var MysqlDateTemporalDescriptor = class extends MysqlCodecDescriptor {
+	dataType = mysqlDate.id;
+	codecId = MYSQL_DATE_TEMPORAL_CODEC_ID;
+	traits = ["equality", "order"];
+	paramsSchema = void 0;
+	jsonProjection(expression) {
+		return identityJsonProjection(expression);
+	}
+	factory() {
+		return () => new MysqlDateTemporalCodec(this, mysqlDate);
+	}
+};
+const mysqlDateTemporalDescriptor = new MysqlDateTemporalDescriptor();
+/** A time of day read as ISO 8601 text, `09:30:00.5`. A MySQL `time` outside 00:00:00 to 23:59:59.999999 is no time of day, so it is refused on read and on write. */
+var MysqlTimeStringCodec = class extends CodecImpl {
+	async toWire(value, _ctx) {
+		return roundedDownToPrecision(storedTextForWrite(this.id, value, mysqlTimeText), this.dataTypeParams);
+	}
+	async fromWire(wire, _ctx) {
+		return storedTextFromWire(this.id, wire, mysqlTimeText);
+	}
+	fromDataTypeValue(value) {
+		return storedWithinPrecision(this.id, value.value, this.dataTypeParams);
+	}
+	toDataTypeValue(input) {
+		return this.storedDataTypeValueOf(input);
+	}
+};
+var MysqlTimeStringDescriptor = class extends MysqlCodecDescriptor {
+	dataType = mysqlTime.id;
+	codecId = MYSQL_TIME_STRING_CODEC_ID;
+	traits = ["equality", "order"];
+	paramsSchema = mysqlDatetimeParams;
+	renderValueLiteral(value) {
+		return renderTsLiteral(value);
+	}
+	jsonProjection(expression) {
+		return identityJsonProjection(expression);
+	}
+	factory(params) {
+		return () => new MysqlTimeStringCodec(this, mysqlTime, params);
+	}
+};
+const mysqlTimeStringDescriptor = new MysqlTimeStringDescriptor();
+/** A time of day read as `Temporal.PlainTime`. */
+var MysqlTimeTemporalCodec = class extends CodecImpl {
+	async toWire(value, _ctx) {
+		return roundedDownToPrecision(storedTextOfTemporal(TIME_TEMPORAL, value, mysqlTimeText), this.dataTypeParams);
+	}
+	async fromWire(wire, _ctx) {
+		return this.plainTimeOf(storedTextFromWire(this.id, wire, mysqlTimeText));
+	}
+	fromDataTypeValue(value) {
+		return this.plainTimeOf(storedWithinPrecision(this.id, value.value, this.dataTypeParams));
+	}
+	toDataTypeValue(input) {
+		return this.dataTypeValueOf(storedTextOfTemporal(TIME_TEMPORAL, input, mysqlTimeText));
+	}
+	plainTimeOf(stored) {
+		return temporalFromStoredText(TIME_TEMPORAL, stored, (temporal, text) => temporal.PlainTime.from(text));
+	}
+};
+var MysqlTimeTemporalDescriptor = class extends MysqlCodecDescriptor {
+	dataType = mysqlTime.id;
+	codecId = MYSQL_TIME_TEMPORAL_CODEC_ID;
+	traits = ["equality", "order"];
+	paramsSchema = mysqlDatetimeParams;
+	jsonProjection(expression) {
+		return identityJsonProjection(expression);
+	}
+	factory(params) {
+		return () => new MysqlTimeTemporalCodec(this, mysqlTime, params);
+	}
+};
+const mysqlTimeTemporalDescriptor = new MysqlTimeTemporalDescriptor();
+/** A length of time read as the ISO 8601 duration it was written as, `PT1H30M`, stored in a `varchar` column. Its text does not sort in the order of the durations, so it offers no order. */
+var MysqlDurationStringCodec = class extends CodecImpl {
+	async toWire(value, _ctx) {
+		return storedTextForWrite(this.id, value, mysqlDurationText);
+	}
+	async fromWire(wire, _ctx) {
+		return storedTextFromWire(this.id, wire, mysqlDurationText);
+	}
+	fromDataTypeValue(value) {
+		return value.value;
+	}
+	toDataTypeValue(input) {
+		return this.storedDataTypeValueOf(input);
+	}
+};
+var MysqlDurationStringDescriptor = class extends MysqlCodecDescriptor {
+	dataType = mysqlDuration.id;
+	codecId = MYSQL_DURATION_STRING_CODEC_ID;
+	traits = ["equality"];
+	paramsSchema = mysqlDurationParams;
+	renderValueLiteral(value) {
+		return renderTsLiteral(value);
+	}
+	jsonProjection(expression) {
+		return identityJsonProjection(expression);
+	}
+	factory(_params) {
+		return () => new MysqlDurationStringCodec(this, mysqlDuration);
+	}
+};
+const mysqlDurationStringDescriptor = new MysqlDurationStringDescriptor();
+const DECIMAL_INTEGER = /^-?\d+$/;
+const BIGINT_MIN = -(2n ** 63n);
+const BIGINT_MAX = 2n ** 63n - 1n;
+/** Projects a bigint as its decimal text: a JSON number past 2^53 would lose digits when JavaScript parses the include. */
+const textJsonProjection = (expression) => CastExpr.as(expression, "CHAR");
+function decodeFailed(codecId, expected, received) {
+	throw mysqlError("RUNTIME.DECODE_FAILED", `${codecId} wire value must be ${expected}`, { meta: {
+		codecId,
+		received: String(received)
+	} });
+}
+function encodeFailed(codecId, expected, received) {
+	throw mysqlError("RUNTIME.ENCODE_FAILED", `${codecId} value must be ${expected}`, { meta: {
+		codecId,
+		received: String(received)
+	} });
+}
+const mysqlSqlCharDescriptor = mysqlCodec(sqlCharDescriptor, {
+	dataType: mysqlChar,
+	renderValueLiteral: renderTsLiteral,
+	jsonProjection: identityJsonProjection,
+	factory: (descriptor, dataType, params) => () => new SqlCharCodec(descriptor, dataType, params)
+});
+const mysqlSqlVarcharDescriptor = mysqlCodec(sqlVarcharDescriptor, {
+	dataType: mysqlVarchar,
+	renderValueLiteral: renderTsLiteral,
+	jsonProjection: identityJsonProjection,
+	factory: (descriptor, dataType, params) => () => new SqlVarcharCodec(descriptor, dataType, params)
+});
+const mysqlSqlRawDescriptor = mysqlCodec(sqlRawDescriptor, {
+	dataType: sqlRawDataType,
+	jsonProjection: () => {
+		throw mysqlQueryNotYetSupported("Reading a raw column inside an include");
+	},
+	factory: (descriptor, dataType, params) => () => new SqlRawCodec(descriptor, dataType, params)
+});
+var MysqlTextCodec = class extends CodecImpl {
+	async toWire(value, _ctx) {
+		return value;
+	}
+	async fromWire(wire, _ctx) {
+		return wire;
+	}
+	fromDataTypeValue(value) {
+		return value.value;
+	}
+	toDataTypeValue(input) {
+		return this.dataTypeValueOf(input);
+	}
+};
+var MysqlTextDescriptor = class extends MysqlCodecDescriptor {
+	dataType = mysqlText.id;
+	codecId = MYSQL_TEXT_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"textual"
+	];
+	paramsSchema = void 0;
+	renderValueLiteral(value) {
+		return renderTsLiteral(value);
+	}
+	jsonProjection(expression) {
+		return identityJsonProjection(expression);
+	}
+	factory() {
+		return () => new MysqlTextCodec(this, mysqlText);
+	}
+};
+const mysqlTextDescriptor = new MysqlTextDescriptor();
+/** A MySQL `int` as a JavaScript number. A row carries it as decimal text, and an include's JSON as a number. */
+var MysqlIntCodec = class extends CodecImpl {
+	async toWire(value, _ctx) {
+		if (!Number.isSafeInteger(value)) return encodeFailed(MYSQL_INT_CODEC_ID, "an integer", value);
+		return value;
+	}
+	async fromWire(wire, _ctx) {
+		if (typeof wire === "number") return wire;
+		if (!DECIMAL_INTEGER.test(wire)) return decodeFailed(MYSQL_INT_CODEC_ID, "the decimal text of an integer", wire);
+		return Number(wire);
+	}
+	fromDataTypeValue(value) {
+		return value.value;
+	}
+	toDataTypeValue(input) {
+		return this.dataTypeValueOf(input);
+	}
+};
+var MysqlIntDescriptor = class extends MysqlCodecDescriptor {
+	dataType = mysqlInt.id;
+	codecId = MYSQL_INT_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"numeric"
+	];
+	paramsSchema = void 0;
+	renderValueLiteral(value) {
+		return renderTsLiteral(value);
+	}
+	jsonProjection(expression) {
+		return identityJsonProjection(expression);
+	}
+	factory() {
+		return () => new MysqlIntCodec(this, mysqlInt);
+	}
+};
+const mysqlIntDescriptor = new MysqlIntDescriptor();
+/** A MySQL `bigint` as a JavaScript bigint. A row, an include's JSON and a parameter carry it as decimal text, as the Postgres `int8` codec does; MySQL reads a text parameter beside a `bigint` column exactly. */
+var MysqlBigintCodec = class extends CodecImpl {
+	/** The bigint itself: the driver writes it as bare digits, which MySQL reads as an exact integer even beside an expression, where it compares quoted text as a double. */
+	async toWire(value, _ctx) {
+		if (typeof value !== "bigint" || value < BIGINT_MIN || value > BIGINT_MAX) return encodeFailed(MYSQL_BIGINT_CODEC_ID, `a bigint from ${BIGINT_MIN} to ${BIGINT_MAX}`, value);
+		return value;
+	}
+	async fromWire(wire, _ctx) {
+		if (typeof wire === "bigint") return wire;
+		if (!DECIMAL_INTEGER.test(wire)) return decodeFailed(MYSQL_BIGINT_CODEC_ID, "the decimal text of an integer", wire);
+		return BigInt(wire);
+	}
+	fromDataTypeValue(value) {
+		return BigInt(value.value);
+	}
+	toDataTypeValue(input) {
+		return this.dataTypeValueOf(input.toString());
+	}
+};
+var MysqlBigintDescriptor = class extends MysqlCodecDescriptor {
+	dataType = mysqlBigint.id;
+	codecId = MYSQL_BIGINT_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"numeric"
+	];
+	paramsSchema = void 0;
+	renderValueLiteral(value) {
+		return decimalTextBigintLiteral(value);
+	}
+	jsonProjection(expression) {
+		return textJsonProjection(expression);
+	}
+	factory() {
+		return () => new MysqlBigintCodec(this, mysqlBigint);
+	}
+};
+const mysqlBigintDescriptor = new MysqlBigintDescriptor();
+/**
+* Reads the text MySQL sends for a `datetime` as the instant it names in UTC: the codec writes every value in UTC, so the column holds no time zone of its own.
+*/
+function decodeMysqlDatetime(wire) {
+	return dateOfWireText(MYSQL_DATETIME_CODEC_ID, wire);
+}
+/** The text MySQL reads for an instant in UTC, with millisecond digits. A `Date` outside the years a `datetime` holds is refused. */
+function encodeMysqlDatetime(value) {
+	return wireTextOfDate(MYSQL_DATETIME_CODEC_ID, value, mysqlDatetimeText);
+}
+/** A MySQL `datetime` as a JavaScript `Date`, read and written in UTC. */
+var MysqlDatetimeCodec = class extends CodecImpl {
+	async toWire(value, _ctx) {
+		return roundedDownToPrecision(encodeMysqlDatetime(value), this.dataTypeParams);
+	}
+	async fromWire(wire, _ctx) {
+		return decodeMysqlDatetime(wire);
+	}
+	fromDataTypeValue(value) {
+		const stored = storedWithinPrecision(this.id, value.value, this.dataTypeParams);
+		if (hasDigitsBelowAMillisecond(stored)) return refuseJsonValue(this.id, `a datetime with no digits below a millisecond, which a Date drops: ${JSON.stringify(value.value)} has them`, value.value);
+		return /* @__PURE__ */ new Date(`${stored}Z`);
+	}
+	toDataTypeValue(input) {
+		return this.dataTypeValueOf(input.toISOString().replace("Z", ""));
+	}
+};
+var MysqlDatetimeDescriptor = class extends MysqlCodecDescriptor {
+	dataType = mysqlDatetime.id;
+	codecId = MYSQL_DATETIME_CODEC_ID;
+	traits = ["equality", "order"];
+	paramsSchema = mysqlDatetimeParams;
+	jsonProjection(expression) {
+		return identityJsonProjection(expression);
+	}
+	factory(params) {
+		return () => new MysqlDatetimeCodec(this, mysqlDatetime, params);
+	}
+};
+const mysqlDatetimeDescriptor = new MysqlDatetimeDescriptor();
+/** A native MySQL enum column, whose value is the member's text. */
+var MysqlEnumCodec = class extends CodecImpl {
+	async toWire(value, _ctx) {
+		return value;
+	}
+	async fromWire(wire, _ctx) {
+		return wire;
+	}
+	fromDataTypeValue(value) {
+		return value.value;
+	}
+	toDataTypeValue(input) {
+		return this.dataTypeValueOf(input);
+	}
+};
+var MysqlEnumDescriptor = class extends MysqlCodecDescriptor {
+	dataType = mysqlEnum.id;
+	codecId = MYSQL_ENUM_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"textual"
+	];
+	paramsSchema = mysqlEnumParams;
+	renderValueLiteral(value) {
+		return renderTsLiteral(value);
+	}
+	jsonProjection(expression) {
+		return identityJsonProjection(expression);
+	}
+	factory(params) {
+		return () => new MysqlEnumCodec(this, mysqlEnum, params);
+	}
+};
+/** Every codec descriptor this target ships. */
+const codecDescriptors = [
+	mysqlSqlCharDescriptor,
+	mysqlSqlVarcharDescriptor,
+	mysqlSqlRawDescriptor,
+	mysqlTextDescriptor,
+	mysqlIntDescriptor,
+	mysqlBigintDescriptor,
+	mysqlDatetimeDescriptor,
+	mysqlDatetimeTemporalDescriptor,
+	mysqlDatetimeStringDescriptor,
+	mysqlTimestampDateDescriptor,
+	mysqlTimestampTemporalDescriptor,
+	mysqlTimestampStringDescriptor,
+	mysqlDateStringDescriptor,
+	mysqlDateTemporalDescriptor,
+	mysqlTimeStringDescriptor,
+	mysqlTimeTemporalDescriptor,
+	mysqlDurationStringDescriptor,
+	new MysqlEnumDescriptor()
+];
+/** Every codec descriptor `@internal/target-mysql` ships, for consumers that enumerate or look up a MySQL codec by id. ADR 208. */
+const mysqlCodecRegistry = buildCodecDescriptorRegistry(codecDescriptors);
+const mysqlCodecDescriptorRegistry = buildMysqlCodecDescriptorRegistry(codecDescriptors);
+function descriptorsFrom(contributors) {
+	return contributors.flatMap((contributor) => contributor.types?.codecTypes?.codecDescriptors ?? []);
+}
+function buildMysqlCodecRegistry(descriptors) {
+	const descriptorRegistry = buildMysqlCodecDescriptorRegistry(descriptors);
+	const registry = {
+		...extractCodecLookup([{
+			id: "mysql-codecs",
+			types: { codecTypes: { codecDescriptors: Array.from(descriptorRegistry.values()) } }
+		}]),
+		descriptorFor: (codecId) => descriptorRegistry.descriptorFor(codecId),
+		values: () => descriptorRegistry.values()
+	};
+	return Object.freeze(registry);
+}
+/** The codec registry of a MySQL stack: the target's built-in codecs and those its extensions contribute. */
+function assembleMysqlCodecRegistry(target, extensions) {
+	return buildMysqlCodecRegistry([
+		...descriptorsFrom([target]),
+		...mysqlCodecDescriptorRegistry.values(),
+		...descriptorsFrom(extensions)
+	]);
+}
+/** A codec registry of the MySQL built-in codecs only. */
+function createMysqlBuiltinCodecLookup() {
+	return buildMysqlCodecRegistry([...mysqlCodecDescriptorRegistry.values()]);
+}
+//#endregion
+export { mysqlCodecDescriptorRegistry as a, encodeMysqlDatetime as i, createMysqlBuiltinCodecLookup as n, mysqlCodecRegistry as o, decodeMysqlDatetime as r, assembleMysqlCodecRegistry as t };
+
+//# sourceMappingURL=codecs-BfiB79-5.mjs.map