qubu 0.5.0 → 0.6.0

package/dist/{sqlite-CsIUtZ2Q.mjs → serialize-BN07IK0v.mjs}

@@ -1,9 +1,8 @@
 import { t as standardDialect } from "./standard-DfcZEVOj.mjs";
-import { F as isValidSchemaObjectName, P as generatedSchemaObjectName, r as isColumnReference } from "./column-DmazTL67.mjs";
-import { _ as isUnsafeSchemaSql, m as validateConstraintDialect, n as defaultSchemaNamingPolicy, w as validateIndexDialect, y as renderSchemaExpression } from "./registry-BGqa05et.mjs";
+import { r as isColumnReference, u as generatedSchemaObjectName } from "./column-r1Y4ivwt.mjs";
+import { c as isUnsafeSchemaSql, n as defaultSchemaNamingPolicy, u as renderSchemaExpression } from "./registry-BRcUuazJ.mjs";
 import { t as createSchemaDialect } from "./dialect-wUKrnPMB.mjs";
 import { a as toSnapshotJsonValue, f as schemaSnapshotFormat, i as schemaSnapshotFingerprint, o as SnapshotValidationError, r as encodeCanonicalSnapshot, s as assertSchemaSnapshot, u as neutralSnapshotDialect } from "./canonical-DMvR9yBe.mjs";
-import { sqliteDialect } from "./sqlite.mjs";
 //#region src/snapshot/serialize.ts
 const neutralSchemaDialect = createSchemaDialect(Object.freeze({
 	...standardDialect(),
@@ -554,317 +553,4 @@ function compareId(left, right) {
 	return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
 }
 //#endregion
-//#region src/snapshot/sqlite.ts
-/** SQLite's v1 snapshot extension identity. */
-const sqliteSnapshotDialect = Object.freeze({
-	name: "sqlite",
-	version: 1
-});
-var SqliteSnapshotDialectError = class extends TypeError {
-	code = "dialect-mismatch";
-};
-const sqliteStorageTypes = Object.freeze({
-	integer: "INTEGER",
-	numeric: "NUMERIC",
-	text: "TEXT",
-	boolean: "INTEGER",
-	date: "TEXT",
-	timestamp: "TEXT",
-	uuid: "TEXT",
-	json: "TEXT",
-	bigint: "INTEGER",
-	binary: "BLOB"
-});
-/**
-* Resolve SQLite's declared-type affinity without changing the declaration. SQLite applies these
-* ordered substring rules at table creation time; the returned affinity is useful metadata, not a
-* replacement for the exact type.
-*/
-function sqliteStorageAffinity(declaration) {
-	const upper = declaration.toUpperCase();
-	if (upper.includes("INT")) return "integer";
-	if (upper.includes("CHAR") || upper.includes("CLOB") || upper.includes("TEXT")) return "text";
-	if (upper.includes("BLOB") || upper.trim().length === 0) return "blob";
-	if (upper.includes("REAL") || upper.includes("FLOA") || upper.includes("DOUB")) return "real";
-	return "numeric";
-}
-/** SQLite's query dialect plus its schema metadata behavior. */
-const sqliteSchemaDialect = createSchemaDialect(sqliteDialect(), {
-	version: 1,
-	validate: validateSqliteSchema,
-	encodeStorage(storage, context) {
-		return encodeSqliteStorage(storage, context.dialect);
-	},
-	encodeExpression(expression, context) {
-		return encodeSqliteExpression(expression, context.mode, context.dialect);
-	},
-	encodeDialectExtension(extension, context) {
-		return encodeSqliteExtension(extension, context.dialect);
-	}
-});
-/** Snapshot adapter retaining the historical adapter-shaped entry point. */
-const sqliteSnapshotAdapter = Object.freeze({ dialect: sqliteSchemaDialect });
-/** Create a canonical SQLite schema snapshot. */
-function createSqliteSchemaSnapshot(schema, options = {}) {
-	return createSchemaSnapshot(schema, {
-		...options,
-		adapter: sqliteSnapshotAdapter
-	});
-}
-/** Return SQLite capability diagnostics without throwing. */
-function tryCreateSqliteSchemaSnapshot(schema, options = {}) {
-	return tryCreateSchemaSnapshot(schema, {
-		...options,
-		adapter: sqliteSnapshotAdapter
-	});
-}
-function encodeSqliteStorage(storage, dialect) {
-	if (storage.kind === "native") {
-		if (storage.dialect !== dialect.name) throw new SqliteSnapshotDialectError(`SQLite storage cannot encode a native declaration owned by "${storage.dialect}"`);
-		if (storage.type.trim().length === 0) throw new TypeError("SQLite native storage declarations cannot be empty");
-		return {
-			kind: "native",
-			dialect: dialect.name,
-			type: storage.type,
-			affinity: sqliteStorageAffinity(storage.type)
-		};
-	}
-	const type = sqliteStorageTypes[storage.type];
-	if (type === void 0) throw new TypeError(`Unsupported portable storage type for SQLite: ${String(storage.type)}`);
-	return {
-		kind: "native",
-		dialect: dialect.name,
-		type,
-		affinity: sqliteStorageAffinity(type)
-	};
-}
-function encodeSqliteExpression(expression, mode, dialect) {
-	if (isUnsafeSchemaSql(expression) && expression.schemaSqlDialect !== dialect.name) throw new SqliteSnapshotDialectError(`Schema SQL is tagged for "${expression.schemaSqlDialect}" but the SQLite schema dialect is "${dialect.name}"`);
-	const rendered = renderSchemaExpression(expression, {
-		mode,
-		dialect
-	});
-	if (rendered.parameters.length !== 0) throw new TypeError("SQLite schema expressions must be parameter-free");
-	return {
-		kind: "expression",
-		expressionKind: expression.expressionKind,
-		sql: rendered.text,
-		...isUnsafeSchemaSql(expression) ? { dialect: dialect.name } : {}
-	};
-}
-function encodeSqliteExtension(extension, dialect) {
-	if (extension.dialect !== dialect.name) throw new TypeError(`SQLite schema extensions require dialect "${dialect.name}"`);
-	const data = Object.fromEntries(Object.entries(extension).filter(([key]) => key !== "dialect").sort(([left], [right]) => left.localeCompare(right)));
-	return {
-		dialect: dialect.name,
-		version: dialect.schema.version,
-		data: sortSnapshotJson(toSnapshotJsonValue(data))
-	};
-}
-function sortSnapshotJson(value) {
-	if (Array.isArray(value)) return value.map(sortSnapshotJson);
-	if (typeof value !== "object" || value === null) return value;
-	return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, sortSnapshotJson(child)]));
-}
-function validateSqliteSchema(schema, context) {
-	const diagnostics = [];
-	const tableEntries = Object.entries(schema.registry).sort(([left], [right]) => compareIds(left, right));
-	const relationNames = /* @__PURE__ */ new Map();
-	if (schema.namespace !== void 0) validateSqliteName(schema.namespace, ["namespace"], "SQLite namespace", diagnostics);
-	for (const [id, entry] of tableEntries) {
-		const tablePath = ["tables", id];
-		validateSqliteName(entry.physicalName, [...tablePath, "physicalName"], "SQLite table", diagnostics);
-		addRelationName(relationNames, entry.physicalName, [...tablePath, "physicalName"], "table", diagnostics);
-	}
-	for (const [id, entry] of tableEntries) validateSqliteTable(id, entry, context, relationNames, diagnostics);
-	return Object.freeze(diagnostics);
-}
-function validateSqliteTable(tableId, entry, context, relationNames, diagnostics) {
-	const table = entry.table;
-	const tablePath = ["tables", tableId];
-	const definitions = table.definitions;
-	const metadata = table;
-	for (const [columnId, definition] of Object.entries(definitions).sort(([left], [right]) => compareIds(left, right))) {
-		validateSqliteName(table.sqlNames[columnId] ?? columnId, [
-			...tablePath,
-			"columns",
-			columnId,
-			"physicalName"
-		], "SQLite column", diagnostics);
-		if (definition.onUpdate !== void 0) diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "MySQL ON UPDATE expressions are not supported by SQLite",
-			path: [
-				...tablePath,
-				"columns",
-				columnId,
-				"onUpdate"
-			]
-		});
-		const storage = definition.storage;
-		const identity = definition.identity;
-		if (identity !== void 0) {
-			const identityPath = [
-				...tablePath,
-				"columns",
-				columnId,
-				"identity"
-			];
-			const extension = identity.dialect;
-			if (extension !== void 0 && extension.dialect === "sqlite" && extension.autoIncrement !== void 0 && typeof extension.autoIncrement !== "boolean") diagnostics.push({
-				code: "unsupported-dialect-option",
-				message: "SQLite identity autoIncrement must be boolean",
-				path: [
-					...identityPath,
-					"dialect",
-					"autoIncrement"
-				]
-			});
-			const primary = primaryKeyForColumn(metadata.constraints, columnId);
-			const declaration = sqliteDeclaration(storage);
-			if ((declaration === void 0 ? void 0 : sqliteStorageAffinity(declaration)) !== "integer") diagnostics.push({
-				code: "unsupported-dialect-option",
-				message: "SQLite identity columns must use INTEGER affinity so they can be rowid aliases",
-				path: [...identityPath, "generation"]
-			});
-			if (primary === void 0 || primary.length !== 1) diagnostics.push({
-				code: "unsupported-dialect-option",
-				message: "SQLite identity columns must be the sole column of a PRIMARY KEY constraint",
-				path: [...identityPath, "generation"]
-			});
-			if (extension?.dialect === "sqlite" && extension.autoIncrement === true && declaration?.trim().toUpperCase() !== "INTEGER") diagnostics.push({
-				code: "unsupported-dialect-option",
-				message: "SQLite AUTOINCREMENT requires an exact INTEGER PRIMARY KEY declaration",
-				path: [
-					...identityPath,
-					"dialect",
-					"autoIncrement"
-				]
-			});
-		}
-		if (definition.generatedColumn?.kind === "expression" && primaryKeyForColumn(metadata.constraints, columnId) !== void 0) diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "SQLite generated columns cannot be part of a PRIMARY KEY",
-			path: [
-				...tablePath,
-				"columns",
-				columnId,
-				"generatedColumn"
-			]
-		});
-	}
-	const constraintNames = /* @__PURE__ */ new Map();
-	const constraints = Object.entries(metadata.constraints);
-	for (const [constraintId, constraint] of constraints.sort(([left], [right]) => compareIds(left, right))) {
-		const constraintPath = [
-			...tablePath,
-			"constraints",
-			constraintId
-		];
-		const physicalName = constraint.physicalName ?? constraintId;
-		validateSqliteName(physicalName, [...constraintPath, "physicalName"], "SQLite constraint", diagnostics);
-		addScopedName(constraintNames, physicalName, [...constraintPath, "physicalName"], "constraint", diagnostics);
-		appendMetadataDiagnostics(diagnostics, validateConstraintDialect(constraint, context.dialect.name, constraintPath));
-		if ((constraint.kind === "primary-key" || constraint.kind === "unique" || constraint.kind === "unique-constraint" || constraint.kind === "check") && (constraint.deferrable === true || constraint.initially !== void 0)) diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "SQLite only supports DEFERRABLE timing on foreign-key constraints",
-			path: [...constraintPath, constraint.deferrable ? "deferrable" : "initially"]
-		});
-		if (constraint.kind === "foreign-key" && constraint.match !== void 0 && constraint.match !== "simple") diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "SQLite supports MATCH SIMPLE foreign keys only",
-			path: [...constraintPath, "match"]
-		});
-		if (constraint.kind === "unique-constraint" && constraint.nulls === "not-distinct") diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "SQLite UNIQUE constraints always use distinct NULL semantics in v1",
-			path: [...constraintPath, "nulls"]
-		});
-		if (constraint.dialect?.dialect === "sqlite" && "onConflict" in constraint.dialect && constraint.dialect.onConflict !== void 0 && ![
-			"rollback",
-			"abort",
-			"fail",
-			"ignore",
-			"replace"
-		].includes(String(constraint.dialect.onConflict))) diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "SQLite constraint onConflict has an unsupported value",
-			path: [
-				...constraintPath,
-				"dialect",
-				"onConflict"
-			]
-		});
-	}
-	const indexes = Object.entries(metadata.indexes);
-	for (const [indexId, index] of indexes.sort(([left], [right]) => compareIds(left, right))) {
-		const indexPath = [
-			...tablePath,
-			"indexes",
-			indexId
-		];
-		const physicalName = index.physicalName ?? indexId;
-		validateSqliteName(physicalName, [...indexPath, "physicalName"], "SQLite index", diagnostics);
-		addRelationName(relationNames, physicalName, [...indexPath, "physicalName"], "index", diagnostics);
-		appendMetadataDiagnostics(diagnostics, validateIndexDialect(index, context.dialect.name, indexPath));
-		if (index.dialect?.dialect === "sqlite" && "auto" in index.dialect && index.dialect.auto !== void 0 && typeof index.dialect.auto !== "boolean") diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "SQLite index auto must be boolean",
-			path: [
-				...indexPath,
-				"dialect",
-				"auto"
-			]
-		});
-	}
-}
-function sqliteDeclaration(storage) {
-	if (storage === void 0) return;
-	if (storage.kind === "native") return storage.type;
-	return sqliteStorageTypes[storage.type];
-}
-function primaryKeyForColumn(constraints, columnId) {
-	for (const constraint of Object.values(constraints)) {
-		if (constraint.kind !== "primary-key") continue;
-		if (constraint.columns.some((column) => isColumnReference(column) && column.fieldName === columnId)) return constraint.columns;
-	}
-}
-function validateSqliteName(name, path, kind, diagnostics) {
-	if (!isValidSchemaObjectName(name) || name.length === 0) diagnostics.push({
-		code: "invalid-schema",
-		message: `${kind} name "${name}" is not a valid unqualified identifier`,
-		path
-	});
-}
-function addRelationName(names, name, path, kind, diagnostics) {
-	addScopedName(names, name, path, kind, diagnostics);
-}
-function addScopedName(names, name, path, kind, diagnostics) {
-	const previousPath = names.get(name);
-	if (previousPath !== void 0) {
-		diagnostics.push({
-			code: "invalid-schema",
-			message: `SQLite ${kind} name "${name}" collides with another table or index`,
-			path,
-			relatedPaths: [previousPath]
-		});
-		return;
-	}
-	names.set(name, path);
-}
-function appendMetadataDiagnostics(diagnostics, issues) {
-	for (const issue of issues) {
-		if (issue.code === "dialect-mismatch") continue;
-		diagnostics.push({
-			code: issue.code === "unsupported-dialect-option" ? "unsupported-dialect-option" : "invalid-schema",
-			message: issue.message,
-			path: issue.path,
-			...issue.relatedPaths === void 0 ? {} : { relatedPaths: issue.relatedPaths }
-		});
-	}
-}
-function compareIds(left, right) {
-	return left < right ? -1 : left > right ? 1 : 0;
-}
-//#endregion
-export { sqliteStorageAffinity as a, createSchemaSnapshot as c, fingerprintSchemaSnapshot as d, serializeSchema as f, sqliteSnapshotDialect as i, encodeSchemaSnapshot as l, sqliteSchemaDialect as n, tryCreateSqliteSchemaSnapshot as o, tryCreateSchemaSnapshot as p, sqliteSnapshotAdapter as r, SnapshotSerializationError as s, createSqliteSchemaSnapshot as t, encodeSnapshot as u };
+export { fingerprintSchemaSnapshot as a, encodeSnapshot as i, createSchemaSnapshot as n, serializeSchema as o, encodeSchemaSnapshot as r, tryCreateSchemaSnapshot as s, SnapshotSerializationError as t };

package/dist/serialize-CEIIlWhC.d.mts

@@ -0,0 +1,66 @@
+import { T as SnapshotJsonValue, Tr as SchemaDialect, Ur as Schema, f as SnapshotDiagnostic, i as SchemaSnapshotInput, l as SnapshotCreateResult, n as SchemaSnapshot, r as SchemaSnapshotAdapter, u as SnapshotDecodeResult } from "./types-C0VkiwpR.mjs";
+//#region src/snapshot/canonical.d.ts
+/** Error raised when a value cannot cross the canonical JSON boundary. */
+declare class SnapshotCanonicalError extends TypeError {
+  readonly path: readonly (string | number)[];
+  constructor(message: string, path?: readonly (string | number)[]);
+}
+/** Convert a JavaScript value to the explicit JSON-safe snapshot domain. */
+declare function toSnapshotJsonValue(value: unknown, path?: readonly (string | number)[], seen?: WeakSet<object>): SnapshotJsonValue;
+/** Render a JSON-safe value with deterministic scalar and object handling. */
+declare function canonicalJson(value: SnapshotJsonValue): string;
+/** Canonical JSON for a schema snapshot after fixed-order reconstruction. */
+declare function encodeCanonicalSnapshot(snapshot: SchemaSnapshot): string;
+/**
+ * Compute a small deterministic content fingerprint for cache keys and diagnostics. It is
+ * deliberately not an entity identity, signature, or migration lineage.
+ */
+declare function schemaSnapshotFingerprint(snapshot: SchemaSnapshotInput | string): string;
+//#endregion
+//#region src/snapshot/decode.d.ts
+/** Error raised by throwing snapshot APIs after collecting diagnostics. */
+declare class SnapshotValidationError extends TypeError {
+  readonly name: string;
+  readonly diagnostics: readonly SnapshotDiagnostic[];
+  readonly issues: readonly SnapshotDiagnostic[];
+  constructor(diagnostics: readonly SnapshotDiagnostic[]);
+}
+/** Decode and strictly validate a JSON string or parsed snapshot value. */
+declare function decodeSchemaSnapshot(input: string | unknown): SnapshotDecodeResult;
+/** Validate a snapshot and throw one structured error if it is malformed. */
+declare function assertSchemaSnapshot(input: SchemaSnapshotInput | string): SchemaSnapshot;
+/** Return a fixed-order, deeply immutable copy of a valid snapshot. */
+declare function canonicalizeSchemaSnapshot(input: SchemaSnapshotInput): SchemaSnapshot;
+//#endregion
+//#region src/snapshot/serialize.d.ts
+/** Error raised when a live Qubu schema cannot be represented as a snapshot. */
+declare class SnapshotSerializationError extends SnapshotValidationError {
+  readonly name = "SnapshotSerializationError";
+}
+/** Options for the neutral traversal and a future dialect adapter. */
+interface SchemaSnapshotOptions {
+  readonly adapter?: SchemaSnapshotAdapter;
+  readonly dialect?: SchemaDialect;
+  /** Explicit hook overrides retained for custom tooling integrations. */
+  readonly expressionEncoder?: SchemaDialect["schema"]["encodeExpression"];
+  readonly storageEncoder?: SchemaDialect["schema"]["encodeStorage"];
+  readonly extensionEncoder?: SchemaDialect["schema"]["encodeDialectExtension"];
+  readonly namingPolicy?: {
+    readonly name: string;
+    readonly version?: number;
+  };
+}
+/** Create a neutral or adapter-owned immutable snapshot from a live schema. */
+declare function createSchemaSnapshot<TSchema extends Schema<any>>(schema: TSchema, options?: SchemaSnapshotOptions): SchemaSnapshot;
+/** Non-throwing form of {@link createSchemaSnapshot}. */
+declare function tryCreateSchemaSnapshot<TSchema extends Schema<any>>(schema: TSchema, options?: SchemaSnapshotOptions): SnapshotCreateResult;
+/** Encode a valid snapshot using fixed property order and canonical JSON. */
+declare function encodeSchemaSnapshot(snapshot: SchemaSnapshot): string;
+/** Alias used by tooling packages that call the operation serialization. */
+declare const serializeSchema: typeof createSchemaSnapshot;
+/** Alias for the canonical snapshot encoder. */
+declare const encodeSnapshot: typeof encodeSchemaSnapshot;
+/** Alias for the canonical snapshot fingerprint helper. */
+declare const fingerprintSchemaSnapshot: typeof schemaSnapshotFingerprint;
+//#endregion
+export { toSnapshotJsonValue as _, encodeSnapshot as a, tryCreateSchemaSnapshot as c, canonicalizeSchemaSnapshot as d, decodeSchemaSnapshot as f, schemaSnapshotFingerprint as g, encodeCanonicalSnapshot as h, encodeSchemaSnapshot as i, SnapshotValidationError as l, canonicalJson as m, SnapshotSerializationError as n, fingerprintSchemaSnapshot as o, SnapshotCanonicalError as p, createSchemaSnapshot as r, serializeSchema as s, SchemaSnapshotOptions as t, assertSchemaSnapshot as u };

package/dist/snapshot/mysql.d.mts

@@ -0,0 +1,17 @@
+import { Tr as SchemaDialect, Ur as Schema, l as SnapshotCreateResult, m as SnapshotDialect, n as SchemaSnapshot, r as SchemaSnapshotAdapter } from "../types-C0VkiwpR.mjs";
+import { t as SchemaSnapshotOptions } from "../serialize-CEIIlWhC.mjs";
+//#region src/snapshot/mysql.d.ts
+/** MySQL's v1 snapshot extension identity. */
+declare const mysqlSnapshotDialect: SnapshotDialect;
+/** MySQL's query dialect plus its schema metadata behavior. */
+declare const mysqlSchemaDialect: SchemaDialect<"json" | "row-locking">;
+/** Snapshot adapter retaining the historical adapter-shaped entry point. */
+declare const mysqlSnapshotAdapter: SchemaSnapshotAdapter<"json" | "row-locking">;
+/** Create a canonical MySQL schema snapshot. */
+declare function createSchemaSnapshot<TSchema extends Schema<any>>(schema: TSchema, options?: MysqlSnapshotOptions): SchemaSnapshot;
+/** Return MySQL capability diagnostics without throwing. */
+declare function tryCreateSchemaSnapshot<TSchema extends Schema<any>>(schema: TSchema, options?: MysqlSnapshotOptions): SnapshotCreateResult;
+/** Options accepted by the MySQL snapshot convenience functions. */
+type MysqlSnapshotOptions = Omit<SchemaSnapshotOptions, "adapter" | "dialect">;
+//#endregion
+export { MysqlSnapshotOptions, createSchemaSnapshot, mysqlSchemaDialect, mysqlSnapshotAdapter, mysqlSnapshotDialect, tryCreateSchemaSnapshot };