qubu 0.4.3 → 0.5.1

package/dist/snapshot.mjs

@@ -1,6 +1,586 @@
+import { F as isValidSchemaObjectName, r as isColumnReference } from "./column-DmazTL67.mjs";
+import { _ as isUnsafeSchemaSql, m as validateConstraintDialect, w as validateIndexDialect, y as renderSchemaExpression } from "./registry-BGqa05et.mjs";
 import { t as createSchemaDialect } from "./dialect-wUKrnPMB.mjs";
-import { a as toSnapshotJsonValue, c as canonicalizeSchemaSnapshot, d as schemaSnapshotDialectVersion, f as schemaSnapshotFormat, i as schemaSnapshotDigest, l as decodeSchemaSnapshot, m as schemaSnapshotVersion, n as canonicalJson, o as SnapshotValidationError, p as schemaSnapshotNamingPolicyVersion, r as encodeCanonicalSnapshot, s as assertSchemaSnapshot, t as SnapshotCanonicalError, u as neutralSnapshotDialect } from "./canonical-BXUguqfo.mjs";
-import { a as sqliteStorageAffinity, c as createSchemaSnapshot, d as encodeSnapshot, f as serializeSchema, i as sqliteSnapshotDialect, l as digestSchemaSnapshot, n as sqliteSchemaDialect, o as tryCreateSqliteSchemaSnapshot, p as tryCreateSchemaSnapshot, r as sqliteSnapshotAdapter, s as SnapshotSerializationError, t as createSqliteSchemaSnapshot, u as encodeSchemaSnapshot } from "./sqlite-mPVdrKrk.mjs";
-import { _ as completeSchemaSnapshotVersion, a as canonicalizeCompleteSchemaSnapshot, b as schemaSnapshotVersion2, c as decodeCompleteSchemaSnapshot, d as digestCompleteSchemaSnapshot, f as encodeCompleteSchemaSnapshot, g as completeSchemaSnapshotFormat, h as schemaSnapshotV2Digest, i as assertSchemaSnapshotV2, l as decodeCompleteSnapshot, m as encodeSchemaSnapshotV2, n as assertCompleteSchemaSnapshot, o as canonicalizeSchemaSnapshotV2, p as encodeCompleteSnapshot, r as assertCompleteSnapshot, s as completeSchemaSnapshotDigest, t as CompleteSnapshotValidationError, u as decodeSchemaSnapshotV2, v as schemaSnapshotCompleteVersion, y as schemaSnapshotV2Version } from "./complete-WYyVozgK.mjs";
-import { a as tryCreateMysqlSchemaSnapshot, c as postgresSnapshotAdapter, i as mysqlSnapshotDialect, l as postgresSnapshotDialect, n as mysqlSchemaDialect, o as createPostgresSchemaSnapshot, r as mysqlSnapshotAdapter, s as postgresSchemaDialect, t as createMysqlSchemaSnapshot, u as tryCreatePostgresSchemaSnapshot } from "./mysql-DxFleLw4.mjs";
-export { CompleteSnapshotValidationError, SnapshotCanonicalError, SnapshotSerializationError, SnapshotValidationError, assertCompleteSchemaSnapshot, assertCompleteSnapshot, assertSchemaSnapshot, assertSchemaSnapshotV2, canonicalJson, canonicalizeCompleteSchemaSnapshot, canonicalizeSchemaSnapshot, canonicalizeSchemaSnapshotV2, completeSchemaSnapshotDigest, completeSchemaSnapshotFormat, completeSchemaSnapshotVersion, createMysqlSchemaSnapshot, createPostgresSchemaSnapshot, createSchemaDialect, createSchemaSnapshot, createSqliteSchemaSnapshot, decodeCompleteSchemaSnapshot, decodeCompleteSnapshot, decodeSchemaSnapshot, decodeSchemaSnapshotV2, digestCompleteSchemaSnapshot, digestSchemaSnapshot, encodeCanonicalSnapshot, encodeCompleteSchemaSnapshot, encodeCompleteSnapshot, encodeSchemaSnapshot, encodeSchemaSnapshotV2, encodeSnapshot, mysqlSchemaDialect, mysqlSnapshotAdapter, mysqlSnapshotDialect, neutralSnapshotDialect, postgresSchemaDialect, postgresSnapshotAdapter, postgresSnapshotDialect, schemaSnapshotCompleteVersion, schemaSnapshotDialectVersion, schemaSnapshotDigest, schemaSnapshotFormat, schemaSnapshotNamingPolicyVersion, schemaSnapshotV2Digest, schemaSnapshotV2Version, schemaSnapshotVersion, schemaSnapshotVersion2, serializeSchema, sqliteSchemaDialect, sqliteSnapshotAdapter, sqliteSnapshotDialect, sqliteStorageAffinity, toSnapshotJsonValue, tryCreateMysqlSchemaSnapshot, tryCreatePostgresSchemaSnapshot, tryCreateSchemaSnapshot, tryCreateSqliteSchemaSnapshot };
+import { a as toSnapshotJsonValue, c as canonicalizeSchemaSnapshot, d as schemaSnapshotDialectVersion, f as schemaSnapshotFormat, i as schemaSnapshotFingerprint, l as decodeSchemaSnapshot, m as schemaSnapshotVersion, n as canonicalJson, o as SnapshotValidationError, p as schemaSnapshotNamingPolicyVersion, r as encodeCanonicalSnapshot, s as assertSchemaSnapshot, t as SnapshotCanonicalError, u as neutralSnapshotDialect } from "./canonical-DMvR9yBe.mjs";
+import { a as sqliteStorageAffinity, c as createSchemaSnapshot, d as fingerprintSchemaSnapshot, f as serializeSchema, i as sqliteSnapshotDialect, l as encodeSchemaSnapshot, n as sqliteSchemaDialect, o as tryCreateSqliteSchemaSnapshot, p as tryCreateSchemaSnapshot, r as sqliteSnapshotAdapter, s as SnapshotSerializationError, t as createSqliteSchemaSnapshot, u as encodeSnapshot } from "./sqlite-CsIUtZ2Q.mjs";
+import { _ as completeSchemaSnapshotVersion, a as canonicalizeCompleteSchemaSnapshot, b as schemaSnapshotVersion2, c as decodeCompleteSchemaSnapshot, d as encodeCompleteSchemaSnapshot, f as encodeCompleteSnapshot, g as completeSchemaSnapshotFormat, h as schemaSnapshotV2Fingerprint, i as assertSchemaSnapshotV2, l as decodeCompleteSnapshot, m as fingerprintCompleteSchemaSnapshot, n as assertCompleteSchemaSnapshot, o as canonicalizeSchemaSnapshotV2, p as encodeSchemaSnapshotV2, r as assertCompleteSnapshot, s as completeSchemaSnapshotFingerprint, t as CompleteSnapshotValidationError, u as decodeSchemaSnapshotV2, v as schemaSnapshotCompleteVersion, y as schemaSnapshotV2Version } from "./complete-DP7pliuY.mjs";
+import { postgresDialect } from "./postgres.mjs";
+import { mysqlDialect } from "./mysql.mjs";
+//#region src/snapshot/postgres.ts
+/** PostgreSQL's v1 snapshot extension identity. */
+const postgresSnapshotDialect = Object.freeze({
+	name: "postgresql",
+	version: 1
+});
+var PostgresSnapshotDialectError = class extends TypeError {
+	code = "dialect-mismatch";
+};
+const postgresStorageTypes = Object.freeze({
+	integer: "INTEGER",
+	numeric: "NUMERIC",
+	text: "TEXT",
+	boolean: "BOOLEAN",
+	date: "DATE",
+	timestamp: "TIMESTAMP",
+	uuid: "UUID",
+	json: "JSONB",
+	bigint: "BIGINT",
+	binary: "BYTEA"
+});
+/** PostgreSQL's query dialect plus its schema metadata behavior. */
+const postgresSchemaDialect = createSchemaDialect(postgresDialect(), {
+	version: 1,
+	validate: validatePostgresSchema,
+	encodeStorage(storage, context) {
+		return encodePostgresStorage(storage, context.dialect);
+	},
+	encodeExpression(expression, context) {
+		return encodePostgresExpression(expression, context.mode, context.dialect);
+	},
+	encodeDialectExtension(extension, context) {
+		return encodePostgresExtension(extension, context.dialect);
+	}
+});
+/** Snapshot adapter retaining the historical adapter-shaped entry point. */
+const postgresSnapshotAdapter = Object.freeze({ dialect: postgresSchemaDialect });
+/** Create a canonical PostgreSQL schema snapshot. */
+function createPostgresSchemaSnapshot(schema, options = {}) {
+	return createSchemaSnapshot(schema, {
+		...options,
+		adapter: postgresSnapshotAdapter
+	});
+}
+/** Return PostgreSQL capability diagnostics without throwing. */
+function tryCreatePostgresSchemaSnapshot(schema, options = {}) {
+	return tryCreateSchemaSnapshot(schema, {
+		...options,
+		adapter: postgresSnapshotAdapter
+	});
+}
+function encodePostgresStorage(storage, dialect) {
+	if (storage.kind === "native") {
+		if (storage.dialect !== dialect.name) throw new TypeError(`PostgreSQL storage cannot encode a native declaration owned by "${storage.dialect}"`);
+		if (storage.type.trim().length === 0) throw new TypeError("PostgreSQL native storage declarations cannot be empty");
+		return {
+			kind: "native",
+			dialect: dialect.name,
+			type: storage.type
+		};
+	}
+	const type = postgresStorageTypes[storage.type];
+	if (type === void 0) throw new TypeError(`Unsupported portable storage type for PostgreSQL: ${String(storage.type)}`);
+	return {
+		kind: "native",
+		dialect: dialect.name,
+		type
+	};
+}
+function encodePostgresExpression(expression, mode, dialect) {
+	if (isUnsafeSchemaSql(expression) && expression.schemaSqlDialect !== dialect.name) throw new PostgresSnapshotDialectError(`Schema SQL is tagged for "${expression.schemaSqlDialect}" but the PostgreSQL schema dialect is "${dialect.name}"`);
+	const rendered = renderSchemaExpression(expression, {
+		mode,
+		dialect
+	});
+	if (rendered.parameters.length !== 0) throw new TypeError("PostgreSQL schema expressions must be parameter-free");
+	return {
+		kind: "expression",
+		expressionKind: expression.expressionKind,
+		sql: rendered.text,
+		...isUnsafeSchemaSql(expression) ? { dialect: dialect.name } : {}
+	};
+}
+function encodePostgresExtension(extension, dialect) {
+	if (extension.dialect !== dialect.name) throw new TypeError(`PostgreSQL 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$1(toSnapshotJsonValue(data))
+	};
+}
+function sortSnapshotJson$1(value) {
+	if (Array.isArray(value)) return value.map(sortSnapshotJson$1);
+	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$1(child)]));
+}
+function validatePostgresSchema(schema, context) {
+	const diagnostics = [];
+	const tableEntries = Object.entries(schema.registry).sort(([left], [right]) => compareIds$1(left, right));
+	const relationNames = /* @__PURE__ */ new Map();
+	if (schema.namespace !== void 0) validatePostgresName(schema.namespace, ["namespace"], "PostgreSQL namespace", diagnostics);
+	for (const [id, entry] of tableEntries) {
+		const tablePath = ["tables", id];
+		validatePostgresName(entry.physicalName, [...tablePath, "physicalName"], "PostgreSQL table", diagnostics);
+		addRelationName(relationNames, entry.physicalName, [...tablePath, "physicalName"], "table", diagnostics);
+	}
+	for (const [id, entry] of tableEntries) validatePostgresTable(id, entry, context, relationNames, diagnostics);
+	return Object.freeze(diagnostics);
+}
+function validatePostgresTable(tableId, entry, context, relationNames, diagnostics) {
+	const table = entry.table;
+	const tablePath = ["tables", tableId];
+	const definitions = table.definitions;
+	for (const [columnId, definition] of Object.entries(definitions).sort(([left], [right]) => compareIds$1(left, right))) {
+		validatePostgresName(table.sqlNames[columnId] ?? columnId, [
+			...tablePath,
+			"columns",
+			columnId,
+			"physicalName"
+		], "PostgreSQL column", diagnostics);
+		if (definition.onUpdate !== void 0) diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "MySQL ON UPDATE expressions are not supported by PostgreSQL",
+			path: [
+				...tablePath,
+				"columns",
+				columnId,
+				"onUpdate"
+			]
+		});
+		const generated = definition.generatedColumn;
+		if (generated !== void 0 && generated.kind === "expression" && generated.mode === "virtual") diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "PostgreSQL v1 snapshots support stored generated columns only; virtual generated columns are not supported",
+			path: [
+				...tablePath,
+				"columns",
+				columnId,
+				"generatedColumn",
+				"mode"
+			]
+		});
+	}
+	const metadata = table;
+	const constraintNames = /* @__PURE__ */ new Map();
+	const constraints = Object.entries(metadata.constraints);
+	for (const [constraintId, constraint] of constraints.sort(([left], [right]) => compareIds$1(left, right))) {
+		const constraintPath = [
+			...tablePath,
+			"constraints",
+			constraintId
+		];
+		const physicalName = constraint.physicalName ?? constraintId;
+		validatePostgresName(physicalName, [...constraintPath, "physicalName"], "PostgreSQL constraint", diagnostics);
+		addScopedName$1(constraintNames, physicalName, [...constraintPath, "physicalName"], "constraint", diagnostics);
+		appendMetadataDiagnostics$1(diagnostics, validateConstraintDialect(constraint, context.dialect.name, constraintPath));
+		if (constraint.kind === "check" && constraint.deferrable === true) diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "PostgreSQL CHECK constraints cannot be DEFERRABLE",
+			path: [...constraintPath, "deferrable"]
+		});
+		if (constraint.kind === "foreign-key" && constraint.match === "partial") diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "PostgreSQL does not implement MATCH PARTIAL foreign keys",
+			path: [...constraintPath, "match"]
+		});
+		if (constraint.kind === "unique-constraint" && constraint.nulls === "not-distinct") diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "PostgreSQL NULLS NOT DISTINCT requires a server-version policy; the v1 adapter does not assume PostgreSQL 15 or newer",
+			path: [...constraintPath, "nulls"]
+		});
+	}
+	const indexes = Object.entries(metadata.indexes);
+	for (const [indexId, index] of indexes.sort(([left], [right]) => compareIds$1(left, right))) {
+		const indexPath = [
+			...tablePath,
+			"indexes",
+			indexId
+		];
+		const physicalName = index.physicalName ?? indexId;
+		validatePostgresName(physicalName, [...indexPath, "physicalName"], "PostgreSQL index", diagnostics);
+		addRelationName(relationNames, physicalName, [...indexPath, "physicalName"], "index", diagnostics);
+		appendMetadataDiagnostics$1(diagnostics, validateIndexDialect(index, context.dialect.name, indexPath));
+	}
+}
+function validatePostgresName(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 (new TextEncoder().encode(name).length > 63) diagnostics.push({
+		code: "unsupported-dialect-option",
+		message: `${kind} name exceeds PostgreSQL's 63-byte identifier limit`,
+		path
+	});
+}
+function addRelationName(names, name, path, kind, diagnostics) {
+	addScopedName$1(names, name, path, kind, diagnostics);
+}
+function addScopedName$1(names, name, path, kind, diagnostics) {
+	const previousPath = names.get(name);
+	if (previousPath !== void 0) {
+		diagnostics.push({
+			code: "invalid-schema",
+			message: `PostgreSQL ${kind} name "${name}" collides with another relation or metadata object`,
+			path,
+			relatedPaths: [previousPath]
+		});
+		return;
+	}
+	names.set(name, path);
+}
+function appendMetadataDiagnostics$1(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 compareIds$1(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+//#endregion
+//#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;
+	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 { CompleteSnapshotValidationError, SnapshotCanonicalError, SnapshotSerializationError, SnapshotValidationError, assertCompleteSchemaSnapshot, assertCompleteSnapshot, assertSchemaSnapshot, assertSchemaSnapshotV2, canonicalJson, canonicalizeCompleteSchemaSnapshot, canonicalizeSchemaSnapshot, canonicalizeSchemaSnapshotV2, completeSchemaSnapshotFingerprint, completeSchemaSnapshotFormat, completeSchemaSnapshotVersion, createMysqlSchemaSnapshot, createPostgresSchemaSnapshot, createSchemaDialect, createSchemaSnapshot, createSqliteSchemaSnapshot, decodeCompleteSchemaSnapshot, decodeCompleteSnapshot, decodeSchemaSnapshot, decodeSchemaSnapshotV2, encodeCanonicalSnapshot, encodeCompleteSchemaSnapshot, encodeCompleteSnapshot, encodeSchemaSnapshot, encodeSchemaSnapshotV2, encodeSnapshot, fingerprintCompleteSchemaSnapshot, fingerprintSchemaSnapshot, mysqlSchemaDialect, mysqlSnapshotAdapter, mysqlSnapshotDialect, neutralSnapshotDialect, postgresSchemaDialect, postgresSnapshotAdapter, postgresSnapshotDialect, schemaSnapshotCompleteVersion, schemaSnapshotDialectVersion, schemaSnapshotFingerprint, schemaSnapshotFormat, schemaSnapshotNamingPolicyVersion, schemaSnapshotV2Fingerprint, schemaSnapshotV2Version, schemaSnapshotVersion, schemaSnapshotVersion2, serializeSchema, sqliteSchemaDialect, sqliteSnapshotAdapter, sqliteSnapshotDialect, sqliteStorageAffinity, toSnapshotJsonValue, tryCreateMysqlSchemaSnapshot, tryCreatePostgresSchemaSnapshot, tryCreateSchemaSnapshot, tryCreateSqliteSchemaSnapshot };

package/dist/{sqlite-mPVdrKrk.mjs → sqlite-CsIUtZ2Q.mjs}

@@ -2,7 +2,7 @@ import { t as standardDialect } from "./standard-DfcZEVOj.mjs";
 import { F as isValidSchemaObjectName, P as generatedSchemaObjectName, r as isColumnReference } from "./column-DmazTL67.mjs";
 import { _ as isUnsafeSchemaSql, m as validateConstraintDialect, n as defaultSchemaNamingPolicy, w as validateIndexDialect, y as renderSchemaExpression } from "./registry-BGqa05et.mjs";
 import { t as createSchemaDialect } from "./dialect-wUKrnPMB.mjs";
-import { a as toSnapshotJsonValue, f as schemaSnapshotFormat, i as schemaSnapshotDigest, o as SnapshotValidationError, r as encodeCanonicalSnapshot, s as assertSchemaSnapshot, u as neutralSnapshotDialect } from "./canonical-BXUguqfo.mjs";
+import { a as toSnapshotJsonValue, f as schemaSnapshotFormat, i as schemaSnapshotFingerprint, o as SnapshotValidationError, r as encodeCanonicalSnapshot, s as assertSchemaSnapshot, u as neutralSnapshotDialect } from "./canonical-DMvR9yBe.mjs";
 import { sqliteDialect } from "./sqlite.mjs";
 //#region src/snapshot/serialize.ts
 const neutralSchemaDialect = createSchemaDialect(Object.freeze({
@@ -113,8 +113,8 @@ function encodeSchemaSnapshot(snapshot) {
 const serializeSchema = createSchemaSnapshot;
 /** Alias for the canonical snapshot encoder. */
 const encodeSnapshot = encodeSchemaSnapshot;
-/** Alias for the canonical snapshot digest helper. */
-const digestSchemaSnapshot = schemaSnapshotDigest;
+/** Alias for the canonical snapshot fingerprint helper. */
+const fingerprintSchemaSnapshot = schemaSnapshotFingerprint;
 function serializeTable(id, table, physicalName, tableIds, tablesById, dialect, options, diagnostics) {
 	const definitions = table.definitions;
 	const tableMetadata = table;
@@ -867,4 +867,4 @@ function compareIds(left, right) {
 	return left < right ? -1 : left > right ? 1 : 0;
 }
 //#endregion
-export { sqliteStorageAffinity as a, createSchemaSnapshot as c, encodeSnapshot as d, serializeSchema as f, sqliteSnapshotDialect as i, digestSchemaSnapshot as l, sqliteSchemaDialect as n, tryCreateSqliteSchemaSnapshot as o, tryCreateSchemaSnapshot as p, sqliteSnapshotAdapter as r, SnapshotSerializationError as s, createSqliteSchemaSnapshot as t, encodeSchemaSnapshot as u };
+export { sqliteStorageAffinity as a, createSchemaSnapshot as c, fingerprintSchemaSnapshot as d, serializeSchema as f, sqliteSnapshotDialect as i, encodeSchemaSnapshot as l, sqliteSchemaDialect as n, tryCreateSqliteSchemaSnapshot as o, tryCreateSchemaSnapshot as p, sqliteSnapshotAdapter as r, SnapshotSerializationError as s, createSqliteSchemaSnapshot as t, encodeSnapshot as u };

package/docs/config.json

@@ -10,6 +10,7 @@
       "getting-started.md",
       "query-model/",
       "schema/",
+      "migrations/",
       "dialects-and-execution.md",
       "sql-semantic-types.md",
       "guides/",

package/docs/dialects-and-execution.md

@@ -111,6 +111,40 @@ const adapter: QueryAdapter = {
 }
 ```
 
+### Experimental cloud adapters
+
+The workspace also publishes experimental adapters for HTTP and serverless
+database clients. They are not production-ready and are intentionally outside
+provider-backed CI until funded infrastructure and an external maintainer are
+available.
+
+| Package                                   | Driver boundary                        | Advertised capabilities                                                                              |
+| ----------------------------------------- | -------------------------------------- | ---------------------------------------------------------------------------------------------------- |
+| `@qubu/adapter-neon`                      | Neon HTTP PostgreSQL query function    | PostgreSQL rendering, object rows, mutation counts, EXPLAIN, and fetch cancellation                  |
+| `@qubu/adapter-planetscale`               | PlanetScale serverless MySQL client    | MySQL rendering, rows, mutation metadata, EXPLAIN, and provider transaction callbacks                |
+| `@qubu/adapter-aws-rds-data-api/postgres` | AWS RDS Data API for Aurora PostgreSQL | PostgreSQL rendering, typed Data API values/results, EXPLAIN, mutation metadata, and transaction IDs |
+| `@qubu/adapter-aws-rds-data-api/mysql`    | AWS RDS Data API for Aurora MySQL      | MySQL rendering, typed Data API values/results, EXPLAIN, mutation metadata, and transaction IDs      |
+
+Neon HTTP and the RDS Data API do not advertise interactive streaming. The
+RDS adapter uses named placeholders (`:p1`, `:p2`, ...), while PlanetScale uses
+the MySQL dialect and the provider's own value formatting. Read each package's
+README for its experimental boundary and required provider setup.
+
+### Official SQLite WASM adapter
+
+`@qubu/adapter-sqlite-wasm` adapts the official SQLite WASM OO1
+`sqlite3.oo1.DB` API for browser and web-worker use. It prepares one statement
+per request, binds Qubu's ordered parameters, copies object rows, and finalizes
+the statement in a `finally` block. SQLite's change count and generated row ID
+are returned as mutation metadata when the request is a mutation.
+
+The package does not create or terminate workers. Initialize the official
+SQLite module inside a dedicated worker, construct the adapter around its
+`sqlite3.oo1.DB`, and close the adapter before terminating that worker. The
+browser build must serve the package's `sqlite3.wasm` asset beside the bundled
+worker module; the combo runner's verified browser scenario demonstrates this
+lifecycle.
+
 ### Decode schema-aware result values
 
 Portable boolean, date, timestamp, and JSON columns retain their logical