qubu 0.0.0 → 0.3.4

package/dist/snapshot-CWPgzxNx.mjs

@@ -0,0 +1,392 @@
+import { s as assertSchemaSnapshot } from "./canonical-BbnqavJm.mjs";
+import { a as sqliteStorageAffinity } from "./sqlite-BU6DBxef.mjs";
+//#region src/introspection/diagnostics.ts
+/**
+* Create one immutable diagnostic without interpreting catalog text or
+* copying driver error details into the structured fields.
+*/
+function createIntrospectionDiagnostic(diagnostic) {
+	return freezeDiagnostic(diagnostic);
+}
+/** Return whether a diagnostic list prevents strict introspection output. */
+function hasIntrospectionErrors(diagnostics) {
+	return diagnostics.some((diagnostic) => diagnostic.severity === "error");
+}
+/** Error raised by a throwing introspection operation after collecting findings. */
+var IntrospectionError = class extends Error {
+	name = "IntrospectionError";
+	diagnostics;
+	issues;
+	constructor(diagnostics) {
+		const frozenDiagnostics = Object.freeze(diagnostics.map((diagnostic) => freezeDiagnostic(diagnostic)));
+		super(frozenDiagnostics.map((diagnostic) => diagnostic.message).join("\n"));
+		this.diagnostics = frozenDiagnostics;
+		this.issues = frozenDiagnostics;
+	}
+};
+function freezeDiagnostic(diagnostic) {
+	return Object.freeze({
+		...diagnostic,
+		path: Object.freeze([...diagnostic.path]),
+		physicalReference: diagnostic.physicalReference ? freezeReference(diagnostic.physicalReference) : void 0,
+		relatedReferences: diagnostic.relatedReferences ? Object.freeze(diagnostic.relatedReferences.map((reference) => freezeReference(reference))) : void 0
+	});
+}
+function freezeReference(reference) {
+	return Object.freeze({
+		...reference,
+		catalog: reference.catalog ? Object.freeze({ ...reference.catalog }) : void 0
+	});
+}
+//#endregion
+//#region src/introspection/identity.ts
+/** The naming policy used by the first introspection snapshot mapper. */
+const introspectedPhysicalIdentityPolicy = Object.freeze({
+	name: "introspected-physical",
+	version: 1,
+	fallback: "escaped",
+	precedence: Object.freeze([
+		"explicit-hint",
+		"previous-snapshot",
+		"physical-name",
+		"deterministic-fallback"
+	])
+});
+//#endregion
+//#region src/introspection/snapshot.ts
+/** Construct and validate a canonical Snapshot v1 from a normalized catalog. */
+function mapCatalogToSnapshot(catalog, options) {
+	const mode = options.mode ?? "strict";
+	const diagnostics = [...catalog.diagnostics];
+	const tables = catalog.tables.map((table) => mapTable(catalog, table, options, mode, diagnostics)).sort(compareById);
+	const snapshot = {
+		format: "qubu-schema",
+		version: 1,
+		dialect: {
+			name: catalog.dialect,
+			version: 1
+		},
+		namingPolicy: {
+			name: introspectedPhysicalIdentityPolicy.name,
+			version: introspectedPhysicalIdentityPolicy.version
+		},
+		namespace: catalog.namespace.name,
+		tables
+	};
+	if (mode === "strict" && diagnostics.some(isError)) return failure(catalog, diagnostics);
+	try {
+		const value = assertSchemaSnapshot(snapshot);
+		const lossy = mode === "lossy" && diagnostics.some((diagnostic) => diagnostic.severity === "warning");
+		const result = {
+			ok: true,
+			catalog,
+			snapshot: value,
+			diagnostics: Object.freeze(diagnostics),
+			lossy
+		};
+		return Object.freeze(result);
+	} catch (error) {
+		const severity = mode === "strict" ? "error" : "warning";
+		diagnostics.push(createIntrospectionDiagnostic({
+			severity,
+			code: "invalid-catalog-row",
+			message: error instanceof Error ? `Catalog facts could not form Snapshot v1: ${error.message}` : "Catalog facts could not form Snapshot v1",
+			path: [],
+			remediation: "Inspect the catalog diagnostics and unsupported features."
+		}));
+		return failure(catalog, diagnostics);
+	}
+}
+function mapTable(catalog, table, options, mode, diagnostics) {
+	const tableId = resolveId("table", table.id, table.physicalName, void 0, options);
+	const columnIds = new Map(table.columns.map((column) => [column.physicalName, resolveId("column", column.id, column.physicalName, table.physicalName, options)]));
+	const columns = [...table.columns].sort((left, right) => left.ordinalPosition - right.ordinalPosition).map((column) => mapColumn(catalog.dialect, table, column, options, diagnostics)).sort(compareById);
+	const constraints = [...table.constraints].map((constraint) => mapConstraint(catalog, table, constraint, columnIds, options, mode, diagnostics)).filter((value) => value !== void 0).sort(compareById);
+	const indexes = [...table.indexes].map((index) => mapIndex(table, index, columnIds, options, mode, diagnostics)).filter((value) => value !== void 0).sort(compareById);
+	return {
+		id: tableId,
+		physicalName: table.physicalName,
+		columns,
+		constraints,
+		indexes
+	};
+}
+function mapColumn(dialect, table, column, options, diagnostics) {
+	const defaultValue = column.default ? mapDefault(column.default, column, diagnostics) : void 0;
+	const generated = column.generated ? mapGenerated(column.generated, column, options.mode ?? "strict", diagnostics) : void 0;
+	const identity = column.identity ? mapIdentity(column.identity, column, diagnostics) : void 0;
+	const storage = {
+		kind: "native",
+		dialect,
+		type: column.storage.nativeType,
+		...dialect === "sqlite" ? { affinity: sqliteStorageAffinity(column.storage.nativeType) } : {}
+	};
+	return {
+		id: resolveId("column", column.id, column.physicalName, table.physicalName, options),
+		physicalName: column.physicalName,
+		nullable: column.nullable,
+		hasDefault: defaultValue !== void 0,
+		generated: generated !== void 0 || identity !== void 0,
+		storage,
+		default: defaultValue,
+		generatedColumn: generated,
+		identity,
+		onUpdate: column.onUpdate ? mapExpression(column.onUpdate) : void 0
+	};
+}
+function mapConstraint(catalog, table, constraint, columnIds, options, mode, diagnostics) {
+	const physicalName = constraint.physicalName ?? constraint.id;
+	const id = resolveId("constraint", constraint.id, physicalName, table.physicalName, options);
+	if (constraint.kind === "check") return {
+		id,
+		kind: "check",
+		physicalName,
+		expression: mapExpression(constraint.expression),
+		deferrable: constraint.deferrable,
+		initially: constraint.initially,
+		dialect: mapExtension(constraint.dialect)
+	};
+	const columns = constraint.columns.map((column) => {
+		const value = columnIds.get(column);
+		if (value) return value;
+		addIssue(mode, diagnostics, "unresolved-reference", `Constraint column ${column} was not found`, constraint);
+		return column;
+	});
+	if (constraint.kind === "primary-key") return {
+		id,
+		kind: "primary-key",
+		physicalName,
+		columns,
+		deferrable: constraint.deferrable,
+		initially: constraint.initially,
+		dialect: mapExtension(constraint.dialect)
+	};
+	if (constraint.kind === "unique") {
+		if (constraint.columns.some((column) => table.columns.find((candidate) => candidate.physicalName === column)?.nullable) || constraint.nulls === "not-distinct") return {
+			id,
+			kind: "unique-constraint",
+			physicalName,
+			columns,
+			nulls: constraint.nulls,
+			deferrable: constraint.deferrable,
+			initially: constraint.initially,
+			dialect: mapExtension(constraint.dialect)
+		};
+		return {
+			id,
+			kind: "unique",
+			physicalName,
+			columns,
+			deferrable: constraint.deferrable,
+			initially: constraint.initially,
+			dialect: mapExtension(constraint.dialect)
+		};
+	}
+	const targetTable = catalog.tables.find((candidate) => candidate.physicalName === constraint.target.table);
+	if (!targetTable) {
+		addIssue(mode, diagnostics, "unresolved-reference", `Foreign key target table ${constraint.target.table} was not found`, constraint);
+		return;
+	}
+	return {
+		id,
+		kind: "foreign-key",
+		physicalName,
+		columns,
+		target: {
+			table: resolveId("table", targetTable.id, targetTable.physicalName, void 0, options),
+			columns: constraint.target.columns.map((column) => {
+				const target = targetTable.columns.find((candidate) => candidate.physicalName === column);
+				if (target) return resolveId("column", target.id, target.physicalName, targetTable.physicalName, options);
+				addIssue(mode, diagnostics, "unresolved-reference", `Foreign key target column ${column} was not found`, constraint);
+				return column;
+			})
+		},
+		onUpdate: constraint.onUpdate,
+		onDelete: constraint.onDelete,
+		match: constraint.match,
+		deferrable: constraint.deferrable,
+		initially: constraint.initially,
+		dialect: mapExtension(constraint.dialect)
+	};
+}
+function mapIndex(table, index, columnIds, options, mode, diagnostics) {
+	const physicalName = index.physicalName ?? index.id;
+	const id = resolveId("index", index.id, physicalName, table.physicalName, options);
+	const terms = [...index.terms].sort((left, right) => left.position - right.position).map((term) => mapIndexTerm(term, columnIds, index, mode, diagnostics)).filter((value) => value !== void 0);
+	const includedColumns = index.includedColumns?.map((column) => {
+		const value = columnIds.get(column);
+		if (value) return value;
+		addIssue(mode, diagnostics, "unresolved-reference", `Index column ${column} was not found`, index);
+		return column;
+	});
+	const candidateKey = index.unique && index.predicate === void 0 && index.terms.every((term) => term.kind === "column" && table.columns.find((column) => column.physicalName === term.column)?.nullable === false);
+	return {
+		id,
+		kind: "index",
+		physicalName,
+		terms,
+		unique: index.unique,
+		candidateKey,
+		predicate: index.predicate ? mapExpression(index.predicate) : void 0,
+		includedColumns,
+		dialect: mapExtension(index.dialect)
+	};
+}
+function mapIndexTerm(term, columnIds, index, mode, diagnostics) {
+	let expression;
+	if (term.kind === "column") {
+		const column = columnIds.get(term.column);
+		if (!column) {
+			addIssue(mode, diagnostics, "unresolved-reference", `Index column ${term.column} was not found`, index);
+			return;
+		}
+		expression = {
+			kind: "column",
+			column
+		};
+		if (term.prefixLength !== void 0 || term.operatorClass !== void 0) addIssue(mode, diagnostics, "unsupported-feature", "Index term metadata is not represented by Snapshot v1", index);
+	} else {
+		expression = {
+			kind: "expression",
+			expression: mapExpression(term.expression)
+		};
+		if (term.operatorClass !== void 0) addIssue(mode, diagnostics, "unsupported-feature", "Index operator classes are not represented by Snapshot v1", index);
+	}
+	if (term.direction === void 0 && term.nulls === void 0) return expression;
+	return {
+		kind: "order",
+		expression,
+		direction: term.direction,
+		nulls: term.nulls
+	};
+}
+function mapDefault(value, owner, diagnostics) {
+	if (value.kind === "literal") return {
+		kind: "literal",
+		value: mapLiteral(value)
+	};
+	if (value.expression.text.trim().length === 0) diagnostics.push(createIntrospectionDiagnostic({
+		severity: "error",
+		code: "invalid-catalog-row",
+		message: "A default expression was empty",
+		path: [owner.id, "default"],
+		remediation: "Return the database expression or omit the default fact."
+	}));
+	return {
+		kind: "expression",
+		expression: mapExpression(value.expression)
+	};
+}
+function mapGenerated(value, owner, mode, diagnostics) {
+	if (value.mode === "unknown") {
+		addIssue(mode, diagnostics, "unsupported-feature", "Generated-column storage mode was not recovered", owner);
+		return { kind: "external" };
+	}
+	return {
+		kind: "expression",
+		expression: mapExpression(value.expression),
+		mode: value.mode
+	};
+}
+function mapIdentity(value, owner, diagnostics) {
+	if (Object.keys(value.options).length > 0) diagnostics.push(createIntrospectionDiagnostic({
+		severity: "warning",
+		code: "lossy-mapping",
+		message: "Identity sequence options are not represented by Snapshot v1",
+		path: [owner.id, "identity"],
+		remediation: "Use the normalized catalog for options or add a typed dialect extension."
+	}));
+	return {
+		kind: "identity",
+		generation: value.generation,
+		dialect: mapExtension(value.dialect)
+	};
+}
+function mapExpression(value) {
+	return {
+		kind: "expression",
+		expressionKind: "unsafe",
+		sql: value.text.replace(/\r\n?/g, "\n").trim(),
+		dialect: value.dialect
+	};
+}
+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 mapExtension(value) {
+	if (!value) return void 0;
+	return {
+		dialect: value.dialect,
+		version: value.version,
+		data: toSnapshotData(value.data)
+	};
+}
+function toSnapshotData(value) {
+	if (typeof value === "bigint") return { $bigint: value.toString() };
+	if (Array.isArray(value)) return value.map(toSnapshotData);
+	if (value !== null && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, toSnapshotData(child)]));
+	return value;
+}
+function resolveId(kind, currentId, physicalName, tablePhysicalName, options) {
+	const hint = options.identityHints?.find((candidate) => candidate.kind === kind && candidate.physicalName === physicalName && candidate.tablePhysicalName === tablePhysicalName);
+	if (hint) return hint.logicalId;
+	const previous = options.previousSnapshot;
+	if (previous) {
+		const table = tablePhysicalName ? previous.tables.find((candidate) => candidate.physicalName === tablePhysicalName) : previous.tables.find((candidate) => candidate.physicalName === physicalName);
+		if (kind === "table" && table) return table.id;
+		if (table && kind === "column") {
+			const column = table.columns.find((candidate) => candidate.physicalName === physicalName);
+			if (column) return column.id;
+		}
+		if (table && kind === "constraint") {
+			const constraint = table.constraints.find((candidate) => candidate.physicalName === physicalName);
+			if (constraint) return constraint.id;
+		}
+		if (table && kind === "index") {
+			const index = table.indexes.find((candidate) => candidate.physicalName === physicalName);
+			if (index) return index.id;
+		}
+	}
+	return currentId || physicalName;
+}
+function addIssue(mode, diagnostics, code, message, owner) {
+	diagnostics.push(createIntrospectionDiagnostic({
+		severity: mode === "strict" ? "error" : "warning",
+		code,
+		message,
+		path: owner.id ? [owner.id] : [],
+		remediation: "Use lossy mode or add a typed dialect mapping for this feature."
+	}));
+}
+function failure(catalog, diagnostics) {
+	return Object.freeze({
+		ok: false,
+		catalog,
+		diagnostics: Object.freeze([...diagnostics]),
+		lossy: false
+	});
+}
+function compareById(left, right) {
+	return left.id.localeCompare(right.id);
+}
+function isError(value) {
+	return value.severity === "error";
+}
+//#endregion
+export { hasIntrospectionErrors as a, createIntrospectionDiagnostic as i, introspectedPhysicalIdentityPolicy as n, IntrospectionError as r, mapCatalogToSnapshot as t };

package/dist/snapshot.d.mts

@@ -0,0 +1,4 @@
+import { A as SnapshotStorage, C as SnapshotIndexTerm, D as SnapshotLiteral, E as SnapshotKeyConstraint, F as neutralSnapshotDialect, Hs as PortableColumnStorage, I as schemaSnapshotDialectVersion, L as schemaSnapshotFormat, M as SnapshotTable, Mr as SchemaDialect, N as SnapshotUniqueConstraint, Nr as SchemaDialectHooks, O as SnapshotNamingPolicy, P as SnapshotValidationContext, Pr as createSchemaDialect, R as schemaSnapshotNamingPolicyVersion, S as SnapshotIndex, T as SnapshotJsonValue, _ as SnapshotExpressionContext, a as SnapshotBigInt, b as SnapshotGeneratedColumn, c as SnapshotConstraint, d as SnapshotDefault, f as SnapshotDiagnostic, g as SnapshotExpression, h as SnapshotDialectExtension, i as SchemaSnapshotInput, j as SnapshotStorageContext, k as SnapshotSpecialNumber, l as SnapshotCreateResult, m as SnapshotDialect, n as SchemaSnapshot, o as SnapshotCheckConstraint, p as SnapshotDiagnosticCode, r as SchemaSnapshotAdapter, s as SnapshotColumn, t as AnySchema, u as SnapshotDecodeResult, v as SnapshotExtensionContext, w as SnapshotIndexTermExpression, x as SnapshotIdentity, y as SnapshotForeignKey, z as schemaSnapshotVersion, zs as NativeColumnStorage } from "./types-4Q076HKo.mjs";
+import { A as CompleteSnapshotProvenance, B as SchemaSnapshotV2Input, C as CompleteSnapshotObjectMetadata, D as CompleteSnapshotPartition, E as CompleteSnapshotOwnership, F as CompleteSnapshotTrigger, G as schemaSnapshotVersion2, H as completeSchemaSnapshotVersion, I as CompleteSnapshotValueFact, L as CompleteSnapshotView, M as CompleteSnapshotRoutineParameter, N as CompleteSnapshotSequence, O as CompleteSnapshotPhysicalReference, P as CompleteSnapshotTable, R as SchemaSnapshotV2, S as CompleteSnapshotObjectKind, T as CompleteSnapshotOpaqueObject, U as schemaSnapshotCompleteVersion, V as completeSchemaSnapshotFormat, W as schemaSnapshotV2Version, _ as CompleteSnapshotIndex, a as CompleteSnapshotCollation, b as CompleteSnapshotNamespace, c as CompleteSnapshotConstraint, d as CompleteSnapshotDeferredObject, f as CompleteSnapshotDomain, g as CompleteSnapshotIdentity, h as CompleteSnapshotForeignKey, i as CompleteSnapshotCheckConstraint, j as CompleteSnapshotRoutine, k as CompleteSnapshotPolicy, l as CompleteSnapshotCreateResult, m as CompleteSnapshotExtension, n as CompleteSchemaSnapshotInput, o as CompleteSnapshotColumn, p as CompleteSnapshotEnum, r as CompleteSnapshotCapabilities, s as CompleteSnapshotComment, t as CompleteSchemaSnapshot, u as CompleteSnapshotDecodeResult, v as CompleteSnapshotIndexTerm, w as CompleteSnapshotObjectReference, x as CompleteSnapshotObject, y as CompleteSnapshotKeyConstraint, z as SchemaSnapshotV2DecodeResult } from "./complete-types-BdFqUfbb.mjs";
+import { A as assertSchemaSnapshot, B as decodeCompleteSchemaSnapshot, C as createSchemaSnapshot, D as serializeSchema, E as encodeSnapshot, F as assertCompleteSnapshot, G as encodeCompleteSnapshot, H as decodeSchemaSnapshotV2, I as assertSchemaSnapshotV2, J as SnapshotCanonicalError, K as encodeSchemaSnapshotV2, L as canonicalizeCompleteSchemaSnapshot, M as decodeSchemaSnapshot, N as CompleteSnapshotValidationError, O as tryCreateSchemaSnapshot, P as assertCompleteSchemaSnapshot, Q as toSnapshotJsonValue, R as canonicalizeSchemaSnapshotV2, S as SnapshotSerializationError, T as encodeSchemaSnapshot, U as digestCompleteSchemaSnapshot, V as decodeCompleteSnapshot, W as encodeCompleteSchemaSnapshot, X as encodeCanonicalSnapshot, Y as canonicalJson, Z as schemaSnapshotDigest, _ as postgresSchemaDialect, a as mysqlSnapshotDialect, b as tryCreatePostgresSchemaSnapshot, c as SqliteStorageAffinity, d as sqliteSnapshotAdapter, f as sqliteSnapshotDialect, g as createPostgresSchemaSnapshot, h as PostgresSnapshotOptions, i as mysqlSnapshotAdapter, j as canonicalizeSchemaSnapshot, k as SnapshotValidationError, l as createSqliteSchemaSnapshot, m as tryCreateSqliteSchemaSnapshot, n as createMysqlSchemaSnapshot, o as tryCreateMysqlSchemaSnapshot, p as sqliteStorageAffinity, q as schemaSnapshotV2Digest, r as mysqlSchemaDialect, s as SqliteSnapshotOptions, t as MysqlSnapshotOptions, u as sqliteSchemaDialect, v as postgresSnapshotAdapter, w as digestSchemaSnapshot, x as SchemaSnapshotOptions, y as postgresSnapshotDialect, z as completeSchemaSnapshotDigest } from "./index-Ds7-mhJi.mjs";
+export { AnySchema, CompleteSchemaSnapshot, CompleteSchemaSnapshotInput, CompleteSnapshotCapabilities, CompleteSnapshotCheckConstraint, CompleteSnapshotCollation, CompleteSnapshotColumn, CompleteSnapshotComment, CompleteSnapshotConstraint, CompleteSnapshotCreateResult, CompleteSnapshotDecodeResult, CompleteSnapshotDeferredObject, CompleteSnapshotDomain, CompleteSnapshotEnum, CompleteSnapshotExtension, CompleteSnapshotForeignKey, CompleteSnapshotIdentity, CompleteSnapshotIndex, CompleteSnapshotIndexTerm, CompleteSnapshotKeyConstraint, CompleteSnapshotNamespace, CompleteSnapshotObject, CompleteSnapshotObjectKind, CompleteSnapshotObjectMetadata, CompleteSnapshotObjectReference, CompleteSnapshotOpaqueObject, CompleteSnapshotOwnership, CompleteSnapshotPartition, CompleteSnapshotPhysicalReference, CompleteSnapshotPolicy, CompleteSnapshotProvenance, CompleteSnapshotRoutine, CompleteSnapshotRoutineParameter, CompleteSnapshotSequence, CompleteSnapshotTable, CompleteSnapshotTrigger, CompleteSnapshotValidationError, CompleteSnapshotValueFact, CompleteSnapshotView, MysqlSnapshotOptions, type NativeColumnStorage, type PortableColumnStorage, PostgresSnapshotOptions, type SchemaDialect, type SchemaDialectHooks, SchemaSnapshot, SchemaSnapshotAdapter, SchemaSnapshotInput, SchemaSnapshotOptions, SchemaSnapshotV2, SchemaSnapshotV2DecodeResult, SchemaSnapshotV2Input, SnapshotBigInt, SnapshotCanonicalError, SnapshotCheckConstraint, SnapshotColumn, SnapshotConstraint, SnapshotCreateResult, SnapshotDecodeResult, SnapshotDefault, SnapshotDiagnostic, SnapshotDiagnosticCode, SnapshotDialect, SnapshotDialectExtension, SnapshotExpression, SnapshotExpressionContext, SnapshotExtensionContext, SnapshotForeignKey, SnapshotGeneratedColumn, SnapshotIdentity, SnapshotIndex, SnapshotIndexTerm, SnapshotIndexTermExpression, SnapshotJsonValue, SnapshotKeyConstraint, SnapshotLiteral, SnapshotNamingPolicy, SnapshotSerializationError, SnapshotSpecialNumber, SnapshotStorage, SnapshotStorageContext, SnapshotTable, SnapshotUniqueConstraint, SnapshotValidationContext, SnapshotValidationError, SqliteSnapshotOptions, SqliteStorageAffinity, 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 };

package/dist/snapshot.mjs

@@ -0,0 +1,8 @@
+import { t as createSchemaDialect } from "./dialect-b2-Z6uBF.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-BbnqavJm.mjs";
+import { a as encodeSnapshot, i as encodeSchemaSnapshot, n as createSchemaSnapshot, o as serializeSchema, r as digestSchemaSnapshot, s as tryCreateSchemaSnapshot, t as SnapshotSerializationError } from "./serialize-PF1cfH2P.mjs";
+import { a as sqliteStorageAffinity, i as sqliteSnapshotDialect, n as sqliteSchemaDialect, o as tryCreateSqliteSchemaSnapshot, r as sqliteSnapshotAdapter, t as createSqliteSchemaSnapshot } from "./sqlite-BU6DBxef.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-D5Djh-zo.mjs";
+import { a as tryCreatePostgresSchemaSnapshot, i as postgresSnapshotDialect, n as postgresSchemaDialect, r as postgresSnapshotAdapter, t as createPostgresSchemaSnapshot } from "./postgres-DEBBeh52.mjs";
+import { a as tryCreateMysqlSchemaSnapshot, i as mysqlSnapshotDialect, n as mysqlSchemaDialect, r as mysqlSnapshotAdapter, t as createMysqlSchemaSnapshot } from "./mysql-DqkqXB6A.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 };

package/dist/source-DUoJVXmL.mjs

@@ -0,0 +1,68 @@
+import { t as createColumnReference } from "./column-CXMxx8Hq.mjs";
+import { t as resolveSqlNames } from "./naming-QVCOnSj2.mjs";
+//#region src/schema/source.ts
+const sourceIdentity = Symbol("qubu.source.identity");
+function createSource(sourceKind, render, reference, constraints = {}) {
+	return {
+		sourceKind,
+		render,
+		reference,
+		columns: {},
+		constraints
+	};
+}
+/**
+* Create a typed source-producing fragment for a custom FROM relation such as
+* a table-valued function. The renderer owns the relation syntax and may bind
+* values through context.parameter(); the source identity and output columns
+* remain available to the normal FROM/JOIN scope checks.
+*/
+function customSource(options) {
+	const source = createSource(options.sourceKind ?? "custom", options.render, options.reference);
+	const sqlNames = resolveSqlNames(Object.entries(options.columns).map(([fieldName, definition]) => ({
+		fieldName,
+		sqlName: definition.sqlName
+	})));
+	const columns = Object.fromEntries(Object.keys(options.columns).map((fieldName) => {
+		return [fieldName, createColumnReference(sqlNames[fieldName], source.reference, fieldName)];
+	}));
+	Object.assign(source, {
+		identity: options.identity,
+		definitions: options.columns,
+		columns
+	});
+	exposeColumns(source, columns);
+	return source;
+}
+/**
+* Add convenient direct column properties without allowing a column name to
+* overwrite the source's rendering or metadata primitives.
+*/
+function exposeColumns(target, columns) {
+	const reserved = /* @__PURE__ */ new Set([
+		"render",
+		"reference",
+		"sourceKind",
+		"columns",
+		"tableName",
+		"definitions",
+		"sqlNames",
+		"alias",
+		"base",
+		"query",
+		"cteName",
+		"identity",
+		"constraints"
+	]);
+	for (const [name, column] of Object.entries(columns)) {
+		if (reserved.has(name)) continue;
+		Object.defineProperty(target, name, {
+			configurable: true,
+			enumerable: true,
+			value: column,
+			writable: false
+		});
+	}
+}
+//#endregion
+export { sourceIdentity as i, customSource as n, exposeColumns as r, createSource as t };