qubu 0.6.1 → 0.6.2

package/dist/introspection.mjs

@@ -1,673 +1,3 @@
-import { a as toSnapshotJsonValue } from "./canonical-DMvR9yBe.mjs";
+import { a as createCompleteIntrospectionCatalog, i as introspectedPhysicalIdentityPolicy, n as mapCatalogToCompleteSnapshot, o as freezeIntrospectionCatalog, r as mapCatalogToSnapshotV1, s as toIntrospectionCatalog, t as mapCatalogToSnapshot } from "./snapshot-mIb-Zzb5.mjs";
 import { n as createIntrospectionDiagnostic, r as hasIntrospectionErrors, t as IntrospectionError } from "./diagnostics-I9vVtXkc.mjs";
-import { n as introspectedPhysicalIdentityPolicy, t as mapCatalogToSnapshot } from "./snapshot-DgsOhf_8.mjs";
-import { n as assertCompleteSchemaSnapshot } from "./complete-DP7pliuY.mjs";
-import "./snapshot.mjs";
-//#region src/introspection/catalog.ts
-/**
-* Materialize every optional object-family collection and deeply freeze the normalized catalog.
-* Catalog text and extension data remain values; this helper never evaluates SQL or assigns
-* persisted logical identities.
-*/
-function createCompleteIntrospectionCatalog(catalog) {
-	return deepFreeze({
-		dialect: catalog.dialect,
-		server: catalog.server,
-		capabilities: catalog.capabilities ?? catalog.server.capabilities,
-		namespace: catalog.namespace,
-		tables: sortTables(catalog.tables),
-		views: sortObjects(catalog.views ?? []),
-		sequences: sortObjects(catalog.sequences ?? []),
-		enums: sortObjects(catalog.enums ?? []),
-		domains: sortObjects(catalog.domains ?? []),
-		collations: sortObjects(catalog.collations ?? []),
-		triggers: sortObjects(catalog.triggers ?? []),
-		routines: sortObjects(catalog.routines ?? []),
-		partitions: sortObjects(catalog.partitions ?? []),
-		policies: sortObjects(catalog.policies ?? []),
-		extensionObjects: sortObjects(catalog.extensionObjects ?? []),
-		deferredObjects: [...catalog.deferredObjects].sort(compareDeferred),
-		opaqueObjects: sortObjects(catalog.opaqueObjects ?? []),
-		comments: [...catalog.comments ?? []].sort(compareId$1),
-		ownership: [...catalog.ownership ?? []].sort(compareId$1),
-		diagnostics: [...catalog.diagnostics]
-	});
-}
-/** Alias for callers that already use the normalized-catalog terminology. */
-const freezeIntrospectionCatalog = createCompleteIntrospectionCatalog;
-/** Convert a complete catalog back to the optional reader-facing contract. */
-function toIntrospectionCatalog(catalog) {
-	return deepFreeze({
-		...catalog,
-		capabilities: catalog.capabilities
-	});
-}
-function sortTables(tables) {
-	return [...tables].map((table) => deepFreeze({
-		...table,
-		columns: [...table.columns].sort(compareColumn),
-		constraints: [...table.constraints].sort(compareId$1),
-		indexes: [...table.indexes].sort(compareId$1)
-	})).sort(compareId$1);
-}
-function sortObjects(objects) {
-	return [...objects].sort(compareId$1);
-}
-function compareId$1(left, right) {
-	return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
-}
-function compareDeferred(left, right) {
-	const leftId = left.id ?? left.physicalName;
-	const rightId = right.id ?? right.physicalName;
-	return leftId < rightId ? -1 : leftId > rightId ? 1 : 0;
-}
-function compareColumn(left, right) {
-	return left.ordinalPosition - right.ordinalPosition || compareId$1(left, right);
-}
-/**
-* Freeze nested catalog values without imposing JSON semantics on bigint or opaque driver values.
-* The normalized contract is expected to contain plain records, arrays, and scalar values;
-* unsupported prototypes are retained but still frozen so the operation remains non-destructive.
-*/
-function deepFreeze(value, seen = /* @__PURE__ */ new WeakSet()) {
-	if (value === null || typeof value !== "object") return value;
-	if (seen.has(value)) return value;
-	seen.add(value);
-	if (Array.isArray(value)) for (const item of value) deepFreeze(item, seen);
-	else for (const child of Object.values(value)) deepFreeze(child, seen);
-	return Object.freeze(value);
-}
-//#endregion
-//#region src/introspection/complete-snapshot.ts
-/**
-* Map a normalized catalog to strict Snapshot v2 data. This is intentionally separate from the
-* Snapshot v1 mapper: complete objects are never fabricated as tables, and catalog references
-* remain evidence rather than logical IDs.
-*/
-function mapCatalogToCompleteSnapshot(input) {
-	const catalog = createCompleteIntrospectionCatalog(input);
-	const diagnostics = [...catalog.diagnostics];
-	const tableByPhysicalName = new Map(catalog.tables.map((table) => [table.physicalName, table]));
-	const tables = catalog.tables.map((table) => mapTable(table, catalog.dialect, tableByPhysicalName, diagnostics));
-	const views = catalog.views.map((view) => mapView(view, catalog.dialect));
-	const sequences = catalog.sequences.map((sequence) => mapSequence(sequence, catalog.dialect));
-	const enums = catalog.enums.map((item) => mapEnum(item, catalog.dialect));
-	const domains = catalog.domains.map((domain) => mapDomain(domain, catalog.dialect));
-	const collations = catalog.collations.map((collation) => ({
-		kind: "collation",
-		id: collation.id,
-		physicalName: collation.physicalName,
-		...collation.provider === void 0 ? {} : { provider: collation.provider },
-		...collation.locale === void 0 ? {} : { locale: collation.locale },
-		...collation.deterministic === void 0 ? {} : { deterministic: collation.deterministic },
-		...collation.version === void 0 ? {} : { version: collation.version },
-		...mapMetadata(collation.provenance, collation.dialect, catalog.dialect, collation.reference)
-	}));
-	const triggers = catalog.triggers.map((trigger) => mapTrigger(trigger, catalog.dialect, diagnostics));
-	const routines = catalog.routines.map((routine) => mapRoutine(routine, catalog.dialect));
-	const partitions = catalog.partitions.map((partition) => mapPartition(partition, catalog.dialect));
-	const policies = catalog.policies.map((policy) => mapPolicy(policy, catalog.dialect));
-	const extensions = catalog.extensionObjects.map((extension) => mapExtensionObject(extension, catalog.dialect));
-	const deferredObjects = catalog.deferredObjects.map((object) => mapDeferredObject(object, catalog.dialect));
-	const opaqueObjects = catalog.opaqueObjects.map((object) => mapOpaqueObject(object, catalog.dialect));
-	for (const object of catalogObjectsWithUnknownFields(catalog)) for (const field of object.unknownFields ?? []) opaqueObjects.push(mapUnknownField(object, field, catalog.dialect));
-	const comments = (catalog.comments ?? []).map((comment) => mapComment(comment, catalog.dialect));
-	const ownership = (catalog.ownership ?? []).map((item) => mapOwnership(item, catalog.dialect));
-	for (const object of catalogObjectList(catalog)) {
-		if (object.comment && !comments.some((item) => item.id === object.comment?.id)) comments.push(mapComment(object.comment, catalog.dialect));
-		if (object.ownership && !ownership.some((item) => item.id === object.ownership?.id)) ownership.push(mapOwnership(object.ownership, catalog.dialect));
-	}
-	const snapshot = {
-		format: "qubu-schema",
-		version: 2,
-		dialect: {
-			name: catalog.dialect,
-			version: 1
-		},
-		namingPolicy: {
-			name: introspectedPhysicalIdentityPolicy.name,
-			version: introspectedPhysicalIdentityPolicy.version
-		},
-		namespace: {
-			kind: catalog.namespace.kind,
-			name: catalog.namespace.name,
-			...mapMetadata(catalog.namespace.provenance, catalog.namespace.dialect, catalog.dialect, catalog.namespace.reference)
-		},
-		capabilities: catalog.capabilities,
-		tables: tables.sort(compareId),
-		views: views.sort(compareId),
-		sequences: sequences.sort(compareId),
-		enums: enums.sort(compareId),
-		domains: domains.sort(compareId),
-		collations: collations.sort(compareId),
-		triggers: triggers.sort(compareId),
-		routines: routines.sort(compareId),
-		partitions: partitions.sort(compareId),
-		policies: policies.sort(compareId),
-		extensions: extensions.sort(compareId),
-		deferredObjects: deferredObjects.sort(compareId),
-		opaqueObjects: opaqueObjects.sort(compareId),
-		comments: comments.sort(compareId),
-		ownership: ownership.sort(compareId)
-	};
-	if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) return Object.freeze({
-		ok: false,
-		catalog,
-		diagnostics: Object.freeze(diagnostics),
-		lossy: false
-	});
-	try {
-		const value = assertCompleteSchemaSnapshot(snapshot);
-		return Object.freeze({
-			ok: true,
-			catalog,
-			snapshot: value,
-			diagnostics: Object.freeze(diagnostics),
-			lossy: false
-		});
-	} catch (error) {
-		diagnostics.push(createIntrospectionDiagnostic({
-			severity: "error",
-			code: "invalid-catalog-row",
-			message: error instanceof Error ? `Catalog facts could not form Snapshot v2: ${error.message}` : "Catalog facts could not form Snapshot v2",
-			path: [],
-			remediation: "Inspect the catalog diagnostics and complete object mappings."
-		}));
-		return Object.freeze({
-			ok: false,
-			catalog,
-			diagnostics: Object.freeze(diagnostics),
-			lossy: false
-		});
-	}
-}
-/** Numbered alias for callers that keep both snapshot mappers available. */
-const mapCatalogToSnapshotV2 = mapCatalogToCompleteSnapshot;
-function mapTable(table, dialect, tables, diagnostics) {
-	const columns = table.columns.map((column) => mapColumn(column, dialect)).sort(compareId);
-	const columnIds = new Map(table.columns.map((column) => [column.physicalName, column.id]));
-	const constraints = table.constraints.map((constraint) => mapConstraint(constraint, dialect, columnIds, tables, diagnostics)).filter((value) => value !== void 0).sort(compareId);
-	const indexes = table.indexes.map((index) => mapIndex(index, dialect, columnIds)).sort(compareId);
-	return {
-		kind: "table",
-		id: table.id,
-		physicalName: table.physicalName,
-		columns,
-		constraints,
-		indexes,
-		...mapMetadata(table.provenance, table.dialect, dialect, table.reference)
-	};
-}
-function mapColumn(column, dialect) {
-	const defaultValue = column.default ? mapValueFact(column.default) : void 0;
-	const generatedColumn = column.generated ? column.generated.mode === "unknown" ? { kind: "external" } : {
-		kind: "expression",
-		expression: mapExpression(column.generated.expression),
-		mode: column.generated.mode
-	} : void 0;
-	const identity = column.identity ? mapIdentity(column.identity, dialect) : void 0;
-	return {
-		kind: "column",
-		id: column.id,
-		physicalName: column.physicalName,
-		ordinalPosition: column.ordinalPosition,
-		nullable: column.nullable,
-		hasDefault: defaultValue !== void 0 || generatedColumn !== void 0 || identity !== void 0,
-		generated: generatedColumn !== void 0,
-		storage: mapStorage(column.storage, dialect),
-		...defaultValue === void 0 ? {} : { default: defaultValue },
-		...generatedColumn === void 0 ? {} : { generatedColumn },
-		...identity === void 0 ? {} : { identity },
-		...column.onUpdate === void 0 ? {} : { onUpdate: mapExpression(column.onUpdate) },
-		...mapMetadata(column.provenance, column.dialect, dialect, column.reference)
-	};
-}
-function mapConstraint(constraint, dialect, columns, tables, diagnostics) {
-	const physicalName = constraint.physicalName ?? constraint.id;
-	const common = {
-		id: constraint.id,
-		physicalName,
-		...mapMetadata(constraint.provenance, constraint.dialect, dialect, constraint.reference)
-	};
-	const mappedColumns = constraint.kind === "check" ? void 0 : constraint.columns.map((column) => {
-		const id = columns.get(column);
-		if (id !== void 0) return id;
-		diagnostics.push(createIntrospectionDiagnostic({
-			severity: "error",
-			code: "unresolved-reference",
-			message: `Constraint column ${column} was not found`,
-			path: [constraint.id, "columns"]
-		}));
-		return column;
-	});
-	if (constraint.kind === "check") return {
-		kind: "check",
-		...common,
-		expression: mapExpression(constraint.expression),
-		...constraint.deferrable === void 0 ? {} : { deferrable: constraint.deferrable },
-		...constraint.initially === void 0 ? {} : { initially: constraint.initially },
-		...constraint.validated === void 0 ? {} : { validated: constraint.validated }
-	};
-	if (constraint.kind === "primary-key") return {
-		kind: "primary-key",
-		...common,
-		columns: mappedColumns ?? [],
-		...constraint.backingIndex === void 0 ? {} : { backingIndex: mapReference(constraint.backingIndex) },
-		...constraint.deferrable === void 0 ? {} : { deferrable: constraint.deferrable },
-		...constraint.initially === void 0 ? {} : { initially: constraint.initially },
-		...constraint.validated === void 0 ? {} : { validated: constraint.validated }
-	};
-	if (constraint.kind === "unique") return {
-		kind: "unique-constraint",
-		...common,
-		columns: mappedColumns ?? [],
-		nulls: constraint.nulls,
-		...constraint.backingIndex === void 0 ? {} : { backingIndex: mapReference(constraint.backingIndex) },
-		...constraint.deferrable === void 0 ? {} : { deferrable: constraint.deferrable },
-		...constraint.initially === void 0 ? {} : { initially: constraint.initially },
-		...constraint.validated === void 0 ? {} : { validated: constraint.validated }
-	};
-	const targetTable = tables.get(constraint.target.table);
-	const targetId = targetTable?.id;
-	if (targetId === void 0) diagnostics.push(createIntrospectionDiagnostic({
-		severity: "error",
-		code: "unresolved-reference",
-		message: `Foreign-key target table ${constraint.target.table} was not found`,
-		path: [
-			constraint.id,
-			"target",
-			"table"
-		]
-	}));
-	const targetColumns = targetTable ? constraint.target.columns.map((column) => targetTable.columns.find((item) => item.physicalName === column)?.id ?? column) : constraint.target.columns;
-	return {
-		kind: "foreign-key",
-		...common,
-		columns: mappedColumns ?? [],
-		target: {
-			table: {
-				kind: "table",
-				id: targetId ?? constraint.target.table
-			},
-			columns: targetColumns
-		},
-		...constraint.onUpdate === void 0 ? {} : { onUpdate: constraint.onUpdate },
-		...constraint.onDelete === void 0 ? {} : { onDelete: constraint.onDelete },
-		...constraint.match === void 0 ? {} : { match: constraint.match },
-		...constraint.deferrable === void 0 ? {} : { deferrable: constraint.deferrable },
-		...constraint.initially === void 0 ? {} : { initially: constraint.initially },
-		...constraint.validated === void 0 ? {} : { validated: constraint.validated }
-	};
-}
-function mapIndex(index, dialect, columns) {
-	return {
-		kind: "index",
-		id: index.id,
-		physicalName: index.physicalName ?? index.id,
-		terms: index.terms.map((term) => mapIndexTerm(term, columns)).filter((term) => term !== void 0).sort((left, right) => left.position - right.position),
-		unique: index.unique,
-		candidateKey: index.unique,
-		...index.predicate === void 0 ? {} : { predicate: mapExpression(index.predicate) },
-		...index.includedColumns === void 0 ? {} : { includedColumns: index.includedColumns.map((column) => columns.get(column) ?? column) },
-		...index.backingConstraint === void 0 ? {} : { backingConstraint: mapReference(index.backingConstraint) },
-		...index.method === void 0 ? {} : { method: index.method },
-		...mapMetadata(void 0, index.dialect, dialect, index.reference)
-	};
-}
-function mapIndexTerm(term, columns) {
-	if (term.kind === "column") return {
-		kind: "column",
-		column: columns.get(term.column) ?? term.column,
-		position: term.position,
-		...term.direction === void 0 ? {} : { direction: term.direction },
-		...term.nulls === void 0 ? {} : { nulls: term.nulls },
-		...term.prefixLength === void 0 ? {} : { prefixLength: mapValueFact(term.prefixLength) },
-		...term.operatorClass === void 0 ? {} : { operatorClass: term.operatorClass }
-	};
-	return {
-		kind: "expression",
-		expression: mapExpression(term.expression),
-		position: term.position,
-		...term.direction === void 0 ? {} : { direction: term.direction },
-		...term.nulls === void 0 ? {} : { nulls: term.nulls },
-		...term.operatorClass === void 0 ? {} : { operatorClass: term.operatorClass }
-	};
-}
-function mapView(view, dialect) {
-	return {
-		kind: view.kind,
-		id: view.id,
-		physicalName: view.physicalName,
-		columns: view.columns.map((column) => mapColumn(column, dialect)).sort(compareId),
-		definition: mapExpression(view.definition),
-		...view.dependencies === void 0 ? {} : { dependencies: view.dependencies.map(mapReference) },
-		...view.checkOption === void 0 ? {} : { checkOption: view.checkOption },
-		...view.securityBarrier === void 0 ? {} : { securityBarrier: view.securityBarrier },
-		...view.securityInvoker === void 0 ? {} : { securityInvoker: view.securityInvoker },
-		...mapMetadata(view.provenance, view.dialect, dialect, view.reference)
-	};
-}
-function mapSequence(sequence, dialect) {
-	return {
-		kind: "sequence",
-		id: sequence.id,
-		physicalName: sequence.physicalName,
-		...sequence.storage === void 0 ? {} : { storage: mapStorage(sequence.storage, dialect) },
-		...sequence.start === void 0 ? {} : { start: mapValueFact(sequence.start) },
-		...sequence.increment === void 0 ? {} : { increment: mapValueFact(sequence.increment) },
-		...sequence.minimum === void 0 ? {} : { minimum: mapValueFact(sequence.minimum) },
-		...sequence.maximum === void 0 ? {} : { maximum: mapValueFact(sequence.maximum) },
-		...sequence.cache === void 0 ? {} : { cache: mapValueFact(sequence.cache) },
-		...sequence.cycle === void 0 ? {} : { cycle: sequence.cycle },
-		...sequence.ownedBy === void 0 ? {} : { ownedBy: mapReference(sequence.ownedBy) },
-		...sequence.identity === void 0 ? {} : { identity: mapIdentity(sequence.identity, dialect) },
-		...mapMetadata(sequence.provenance, sequence.dialect, dialect, sequence.reference)
-	};
-}
-function mapEnum(item, dialect) {
-	return {
-		kind: "enum",
-		id: item.id,
-		physicalName: item.physicalName,
-		values: [...item.values].sort((left, right) => left.ordinalPosition - right.ordinalPosition).map((value) => ({
-			value: value.value,
-			ordinalPosition: value.ordinalPosition,
-			...value.provenance === void 0 ? {} : { provenance: mapProvenance(value.provenance) }
-		})),
-		...mapMetadata(item.provenance, item.dialect, dialect, item.reference)
-	};
-}
-function mapDomain(domain, dialect) {
-	return {
-		kind: "domain",
-		id: domain.id,
-		physicalName: domain.physicalName,
-		storage: mapStorage(domain.storage, dialect),
-		...domain.nullable === void 0 ? {} : { nullable: domain.nullable },
-		...domain.default === void 0 ? {} : { default: mapValueFact(domain.default) },
-		...domain.constraints === void 0 ? {} : { constraints: domain.constraints.map((constraint) => mapCheckConstraint(constraint, dialect)).sort(compareId) },
-		...mapMetadata(domain.provenance, domain.dialect, dialect, domain.reference)
-	};
-}
-function mapCheckConstraint(constraint, dialect) {
-	return {
-		kind: "check",
-		id: constraint.id,
-		physicalName: constraint.physicalName ?? constraint.id,
-		expression: mapExpression(constraint.expression),
-		...constraint.deferrable === void 0 ? {} : { deferrable: constraint.deferrable },
-		...constraint.initially === void 0 ? {} : { initially: constraint.initially },
-		...constraint.validated === void 0 ? {} : { validated: constraint.validated },
-		...mapMetadata(constraint.provenance, constraint.dialect, dialect, constraint.reference)
-	};
-}
-function mapTrigger(trigger, dialect, _diagnostics) {
-	return {
-		kind: "trigger",
-		id: trigger.id,
-		physicalName: trigger.physicalName,
-		table: mapReference(trigger.table),
-		timing: trigger.timing,
-		events: [...trigger.events].sort(),
-		...trigger.orientation === void 0 ? {} : { orientation: trigger.orientation },
-		...trigger.condition === void 0 ? {} : { condition: mapExpression(trigger.condition) },
-		body: mapExpression(trigger.body),
-		...trigger.enabled === void 0 ? {} : { enabled: trigger.enabled },
-		...mapMetadata(trigger.provenance, trigger.dialect, dialect, trigger.reference)
-	};
-}
-function mapRoutine(routine, dialect) {
-	return {
-		kind: "routine",
-		id: routine.id,
-		physicalName: routine.physicalName,
-		routineKind: routine.routineKind,
-		parameters: [...routine.parameters].sort((left, right) => left.ordinalPosition - right.ordinalPosition).map((parameter) => mapRoutineParameter(parameter, dialect)),
-		...routine.returnType === void 0 ? {} : { returnType: mapStorage(routine.returnType, dialect) },
-		...routine.language === void 0 ? {} : { language: routine.language },
-		...routine.body === void 0 ? {} : { body: mapExpression(routine.body) },
-		...routine.volatility === void 0 ? {} : { volatility: routine.volatility },
-		...routine.parallel === void 0 ? {} : { parallel: routine.parallel },
-		...routine.security === void 0 ? {} : { security: routine.security },
-		...routine.dependencies === void 0 ? {} : { dependencies: routine.dependencies.map(mapReference) },
-		...mapMetadata(routine.provenance, routine.dialect, dialect, routine.reference)
-	};
-}
-function mapRoutineParameter(parameter, dialect) {
-	return {
-		...parameter.name === void 0 ? {} : { name: parameter.name },
-		...parameter.mode === void 0 ? {} : { mode: parameter.mode },
-		storage: mapStorage(parameter.storage, dialect),
-		...parameter.default === void 0 ? {} : { default: mapValueFact(parameter.default) },
-		ordinalPosition: parameter.ordinalPosition
-	};
-}
-function mapPartition(partition, dialect) {
-	return {
-		kind: "partition",
-		id: partition.id,
-		physicalName: partition.physicalName,
-		parent: mapReference(partition.parent),
-		strategy: partition.strategy,
-		...partition.keyColumns === void 0 ? {} : { keyColumns: [...partition.keyColumns] },
-		...partition.bound === void 0 ? {} : { bound: mapExpression(partition.bound) },
-		...partition.default === void 0 ? {} : { default: partition.default },
-		...mapMetadata(partition.provenance, partition.dialect, dialect, partition.reference)
-	};
-}
-function mapPolicy(policy, dialect) {
-	return {
-		kind: "policy",
-		id: policy.id,
-		physicalName: policy.physicalName,
-		table: mapReference(policy.table),
-		command: policy.command,
-		...policy.roles === void 0 ? {} : { roles: [...policy.roles].sort() },
-		...policy.permissive === void 0 ? {} : { permissive: policy.permissive },
-		...policy.using === void 0 ? {} : { using: mapExpression(policy.using) },
-		...policy.check === void 0 ? {} : { check: mapExpression(policy.check) },
-		...mapMetadata(policy.provenance, policy.dialect, dialect, policy.reference)
-	};
-}
-function mapExtensionObject(extension, dialect) {
-	return {
-		kind: "extension",
-		id: extension.id,
-		physicalName: extension.physicalName,
-		extensionName: extension.extensionName,
-		...extension.extensionVersion === void 0 ? {} : { extensionVersion: extension.extensionVersion },
-		...extension.schema === void 0 ? {} : { schema: extension.schema },
-		data: toSnapshotJsonValue(extension.data),
-		...extension.configuration === void 0 ? {} : { configuration: toSnapshotJsonValue(extension.configuration) },
-		...mapMetadata(extension.provenance, extension.dialect, dialect, extension.reference)
-	};
-}
-function mapDeferredObject(object, dialect) {
-	const data = object.unknownFields ? Object.fromEntries(object.unknownFields.map((field) => [field.name, toSnapshotJsonValue(isCatalogSqlExpression(field.value) ? field.value.text : field.value)])) : void 0;
-	return {
-		kind: "deferred-object",
-		id: object.id ?? `deferred:${object.objectKind}:${object.physicalName}`,
-		objectKind: object.objectKind,
-		physicalName: object.physicalName,
-		...data === void 0 ? {} : { data: toSnapshotJsonValue(data) },
-		...mapMetadata(object.provenance, object.dialect, dialect, object.reference)
-	};
-}
-function mapOpaqueObject(object, dialect) {
-	return {
-		kind: "opaque-object",
-		id: object.id,
-		objectKind: object.objectKind,
-		physicalName: object.physicalName,
-		data: toSnapshotJsonValue(object.data),
-		...object.sql === void 0 ? {} : { sql: mapExpression(object.sql) },
-		...mapMetadata(object.provenance, object.dialect, dialect, object.reference)
-	};
-}
-function mapComment(comment, dialect) {
-	return {
-		kind: "comment",
-		id: comment.id,
-		physicalName: comment.reference?.name ?? comment.id,
-		object: mapReference(comment.object),
-		text: comment.text,
-		...mapMetadata(comment.provenance, comment.dialect, dialect, comment.reference)
-	};
-}
-function mapOwnership(ownership, dialect) {
-	return {
-		kind: "ownership",
-		id: ownership.id,
-		physicalName: ownership.reference?.name ?? ownership.id,
-		object: mapReference(ownership.object),
-		owner: ownership.owner,
-		...mapMetadata(ownership.provenance, ownership.dialect, dialect, ownership.reference)
-	};
-}
-function mapStorage(storage, dialect) {
-	if (storage.portable !== void 0) return {
-		kind: "portable",
-		type: storage.portable.type
-	};
-	return {
-		kind: "native",
-		dialect,
-		type: storage.nativeType
-	};
-}
-function mapValueFact(value) {
-	if (value.kind === "literal") return {
-		kind: "literal",
-		value: mapLiteral(value)
-	};
-	return {
-		kind: "expression",
-		expression: mapExpression(value.expression)
-	};
-}
-function mapLiteral(value) {
-	if (value.value === null) return { kind: "null" };
-	if (typeof value.value === "boolean") return {
-		kind: "boolean",
-		value: value.value
-	};
-	if (typeof value.value === "bigint") return {
-		kind: "bigint",
-		value: value.value.toString()
-	};
-	if (typeof value.value === "number") return {
-		kind: "number",
-		value: String(value.value)
-	};
-	return {
-		kind: "string",
-		value: value.value
-	};
-}
-function mapIdentity(identity, dialect) {
-	return {
-		kind: "identity",
-		generation: identity.generation,
-		options: Object.fromEntries(Object.entries(identity.options).map(([key, value]) => [key, mapValueFact(value)])),
-		...mapMetadata(void 0, identity.dialect, dialect)
-	};
-}
-function mapExpression(value) {
-	return {
-		kind: "expression",
-		expressionKind: "unsafe",
-		sql: value.text.replace(/\r\n?/g, "\n").trim(),
-		dialect: value.dialect
-	};
-}
-function mapMetadata(provenance, extension, dialect, reference) {
-	const mappedProvenance = provenance ? mapProvenance(provenance) : void 0;
-	const mappedExtension = extension ? {
-		dialect: extension.dialect,
-		version: extension.version,
-		data: toSnapshotJsonValue(extension.data)
-	} : void 0;
-	const physicalReference = reference ? {
-		kind: reference.kind,
-		...reference.namespace === void 0 ? {} : { namespace: reference.namespace },
-		...reference.table === void 0 ? {} : { table: reference.table },
-		name: reference.name
-	} : void 0;
-	return {
-		...mappedProvenance === void 0 ? {} : { provenance: mappedProvenance },
-		...physicalReference === void 0 ? {} : { physicalReference },
-		...mappedExtension === void 0 ? {} : { dialect: mappedExtension }
-	};
-}
-function mapProvenance(value) {
-	return {
-		kind: value.kind,
-		dialect: value.dialect,
-		...value.path === void 0 ? {} : { path: [...value.path] }
-	};
-}
-function mapReference(reference) {
-	return {
-		kind: reference.kind,
-		id: reference.id
-	};
-}
-function catalogObjectList(catalog) {
-	const topLevel = [
-		catalog.namespace,
-		...catalog.tables,
-		...catalog.views,
-		...catalog.sequences,
-		...catalog.enums,
-		...catalog.domains,
-		...catalog.collations,
-		...catalog.triggers,
-		...catalog.routines,
-		...catalog.partitions,
-		...catalog.policies,
-		...catalog.extensionObjects,
-		...catalog.deferredObjects,
-		...catalog.opaqueObjects,
-		...catalog.comments,
-		...catalog.ownership
-	];
-	const nested = [
-		...catalog.tables.flatMap((table) => [
-			...table.columns,
-			...table.constraints,
-			...table.indexes
-		]),
-		...catalog.views.flatMap((view) => view.columns),
-		...catalog.domains.flatMap((domain) => domain.constraints ?? [])
-	];
-	return [...topLevel, ...nested];
-}
-function catalogObjectsWithUnknownFields(catalog) {
-	return catalogObjectList(catalog);
-}
-function mapUnknownField(object, field, dialect) {
-	const sql = isCatalogSqlExpression(field.value) ? mapExpression(field.value) : void 0;
-	const value = isCatalogSqlExpression(field.value) ? field.value.text : field.value;
-	return {
-		kind: "opaque-object",
-		id: `unknown:${object.kind}:${object.id ?? object.physicalName ?? "object"}:${field.name}`,
-		objectKind: "unknown-field",
-		physicalName: object.physicalName ?? object.id ?? field.name,
-		data: toSnapshotJsonValue({
-			ownerKind: object.kind,
-			ownerId: object.id ?? object.physicalName ?? field.name,
-			field: field.name,
-			value
-		}),
-		...sql === void 0 ? {} : { sql },
-		...mapMetadata(field.provenance, void 0, dialect)
-	};
-}
-function compareId(left, right) {
-	return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
-}
-function isCatalogSqlExpression(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value) && value.kind === "sql" && typeof value.text === "string";
-}
-//#endregion
-export { IntrospectionError, createCompleteIntrospectionCatalog, createIntrospectionDiagnostic, freezeIntrospectionCatalog, hasIntrospectionErrors, introspectedPhysicalIdentityPolicy, mapCatalogToCompleteSnapshot, mapCatalogToSnapshot, mapCatalogToSnapshotV2, toIntrospectionCatalog };
+export { IntrospectionError, createCompleteIntrospectionCatalog, createIntrospectionDiagnostic, freezeIntrospectionCatalog, hasIntrospectionErrors, introspectedPhysicalIdentityPolicy, mapCatalogToCompleteSnapshot, mapCatalogToSnapshot, mapCatalogToSnapshotV1, toIntrospectionCatalog };

package/dist/mysql.d.mts

@@ -1,5 +1,5 @@
-import { V as Dialect } from "./types-DUe6eeI0.mjs";
+import { Cr as onDuplicateKeyUpdate, Pt as Dialect, Sr as incoming, br as IncomingIdentity, xr as OnDuplicateKeyUpdateClause, yr as IncomingColumns } from "./types-Dqr4o2I1.mjs";
 //#region src/dialects/mysql.d.ts
-declare function mysqlDialect(): Dialect<"json" | "row-locking">;
+declare function mysqlDialect(): Dialect<"row-locking" | "on-duplicate-key-update" | "json">;
 //#endregion
-export { mysqlDialect };
+export { type IncomingColumns, type IncomingIdentity, type OnDuplicateKeyUpdateClause, incoming, mysqlDialect, onDuplicateKeyUpdate };