qubu 0.6.0 → 0.6.2

package/dist/snapshot-Xam8-q0j.mjs

@@ -1,392 +0,0 @@
-import { s as assertSchemaSnapshot } from "./canonical-DMvR9yBe.mjs";
-import { sqliteStorageAffinity } from "./snapshot/sqlite.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;
-	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/standard-DfcZEVOj.mjs

@@ -1,12 +0,0 @@
-import { i as standardJson, o as createDialect } from "./json-Db7XRD91.mjs";
-//#region src/dialects/standard.ts
-/** SQL:2008-style rendering defaults used by the core builder. */
-function standardDialect() {
-	return createDialect({
-		name: "standard-sql",
-		placeholder: () => "?",
-		json: standardJson
-	});
-}
-//#endregion
-export { standardDialect as t };

package/dist/value-D14I_XgL.mjs

@@ -1,29 +0,0 @@
-import { C as fragment, y as makeSchemaExpression } from "./column-r1Y4ivwt.mjs";
-//#region src/core/primitives/parameter.ts
-function parameter(_value) {
-	return fragment((context) => context.parameter(_value));
-}
-//#endregion
-//#region src/expressions/value.ts
-function value(input) {
-	const expression = makeSchemaExpression("value", (context) => context.render(parameter(input)));
-	return Object.freeze({
-		...expression,
-		value: input
-	});
-}
-/** Bind a value while declaring its SQL semantic domain. */
-function typedValue(input) {
-	return value(input);
-}
-function isExpressionValue(valueToCheck) {
-	return typeof valueToCheck === "object" && valueToCheck !== null && "expressionKind" in valueToCheck && "render" in valueToCheck && typeof valueToCheck.render === "function";
-}
-function isValueExpression(valueToCheck) {
-	return isExpressionValue(valueToCheck) && valueToCheck.expressionKind === "value" && "value" in valueToCheck;
-}
-function asValue(input) {
-	return isExpressionValue(input) ? input : value(input);
-}
-//#endregion
-export { parameter as a, value as i, isValueExpression as n, typedValue as r, asValue as t };