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

package/dist/control-WTY7Jpxk.mjs

@@ -0,0 +1,577 @@
+import { n as mysqlQueryNotYetSupported } from "./errors-rvH_F2Yj-BQrO_--u.mjs";
+import { n as quoteIdentifier, r as quoteLiteral } from "./sql-utils-Db0IQO_B-PaULnfrE.mjs";
+import { i as encodeMysqlDatetime, r as decodeMysqlDatetime, t as assembleMysqlCodecRegistry } from "./codecs-C00kjHgh.mjs";
+import { n as LEDGER_TABLE_NAME, r as MARKER_TABLE_NAME, t as CONTROL_TABLE_NAMES } from "./control-tables-CcQ77JE7-CxTQYoQJ.mjs";
+import { n as buildSignMarkerBootstrapQueries, t as buildControlTableBootstrapQueries } from "./contract-free-BvCdx_Ee.mjs";
+import { n as readMysqlDefault } from "./default-normalizer-BDUgHXUn-Xk7HQJuI.mjs";
+import { i as withMarkerLock } from "./marker-lock-CmGvN4hw-Com29AtQ.mjs";
+import { a as readMarkerRows, i as readMarkerResult, n as mysqlAdapterDescriptorMeta, o as tableExists, r as parseJsonColumn, t as decodeMysqlMarkerRow } from "./marker-read-aEaHihYj-Cyg16yn1.mjs";
+import { codecForRef } from "@prisma/orm-framework/components/codec";
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
+import { encodeLiteralDefault, isDdlNode, renderOpaqueSql } from "@prisma/orm-family-sql/relational-core/ast";
+import { APP_SPACE_ID } from "@prisma/orm-framework/components/control";
+import { checkSqlDefaultText, contractColumns, readColumnDefault, sqlDefaultFunctions } from "@prisma/orm-family-sql/family/control";
+import { RelationalSchemaNodeKind, SqlSchemaIR, SqlTableIR } from "@prisma/orm-family-sql/schema-ir/types";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { REFERENTIAL_ACTION_SQL } from "@prisma/orm-family-sql/contract/referential-action-sql";
+import { parseMarkerRowSafely, withMarkerReadErrorHandling } from "@prisma/orm-framework/errors/execution";
+import { resolveIntrospectedColumnType } from "@prisma/orm-family-sql/family/control-adapter";
+import { ledgerOriginFromStored } from "@prisma/orm-toolchain/migration-tools/ledger-origin";
+//#region ../../../3-targets/mysql/2-adapter/dist/control.mjs
+/** Column types MySQL gives a default only when it is written as an expression in parentheses. */
+const EXPRESSION_DEFAULT_ONLY = /^(?:(?:tiny|medium|long)?(?:text|blob)|json|geometry)\b/i;
+const FRACTIONAL_SECONDS = /^(?:datetime|timestamp)\((\d)\)$/i;
+function refusedDefault(where, why) {
+	throw structuredError("CONTRACT.DEFAULT_INVALID", `Column "${where.table}"."${where.column}" has a default MySQL cannot store: ${why}`, { meta: {
+		table: where.table,
+		column: where.column
+	} });
+}
+/** A wire value as the SQL literal MySQL reads for it. */
+function mysqlInlineLiteral(wire, where) {
+	if (wire === null) return "NULL";
+	if (typeof wire === "boolean") return wire ? "1" : "0";
+	if (typeof wire === "number") {
+		if (!Number.isFinite(wire)) return refusedDefault(where, `${wire} is not a finite number`);
+		return String(wire);
+	}
+	if (typeof wire === "bigint") return String(wire);
+	if (typeof wire === "string") return quoteLiteral(wire);
+	if (wire instanceof Date) return quoteLiteral(encodeMysqlDatetime(wire));
+	if (wire instanceof Uint8Array) return `X'${Buffer.from(wire).toString("hex")}'`;
+	if (typeof wire === "object") return quoteLiteral(JSON.stringify(wire));
+	return refusedDefault(where, `a ${typeof wire} has no SQL literal`);
+}
+function withinParentheses(columnType, literal) {
+	return EXPRESSION_DEFAULT_ONLY.test(columnType.trim()) ? `(${literal})` : literal;
+}
+/** `CURRENT_TIMESTAMP` with the column's fractional-second precision, which MySQL requires to match. */
+function currentTimestampFor(columnType) {
+	const precision = FRACTIONAL_SECONDS.exec(columnType.trim())?.[1];
+	return precision === void 0 ? "CURRENT_TIMESTAMP" : `CURRENT_TIMESTAMP(${precision})`;
+}
+/**
+* The `DEFAULT …` clause of a column, or `''` for an `autoincrement()` default, which a column writes as `AUTO_INCREMENT` instead. A literal is read by the column's codec, and a text or blob column's literal is written as an expression, as MySQL requires.
+*/
+async function renderMysqlColumnDefault(def, columnType, codecLookup, codecRef, where) {
+	if (def.kind === "function") {
+		const text = def.expression.text;
+		if (text === "autoincrement()") return "";
+		if (text === "now()") return `DEFAULT (${currentTimestampFor(columnType)})`;
+		if (checkSqlDefaultText(text) !== void 0) throw structuredError("CONTRACT.DEFAULT_INVALID", `Unsafe default expression in contract: "${text}". Default expressions must not contain semicolons, SQL comment tokens, dollar-quoting, or subqueries.`, { meta: { expression: text } });
+		return `DEFAULT (${renderOpaqueSql(def.expression)})`;
+	}
+	const encoded = codecRef === void 0 ? void 0 : await encodeLiteralDefault(codecLookup, codecRef, def.value, where);
+	if (encoded?.kind === "sql-null") return "DEFAULT NULL";
+	return `DEFAULT ${withinParentheses(columnType, mysqlInlineLiteral(encoded === void 0 ? def.value : encoded.wire, where))}`;
+}
+function isAutoincrement(column) {
+	return column.default?.kind === "function" && column.default.expression.text === "autoincrement()";
+}
+async function renderColumn(column, codecLookup, table) {
+	const parts = [quoteIdentifier(column.name), column.type];
+	if (column.notNull) parts.push("NOT NULL");
+	if (column.default !== void 0) {
+		const clause = await renderMysqlColumnDefault(column.default, column.type, codecLookup, column.codecRef, {
+			table,
+			column: column.name
+		});
+		if (clause.length > 0) parts.push(clause);
+	}
+	if (isAutoincrement(column)) parts.push("AUTO_INCREMENT");
+	if (column.primaryKey) parts.push("PRIMARY KEY");
+	return parts.join(" ");
+}
+function columnList(columns) {
+	return columns.map(quoteIdentifier).join(", ");
+}
+function named(name, body) {
+	return name === void 0 ? body : `CONSTRAINT ${quoteIdentifier(name)} ${body}`;
+}
+function renderConstraint(constraint) {
+	switch (constraint.kind) {
+		case "primary-key": return named(constraint.name, `PRIMARY KEY (${columnList(constraint.columns)})`);
+		case "unique": return named(constraint.name, `UNIQUE (${columnList(constraint.columns)})`);
+		case "foreign-key": {
+			const actions = [constraint.onDelete === void 0 ? void 0 : `ON DELETE ${REFERENTIAL_ACTION_SQL[constraint.onDelete]}`, constraint.onUpdate === void 0 ? void 0 : `ON UPDATE ${REFERENTIAL_ACTION_SQL[constraint.onUpdate]}`].filter((action) => action !== void 0);
+			return named(constraint.name, [`FOREIGN KEY (${columnList(constraint.columns)}) REFERENCES ${quoteIdentifier(constraint.refTable)} (${columnList(constraint.refColumns)})`, ...actions].join(" "));
+		}
+		case "check-expression": throw structuredError("CONTRACT.CONSTRAINT_INVALID", `The MySQL target does not write CHECK constraints yet (constraint "${constraint.name}").`, { meta: { constraintName: constraint.name } });
+	}
+}
+/** The `CREATE TABLE` statement of a MySQL DDL node. */
+async function renderMysqlCreateTable(node, codecLookup) {
+	const definitions = [...await Promise.all(node.columns.map((column) => renderColumn(column, codecLookup, node.table))), ...(node.constraints ?? []).map(renderConstraint)];
+	return {
+		sql: `CREATE TABLE ${node.ifNotExists === true ? "IF NOT EXISTS " : ""}${quoteIdentifier(node.table)} (\n  ${definitions.join(",\n  ")}\n)`,
+		params: []
+	};
+}
+function isLoose(value) {
+	return typeof value === "object" && value !== null;
+}
+function child(value, key) {
+	const found = isLoose(value) ? value[key] : void 0;
+	return isLoose(found) ? found : void 0;
+}
+function tableIndexKey(tableName, indexName) {
+	return JSON.stringify([tableName, indexName]);
+}
+/** The indexes the contract handed to introspection declares, read from every contract space it holds. */
+function declaredIndexes(contract) {
+	const contracts = isLoose(contract) && Array.isArray(contract["contracts"]) ? contract["contracts"] : [contract];
+	const declared = /* @__PURE__ */ new Set();
+	const declaredUnique = /* @__PURE__ */ new Set();
+	for (const space of contracts) for (const namespace of Object.values(child(child(space, "storage"), "namespaces") ?? {})) for (const [tableName, table] of Object.entries(child(child(namespace, "entries"), "table") ?? {})) {
+		const indexes = isLoose(table) ? table["indexes"] : void 0;
+		for (const index of Array.isArray(indexes) ? indexes : []) {
+			if (!isLoose(index) || typeof index["name"] !== "string") continue;
+			const key = tableIndexKey(tableName, index["name"]);
+			declared.add(key);
+			if (index["unique"] === true) declaredUnique.add(key);
+		}
+	}
+	return {
+		declaresIndex: (tableName, indexName) => declared.has(tableIndexKey(tableName, indexName)),
+		declaresUniqueIndex: (tableName, indexName) => declaredUnique.has(tableIndexKey(tableName, indexName))
+	};
+}
+const NOTHING_DECLARED = {
+	declaresIndex: () => false,
+	declaresUniqueIndex: () => false
+};
+const PRIMARY_INDEX = "PRIMARY";
+const REFERENTIAL_ACTIONS = {
+	RESTRICT: "restrict",
+	CASCADE: "cascade",
+	"SET NULL": "setNull",
+	"SET DEFAULT": "setDefault"
+};
+/** A rule `REFERENTIAL_CONSTRAINTS` reports, with `NO ACTION`, MySQL's default, as no action at all. */
+function referentialAction(rule) {
+	const normalized = rule.toUpperCase();
+	if (normalized === "NO ACTION") return void 0;
+	const action = REFERENTIAL_ACTIONS[normalized];
+	if (action === void 0) throw structuredError("CONTRACT.INTROSPECTION_UNSUPPORTED", `Unknown MySQL referential action rule: "${rule}". Expected one of: NO ACTION, RESTRICT, CASCADE, SET NULL, SET DEFAULT.`, { meta: { rule } });
+	return action;
+}
+function tableDependsOn(tableName) {
+	return [{
+		nodeKind: RelationalSchemaNodeKind.schema,
+		id: "database"
+	}, {
+		nodeKind: RelationalSchemaNodeKind.table,
+		id: tableName
+	}];
+}
+function columnDependsOn(tableName, columns) {
+	return columns.map((column) => [...tableDependsOn(tableName), {
+		nodeKind: RelationalSchemaNodeKind.column,
+		id: `column:${column}`
+	}]);
+}
+function groupBy(rows, key) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const group = groups.get(key(row));
+		if (group === void 0) groups.set(key(row), [row]);
+		else group.push(row);
+	}
+	return groups;
+}
+function byPosition(position) {
+	return (a, b) => Number(position(a)) - Number(position(b));
+}
+async function columnOf(row, dataTypes, readLiteralDefault) {
+	const reported = readMysqlDefault(row.column_default, row.extra);
+	const readDefault = reported === void 0 ? {} : reported.kind === "function" ? { resolvedDefault: reported } : await readLiteralDefault(row.table_name, row.column_name, reported.literal.body);
+	const reportedType = {
+		text: row.column_type,
+		kind: void 0,
+		schema: void 0,
+		name: void 0
+	};
+	return {
+		name: row.column_name,
+		typeText: row.column_type,
+		nullable: row.is_nullable === "YES",
+		...ifDefined("default", row.column_default ?? void 0),
+		...readDefault,
+		reportedType,
+		...resolveIntrospectedColumnType(reportedType, dataTypes)
+	};
+}
+function indexesOf(rows) {
+	return [...groupBy(rows, (row) => row.index_name).entries()].map(([name, parts]) => {
+		const ordered = [...parts].sort(byPosition((part) => part.seq_in_index));
+		const expressions = ordered.flatMap((part) => part.expression === null ? [] : [part.expression]);
+		return {
+			name,
+			unique: ordered[0]?.non_unique === "0",
+			columns: ordered.flatMap((part) => part.column_name === null ? [] : [part.column_name]),
+			expression: expressions.length === 0 ? void 0 : expressions.join(", ")
+		};
+	});
+}
+function sameColumns(a, b) {
+	return a.length === b.length && a.every((column, index) => column === b[index]);
+}
+function foreignKeysOf(tableName, rows) {
+	return [...groupBy(rows, (row) => row.constraint_name).entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([name, parts]) => {
+		const ordered = [...parts].sort(byPosition((part) => part.ordinal_position));
+		const [first] = ordered;
+		const columns = ordered.map((part) => part.column_name);
+		const referencedTable = first?.referenced_table_name ?? "";
+		const referencedSchema = first?.referenced_table_schema ?? void 0;
+		return {
+			columns,
+			referencedTable,
+			referencedColumns: ordered.map((part) => part.referenced_column_name),
+			...ifDefined("referencedSchema", referencedSchema),
+			name,
+			...ifDefined("onDelete", first === void 0 ? void 0 : referentialAction(first.delete_rule)),
+			...ifDefined("onUpdate", first === void 0 ? void 0 : referentialAction(first.update_rule)),
+			dependsOn: [...referencedSchema === void 0 ? [tableDependsOn(referencedTable)] : [], ...columnDependsOn(tableName, columns)]
+		};
+	});
+}
+/**
+* The index InnoDB creates for a foreign key that no index already serves: it carries the key's name and exactly the key's columns. Introspection leaves it out, because the contract describes the key, not that index. An explicit index can look the same, so one the contract declares is kept.
+*/
+function isForeignKeyIndex(tableName, index, foreignKeys, declared) {
+	if (declared.declaresIndex(tableName, index.name)) return false;
+	return foreignKeys.some((fk) => fk.name === index.name && index.expression === void 0 && sameColumns(fk.columns, index.columns));
+}
+async function tableOf(tableName, rows, dataTypes, readLiteralDefault, declared) {
+	const columns = {};
+	for (const row of [...rows.columns].sort(byPosition((column) => column.ordinal_position))) columns[row.column_name] = await columnOf(row, dataTypes, readLiteralDefault);
+	const foreignKeys = foreignKeysOf(tableName, rows.foreignKeys);
+	const indexes = indexesOf(rows.indexes);
+	const expressionIndexNames = new Set(indexes.filter((index) => index.expression !== void 0).map((index) => index.name));
+	const uniqueConstraintNames = new Set(rows.constraints.filter((constraint) => constraint.constraint_type === "UNIQUE" && !expressionIndexNames.has(constraint.constraint_name) && !declared.declaresUniqueIndex(tableName, constraint.constraint_name)).map((constraint) => constraint.constraint_name));
+	const primary = indexes.find((index) => index.name === PRIMARY_INDEX);
+	const primaryKey = primary === void 0 ? void 0 : {
+		columns: primary.columns,
+		dependsOn: columnDependsOn(tableName, primary.columns)
+	};
+	const uniques = indexes.filter((index) => uniqueConstraintNames.has(index.name)).map((index) => ({
+		columns: index.columns,
+		name: index.name,
+		dependsOn: columnDependsOn(tableName, index.columns)
+	}));
+	const plainIndexes = indexes.filter((index) => index.name !== PRIMARY_INDEX && !uniqueConstraintNames.has(index.name) && !isForeignKeyIndex(tableName, index, foreignKeys, declared)).map((index) => {
+		const base = {
+			naming: {
+				kind: "exact",
+				name: index.name
+			},
+			where: void 0,
+			unique: index.unique,
+			partial: false,
+			type: void 0,
+			options: void 0,
+			annotations: void 0,
+			dependsOn: columnDependsOn(tableName, index.columns)
+		};
+		return index.expression === void 0 ? {
+			...base,
+			columns: index.columns
+		} : {
+			...base,
+			expression: index.expression
+		};
+	});
+	return new SqlTableIR({
+		name: tableName,
+		columns,
+		...ifDefined("primaryKey", primaryKey),
+		foreignKeys,
+		uniques,
+		indexes: plainIndexes
+	});
+}
+/**
+* The schema IR of the database the rows describe: one flat tree of its tables. MySQL lists every unique index as a UNIQUE constraint, so one is reported as a unique constraint unless the contract declares a unique index of that name on the table, or it indexes an expression. The index InnoDB creates for a foreign key is left out, unless the contract declares an index of that name on the table.
+*/
+async function buildMysqlSchemaIR(rows, dataTypes, readLiteralDefault, declared = NOTHING_DECLARED) {
+	const columnsByTable = groupBy(rows.columns, (row) => row.table_name);
+	const indexesByTable = groupBy(rows.indexes, (row) => row.table_name);
+	const constraintsByTable = groupBy(rows.constraints, (row) => row.table_name);
+	const foreignKeysByTable = groupBy(rows.foreignKeys, (row) => row.table_name);
+	const tables = {};
+	for (const tableName of rows.tables) tables[tableName] = await tableOf(tableName, {
+		columns: columnsByTable.get(tableName) ?? [],
+		indexes: indexesByTable.get(tableName) ?? [],
+		constraints: constraintsByTable.get(tableName) ?? [],
+		foreignKeys: foreignKeysByTable.get(tableName) ?? []
+	}, dataTypes, readLiteralDefault, declared);
+	return new SqlSchemaIR({ tables });
+}
+const TABLES = `SELECT TABLE_NAME AS table_name
+  FROM information_schema.TABLES
+  WHERE TABLE_SCHEMA = DATABASE() AND TABLE_TYPE = 'BASE TABLE'
+  ORDER BY TABLE_NAME`;
+const COLUMNS = `SELECT TABLE_NAME AS table_name, COLUMN_NAME AS column_name,
+    ORDINAL_POSITION AS ordinal_position, COLUMN_DEFAULT AS column_default,
+    IS_NULLABLE AS is_nullable, COLUMN_TYPE AS column_type, EXTRA AS extra
+  FROM information_schema.COLUMNS
+  WHERE TABLE_SCHEMA = DATABASE()
+  ORDER BY TABLE_NAME, ORDINAL_POSITION`;
+const INDEXES = `SELECT TABLE_NAME AS table_name, INDEX_NAME AS index_name,
+    NON_UNIQUE AS non_unique, SEQ_IN_INDEX AS seq_in_index,
+    COLUMN_NAME AS column_name, EXPRESSION AS expression
+  FROM information_schema.STATISTICS
+  WHERE TABLE_SCHEMA = DATABASE()
+  ORDER BY TABLE_NAME, INDEX_NAME, SEQ_IN_INDEX`;
+const CONSTRAINTS = `SELECT TABLE_NAME AS table_name, CONSTRAINT_NAME AS constraint_name,
+    CONSTRAINT_TYPE AS constraint_type
+  FROM information_schema.TABLE_CONSTRAINTS
+  WHERE TABLE_SCHEMA = DATABASE()`;
+const FOREIGN_KEYS = `SELECT k.TABLE_NAME AS table_name, k.CONSTRAINT_NAME AS constraint_name,
+    k.COLUMN_NAME AS column_name, k.ORDINAL_POSITION AS ordinal_position,
+    NULLIF(k.REFERENCED_TABLE_SCHEMA, k.TABLE_SCHEMA) AS referenced_table_schema,
+    k.REFERENCED_TABLE_NAME AS referenced_table_name,
+    k.REFERENCED_COLUMN_NAME AS referenced_column_name,
+    r.UPDATE_RULE AS update_rule, r.DELETE_RULE AS delete_rule
+  FROM information_schema.KEY_COLUMN_USAGE k
+  JOIN information_schema.REFERENTIAL_CONSTRAINTS r
+    ON r.CONSTRAINT_SCHEMA = k.CONSTRAINT_SCHEMA
+    AND r.TABLE_NAME = k.TABLE_NAME
+    AND r.CONSTRAINT_NAME = k.CONSTRAINT_NAME
+  WHERE k.TABLE_SCHEMA = DATABASE() AND k.REFERENCED_TABLE_NAME IS NOT NULL
+  ORDER BY k.TABLE_NAME, k.CONSTRAINT_NAME, k.ORDINAL_POSITION`;
+/** Reads the catalog rows of the connection's database, leaving out the runner's control tables. */
+async function readMysqlCatalog(driver) {
+	const keep = (rows) => rows.filter((row) => !CONTROL_TABLE_NAMES.has(row.table_name));
+	const tables = await driver.query(TABLES);
+	const columns = await driver.query(COLUMNS);
+	const indexes = await driver.query(INDEXES);
+	const constraints = await driver.query(CONSTRAINTS);
+	const foreignKeys = await driver.query(FOREIGN_KEYS);
+	return {
+		tables: keep(tables.rows).map((row) => row.table_name),
+		columns: keep(columns.rows),
+		indexes: keep(indexes.rows),
+		constraints: keep(constraints.rows),
+		foreignKeys: keep(foreignKeys.rows)
+	};
+}
+const LEDGER_COLUMNS = "space, migration_name, migration_hash, origin_core_hash, destination_core_hash, operations, created_at";
+function operationCount(operations) {
+	const parsed = typeof operations === "string" ? parseOperations(operations) : operations;
+	return Array.isArray(parsed) ? parsed.length : 0;
+}
+function parseOperations(text) {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return;
+	}
+}
+function text(row, column) {
+	const value = row[column];
+	return typeof value === "string" ? value : String(value);
+}
+/** The ledger's entries for `space`, or for every space, in the order they were applied. */
+async function readLedgerEntries(driver, space) {
+	if (!await tableExists(driver, "_prisma_ledger")) return [];
+	const select = `SELECT ${LEDGER_COLUMNS} FROM ${quoteIdentifier(LEDGER_TABLE_NAME)}`;
+	const { rows } = space === void 0 ? await driver.query(`${select} ORDER BY id`) : await driver.query(`${select} WHERE space = ? ORDER BY id`, [space]);
+	return rows.map((row) => {
+		const origin = row["origin_core_hash"];
+		return {
+			space: text(row, "space"),
+			migrationName: text(row, "migration_name"),
+			migrationHash: text(row, "migration_hash"),
+			from: ledgerOriginFromStored(typeof origin === "string" ? origin : null),
+			to: text(row, "destination_core_hash"),
+			appliedAt: decodeMysqlDatetime(text(row, "created_at")),
+			operationCount: operationCount(row["operations"])
+		};
+	});
+}
+const MARKER_INSERT = `INSERT INTO ${quoteIdentifier(MARKER_TABLE_NAME)} (space, core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta, invariants) VALUES (?, ?, ?, NULL, NULL, CURRENT_TIMESTAMP(3), NULL, '{}', ?)`;
+function markerInsertParams(space, destination) {
+	return [
+		space,
+		destination.storageHash,
+		destination.profileHash,
+		JSON.stringify(destination.invariants ?? [])
+	];
+}
+/** Inserts the marker row of `space`; fails when the space already has one. */
+async function insertMarkerRow(driver, space, destination) {
+	await driver.query(MARKER_INSERT, markerInsertParams(space, destination));
+}
+/** Writes the marker row of `space`, replacing the row the space already has. */
+async function upsertMarkerRow(driver, space, destination) {
+	await driver.query(`${MARKER_INSERT} AS incoming ON DUPLICATE KEY UPDATE core_hash = incoming.core_hash, profile_hash = incoming.profile_hash, contract_json = incoming.contract_json, canonical_version = incoming.canonical_version, updated_at = CURRENT_TIMESTAMP(3), app_tag = incoming.app_tag, meta = incoming.meta, invariants = incoming.invariants`, markerInsertParams(space, destination));
+}
+function invariantsOf(text) {
+	const parsed = parseJsonColumn("invariants", text);
+	return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+}
+/**
+* Advances the marker row of `space` from `expectedFrom` to `destination`, and says whether it did. MySQL has no `RETURNING`, so the row is read and locked with `FOR UPDATE` first, inside the transaction the caller holds, and written only when it still holds `expectedFrom`. Supplied invariants are merged with the stored ones.
+*/
+async function compareAndSwapMarkerRow(driver, space, expectedFrom, destination) {
+	const { rows } = await driver.query(`SELECT core_hash, invariants FROM ${quoteIdentifier(MARKER_TABLE_NAME)} WHERE space = ? FOR UPDATE`, [space]);
+	const [row] = rows;
+	if (row === void 0 || row["core_hash"] !== expectedFrom) return false;
+	const invariants = destination.invariants === void 0 ? void 0 : [.../* @__PURE__ */ new Set([...invariantsOf(row["invariants"]), ...destination.invariants])].sort();
+	await driver.query(`UPDATE ${quoteIdentifier(MARKER_TABLE_NAME)} SET core_hash = ?, profile_hash = ?, updated_at = CURRENT_TIMESTAMP(3)${invariants === void 0 ? "" : ", invariants = ?"} WHERE space = ? AND core_hash = ?`, [
+		destination.storageHash,
+		destination.profileHash,
+		...invariants === void 0 ? [] : [JSON.stringify(invariants)],
+		space,
+		expectedFrom
+	]);
+	return true;
+}
+/** Appends a ledger entry for `space`. */
+async function insertLedgerRow(driver, space, entry) {
+	await driver.query(`INSERT INTO ${quoteIdentifier(LEDGER_TABLE_NAME)} (space, migration_name, migration_hash, origin_core_hash, destination_core_hash, operations) VALUES (?, ?, ?, ?, ?, ?)`, [
+		space,
+		entry.migrationName,
+		entry.migrationHash,
+		entry.from,
+		entry.to,
+		JSON.stringify(entry.operations)
+	]);
+}
+/** A DDL node MySQL does not build, such as one another target's visitor accepts. */
+function unsupportedDdl(ast) {
+	return structuredError("RUNTIME.DDL_UNSUPPORTED", `The MySQL control adapter cannot lower the DDL node "${ast.kind}".`, { meta: {
+		surface: "control-adapter",
+		kind: ast.kind
+	} });
+}
+/**
+* The MySQL control adapter. It introspects the connection's database from `information_schema`, creates, reads and writes the marker and ledger tables, takes the marker lock, and runs work in a transaction. Query lowering refuses with `RUNTIME.AST_UNSUPPORTED`.
+*/
+var MysqlControlAdapter = class {
+	codecRegistry;
+	declaredDataTypes;
+	familyId = "sql";
+	targetId = "mysql";
+	markerLocation = MARKER_TABLE_NAME;
+	/** `declaredDataTypes` are the stack's data types, which introspection resolves each column's reported type over. */
+	constructor(codecRegistry, declaredDataTypes) {
+		this.codecRegistry = codecRegistry;
+		this.declaredDataTypes = declaredDataTypes;
+	}
+	bootstrapControlTableQueries() {
+		return buildControlTableBootstrapQueries();
+	}
+	bootstrapSignMarkerQueries() {
+		return buildSignMarkerBootstrapQueries();
+	}
+	lower(ast) {
+		if (isDdlNode(ast)) throw structuredError("RUNTIME.DDL_UNSUPPORTED", "lower() cannot lower DDL: DDL default literals require inline codec encoding, which is async. Use lowerToExecuteRequest().", { meta: { surface: "control-adapter" } });
+		throw mysqlQueryNotYetSupported("Lowering queries");
+	}
+	async lowerToExecuteRequest(ast) {
+		if (!isDdlNode(ast)) throw mysqlQueryNotYetSupported("Lowering queries");
+		if (typeof ast.accept !== "function") throw unsupportedDdl(ast);
+		return ast.accept(new Proxy({ createTable: (node) => renderMysqlCreateTable(node, this.codecRegistry) }, { get: (target, method) => Reflect.get(target, method) ?? (() => Promise.reject(unsupportedDdl(ast))) }));
+	}
+	async renderColumnDefault(column, table) {
+		if (column.default === void 0) return "";
+		return renderMysqlColumnDefault(column.default, column.type, this.codecRegistry, column.codecRef, {
+			table,
+			column: column.name
+		});
+	}
+	async readMarker(driver, space) {
+		const result = await readMarkerResult(driver, space);
+		return result.kind === "present" ? result.record : null;
+	}
+	async readAllMarkers(driver) {
+		return withMarkerReadErrorHandling(async () => {
+			const markers = /* @__PURE__ */ new Map();
+			for (const row of await readMarkerRows(driver, void 0) ?? []) {
+				const space = String(row["space"]);
+				markers.set(space, parseMarkerRowSafely(row, () => decodeMysqlMarkerRow(row), {
+					space,
+					markerLocation: MARKER_TABLE_NAME
+				}));
+			}
+			return markers;
+		}, {
+			space: APP_SPACE_ID,
+			markerLocation: MARKER_TABLE_NAME
+		});
+	}
+	async readLedger(driver, space) {
+		return withMarkerReadErrorHandling(() => readLedgerEntries(driver, space), {
+			space: space ?? "*",
+			markerLocation: LEDGER_TABLE_NAME
+		});
+	}
+	async insertMarker(driver, space, destination) {
+		await insertMarkerRow(driver, space, destination);
+	}
+	async initMarker(driver, space, destination) {
+		await upsertMarkerRow(driver, space, destination);
+	}
+	async updateMarker(driver, space, expectedFrom, destination) {
+		return compareAndSwapMarkerRow(driver, space, expectedFrom, destination);
+	}
+	async writeLedgerEntry(driver, space, entry) {
+		await insertLedgerRow(driver, space, entry);
+	}
+	/** Takes no lock: MySQL's `GET_LOCK` lives for the session, not the transaction, so {@link holdMarkerLock} takes it around the transaction instead. */
+	async lockMarker(_driver) {}
+	/** Takes `GET_LOCK` before `work` runs and releases it when `work` ends, so `db sign` creates the marker table, whose DDL would end a transaction, under the lock. */
+	async holdMarkerLock(driver, work) {
+		return withMarkerLock(driver, work);
+	}
+	async withTransaction(driver, fn) {
+		return this.#inTransaction(driver, fn);
+	}
+	async #inTransaction(driver, fn) {
+		await driver.query("START TRANSACTION");
+		let result;
+		try {
+			result = await fn();
+		} catch (error) {
+			try {
+				await driver.query("ROLLBACK");
+			} catch (rollbackError) {
+				if (error instanceof Error && error.cause === void 0) error.cause = rollbackError;
+			}
+			throw error;
+		}
+		await driver.query("COMMIT");
+		return result;
+	}
+	async introspect(driver, contract) {
+		const columns = contractColumns(contract);
+		return buildMysqlSchemaIR(await readMysqlCatalog(driver), this.declaredDataTypes, async (tableName, columnName, rawDefault) => {
+			const column = columns.columnOf(void 0, tableName, columnName);
+			const codec = column === void 0 ? void 0 : codecForRef(this.codecRegistry, column.codecRef);
+			if (codec === void 0) return {};
+			return readColumnDefault(codec, {
+				literal: {
+					kind: "value",
+					body: rawDefault
+				},
+				raw: rawDefault
+			}, void 0);
+		}, declaredIndexes(contract));
+	}
+};
+const mysqlAdapterDescriptor = {
+	...mysqlAdapterDescriptorMeta,
+	controlMutationDefaults: {
+		defaultFunctionRegistry: new Map(Object.entries(sqlDefaultFunctions())),
+		generatorDescriptors: []
+	},
+	create(stack) {
+		return new MysqlControlAdapter(assembleMysqlCodecRegistry(stack.target, stack.extensions), stack.declaredDataTypes.map(({ type }) => type));
+	}
+};
+//#endregion
+export { buildMysqlSchemaIR as n, mysqlAdapterDescriptor as r, MysqlControlAdapter as t };
+
+//# sourceMappingURL=control-WTY7Jpxk.mjs.map