@prisma/orm-target-mysql 0.0.0-stage → 8.0.0-rc.21-dev.23

package/dist/errors-rvH_F2Yj-BQrO_--u.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-rvH_F2Yj-BQrO_--u.mjs","names":[],"sources":["../../../../3-targets/mysql/1-target/dist/errors-rvH_F2Yj.mjs"],"sourcesContent":["import { structuredError } from \"@internal/utils/structured-error\";\n//#region src/core/errors.ts\nfunction mysqlError(code, message, options) {\n\treturn structuredError(code, message, options);\n}\n/** The refusal of a query a later slice of the MySQL target can render: `what` names the feature, as in `Lowering queries`. */\nfunction mysqlQueryNotYetSupported(what) {\n\treturn mysqlError(\"RUNTIME.AST_UNSUPPORTED\", `${what} is not yet supported on MySQL.`, {\n\t\twhy: \"The MySQL target renders reads; writes and some query forms are not built yet.\",\n\t\tfix: \"Use a Postgres or SQLite target for this query until the MySQL target supports it.\",\n\t\tmeta: {\n\t\t\ttarget: \"mysql\",\n\t\t\tfeature: what\n\t\t}\n\t});\n}\n//#endregion\nexport { mysqlQueryNotYetSupported as n, mysqlError as t };\n\n//# sourceMappingURL=errors-rvH_F2Yj.mjs.map"],"mappings":";;AAEA,SAAS,WAAW,MAAM,SAAS,SAAS;CAC3C,OAAO,gBAAgB,MAAM,SAAS,OAAO;AAC9C;;AAEA,SAAS,0BAA0B,MAAM;CACxC,OAAO,WAAW,2BAA2B,GAAG,KAAK,kCAAkC;EACtF,KAAK;EACL,KAAK;EACL,MAAM;GACL,QAAQ;GACR,SAAS;EACV;CACD,CAAC;AACF"}

package/dist/marker-lock-CmGvN4hw-Com29AtQ.mjs

@@ -0,0 +1,51 @@
+import { t as mysqlError } from "./errors-rvH_F2Yj-BQrO_--u.mjs";
+//#region ../../../3-targets/mysql/1-target/dist/marker-lock-CmGvN4hw.mjs
+/** How long a migration runner or `db sign` waits for another one to release the marker lock. */
+const MARKER_LOCK_TIMEOUT_SECONDS = 60;
+/** `GET_LOCK` names are global to the server, so the name carries a hash of the connection's database: two databases on one server never wait on each other. */
+const LOCK_NAME = "CONCAT('prisma_marker_', LEFT(SHA2(DATABASE(), 256), 50))";
+function lockResult(rows) {
+	const value = rows[0]?.["acquired"];
+	return value === null || value === void 0 ? void 0 : String(value);
+}
+/**
+* Takes the marker lock on the connection `driver` holds. MySQL holds a `GET_LOCK` lock for the session, not for a transaction, so the caller releases it with {@link releaseMarkerLock} on the same connection when the work it guards ends.
+*/
+async function acquireMarkerLock(driver, timeoutSeconds = 60) {
+	const { rows } = await driver.query(`SELECT GET_LOCK(${LOCK_NAME}, ?) AS acquired`, [timeoutSeconds]);
+	if (lockResult(rows) !== "1") throw mysqlError("MIGRATION.MARKER_LOCK_TIMEOUT", `Another process held the migration marker lock for ${timeoutSeconds} seconds.`, {
+		why: "A migration or db sign on this database is still running, and they write the contract markers one at a time.",
+		fix: "Wait for the other process to finish, then run the command again.",
+		meta: { timeoutSeconds }
+	});
+}
+/** Releases the marker lock {@link acquireMarkerLock} took on this connection. */
+async function releaseMarkerLock(driver) {
+	await driver.query(`SELECT RELEASE_LOCK(${LOCK_NAME}) AS released`);
+}
+/**
+* Releases the marker lock after work that failed, keeping that failure: a release that fails too is dropped. MySQL frees a session's locks when the session ends, which is the usual reason a release fails.
+*/
+async function releaseMarkerLockAfterFailure(driver) {
+	await releaseMarkerLock(driver).catch(() => void 0);
+}
+/**
+* The one way MySQL holds the marker lock: takes it on the connection `driver` holds, runs `work`, and releases it on the same connection when `work` ends. A failed release is reported only when `work` succeeded; when `work` throws, or `succeeded` says its result is a failure, that outcome is what comes back.
+*/
+async function withMarkerLock(driver, work, succeeded = () => true) {
+	await acquireMarkerLock(driver);
+	let result;
+	try {
+		result = await work();
+	} catch (error) {
+		await releaseMarkerLockAfterFailure(driver);
+		throw error;
+	}
+	if (succeeded(result)) await releaseMarkerLock(driver);
+	else await releaseMarkerLockAfterFailure(driver);
+	return result;
+}
+//#endregion
+export { withMarkerLock as i, acquireMarkerLock as n, releaseMarkerLock as r, MARKER_LOCK_TIMEOUT_SECONDS as t };
+
+//# sourceMappingURL=marker-lock-CmGvN4hw-Com29AtQ.mjs.map

package/dist/marker-lock-CmGvN4hw-Com29AtQ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"marker-lock-CmGvN4hw-Com29AtQ.mjs","names":[],"sources":["../../../../3-targets/mysql/1-target/dist/marker-lock-CmGvN4hw.mjs"],"sourcesContent":["import { t as mysqlError } from \"./errors-rvH_F2Yj.mjs\";\n//#region src/core/marker-lock.ts\n/** How long a migration runner or `db sign` waits for another one to release the marker lock. */\nconst MARKER_LOCK_TIMEOUT_SECONDS = 60;\n/** `GET_LOCK` names are global to the server, so the name carries a hash of the connection's database: two databases on one server never wait on each other. */\nconst LOCK_NAME = \"CONCAT('prisma_marker_', LEFT(SHA2(DATABASE(), 256), 50))\";\nfunction lockResult(rows) {\n\tconst value = rows[0]?.[\"acquired\"];\n\treturn value === null || value === void 0 ? void 0 : String(value);\n}\n/**\n* Takes the marker lock on the connection `driver` holds. MySQL holds a `GET_LOCK` lock for the session, not for a transaction, so the caller releases it with {@link releaseMarkerLock} on the same connection when the work it guards ends.\n*/\nasync function acquireMarkerLock(driver, timeoutSeconds = 60) {\n\tconst { rows } = await driver.query(`SELECT GET_LOCK(${LOCK_NAME}, ?) AS acquired`, [timeoutSeconds]);\n\tif (lockResult(rows) !== \"1\") throw mysqlError(\"MIGRATION.MARKER_LOCK_TIMEOUT\", `Another process held the migration marker lock for ${timeoutSeconds} seconds.`, {\n\t\twhy: \"A migration or db sign on this database is still running, and they write the contract markers one at a time.\",\n\t\tfix: \"Wait for the other process to finish, then run the command again.\",\n\t\tmeta: { timeoutSeconds }\n\t});\n}\n/** Releases the marker lock {@link acquireMarkerLock} took on this connection. */\nasync function releaseMarkerLock(driver) {\n\tawait driver.query(`SELECT RELEASE_LOCK(${LOCK_NAME}) AS released`);\n}\n/**\n* Releases the marker lock after work that failed, keeping that failure: a release that fails too is dropped. MySQL frees a session's locks when the session ends, which is the usual reason a release fails.\n*/\nasync function releaseMarkerLockAfterFailure(driver) {\n\tawait releaseMarkerLock(driver).catch(() => void 0);\n}\n/**\n* The one way MySQL holds the marker lock: takes it on the connection `driver` holds, runs `work`, and releases it on the same connection when `work` ends. A failed release is reported only when `work` succeeded; when `work` throws, or `succeeded` says its result is a failure, that outcome is what comes back.\n*/\nasync function withMarkerLock(driver, work, succeeded = () => true) {\n\tawait acquireMarkerLock(driver);\n\tlet result;\n\ttry {\n\t\tresult = await work();\n\t} catch (error) {\n\t\tawait releaseMarkerLockAfterFailure(driver);\n\t\tthrow error;\n\t}\n\tif (succeeded(result)) await releaseMarkerLock(driver);\n\telse await releaseMarkerLockAfterFailure(driver);\n\treturn result;\n}\n//#endregion\nexport { withMarkerLock as i, acquireMarkerLock as n, releaseMarkerLock as r, MARKER_LOCK_TIMEOUT_SECONDS as t };\n\n//# sourceMappingURL=marker-lock-CmGvN4hw.mjs.map"],"mappings":";;;AAGA,MAAM,8BAA8B;;AAEpC,MAAM,YAAY;AAClB,SAAS,WAAW,MAAM;CACzB,MAAM,QAAQ,KAAK,EAAE,GAAG;CACxB,OAAO,UAAU,QAAQ,UAAU,KAAK,IAAI,KAAK,IAAI,OAAO,KAAK;AAClE;;;;AAIA,eAAe,kBAAkB,QAAQ,iBAAiB,IAAI;CAC7D,MAAM,EAAE,SAAS,MAAM,OAAO,MAAM,mBAAmB,UAAU,mBAAmB,CAAC,cAAc,CAAC;CACpG,IAAI,WAAW,IAAI,MAAM,KAAK,MAAM,WAAW,iCAAiC,sDAAsD,eAAe,YAAY;EAChK,KAAK;EACL,KAAK;EACL,MAAM,EAAE,eAAe;CACxB,CAAC;AACF;;AAEA,eAAe,kBAAkB,QAAQ;CACxC,MAAM,OAAO,MAAM,uBAAuB,UAAU,cAAc;AACnE;;;;AAIA,eAAe,8BAA8B,QAAQ;CACpD,MAAM,kBAAkB,MAAM,CAAC,CAAC,YAAY,KAAK,CAAC;AACnD;;;;AAIA,eAAe,eAAe,QAAQ,MAAM,kBAAkB,MAAM;CACnE,MAAM,kBAAkB,MAAM;CAC9B,IAAI;CACJ,IAAI;EACH,SAAS,MAAM,KAAK;CACrB,SAAS,OAAO;EACf,MAAM,8BAA8B,MAAM;EAC1C,MAAM;CACP;CACA,IAAI,UAAU,MAAM,GAAG,MAAM,kBAAkB,MAAM;MAChD,MAAM,8BAA8B,MAAM;CAC/C,OAAO;AACR"}

package/dist/marker-lock-su6IxinO.d.mts

@@ -0,0 +1,18 @@
+import { SqlControlDriverInstance } from "@prisma/orm-family-sql/contract/types";
+//#region ../../../3-targets/mysql/1-target/dist/marker-lock.d.mts
+//#region src/core/marker-lock.d.ts
+/** How long a migration runner or `db sign` waits for another one to release the marker lock. */
+declare const MARKER_LOCK_TIMEOUT_SECONDS = 60;
+/**
+ * Takes the marker lock on the connection `driver` holds. MySQL holds a `GET_LOCK` lock for the session, not for a transaction, so the caller releases it with {@link releaseMarkerLock} on the same connection when the work it guards ends.
+ */
+declare function acquireMarkerLock(driver: SqlControlDriverInstance<string>, timeoutSeconds?: number): Promise<void>;
+/** Releases the marker lock {@link acquireMarkerLock} took on this connection. */
+declare function releaseMarkerLock(driver: SqlControlDriverInstance<string>): Promise<void>;
+/**
+ * The one way MySQL holds the marker lock: takes it on the connection `driver` holds, runs `work`, and releases it on the same connection when `work` ends. A failed release is reported only when `work` succeeded; when `work` throws, or `succeeded` says its result is a failure, that outcome is what comes back.
+ */
+declare function withMarkerLock<T>(driver: SqlControlDriverInstance<string>, work: () => Promise<T>, succeeded?: (result: T) => boolean): Promise<T>;
+//#endregion
+export { withMarkerLock as i, acquireMarkerLock as n, releaseMarkerLock as r, MARKER_LOCK_TIMEOUT_SECONDS as t };
+//# sourceMappingURL=marker-lock-su6IxinO.d.mts.map

package/dist/marker-lock-su6IxinO.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marker-lock-su6IxinO.d.mts","names":[],"sources":["../../../../3-targets/mysql/1-target/dist/marker-lock.d.mts"],"mappings":";;;;cAGc;;;;iBAIG,kBAAkB,QAAQ,kCAAkC,0BAA0B;;iBAEtF,kBAAkB,QAAQ,mCAAmC;;;;iBAI7D,eAAe,GAAG,QAAQ,kCAAkC,YAAY,QAAQ,IAAI,aAAa,QAAQ,gBAAgB,QAAQ"}

package/dist/marker-read-aEaHihYj-Cyg16yn1.mjs

@@ -0,0 +1,78 @@
+import { n as quoteIdentifier } from "./sql-utils-Db0IQO_B-PaULnfrE.mjs";
+import { o as mysqlCodecRegistry, r as decodeMysqlDatetime } from "./codecs-C00kjHgh.mjs";
+import { r as MARKER_TABLE_NAME } from "./control-tables-CcQ77JE7-CxTQYoQJ.mjs";
+import { n as mysqlAdapterContractContributions } from "./contract-contributions-B9njRJbt-ClEtrK2L.mjs";
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
+import { withMarkerReadErrorHandling } from "@prisma/orm-framework/errors/execution";
+import { parseContractMarkerRow } from "@prisma/orm-family-sql/family/verify";
+//#region ../../../3-targets/mysql/2-adapter/dist/marker-read-aEaHihYj.mjs
+const mysqlAdapterDescriptorMeta = {
+	kind: "adapter",
+	familyId: "sql",
+	targetId: "mysql",
+	id: "mysql",
+	version: "0.0.1",
+	capabilities: mysqlAdapterContractContributions.capabilities,
+	types: { codecTypes: {
+		codecDescriptors: Array.from(mysqlCodecRegistry.values()),
+		import: {
+			package: "@internal/adapter-mysql/codec-types",
+			named: "CodecTypes",
+			alias: "MysqlTypes"
+		}
+	} }
+};
+const MARKER_COLUMNS = "space, core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta, invariants";
+/** Whether the connection's database has the table `name`. */
+async function tableExists(driver, name) {
+	const { rows } = await driver.query("SELECT TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?", [name]);
+	return rows.length > 0;
+}
+function parseJsonColumn(column, text) {
+	if (typeof text !== "string") return text;
+	try {
+		return JSON.parse(text);
+	} catch (error) {
+		const detail = error instanceof Error ? error.message : String(error);
+		throw structuredError("CONTRACT.MARKER_ROW_CORRUPT", `Invalid contract marker row: ${column} is not valid JSON: ${detail}`, {
+			meta: { detail },
+			cause: error
+		});
+	}
+}
+/** A marker row as MySQL's text arrives, in the shape the family's marker parser reads. */
+function decodeMysqlMarkerRow(row) {
+	const canonicalVersion = row["canonical_version"];
+	const updatedAt = row["updated_at"];
+	return parseContractMarkerRow({
+		...row,
+		canonical_version: typeof canonicalVersion === "string" ? Number(canonicalVersion) : canonicalVersion,
+		updated_at: typeof updatedAt === "string" ? decodeMysqlDatetime(updatedAt) : updatedAt,
+		invariants: parseJsonColumn("invariants", row["invariants"])
+	});
+}
+async function readMarkerRows(driver, space) {
+	if (!await tableExists(driver, "_prisma_marker")) return void 0;
+	const select = `SELECT ${MARKER_COLUMNS} FROM ${quoteIdentifier(MARKER_TABLE_NAME)}`;
+	const { rows } = space === void 0 ? await driver.query(select) : await driver.query(`${select} WHERE space = ?`, [space]);
+	return rows;
+}
+/** The marker of `space`, or whether the marker table or the space's row is missing. */
+async function readMarkerResult(driver, space) {
+	return withMarkerReadErrorHandling(async () => {
+		const rows = await readMarkerRows(driver, space);
+		if (rows === void 0) return { kind: "no-table" };
+		const [row] = rows;
+		return row === void 0 ? { kind: "absent" } : {
+			kind: "present",
+			record: decodeMysqlMarkerRow(row)
+		};
+	}, {
+		space,
+		markerLocation: MARKER_TABLE_NAME
+	});
+}
+//#endregion
+export { readMarkerRows as a, readMarkerResult as i, mysqlAdapterDescriptorMeta as n, tableExists as o, parseJsonColumn as r, decodeMysqlMarkerRow as t };
+
+//# sourceMappingURL=marker-read-aEaHihYj-Cyg16yn1.mjs.map

package/dist/marker-read-aEaHihYj-Cyg16yn1.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"marker-read-aEaHihYj-Cyg16yn1.mjs","names":[],"sources":["../../../../3-targets/mysql/2-adapter/dist/marker-read-aEaHihYj.mjs"],"sourcesContent":["import { t as mysqlAdapterContractContributions } from \"./contract-contributions-B9njRJbt.mjs\";\nimport { decodeMysqlDatetime, mysqlCodecRegistry } from \"@internal/target-mysql/codecs\";\nimport { withMarkerReadErrorHandling } from \"@internal/errors/execution\";\nimport { MARKER_TABLE_NAME } from \"@internal/target-mysql/control-tables\";\nimport { structuredError } from \"@internal/utils/structured-error\";\nimport { parseContractMarkerRow } from \"@internal/family-sql/verify\";\nimport { quoteIdentifier } from \"@internal/target-mysql/sql-utils\";\n//#region src/core/descriptor-meta.ts\nconst mysqlAdapterDescriptorMeta = {\n\tkind: \"adapter\",\n\tfamilyId: \"sql\",\n\ttargetId: \"mysql\",\n\tid: \"mysql\",\n\tversion: \"0.0.1\",\n\tcapabilities: mysqlAdapterContractContributions.capabilities,\n\ttypes: { codecTypes: {\n\t\tcodecDescriptors: Array.from(mysqlCodecRegistry.values()),\n\t\timport: {\n\t\t\tpackage: \"@internal/adapter-mysql/codec-types\",\n\t\t\tnamed: \"CodecTypes\",\n\t\t\talias: \"MysqlTypes\"\n\t\t}\n\t} }\n};\n//#endregion\n//#region src/core/marker-read.ts\nconst MARKER_COLUMNS = \"space, core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta, invariants\";\n/** Whether the connection's database has the table `name`. */\nasync function tableExists(driver, name) {\n\tconst { rows } = await driver.query(\"SELECT TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?\", [name]);\n\treturn rows.length > 0;\n}\nfunction parseJsonColumn(column, text) {\n\tif (typeof text !== \"string\") return text;\n\ttry {\n\t\treturn JSON.parse(text);\n\t} catch (error) {\n\t\tconst detail = error instanceof Error ? error.message : String(error);\n\t\tthrow structuredError(\"CONTRACT.MARKER_ROW_CORRUPT\", `Invalid contract marker row: ${column} is not valid JSON: ${detail}`, {\n\t\t\tmeta: { detail },\n\t\t\tcause: error\n\t\t});\n\t}\n}\n/** A marker row as MySQL's text arrives, in the shape the family's marker parser reads. */\nfunction decodeMysqlMarkerRow(row) {\n\tconst canonicalVersion = row[\"canonical_version\"];\n\tconst updatedAt = row[\"updated_at\"];\n\treturn parseContractMarkerRow({\n\t\t...row,\n\t\tcanonical_version: typeof canonicalVersion === \"string\" ? Number(canonicalVersion) : canonicalVersion,\n\t\tupdated_at: typeof updatedAt === \"string\" ? decodeMysqlDatetime(updatedAt) : updatedAt,\n\t\tinvariants: parseJsonColumn(\"invariants\", row[\"invariants\"])\n\t});\n}\nasync function readMarkerRows(driver, space) {\n\tif (!await tableExists(driver, MARKER_TABLE_NAME)) return void 0;\n\tconst select = `SELECT ${MARKER_COLUMNS} FROM ${quoteIdentifier(MARKER_TABLE_NAME)}`;\n\tconst { rows } = space === void 0 ? await driver.query(select) : await driver.query(`${select} WHERE space = ?`, [space]);\n\treturn rows;\n}\n/** The marker of `space`, or whether the marker table or the space's row is missing. */\nasync function readMarkerResult(driver, space) {\n\treturn withMarkerReadErrorHandling(async () => {\n\t\tconst rows = await readMarkerRows(driver, space);\n\t\tif (rows === void 0) return { kind: \"no-table\" };\n\t\tconst [row] = rows;\n\t\treturn row === void 0 ? { kind: \"absent\" } : {\n\t\t\tkind: \"present\",\n\t\t\trecord: decodeMysqlMarkerRow(row)\n\t\t};\n\t}, {\n\t\tspace,\n\t\tmarkerLocation: MARKER_TABLE_NAME\n\t});\n}\n//#endregion\nexport { tableExists as a, readMarkerRows as i, parseJsonColumn as n, mysqlAdapterDescriptorMeta as o, readMarkerResult as r, decodeMysqlMarkerRow as t };\n\n//# sourceMappingURL=marker-read-aEaHihYj.mjs.map"],"mappings":";;;;;;;;AAQA,MAAM,6BAA6B;CAClC,MAAM;CACN,UAAU;CACV,UAAU;CACV,IAAI;CACJ,SAAS;CACT,cAAc,kCAAkC;CAChD,OAAO,EAAE,YAAY;EACpB,kBAAkB,MAAM,KAAK,mBAAmB,OAAO,CAAC;EACxD,QAAQ;GACP,SAAS;GACT,OAAO;GACP,OAAO;EACR;CACD,EAAE;AACH;AAGA,MAAM,iBAAiB;;AAEvB,eAAe,YAAY,QAAQ,MAAM;CACxC,MAAM,EAAE,SAAS,MAAM,OAAO,MAAM,uGAAuG,CAAC,IAAI,CAAC;CACjJ,OAAO,KAAK,SAAS;AACtB;AACA,SAAS,gBAAgB,QAAQ,MAAM;CACtC,IAAI,OAAO,SAAS,UAAU,OAAO;CACrC,IAAI;EACH,OAAO,KAAK,MAAM,IAAI;CACvB,SAAS,OAAO;EACf,MAAM,SAAS,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;EACpE,MAAM,gBAAgB,+BAA+B,gCAAgC,OAAO,sBAAsB,UAAU;GAC3H,MAAM,EAAE,OAAO;GACf,OAAO;EACR,CAAC;CACF;AACD;;AAEA,SAAS,qBAAqB,KAAK;CAClC,MAAM,mBAAmB,IAAI;CAC7B,MAAM,YAAY,IAAI;CACtB,OAAO,uBAAuB;EAC7B,GAAG;EACH,mBAAmB,OAAO,qBAAqB,WAAW,OAAO,gBAAgB,IAAI;EACrF,YAAY,OAAO,cAAc,WAAW,oBAAoB,SAAS,IAAI;EAC7E,YAAY,gBAAgB,cAAc,IAAI,aAAa;CAC5D,CAAC;AACF;AACA,eAAe,eAAe,QAAQ,OAAO;CAC5C,IAAI,CAAC,MAAM,YAAY,QAAA,gBAAyB,GAAG,OAAO,KAAK;CAC/D,MAAM,SAAS,UAAU,eAAe,QAAQ,gBAAgB,iBAAiB;CACjF,MAAM,EAAE,SAAS,UAAU,KAAK,IAAI,MAAM,OAAO,MAAM,MAAM,IAAI,MAAM,OAAO,MAAM,GAAG,OAAO,mBAAmB,CAAC,KAAK,CAAC;CACxH,OAAO;AACR;;AAEA,eAAe,iBAAiB,QAAQ,OAAO;CAC9C,OAAO,4BAA4B,YAAY;EAC9C,MAAM,OAAO,MAAM,eAAe,QAAQ,KAAK;EAC/C,IAAI,SAAS,KAAK,GAAG,OAAO,EAAE,MAAM,WAAW;EAC/C,MAAM,CAAC,OAAO;EACd,OAAO,QAAQ,KAAK,IAAI,EAAE,MAAM,SAAS,IAAI;GAC5C,MAAM;GACN,QAAQ,qBAAqB,GAAG;EACjC;CACD,GAAG;EACF;EACA,gBAAgB;CACjB,CAAC;AACF"}

package/dist/migration-DmlblTTw.d.mts

@@ -0,0 +1,284 @@
+import { t as MysqlPlanTargetDetails } from "./planner-target-details-D6g2uSp--C5NKHmCc.mjs";
+import { DdlColumn, DdlTableConstraint } from "@prisma/orm-family-sql/relational-core/ast";
+import { ControlStack, MigrationAccessChange, MigrationDataLoss, MigrationPlanWithAuthoringSurface, MigrationPlanner, MigrationScaffoldContext, MigrationTemporaryValue, OpFactoryCall, PlanOrigin, ResolvedMigrationStatement, SchemaOwnership } from "@prisma/orm-framework/components/control";
+import { col as col$1, fn as fn$1, lit as lit$1, primaryKey, unique } from "@prisma/orm-family-sql/relational-core/contract-free";
+import { TargetBoundComponentDescriptor } from "@prisma/orm-framework/components/components";
+import { ReferentialAction, SqlStorage } from "@prisma/orm-family-sql/contract/types";
+import { MigrationOperationClass, MigrationOperationPolicy, SqlControlFamilyInstance, SqlMigrationPlanOperation, SqlMigrationPlanner, SqlMigrationRunner, SqlPlannerFailureResult } from "@prisma/orm-family-sql/family/control";
+import { ImportRequirement, TsExpression } from "@prisma/orm-framework/ts-render";
+import { Migration } from "@prisma/orm-family-sql/family/migration";
+import { ImportSpecifierResolver } from "@prisma/orm-framework/components/emission";
+import { MigrationCLI } from "@prisma/orm-toolchain/cli/migration-cli";
+import { placeholder } from "@prisma/orm-framework/errors/migration";
+import { sql } from "@prisma/orm-family-sql/contract/sql-expression";
+import { ExecuteRequestLowerer, SqlControlAdapter } from "@prisma/orm-family-sql/family/control-adapter";
+import { Contract } from "@prisma/orm-framework/contract/types";
+import { MigrationMeta } from "@prisma/orm-toolchain/migration-tools/migration";
+//#region ../../../3-targets/mysql/1-target/dist/migration.d.mts
+//#region src/core/migrations/operations.d.ts
+type Op = SqlMigrationPlanOperation<MysqlPlanTargetDetails>;
+/** An operation written out in full in `migration.ts`, such as a table rename made by hand. */
+declare function rawSql(op: Op): Op;
+//#endregion
+//#region src/core/migrations/mysql-migration.d.ts
+/**
+ * The base class of a MySQL `migration.ts`. Each protected method returns the operation its name says, rendered through the MySQL control adapter the migration CLI builds from `prisma.config.ts`.
+ */
+declare abstract class MysqlMigration<Start extends Contract<SqlStorage> = Contract<SqlStorage>, End extends Contract<SqlStorage> = Contract<SqlStorage>> extends Migration<MysqlPlanTargetDetails, 'mysql', Start, End> {
+  readonly targetId: "mysql";
+  protected readonly controlAdapter: SqlControlAdapter<'mysql'> | undefined;
+  constructor(stack?: ControlStack<'sql', 'mysql'>);
+  private adapterFor;
+  protected createTable(options: {
+    readonly table: string;
+    readonly columns: readonly DdlColumn[];
+    readonly constraints?: readonly DdlTableConstraint[];
+  }): Promise<Op>;
+  protected dropTable(options: {
+    readonly table: string;
+  }): Op;
+  protected addColumn(options: {
+    readonly table: string;
+    readonly column: DdlColumn;
+  }): Promise<Op>;
+  protected dropColumn(options: {
+    readonly table: string;
+    readonly column: string;
+  }): Op;
+  protected createIndex(options: {
+    readonly table: string;
+    readonly index: string;
+    readonly columns: readonly string[];
+    readonly unique?: boolean;
+  }): Op;
+  protected dropIndex(options: {
+    readonly table: string;
+    readonly index: string;
+  }): Op;
+  protected addUnique(options: {
+    readonly table: string;
+    readonly name: string;
+    readonly columns: readonly string[];
+  }): Op;
+  protected dropUnique(options: {
+    readonly table: string;
+    readonly name: string;
+  }): Op;
+  protected addForeignKey(options: {
+    readonly table: string;
+    readonly name: string;
+    readonly columns: readonly string[];
+    readonly references: {
+      readonly table: string;
+      readonly columns: readonly string[];
+    };
+    readonly onDelete?: ReferentialAction;
+    readonly onUpdate?: ReferentialAction;
+  }): Op;
+  protected dropForeignKey(options: {
+    readonly table: string;
+    readonly name: string;
+  }): Op;
+}
+//#endregion
+//#region src/core/migrations/op-factory-call.d.ts
+declare abstract class MysqlOpFactoryCallNode extends TsExpression implements OpFactoryCall {
+  abstract readonly factoryName: string;
+  abstract readonly operationClass: MigrationOperationClass;
+  abstract readonly label: string;
+  abstract toOp(lowerer?: ExecuteRequestLowerer): Op | Promise<Op>;
+  importRequirements(): readonly ImportRequirement[];
+  protected freeze(): void;
+  protected lowererFor(lowerer: ExecuteRequestLowerer | undefined): ExecuteRequestLowerer;
+}
+declare class CreateTableCall extends MysqlOpFactoryCallNode {
+  #private;
+  readonly tableName: string;
+  readonly factoryName: "createTable";
+  readonly operationClass: "additive";
+  readonly label: string;
+  readonly columns: readonly DdlColumn[];
+  readonly constraints: readonly DdlTableConstraint[];
+  constructor(tableName: string, columns: readonly DdlColumn[], constraints: readonly DdlTableConstraint[]);
+  toOp(lowerer?: ExecuteRequestLowerer): Promise<Op>;
+  renderTypeScript(): string;
+  importRequirements(): readonly ImportRequirement[];
+}
+declare class DropTableCall extends MysqlOpFactoryCallNode {
+  readonly tableName: string;
+  readonly factoryName: "dropTable";
+  readonly operationClass: "destructive";
+  readonly label: string;
+  constructor(tableName: string);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class AddColumnCall extends MysqlOpFactoryCallNode {
+  #private;
+  readonly tableName: string;
+  readonly column: DdlColumn;
+  readonly factoryName: "addColumn";
+  readonly operationClass: "additive";
+  readonly label: string;
+  readonly columnName: string;
+  constructor(tableName: string, column: DdlColumn);
+  toOp(lowerer?: ExecuteRequestLowerer): Promise<Op>;
+  renderTypeScript(): string;
+  importRequirements(): readonly ImportRequirement[];
+}
+declare class DropColumnCall extends MysqlOpFactoryCallNode {
+  readonly tableName: string;
+  readonly columnName: string;
+  readonly factoryName: "dropColumn";
+  readonly operationClass: "destructive";
+  readonly label: string;
+  constructor(tableName: string, columnName: string);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class CreateIndexCall extends MysqlOpFactoryCallNode {
+  readonly tableName: string;
+  readonly indexName: string;
+  readonly columns: readonly string[];
+  readonly unique: boolean;
+  readonly factoryName: "createIndex";
+  readonly operationClass: "additive";
+  readonly label: string;
+  constructor(tableName: string, indexName: string, columns: readonly string[], unique: boolean);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class DropIndexCall extends MysqlOpFactoryCallNode {
+  readonly tableName: string;
+  readonly indexName: string;
+  readonly factoryName: "dropIndex";
+  readonly operationClass: "widening";
+  readonly label: string;
+  constructor(tableName: string, indexName: string);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class AddUniqueCall extends MysqlOpFactoryCallNode {
+  readonly tableName: string;
+  readonly constraintName: string;
+  readonly columns: readonly string[];
+  readonly factoryName: "addUnique";
+  readonly operationClass: "additive";
+  readonly label: string;
+  constructor(tableName: string, constraintName: string, columns: readonly string[]);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class DropUniqueCall extends MysqlOpFactoryCallNode {
+  readonly tableName: string;
+  readonly constraintName: string;
+  readonly factoryName: "dropUnique";
+  readonly operationClass: "widening";
+  readonly label: string;
+  constructor(tableName: string, constraintName: string);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+/** A foreign key as `addForeignKey` takes it. */
+interface MysqlForeignKeySpec {
+  readonly name: string;
+  readonly columns: readonly string[];
+  readonly references: {
+    readonly table: string;
+    readonly columns: readonly string[];
+  };
+  readonly onDelete?: ReferentialAction;
+  readonly onUpdate?: ReferentialAction;
+}
+declare class AddForeignKeyCall extends MysqlOpFactoryCallNode {
+  readonly tableName: string;
+  readonly foreignKey: MysqlForeignKeySpec;
+  readonly factoryName: "addForeignKey";
+  readonly operationClass: "additive";
+  readonly label: string;
+  constructor(tableName: string, foreignKey: MysqlForeignKeySpec);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class DropForeignKeyCall extends MysqlOpFactoryCallNode {
+  readonly tableName: string;
+  readonly constraintName: string;
+  readonly factoryName: "dropForeignKey";
+  readonly operationClass: "widening";
+  readonly label: string;
+  constructor(tableName: string, constraintName: string);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+/** An operation built elsewhere, such as the table rename a user writes by hand, carried as it is and written as `rawSql({...})`. */
+declare class RawSqlCall extends MysqlOpFactoryCallNode {
+  readonly op: Op;
+  readonly factoryName: "rawSql";
+  readonly operationClass: MigrationOperationClass;
+  readonly label: string;
+  constructor(op: Op);
+  toOp(): Op;
+  renderTypeScript(): string;
+  importRequirements(): readonly ImportRequirement[];
+}
+type MysqlOpFactoryCall = CreateTableCall | DropTableCall | AddColumnCall | DropColumnCall | CreateIndexCall | DropIndexCall | AddUniqueCall | DropUniqueCall | AddForeignKeyCall | DropForeignKeyCall | RawSqlCall;
+//#endregion
+//#region src/core/migrations/planner-produced-mysql-migration.d.ts
+interface MysqlMigrationDestinationInfo {
+  readonly storageHash: string;
+  readonly profileHash?: string;
+}
+/** The plan the MySQL planner produces: its operations, and the `migration.ts` that writes them. */
+declare class TypeScriptRenderableMysqlMigration extends MysqlMigration implements MigrationPlanWithAuthoringSurface {
+  #private;
+  constructor(options: {
+    readonly calls: readonly OpFactoryCall[];
+    readonly meta: MigrationMeta;
+    readonly spaceId: string;
+    readonly snapshotsImportPath: string;
+    readonly destination?: MysqlMigrationDestinationInfo;
+    readonly lowerer?: ExecuteRequestLowerer;
+  });
+  get operations(): readonly (Op | Promise<Op>)[];
+  describe(): MigrationMeta;
+  get destination(): MysqlMigrationDestinationInfo;
+  get spaceId(): string;
+  renderTypeScript(resolveImportSpecifier: ImportSpecifierResolver): string;
+}
+//#endregion
+//#region src/core/migrations/planner.d.ts
+type MysqlPlanResult = {
+  readonly kind: 'success';
+  readonly plan: TypeScriptRenderableMysqlMigration;
+  readonly appliedStatements: readonly [];
+  readonly dataLoss: readonly MigrationDataLoss[];
+  readonly accessChanges: readonly MigrationAccessChange[];
+  readonly temporaryValues: readonly MigrationTemporaryValue[];
+} | SqlPlannerFailureResult;
+/**
+ * The MySQL migration planner. It diffs the contract's schema against the live one and plans creating and dropping tables, columns, indexes, unique constraints and foreign keys. Every other change, and every statement such as a rename, is refused with a conflict that says it is not yet supported on MySQL.
+ */
+declare class MysqlMigrationPlanner implements SqlMigrationPlanner<MysqlPlanTargetDetails>, MigrationPlanner<'sql', 'mysql'> {
+  #private;
+  constructor(lowerer: ExecuteRequestLowerer);
+  plan(options: {
+    readonly contract: unknown;
+    readonly schema: unknown;
+    readonly policy: MigrationOperationPolicy;
+    readonly fromContract: Contract | null;
+    readonly origin: PlanOrigin | null;
+    readonly statements: readonly ResolvedMigrationStatement[];
+    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+    readonly spaceId: string;
+    readonly ownership?: SchemaOwnership;
+    readonly snapshotsImportPath: string;
+  }): MysqlPlanResult;
+  emptyMigration(context: MigrationScaffoldContext, spaceId: string): TypeScriptRenderableMysqlMigration;
+}
+declare function createMysqlMigrationPlanner(lowerer: ExecuteRequestLowerer): MysqlMigrationPlanner;
+//#endregion
+//#region src/core/migrations/runner.d.ts
+declare function createMysqlMigrationRunner(family: SqlControlFamilyInstance): SqlMigrationRunner<MysqlPlanTargetDetails>;
+//#endregion
+export { lit$1 as C, sql as D, rawSql as E, unique as O, fn$1 as S, primaryKey as T, RawSqlCall as _, CreateTableCall as a, createMysqlMigrationPlanner as b, DropIndexCall as c, MigrationCLI as d, MysqlMigration as f, MysqlPlanResult as g, MysqlOpFactoryCall as h, CreateIndexCall as i, DropTableCall as l, MysqlMigrationPlanner as m, AddForeignKeyCall as n, DropColumnCall as o, MysqlMigrationDestinationInfo as p, AddUniqueCall as r, DropForeignKeyCall as s, AddColumnCall as t, DropUniqueCall as u, TypeScriptRenderableMysqlMigration as v, placeholder as w, createMysqlMigrationRunner as x, col$1 as y };
+//# sourceMappingURL=migration-DmlblTTw.d.mts.map

package/dist/migration-DmlblTTw.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-DmlblTTw.d.mts","names":[],"sources":["../../../../3-targets/mysql/1-target/dist/migration.d.mts"],"mappings":"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"}

package/dist/migration-tFuoN9GB.mjs

@@ -0,0 +1,5 @@
+import { col as col$1, fn as fn$1, lit as lit$1, primaryKey, unique } from "@prisma/orm-family-sql/relational-core/contract-free";
+import { MigrationCLI } from "@prisma/orm-toolchain/cli/migration-cli";
+import { placeholder } from "@prisma/orm-framework/errors/migration";
+import { sql } from "@prisma/orm-family-sql/contract/sql-expression";
+export { placeholder as a, unique as c, lit$1 as i, col$1 as n, primaryKey as o, fn$1 as r, sql as s, MigrationCLI as t };

package/dist/mysql-contract-serializer-DLv0uW_f-Cg4A43Ry.mjs

@@ -0,0 +1,160 @@
+import { t as mysqlError } from "./errors-rvH_F2Yj-BQrO_--u.mjs";
+import { n as quoteIdentifier } from "./sql-utils-Db0IQO_B-PaULnfrE.mjs";
+import { i as mysqlDataTypes } from "./data-types-Dv9gwVRV-BZPzCWZk.mjs";
+import { createDataTypeLookup } from "@prisma/orm-framework/components/codec";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { UNBOUND_NAMESPACE_ID, freezeNode, hydrateNamespaceEntities } from "@prisma/orm-framework/components/ir";
+import { SqlNamespaceBase } from "@prisma/orm-family-sql/contract/types";
+import { SqlContractSerializerBase } from "@prisma/orm-family-sql/family/ir";
+import { tableEntityKind } from "@prisma/orm-family-sql/contract/entity-kinds";
+//#region ../../../3-targets/mysql/1-target/dist/mysql-contract-serializer-DLv0uW_f.mjs
+const MYSQL_NAMESPACE_KIND = "mysql-namespace";
+/**
+* The MySQL database a connection uses, as the contract's one namespace. Tables are addressed unqualified, so the contract runs against whichever database the connection names.
+*/
+var MysqlDatabase = class extends SqlNamespaceBase {
+	id;
+	entries;
+	constructor(input) {
+		super();
+		this.id = input.id;
+		const dispatched = hydrateNamespaceEntities(input.entries, /* @__PURE__ */ new Map([["table", tableEntityKind]]), "carry");
+		this.entries = Object.freeze(blindCast(dispatched));
+		Object.defineProperty(this, "kind", {
+			value: MYSQL_NAMESPACE_KIND,
+			writable: false,
+			enumerable: false,
+			configurable: true
+		});
+		freezeNode(this);
+	}
+	get table() {
+		return this.entries.table ?? Object.freeze({});
+	}
+	qualifier() {
+		return "";
+	}
+	qualifyTable(tableName) {
+		return quoteIdentifier(tableName);
+	}
+};
+function isLoose(value) {
+	return typeof value === "object" && value !== null;
+}
+function enumMembersOf(namespace, tableName, columnName, column) {
+	const subject = `Column "${tableName}"."${columnName}"`;
+	const ref = column["valueSet"];
+	const valueSetName = isLoose(ref) && ref["namespaceId"] === namespace.id ? ref["entityName"] : void 0;
+	const valueSet = typeof valueSetName === "string" ? namespace.entries["valueSet"]?.[valueSetName] : void 0;
+	const values = isLoose(valueSet) ? valueSet["values"] : void 0;
+	if (!Array.isArray(values) || !values.every((value) => typeof value === "string")) throw mysqlError("CONTRACT.TYPE_PARAMS_INVALID", `${subject} is a MySQL enum but has no enum whose text members it can list.`, {
+		why: "A native MySQL enum column is written with its members, which come from the enum that types the column.",
+		fix: "Type the column with a PSL enum or an enumType() whose members are text.",
+		meta: {
+			table: tableName,
+			column: columnName
+		}
+	});
+	return values;
+}
+function isEnumColumn(column) {
+	return isLoose(column) && column["codecId"] === "mysql/enum@1";
+}
+function sameMembers(left, right) {
+	return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function enumColumnWithMembers(namespace, tableName, columnName, column) {
+	const typeParams = isLoose(column["typeParams"]) ? column["typeParams"] : {};
+	const values = enumMembersOf(namespace, tableName, columnName, column);
+	const listed = typeParams["values"];
+	if (listed !== void 0 && !(Array.isArray(listed) && sameMembers(listed, values))) throw mysqlError("CONTRACT.TYPE_PARAMS_INVALID", `Column "${tableName}"."${columnName}" lists enum members that differ from the members of the enum that types it.`, {
+		why: "A MySQL enum column takes its members from its enum, in the order the enum declares them, so the database and the contract enforce the same members.",
+		fix: "Remove the column’s own members, or make them equal the enum’s members in the same order.",
+		meta: {
+			table: tableName,
+			column: columnName,
+			columnValues: listed,
+			valueSetValues: values
+		}
+	});
+	return {
+		...column,
+		typeParams: {
+			...typeParams,
+			values
+		}
+	};
+}
+function withEnumMembers(namespace, tableName, table) {
+	if (!isLoose(table)) return table;
+	const columns = table["columns"];
+	if (!isLoose(columns) || !Object.values(columns).some(isEnumColumn)) return table;
+	const filled = Object.fromEntries(Object.entries(columns).map(([columnName, column]) => [columnName, isEnumColumn(column) ? enumColumnWithMembers(namespace, tableName, columnName, column) : column]));
+	return {
+		...table,
+		columns: filled
+	};
+}
+/**
+* Writes each MySQL enum column's members, from the value set the column names, into its type parameters, in the order the enum declares them, and refuses a column whose own members differ from them. The column's type is then `enum('A','B')`, so the database enforces the members and `db verify` sees a change to them as a change of the column's type.
+*/
+function fillEnumMembers(input) {
+	const tables = input.entries["table"];
+	if (tables === void 0) return input;
+	return {
+		...input,
+		entries: {
+			...input.entries,
+			table: Object.fromEntries(Object.entries(tables).map(([tableName, table]) => [tableName, withEnumMembers(input, tableName, table)]))
+		}
+	};
+}
+/**
+* The MySQL target's refusal of expression and partial indexes, which it neither writes nor introspects yet.
+*/
+function rejectSqlBodyIndexes(input) {
+	for (const [tableName, table] of Object.entries(input.entries["table"] ?? {})) {
+		const indexes = isLoose(table) ? table["indexes"] : void 0;
+		for (const index of Array.isArray(indexes) ? indexes : []) {
+			if (!isLoose(index)) continue;
+			if (index["expression"] !== void 0 || index["where"] !== void 0) throw mysqlError("CONTRACT.ARGUMENT_INVALID", `MySQL does not support expression or partial indexes yet: index "${String(index["name"] ?? "<unnamed>")}" on table "${tableName}" declares ${index["expression"] !== void 0 ? "an expression" : "a where predicate"}. Use a fields-only index.`, { meta: { table: tableName } });
+		}
+	}
+}
+/**
+* The namespace factory the MySQL target hands `defineContract` and the PSL interpreter. MySQL has one namespace per connection, the framework's unbound slot.
+*/
+function mysqlCreateNamespace(input) {
+	if (input.id !== UNBOUND_NAMESPACE_ID) throw mysqlError("CONTRACT.NAMESPACE_INVALID", `The MySQL target has one namespace, "${UNBOUND_NAMESPACE_ID}"; it received "${input.id}".`, { meta: { received: input.id } });
+	rejectSqlBodyIndexes(input);
+	return new MysqlDatabase(fillEnumMembers(input));
+}
+/** The MySQL target's contract serializer: the SQL family's, with each namespace built as a `MysqlDatabase`. */
+var MysqlContractSerializer = class extends SqlContractSerializerBase {
+	constructor() {
+		super(/* @__PURE__ */ new Map(), [], createDataTypeLookup(mysqlDataTypes));
+	}
+	hydrateSqlNamespaceEntry(nsId, raw) {
+		return mysqlCreateNamespace(blindCast(super.hydrateSqlNamespaceEntry(nsId, raw)));
+	}
+	serializeContract(contract) {
+		const { storage, ...rest } = contract;
+		const namespacesJson = {};
+		for (const [nsId, ns] of Object.entries(storage.namespaces)) namespacesJson[nsId] = {
+			id: ns.id,
+			entries: this.serializeNamespaceEntries(ns.entries)
+		};
+		return blindCast({
+			...rest,
+			storage: {
+				storageHash: String(storage.storageHash),
+				namespaces: namespacesJson,
+				...storage.types !== void 0 ? { types: this.serializeJsonObject(storage.types) } : {}
+			}
+		});
+	}
+};
+//#endregion
+export { MysqlDatabase as n, mysqlCreateNamespace as r, MysqlContractSerializer as t };
+
+//# sourceMappingURL=mysql-contract-serializer-DLv0uW_f-Cg4A43Ry.mjs.map