qubu 0.0.0 → 0.3.4

package/dist/mysql-DqkqXB6A.mjs

@@ -0,0 +1,355 @@
+import { r as isColumnReference } from "./column-CXMxx8Hq.mjs";
+import { A as isValidSchemaObjectName, _ as isUnsafeSchemaSql, m as validateConstraintDialect, w as validateIndexDialect, y as renderSchemaExpression } from "./registry-BufIskVN.mjs";
+import { t as createSchemaDialect } from "./dialect-b2-Z6uBF.mjs";
+import { a as toSnapshotJsonValue } from "./canonical-BbnqavJm.mjs";
+import { n as createSchemaSnapshot, s as tryCreateSchemaSnapshot } from "./serialize-PF1cfH2P.mjs";
+import { mysqlDialect } from "./mysql.mjs";
+//#region src/snapshot/mysql.ts
+/** MySQL's v1 snapshot extension identity. */
+const mysqlSnapshotDialect = Object.freeze({
+	name: "mysql",
+	version: 1
+});
+var MysqlSnapshotDialectError = class extends TypeError {
+	code = "dialect-mismatch";
+};
+const mysqlStorageTypes = Object.freeze({
+	integer: "INT",
+	numeric: "DECIMAL",
+	text: "TEXT",
+	boolean: "BOOLEAN",
+	date: "DATE",
+	timestamp: "DATETIME",
+	uuid: "CHAR(36)",
+	json: "JSON",
+	bigint: "BIGINT",
+	binary: "VARBINARY"
+});
+/** MySQL's query dialect plus its schema metadata behavior. */
+const mysqlSchemaDialect = createSchemaDialect(mysqlDialect(), {
+	version: 1,
+	validate: validateMysqlSchema,
+	encodeStorage(storage, context) {
+		return encodeMysqlStorage(storage, context.dialect);
+	},
+	encodeExpression(expression, context) {
+		return encodeMysqlExpression(expression, context.mode, context.dialect);
+	},
+	encodeDialectExtension(extension, context) {
+		return encodeMysqlExtension(extension, context.dialect);
+	}
+});
+/** Snapshot adapter retaining the historical adapter-shaped entry point. */
+const mysqlSnapshotAdapter = Object.freeze({ dialect: mysqlSchemaDialect });
+/** Create a canonical MySQL schema snapshot. */
+function createMysqlSchemaSnapshot(schema, options = {}) {
+	return createSchemaSnapshot(schema, {
+		...options,
+		adapter: mysqlSnapshotAdapter
+	});
+}
+/** Return MySQL capability diagnostics without throwing. */
+function tryCreateMysqlSchemaSnapshot(schema, options = {}) {
+	return tryCreateSchemaSnapshot(schema, {
+		...options,
+		adapter: mysqlSnapshotAdapter
+	});
+}
+function encodeMysqlStorage(storage, dialect) {
+	if (storage.kind === "native") {
+		if (storage.dialect !== dialect.name) throw new MysqlSnapshotDialectError(`MySQL storage cannot encode a native declaration owned by "${storage.dialect}"`);
+		if (storage.type.trim().length === 0) throw new TypeError("MySQL native storage declarations cannot be empty");
+		return {
+			kind: "native",
+			dialect: dialect.name,
+			type: storage.type
+		};
+	}
+	const type = mysqlStorageTypes[storage.type];
+	if (type === void 0) throw new TypeError(`Unsupported portable storage type for MySQL: ${String(storage.type)}`);
+	return {
+		kind: "native",
+		dialect: dialect.name,
+		type
+	};
+}
+function encodeMysqlExpression(expression, mode, dialect) {
+	if (isUnsafeSchemaSql(expression) && expression.schemaSqlDialect !== dialect.name) throw new MysqlSnapshotDialectError(`Schema SQL is tagged for "${expression.schemaSqlDialect}" but the MySQL schema dialect is "${dialect.name}"`);
+	const rendered = renderSchemaExpression(expression, {
+		mode,
+		dialect
+	});
+	if (rendered.parameters.length !== 0) throw new TypeError("MySQL schema expressions must be parameter-free");
+	return {
+		kind: "expression",
+		expressionKind: expression.expressionKind,
+		sql: rendered.text,
+		...isUnsafeSchemaSql(expression) ? { dialect: dialect.name } : {}
+	};
+}
+function encodeMysqlExtension(extension, dialect) {
+	if (extension.dialect !== dialect.name) throw new MysqlSnapshotDialectError(`MySQL schema extensions require dialect "${dialect.name}"`);
+	const data = Object.fromEntries(Object.entries(extension).filter(([key]) => key !== "dialect").sort(([left], [right]) => left.localeCompare(right)));
+	return {
+		dialect: dialect.name,
+		version: dialect.schema.version,
+		data: sortSnapshotJson(toSnapshotJsonValue(data))
+	};
+}
+function sortSnapshotJson(value) {
+	if (Array.isArray(value)) return value.map(sortSnapshotJson);
+	if (typeof value !== "object" || value === null) return value;
+	return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, sortSnapshotJson(child)]));
+}
+function validateMysqlSchema(schema, context) {
+	const diagnostics = [];
+	const tableEntries = Object.entries(schema.registry).sort(([left], [right]) => compareIds(left, right));
+	const relationNames = /* @__PURE__ */ new Map();
+	if (schema.namespace !== void 0) validateMysqlName(schema.namespace, ["namespace"], "MySQL database/schema", diagnostics);
+	for (const [id, entry] of tableEntries) {
+		const tablePath = ["tables", id];
+		validateMysqlName(entry.physicalName, [...tablePath, "physicalName"], "MySQL table", diagnostics);
+		addScopedName(relationNames, entry.physicalName, [...tablePath, "physicalName"], "table", diagnostics);
+	}
+	for (const [id, entry] of tableEntries) validateMysqlTable(id, entry, context, diagnostics);
+	return Object.freeze(diagnostics);
+}
+function validateMysqlTable(tableId, entry, context, diagnostics) {
+	const table = entry.table;
+	const tablePath = ["tables", tableId];
+	const definitions = table.definitions;
+	const metadata = table;
+	for (const [columnId, definition] of Object.entries(definitions).sort(([left], [right]) => compareIds(left, right))) {
+		const columnPath = [
+			...tablePath,
+			"columns",
+			columnId
+		];
+		validateMysqlName(table.sqlNames[columnId] ?? columnId, [...columnPath, "physicalName"], "MySQL column", diagnostics);
+		if (definition.onUpdate !== void 0 && definition.generatedColumn) diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "MySQL generated columns cannot also declare ON UPDATE",
+			path: [...columnPath, "onUpdate"]
+		});
+		const extension = definition.identity?.dialect;
+		const autoIncrement = extension?.dialect === mysqlSnapshotDialect.name ? extension.autoIncrement : void 0;
+		if (extension?.dialect === mysqlSnapshotDialect.name && autoIncrement !== void 0 && typeof autoIncrement !== "boolean") diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "MySQL identity autoIncrement must be boolean",
+			path: [
+				...columnPath,
+				"identity",
+				"dialect",
+				"autoIncrement"
+			]
+		});
+		if (autoIncrement === true) validateMysqlAutoIncrement(columnId, definition, metadata, columnPath, diagnostics);
+	}
+	const constraintNames = /* @__PURE__ */ new Map();
+	const constraints = Object.entries(metadata.constraints);
+	for (const [constraintId, constraint] of constraints.sort(([left], [right]) => compareIds(left, right))) {
+		const constraintPath = [
+			...tablePath,
+			"constraints",
+			constraintId
+		];
+		const physicalName = constraint.physicalName ?? constraintId;
+		validateMysqlName(physicalName, [...constraintPath, "physicalName"], "MySQL constraint", diagnostics);
+		addScopedName(constraintNames, physicalName, [...constraintPath, "physicalName"], "constraint", diagnostics);
+		appendMetadataDiagnostics(diagnostics, validateConstraintDialect(constraint, context.dialect.name, constraintPath));
+		if (constraint.kind === "foreign-key" && (constraint.match === "full" || constraint.match === "partial")) diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "MySQL v1 snapshots support MATCH SIMPLE foreign keys only",
+			path: [...constraintPath, "match"]
+		});
+		if (constraint.kind === "foreign-key" && (constraint.onUpdate === "set-default" || constraint.onDelete === "set-default")) diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "MySQL does not support SET DEFAULT foreign-key actions",
+			path: [...constraintPath, constraint.onUpdate === "set-default" ? "onUpdate" : "onDelete"]
+		});
+		if (constraint.kind === "unique-constraint" && constraint.nulls === "not-distinct") diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "MySQL ordinary UNIQUE constraints use distinct NULL semantics in v1",
+			path: [...constraintPath, "nulls"]
+		});
+		if (constraint.dialect?.dialect === mysqlSnapshotDialect.name && "enforced" in constraint.dialect && constraint.dialect.enforced !== void 0 && typeof constraint.dialect.enforced !== "boolean") diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "MySQL constraint enforced must be boolean",
+			path: [
+				...constraintPath,
+				"dialect",
+				"enforced"
+			]
+		});
+	}
+	const indexes = Object.entries(metadata.indexes);
+	const tableIndexNames = /* @__PURE__ */ new Map();
+	for (const [indexId, index] of indexes.sort(([left], [right]) => compareIds(left, right))) {
+		const indexPath = [
+			...tablePath,
+			"indexes",
+			indexId
+		];
+		const physicalName = index.physicalName ?? indexId;
+		validateMysqlName(physicalName, [...indexPath, "physicalName"], "MySQL index", diagnostics);
+		addScopedName(tableIndexNames, physicalName, [...indexPath, "physicalName"], "index", diagnostics);
+		appendMetadataDiagnostics(diagnostics, validateIndexDialect(index, context.dialect.name, indexPath));
+		if (index.predicate !== void 0) diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "MySQL does not support partial-index predicates",
+			path: [...indexPath, "predicate"]
+		});
+		for (const [termIndex, term] of index.terms.entries()) if (isOrderTerm(term) && term.nulls !== void 0) diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "MySQL index terms do not support NULLS FIRST/LAST syntax",
+			path: [
+				...indexPath,
+				"terms",
+				termIndex,
+				"nulls"
+			]
+		});
+		const extension = index.dialect;
+		if (extension?.dialect === mysqlSnapshotDialect.name) {
+			const mysqlExtension = extension;
+			if (mysqlExtension.algorithm !== void 0 && ![
+				"default",
+				"inplace",
+				"copy"
+			].includes(String(mysqlExtension.algorithm))) diagnostics.push({
+				code: "unsupported-dialect-option",
+				message: "MySQL index algorithm is invalid",
+				path: [
+					...indexPath,
+					"dialect",
+					"algorithm"
+				]
+			});
+			if (mysqlExtension.lock !== void 0 && ![
+				"default",
+				"none",
+				"shared",
+				"exclusive"
+			].includes(String(mysqlExtension.lock))) diagnostics.push({
+				code: "unsupported-dialect-option",
+				message: "MySQL index lock mode is invalid",
+				path: [
+					...indexPath,
+					"dialect",
+					"lock"
+				]
+			});
+			if (mysqlExtension.using !== void 0 && ![
+				"btree",
+				"hash",
+				"rtree"
+			].includes(String(mysqlExtension.using))) diagnostics.push({
+				code: "unsupported-dialect-option",
+				message: "MySQL index access method is invalid",
+				path: [
+					...indexPath,
+					"dialect",
+					"using"
+				]
+			});
+			if (mysqlExtension.parser !== void 0 && (typeof mysqlExtension.parser !== "string" || mysqlExtension.parser.trim().length === 0)) diagnostics.push({
+				code: "unsupported-dialect-option",
+				message: "MySQL index parser must be a non-empty string",
+				path: [
+					...indexPath,
+					"dialect",
+					"parser"
+				]
+			});
+		}
+	}
+}
+function validateMysqlAutoIncrement(columnId, definition, metadata, columnPath, diagnostics) {
+	if (definition.nullable) diagnostics.push({
+		code: "unsupported-dialect-option",
+		message: "MySQL AUTO_INCREMENT columns must be non-nullable",
+		path: [...columnPath, "nullable"]
+	});
+	if (definition.generatedColumn !== void 0) diagnostics.push({
+		code: "unsupported-dialect-option",
+		message: "MySQL AUTO_INCREMENT columns cannot be generated columns",
+		path: [...columnPath, "generatedColumn"]
+	});
+	const declaration = mysqlDeclaration(definition.storage);
+	if (declaration === void 0 || !isMysqlIntegerDeclaration(declaration)) diagnostics.push({
+		code: "unsupported-dialect-option",
+		message: "MySQL AUTO_INCREMENT requires an integer-family physical storage declaration",
+		path: [...columnPath, "storage"]
+	});
+	if (!hasMysqlAutoIncrementKey(columnId, metadata)) diagnostics.push({
+		code: "unsupported-dialect-option",
+		message: "MySQL AUTO_INCREMENT columns must be the first column of a primary, unique, or ordinary index key",
+		path: [
+			...columnPath,
+			"identity",
+			"dialect",
+			"autoIncrement"
+		]
+	});
+}
+function mysqlDeclaration(storage) {
+	if (storage === void 0) return void 0;
+	return storage.kind === "native" ? storage.type : mysqlStorageTypes[storage.type];
+}
+function isMysqlIntegerDeclaration(declaration) {
+	const base = declaration.trim().toUpperCase().split(/\s+/u)[0] ?? "";
+	return /^(?:TINYINT|SMALLINT|MEDIUMINT|INT|INTEGER|BIGINT)(?:\(\d+\))?$/u.test(base);
+}
+function hasMysqlAutoIncrementKey(columnId, metadata) {
+	for (const constraint of Object.values(metadata.constraints)) if ((constraint.kind === "primary-key" || constraint.kind === "unique" || constraint.kind === "unique-constraint") && isColumnReference(constraint.columns[0]) && constraint.columns[0].fieldName === columnId) return true;
+	for (const index of Object.values(metadata.indexes)) {
+		const first = index.terms[0];
+		const expression = isOrderTerm(first) ? first.expression : first;
+		if (isColumnReference(expression) && expression.fieldName === columnId) return true;
+	}
+	return false;
+}
+function validateMysqlName(name, path, kind, diagnostics) {
+	if (!isValidSchemaObjectName(name) || name.length === 0) diagnostics.push({
+		code: "invalid-schema",
+		message: `${kind} name "${name}" is not a valid unqualified identifier`,
+		path
+	});
+	if ([...name].length > 64) diagnostics.push({
+		code: "unsupported-dialect-option",
+		message: `${kind} name exceeds MySQL's 64-character identifier limit`,
+		path
+	});
+}
+function addScopedName(names, name, path, kind, diagnostics) {
+	const previousPath = names.get(name);
+	if (previousPath !== void 0) {
+		diagnostics.push({
+			code: "invalid-schema",
+			message: `MySQL ${kind} name "${name}" collides with another ${kind}`,
+			path,
+			relatedPaths: [previousPath]
+		});
+		return;
+	}
+	names.set(name, path);
+}
+function appendMetadataDiagnostics(diagnostics, issues) {
+	for (const issue of issues) {
+		if (issue.code === "dialect-mismatch") continue;
+		diagnostics.push({
+			code: issue.code === "unsupported-dialect-option" ? "unsupported-dialect-option" : "invalid-schema",
+			message: issue.message,
+			path: issue.path,
+			...issue.relatedPaths === void 0 ? {} : { relatedPaths: issue.relatedPaths }
+		});
+	}
+}
+function isOrderTerm(value) {
+	return typeof value === "object" && value !== null && "orderKind" in value && value.orderKind === "term" && "expression" in value;
+}
+function compareIds(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+//#endregion
+export { tryCreateMysqlSchemaSnapshot as a, mysqlSnapshotDialect as i, mysqlSchemaDialect as n, mysqlSnapshotAdapter as r, createMysqlSchemaSnapshot as t };

package/dist/mysql.d.mts

@@ -0,0 +1,5 @@
+import { V as Dialect } from "./types-4Q076HKo.mjs";
+//#region src/dialects/mysql.d.ts
+declare function mysqlDialect(): Dialect<"json" | "row-locking">;
+//#endregion
+export { mysqlDialect };

package/dist/mysql.mjs

@@ -0,0 +1,50 @@
+import { o as createDialect, t as mysqlJson } from "./json-CUZlv4HT.mjs";
+import { n as queryValidationError } from "./errors-Dxv73YJu.mjs";
+import { t as mysqlExplain } from "./explain-CkIK13L_.mjs";
+//#region src/dialects/mysql.ts
+const mysqlRowLocking = { render(context, mode, wait) {
+	if (mode !== "update" && mode !== "share") throw queryValidationError({
+		code: "invalid-row-lock",
+		context: "dialect.mysql.row-lock",
+		path: ["rowLock", "mode"],
+		message: `MySQL does not support the "${mode}" row-lock mode`,
+		hint: "Use update or share with the MySQL dialect."
+	});
+	context.append(mode === "update" ? "FOR UPDATE" : "FOR SHARE");
+	if (wait === "nowait") context.append(" NOWAIT");
+	if (wait === "skip-locked") context.append(" SKIP LOCKED");
+} };
+function renderMySqlPagination(context, parts) {
+	const fetch = parts.find((part) => part.kind === "fetch");
+	const offset = parts.find((part) => part.kind === "offset");
+	context.append("LIMIT ");
+	if (fetch) context.parameter(fetch.rows);
+	else context.append("18446744073709551615");
+	if (offset) {
+		context.append(" OFFSET ");
+		context.parameter(offset.rows);
+	}
+}
+function mysqlDialect() {
+	return createDialect({
+		name: "mysql",
+		quoteIdentifier: (identifier) => `\`${identifier.replaceAll("`", "``")}\``,
+		placeholder: () => "?",
+		pagination: { render: renderMySqlPagination },
+		rowLocking: mysqlRowLocking,
+		json: mysqlJson,
+		capabilities: ["row-locking"],
+		castTypes: {
+			integer: "SIGNED",
+			text: "CHAR",
+			boolean: "UNSIGNED",
+			timestamp: "DATETIME",
+			uuid: "CHAR",
+			bigint: "SIGNED",
+			binary: "BINARY"
+		},
+		explain: mysqlExplain
+	});
+}
+//#endregion
+export { mysqlDialect };

package/dist/naming-QVCOnSj2.mjs

@@ -0,0 +1,20 @@
+//#region src/core/naming.ts
+/** Convert an application-facing field name to a SQL-facing identifier. */
+function snakeCaseIdentifier(name) {
+	return name.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toLowerCase();
+}
+function resolveSqlNames(fields) {
+	const sqlNames = {};
+	const fieldsBySqlName = /* @__PURE__ */ new Map();
+	for (const field of fields) {
+		const sqlName = field.sqlName ?? snakeCaseIdentifier(field.fieldName);
+		if (sqlName.length === 0) throw new Error(`SQL name for field "${field.fieldName}" cannot be empty`);
+		const existingField = fieldsBySqlName.get(sqlName);
+		if (existingField) throw new Error(`Fields "${existingField}" and "${field.fieldName}" both resolve to SQL name "${sqlName}"`);
+		fieldsBySqlName.set(sqlName, field.fieldName);
+		sqlNames[field.fieldName] = sqlName;
+	}
+	return Object.freeze(sqlNames);
+}
+//#endregion
+export { snakeCaseIdentifier as n, resolveSqlNames as t };

package/dist/omit-OxV58AwX.mjs

@@ -0,0 +1,5 @@
+//#region src/query/omit.ts
+/** An explicit placeholder for a safely omitted SELECT clause or projection field. */
+const omit = Symbol("qubu.omit");
+//#endregion
+export { omit as t };

package/dist/on-conflict-BxnxubMb.mjs

@@ -0,0 +1,143 @@
+import { a as assertDialectCapability } from "./json-CUZlv4HT.mjs";
+import { n as queryValidationError } from "./errors-Dxv73YJu.mjs";
+import { i as identifier, o as isExpression, p as fragment, t as createColumnReference } from "./column-CXMxx8Hq.mjs";
+import { t as omit } from "./omit-OxV58AwX.mjs";
+import { r as exposeColumns, t as createSource } from "./source-DUoJVXmL.mjs";
+//#region src/query/mutation/on-conflict.ts
+/** Columns from the proposed INSERT row, available inside DO UPDATE. */
+function excluded(table) {
+	const reference = fragment((context) => {
+		assertDialectCapability(context.dialect, "on-conflict");
+		context.append("excluded");
+	});
+	const source = createSource("excluded", (context) => context.render(reference), reference);
+	const columns = Object.fromEntries(Object.keys(table.definitions).map((fieldName) => [fieldName, createColumnReference(table.sqlNames[fieldName] ?? fieldName, reference, fieldName)]));
+	Object.assign(source, { columns });
+	exposeColumns(source, columns);
+	return source;
+}
+function doNothing() {
+	return Object.freeze({ actionKind: "do-nothing" });
+}
+function doUpdate(assignments, whereClause) {
+	return Object.freeze({
+		actionKind: "do-update",
+		assignments,
+		where: whereClause
+	});
+}
+function onConflict(...args) {
+	const table = args.length === 1 ? void 0 : args[0];
+	const target = args.length === 1 ? void 0 : args[1];
+	const action = args.length === 1 ? args[0] : args[2];
+	if (table !== void 0 && target !== void 0) validateConflictTarget(table, target);
+	validateConflictAction(table, action);
+	return Object.freeze({
+		clauseKind: "on-conflict",
+		target,
+		action,
+		render(context) {
+			assertDialectCapability(context.dialect, "on-conflict");
+			context.append("ON CONFLICT");
+			if (target !== void 0) {
+				context.append(" (");
+				target.columns.forEach((column, index) => {
+					if (index > 0) context.append(", ");
+					context.render(identifier(table?.sqlNames[column.fieldName] ?? column.columnName));
+				});
+				context.append(")");
+			}
+			if (action.actionKind === "do-nothing") {
+				context.append(" DO NOTHING");
+				return;
+			}
+			context.append(" DO UPDATE SET ");
+			Object.entries(action.assignments).filter(([, value]) => value !== omit).forEach(([columnName, value], index) => {
+				if (index > 0) context.append(", ");
+				context.render(identifier(table?.sqlNames[columnName] ?? columnName));
+				context.append(" = ");
+				if (isExpression(value)) context.render(value);
+				else context.parameter(value);
+			});
+			if (action.where !== void 0) {
+				context.append(" ");
+				context.render(action.where);
+			}
+		}
+	});
+}
+function validateConflictTarget(table, target) {
+	if (target.kind !== "primary-key" && target.kind !== "unique" || target.columns.length === 0) throw queryValidationError({
+		code: "invalid-mutation",
+		context: "upsert.conflict.target",
+		path: ["onConflict", "target"],
+		message: "ON CONFLICT requires a non-empty primary or unique key target",
+		hint: "Use a declared primaryKey() or unique() constraint from the target table."
+	});
+	const tableColumns = new Set(Object.values(table.columns));
+	if (target.columns.some((column) => !tableColumns.has(column))) throw queryValidationError({
+		code: "invalid-mutation",
+		context: "upsert.conflict.target",
+		path: [
+			"onConflict",
+			"target",
+			"columns"
+		],
+		message: "ON CONFLICT target columns must belong to the target table",
+		hint: "Use the key constraint declared on the INSERT target table."
+	});
+}
+function validateConflictAction(table, action) {
+	if (action.actionKind === "do-nothing") {
+		if (table === void 0) return;
+		return;
+	}
+	if (table === void 0) throw queryValidationError({
+		code: "invalid-mutation",
+		context: "upsert.conflict.action",
+		path: ["onConflict", "action"],
+		message: "DO UPDATE requires a target table and conflict target",
+		hint: "Pass the target table and a declared key to onConflict()."
+	});
+	const entries = Object.entries(action.assignments).filter(([, value]) => value !== omit);
+	if (entries.length === 0) throw queryValidationError({
+		code: "invalid-update",
+		context: "upsert.update.assignments",
+		path: [
+			"onConflict",
+			"action",
+			"assignments"
+		],
+		message: "DO UPDATE requires at least one assignment",
+		hint: "Provide at least one writable column, or use doNothing()."
+	});
+	for (const [columnName] of entries) {
+		const definition = table.definitions[columnName];
+		if (!definition) throw queryValidationError({
+			code: "invalid-update",
+			context: "upsert.update.assignments",
+			path: [
+				"onConflict",
+				"action",
+				"assignments",
+				columnName
+			],
+			message: `Unknown update column "${columnName}"`,
+			hint: "Use only columns declared by the INSERT target table."
+		});
+		if (definition.generated) throw queryValidationError({
+			code: "invalid-update",
+			context: "upsert.update.assignments",
+			path: [
+				"onConflict",
+				"action",
+				"assignments",
+				columnName
+			],
+			message: `Generated column "${columnName}" cannot be updated`,
+			hint: "Remove the generated column from the DO UPDATE assignments."
+		});
+	}
+}
+//#endregion
+export { onConflict as i, doUpdate as n, excluded as r, doNothing as t };