qubu 0.0.0 → 0.3.3

package/dist/serialize-PF1cfH2P.mjs

@@ -0,0 +1,556 @@
+import { t as standardDialect } from "./standard-BTVYKh_F.mjs";
+import { r as isColumnReference } from "./column-CXMxx8Hq.mjs";
+import { _ as isUnsafeSchemaSql, k as generatedSchemaObjectName, n as defaultSchemaNamingPolicy, y as renderSchemaExpression } from "./registry-BufIskVN.mjs";
+import { t as createSchemaDialect } from "./dialect-b2-Z6uBF.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-BbnqavJm.mjs";
+//#region src/snapshot/serialize.ts
+const neutralSchemaDialect = createSchemaDialect(Object.freeze({
+	...standardDialect(),
+	name: neutralSnapshotDialect.name
+}), { version: 1 });
+/** Error raised when a live Qubu schema cannot be represented as a snapshot. */
+var SnapshotSerializationError = class extends SnapshotValidationError {
+	name = "SnapshotSerializationError";
+};
+/** Create a neutral or adapter-owned immutable snapshot from a live schema. */
+function createSchemaSnapshot(schema, options = {}) {
+	const result = tryCreateSchemaSnapshot(schema, options);
+	if (!result.ok) throw new SnapshotSerializationError(result.diagnostics);
+	return result.value;
+}
+/** Non-throwing form of {@link createSchemaSnapshot}. */
+function tryCreateSchemaSnapshot(schema, options = {}) {
+	const diagnostics = [];
+	if (!isSchemaRoot(schema)) return {
+		ok: false,
+		diagnostics: [{
+			code: "invalid-schema",
+			message: "Snapshot input must be a Qubu schema registry",
+			path: []
+		}]
+	};
+	if (options.adapter !== void 0 && options.dialect !== void 0 && (options.adapter.dialect.name !== options.dialect.name || options.adapter.dialect.schema.version !== options.dialect.schema.version)) return {
+		ok: false,
+		diagnostics: [{
+			code: "dialect-mismatch",
+			message: "Snapshot adapter and explicit dialect must agree",
+			path: ["dialect"],
+			relatedPaths: [["adapter", "dialect"]]
+		}]
+	};
+	const adapter = options.adapter;
+	const dialect = options.dialect ?? adapter?.dialect ?? neutralSchemaDialect;
+	const namingPolicy = options.namingPolicy ?? dialect.schema.namingPolicy ?? Object.freeze({
+		name: schema.namingPolicy.tableName === defaultSchemaNamingPolicy.tableName ? "snake-case" : "custom",
+		version: schema.namingPolicy.version ?? 1
+	});
+	const tableEntries = Object.entries(schema.registry);
+	const tableIds = /* @__PURE__ */ new Map();
+	const tablesById = /* @__PURE__ */ new Map();
+	const validate = adapter?.dialect.schema.validate ?? dialect.schema.validate;
+	if (validate !== void 0) try {
+		diagnostics.push(...validate(schema, {
+			path: [],
+			dialect
+		}));
+	} catch (error) {
+		diagnostics.push({
+			code: "invalid-schema",
+			message: error instanceof Error ? error.message : String(error),
+			path: []
+		});
+	}
+	for (const [id, entry] of tableEntries) {
+		tableIds.set(entry.table, id);
+		tablesById.set(id, entry.table);
+	}
+	const tables = tableEntries.map(([id, entry]) => serializeTable(id, entry.table, entry.physicalName, tableIds, tablesById, dialect, options, diagnostics)).filter((table) => table !== void 0).sort(compareId);
+	if (diagnostics.length > 0) return {
+		ok: false,
+		diagnostics: Object.freeze(diagnostics)
+	};
+	const rawSnapshot = {
+		format: schemaSnapshotFormat,
+		version: 1,
+		dialect: Object.freeze({
+			name: dialect.name,
+			version: dialect.schema.version
+		}),
+		namingPolicy: Object.freeze({
+			name: namingPolicy.name,
+			version: namingPolicy.version ?? 1
+		}),
+		...schema.namespace === void 0 ? {} : { namespace: schema.namespace },
+		tables
+	};
+	try {
+		return {
+			ok: true,
+			value: assertSchemaSnapshot(rawSnapshot)
+		};
+	} catch (error) {
+		if (error instanceof SnapshotValidationError) return {
+			ok: false,
+			diagnostics: error.diagnostics
+		};
+		return {
+			ok: false,
+			diagnostics: [{
+				code: "invalid-schema",
+				message: error instanceof Error ? error.message : String(error),
+				path: []
+			}]
+		};
+	}
+}
+/** Encode a valid snapshot using fixed property order and canonical JSON. */
+function encodeSchemaSnapshot(snapshot) {
+	const canonical = assertSchemaSnapshot(snapshot);
+	return encodeCanonicalSnapshot(canonical);
+}
+/** Alias used by tooling packages that call the operation serialization. */
+const serializeSchema = createSchemaSnapshot;
+/** Alias for the canonical snapshot encoder. */
+const encodeSnapshot = encodeSchemaSnapshot;
+/** Alias for the canonical snapshot digest helper. */
+const digestSchemaSnapshot = schemaSnapshotDigest;
+function serializeTable(id, table, physicalName, tableIds, tablesById, dialect, options, diagnostics) {
+	const definitions = table.definitions;
+	const tableMetadata = table;
+	return {
+		id,
+		physicalName,
+		columns: Object.entries(definitions).map(([fieldName, definition]) => serializeColumn(fieldName, definition, table.sqlNames[fieldName] ?? fieldName, dialect, options, diagnostics)).sort(compareId),
+		constraints: Object.entries(tableMetadata.constraints).map(([constraintId, constraint]) => serializeConstraint(constraintId, constraint, table, tableIds, tablesById, dialect, options, diagnostics)).filter((constraint) => constraint !== void 0).sort(compareId),
+		indexes: Object.entries(tableMetadata.indexes).map(([indexId, indexMetadata]) => serializeIndex(indexId, indexMetadata, table, dialect, options, diagnostics)).filter((index) => index !== void 0).sort(compareId)
+	};
+}
+function serializeColumn(id, definition, physicalName, dialect, options, diagnostics) {
+	const storage = definition.storage ? encodeStorage(definition.storage, dialect, [
+		"tables",
+		id,
+		"columns",
+		id,
+		"storage"
+	], options, diagnostics) : void 0;
+	const defaultValue = definition.default ? encodeDefault(definition.default, dialect, [
+		"columns",
+		id,
+		"default"
+	], options, diagnostics) : void 0;
+	const generatedColumn = definition.generatedColumn ? encodeGenerated(definition.generatedColumn, dialect, [
+		"columns",
+		id,
+		"generatedColumn"
+	], options, diagnostics) : void 0;
+	const identity = definition.identity ? encodeIdentity(definition.identity, dialect, [
+		"tables",
+		id,
+		"columns",
+		id,
+		"identity"
+	], options, diagnostics) : void 0;
+	const onUpdate = definition.onUpdate ? encodeExpression(definition.onUpdate, "default", dialect, [
+		"columns",
+		id,
+		"onUpdate"
+	], options, diagnostics) : void 0;
+	return {
+		id,
+		physicalName,
+		nullable: definition.nullable,
+		hasDefault: definition.hasDefault,
+		generated: definition.generated,
+		...storage === void 0 ? {} : { storage },
+		...defaultValue === void 0 ? {} : { default: defaultValue },
+		...generatedColumn === void 0 ? {} : { generatedColumn },
+		...identity === void 0 ? {} : { identity },
+		...onUpdate === void 0 ? {} : { onUpdate }
+	};
+}
+function encodeStorage(storage, dialect, path, options, diagnostics) {
+	if (storage.kind === "native" && storage.dialect !== dialect.name) {
+		diagnostics.push({
+			code: "dialect-mismatch",
+			message: `Native storage belongs to "${storage.dialect}" but the snapshot dialect is "${dialect.name}"`,
+			path
+		});
+		return;
+	}
+	const encoder = options.storageEncoder ?? options.adapter?.dialect.schema.encodeStorage ?? dialect.schema.encodeStorage;
+	if (encoder !== void 0) try {
+		return encoder(storage, {
+			path,
+			dialect
+		});
+	} catch (error) {
+		diagnostics.push({
+			code: "invalid-schema",
+			message: error instanceof Error ? error.message : String(error),
+			path
+		});
+		return;
+	}
+	if (storage.kind === "portable") return {
+		kind: "portable",
+		type: storage.type
+	};
+	return {
+		kind: "native",
+		dialect: storage.dialect,
+		type: storage.type
+	};
+}
+function encodeDefault(value, dialect, path, options, diagnostics) {
+	if (value.kind === "external") return { kind: "external" };
+	if (value.kind === "literal") return {
+		kind: "literal",
+		value: value.value
+	};
+	const expression = encodeExpression(value.expression, "default", dialect, path, options, diagnostics);
+	return expression === void 0 ? void 0 : {
+		kind: "expression",
+		expression
+	};
+}
+function encodeGenerated(value, dialect, path, options, diagnostics) {
+	if (value.kind === "external") return { kind: "external" };
+	const expression = encodeExpression(value.expression, "generated", dialect, path, options, diagnostics);
+	return expression === void 0 ? void 0 : {
+		kind: "expression",
+		expression,
+		mode: value.mode
+	};
+}
+function encodeIdentity(value, dialect, path, options, diagnostics) {
+	const extension = encodeExtension(value.dialect, dialect, [...path, "dialect"], options, diagnostics);
+	return {
+		kind: "identity",
+		generation: value.generation,
+		...extension === void 0 ? {} : { dialect: extension }
+	};
+}
+function serializeConstraint(id, constraint, table, tableIds, tablesById, dialect, options, diagnostics) {
+	const physicalName = constraint.physicalName ?? generatedSchemaObjectName(id);
+	const common = {
+		id,
+		kind: constraint.kind,
+		physicalName
+	};
+	if (constraint.kind === "primary-key" || constraint.kind === "unique" || constraint.kind === "unique-constraint") {
+		const columns = serializeColumns(constraint.columns, table, [
+			"constraints",
+			id,
+			"columns"
+		], diagnostics);
+		const extension = encodeExtension(constraint.dialect, dialect, [
+			"constraints",
+			id,
+			"dialect"
+		], options, diagnostics);
+		if (columns === void 0) return void 0;
+		const timing = serializeTiming(constraint);
+		if (constraint.kind === "unique-constraint") return {
+			...common,
+			kind: "unique-constraint",
+			columns,
+			nulls: constraint.nulls,
+			...timing,
+			...extension === void 0 ? {} : { dialect: extension }
+		};
+		return {
+			...common,
+			kind: constraint.kind,
+			columns,
+			...timing,
+			...extension === void 0 ? {} : { dialect: extension }
+		};
+	}
+	if (constraint.kind === "foreign-key") {
+		const columns = serializeColumns(constraint.columns, table, [
+			"constraints",
+			id,
+			"columns"
+		], diagnostics);
+		const target = resolveForeignKeyTarget(constraint, tableIds, tablesById, [
+			"constraints",
+			id,
+			"target"
+		], diagnostics);
+		const extension = encodeExtension(constraint.dialect, dialect, [
+			"constraints",
+			id,
+			"dialect"
+		], options, diagnostics);
+		if (columns === void 0 || target === void 0) return void 0;
+		return {
+			...common,
+			kind: "foreign-key",
+			columns,
+			target,
+			...constraint.onUpdate === void 0 ? {} : { onUpdate: constraint.onUpdate },
+			...constraint.onDelete === void 0 ? {} : { onDelete: constraint.onDelete },
+			...constraint.match === void 0 ? {} : { match: constraint.match },
+			...serializeTiming(constraint),
+			...extension === void 0 ? {} : { dialect: extension }
+		};
+	}
+	if (constraint.kind === "check") {
+		const expression = encodeExpression(constraint.expression, "check", dialect, [
+			"constraints",
+			id,
+			"expression"
+		], options, diagnostics);
+		const extension = encodeExtension(constraint.dialect, dialect, [
+			"constraints",
+			id,
+			"dialect"
+		], options, diagnostics);
+		if (expression === void 0) return void 0;
+		return {
+			...common,
+			kind: "check",
+			expression,
+			...serializeTiming(constraint),
+			...extension === void 0 ? {} : { dialect: extension }
+		};
+	}
+	diagnostics.push({
+		code: "invalid-schema",
+		message: `Unsupported constraint kind on "${id}"`,
+		path: ["constraints", id]
+	});
+}
+function serializeTiming(value) {
+	return {
+		...value.deferrable === void 0 ? {} : { deferrable: value.deferrable },
+		...value.initially === void 0 ? {} : { initially: value.initially }
+	};
+}
+function serializeColumns(columns, table, path, diagnostics) {
+	const result = [];
+	for (const [index, column] of columns.entries()) {
+		if (!isColumnReference(column)) {
+			diagnostics.push({
+				code: "invalid-schema",
+				message: "Constraint columns must be column references",
+				path: [...path, index]
+			});
+			continue;
+		}
+		if (!(column.fieldName in table.definitions)) {
+			diagnostics.push({
+				code: "unresolved-reference",
+				message: `Column "${column.fieldName}" is not declared on table "${table.tableName}"`,
+				path: [...path, index]
+			});
+			continue;
+		}
+		result.push(column.fieldName);
+	}
+	return result.length === columns.length && result.length > 0 ? result : void 0;
+}
+function resolveForeignKeyTarget(constraint, tableIds, tablesById, path, diagnostics) {
+	let target;
+	try {
+		target = typeof constraint.target === "function" ? constraint.target() : constraint.target;
+	} catch (error) {
+		diagnostics.push({
+			code: "unresolved-reference",
+			message: `Foreign-key target could not be resolved: ${error instanceof Error ? error.message : String(error)}`,
+			path
+		});
+		return;
+	}
+	const targetId = tableIds.get(target.table);
+	if (targetId === void 0 || !tablesById.has(targetId)) {
+		diagnostics.push({
+			code: "unresolved-reference",
+			message: "Foreign-key target table is not registered in the schema",
+			path: [...path, "table"]
+		});
+		return;
+	}
+	const targetColumns = serializeColumns(target.columns, target.table, [...path, "columns"], diagnostics);
+	if (targetColumns === void 0) return void 0;
+	return {
+		table: targetId,
+		columns: targetColumns
+	};
+}
+function serializeIndex(id, indexMetadata, table, dialect, options, diagnostics) {
+	const terms = [];
+	for (const [termIndex, term] of indexMetadata.terms.entries()) {
+		const serialized = serializeIndexTerm(term, table, dialect, [
+			"indexes",
+			id,
+			"terms",
+			termIndex
+		], options, diagnostics);
+		if (serialized !== void 0) terms.push(serialized);
+	}
+	const predicate = indexMetadata.predicate === void 0 ? void 0 : encodeExpression(indexMetadata.predicate, "index", dialect, [
+		"indexes",
+		id,
+		"predicate"
+	], options, diagnostics);
+	const includedColumns = indexMetadata.includedColumns === void 0 ? void 0 : serializeColumns(indexMetadata.includedColumns, table, [
+		"indexes",
+		id,
+		"includedColumns"
+	], diagnostics);
+	const extension = encodeExtension(indexMetadata.dialect, dialect, [
+		"indexes",
+		id,
+		"dialect"
+	], options, diagnostics);
+	if (terms.length !== indexMetadata.terms.length || indexMetadata.includedColumns !== void 0 && includedColumns === void 0) return void 0;
+	return {
+		id,
+		kind: "index",
+		physicalName: indexMetadata.physicalName ?? generatedSchemaObjectName(id),
+		terms,
+		unique: indexMetadata.unique,
+		candidateKey: indexMetadata.candidateKey,
+		...predicate === void 0 ? {} : { predicate },
+		...includedColumns === void 0 ? {} : { includedColumns },
+		...extension === void 0 ? {} : { dialect: extension }
+	};
+}
+function serializeIndexTerm(term, table, dialect, path, options, diagnostics) {
+	if (isOrderTerm(term)) {
+		const expression = serializeIndexTermExpression(term.expression, table, dialect, [...path, "expression"], options, diagnostics);
+		return expression === void 0 ? void 0 : {
+			kind: "order",
+			expression,
+			...term.direction === void 0 ? {} : { direction: term.direction },
+			...term.nulls === void 0 ? {} : { nulls: term.nulls }
+		};
+	}
+	return serializeIndexTermExpression(term, table, dialect, path, options, diagnostics);
+}
+function serializeIndexTermExpression(expression, table, dialect, path, options, diagnostics) {
+	if (isColumnReference(expression)) {
+		if (!(expression.fieldName in table.definitions)) {
+			diagnostics.push({
+				code: "unresolved-reference",
+				message: `Index column "${expression.fieldName}" is not declared on table "${table.tableName}"`,
+				path
+			});
+			return;
+		}
+		return {
+			kind: "column",
+			column: expression.fieldName
+		};
+	}
+	const encoded = encodeExpression(expression, "index", dialect, path, options, diagnostics);
+	return encoded === void 0 ? void 0 : {
+		kind: "expression",
+		expression: encoded
+	};
+}
+function encodeExpression(expression, mode, dialect, path, options, diagnostics) {
+	const encoder = options.expressionEncoder ?? options.adapter?.dialect.schema.encodeExpression ?? dialect.schema.encodeExpression;
+	if (encoder !== void 0) try {
+		return encoder(expression, {
+			mode,
+			path,
+			dialect
+		});
+	} catch (error) {
+		const code = error instanceof Error && "code" in error && error.code === "dialect-mismatch" ? "dialect-mismatch" : "unsupported-expression";
+		diagnostics.push({
+			code,
+			message: error instanceof Error ? error.message : String(error),
+			path
+		});
+		return;
+	}
+	if (isUnsafeSchemaSql(expression)) {
+		if (expression.schemaSqlDialect !== dialect.name) {
+			diagnostics.push({
+				code: "dialect-mismatch",
+				message: `Schema SQL is tagged for "${expression.schemaSqlDialect}" but the snapshot dialect is "${dialect.name}"`,
+				path
+			});
+			return;
+		}
+		return {
+			kind: "expression",
+			expressionKind: expression.expressionKind,
+			sql: expression.schemaSql,
+			dialect: expression.schemaSqlDialect
+		};
+	}
+	try {
+		const rendered = renderSchemaExpression(expression, {
+			mode,
+			dialect
+		});
+		return {
+			kind: "expression",
+			expressionKind: expression.expressionKind,
+			sql: rendered.text
+		};
+	} catch (error) {
+		diagnostics.push({
+			code: "unsupported-expression",
+			message: error instanceof Error ? error.message : String(error),
+			path
+		});
+		return;
+	}
+}
+function encodeExtension(extension, dialect, path, options, diagnostics) {
+	if (extension === void 0) return void 0;
+	if (extension.dialect !== dialect.name) {
+		diagnostics.push({
+			code: "dialect-mismatch",
+			message: `Dialect extension belongs to "${extension.dialect}" but the snapshot dialect is "${dialect.name}"`,
+			path
+		});
+		return;
+	}
+	const encoder = options.extensionEncoder ?? options.adapter?.dialect.schema.encodeDialectExtension ?? dialect.schema.encodeDialectExtension;
+	if (encoder !== void 0) try {
+		return encoder(extension, {
+			path,
+			dialect
+		});
+	} catch (error) {
+		diagnostics.push({
+			code: "dialect-mismatch",
+			message: error instanceof Error ? error.message : String(error),
+			path
+		});
+		return;
+	}
+	const data = {};
+	for (const [key, value] of Object.entries(extension)) if (key !== "dialect") data[key] = value;
+	try {
+		return {
+			dialect: extension.dialect,
+			version: dialect.schema.version,
+			data: toSnapshotJsonValue(data)
+		};
+	} catch (error) {
+		diagnostics.push({
+			code: "invalid-value",
+			message: error instanceof Error ? error.message : String(error),
+			path
+		});
+		return;
+	}
+}
+function isOrderTerm(value) {
+	return typeof value === "object" && value !== null && "orderKind" in value && value.orderKind === "term" && "expression" in value;
+}
+function isSchemaRoot(value) {
+	return typeof value === "object" && value !== null && value.schemaKind === "schema" && typeof value.registry === "object" && value.registry !== null;
+}
+function compareId(left, right) {
+	return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
+}
+//#endregion
+export { encodeSnapshot as a, encodeSchemaSnapshot as i, createSchemaSnapshot as n, serializeSchema as o, digestSchemaSnapshot as r, tryCreateSchemaSnapshot as s, SnapshotSerializationError as t };