qubu 0.4.0 → 0.4.2

package/dist/{serialize-CFtYYAdk.mjs → sqlite-Cg0nwYEH.mjs}

@@ -1,8 +1,9 @@
-import { t as standardDialect } from "./standard-BTVYKh_F.mjs";
-import { r as isColumnReference, u as generatedSchemaObjectName } from "./column-D-8OqGuV.mjs";
-import { _ as isUnsafeSchemaSql, n as defaultSchemaNamingPolicy, y as renderSchemaExpression } from "./registry-CXV8u7Pt.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";
+import { t as standardDialect } from "./standard-DfcZEVOj.mjs";
+import { N as generatedSchemaObjectName, P as isValidSchemaObjectName, r as isColumnReference } from "./column-hqKr7-1I.mjs";
+import { _ as isUnsafeSchemaSql, m as validateConstraintDialect, n as defaultSchemaNamingPolicy, w as validateIndexDialect, y as renderSchemaExpression } from "./registry-BRMLYwDp.mjs";
+import { t as createSchemaDialect } from "./dialect-wUKrnPMB.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-BXUguqfo.mjs";
+import { sqliteDialect } from "./sqlite.mjs";
 //#region src/snapshot/serialize.ts
 const neutralSchemaDialect = createSchemaDialect(Object.freeze({
 	...standardDialect(),
@@ -248,7 +249,7 @@ function serializeConstraint(id, constraint, table, tableIds, tablesById, dialec
 			id,
 			"dialect"
 		], options, diagnostics);
-		if (columns === void 0) return void 0;
+		if (columns === void 0) return;
 		const timing = serializeTiming(constraint);
 		if (constraint.kind === "unique-constraint") return {
 			...common,
@@ -282,7 +283,7 @@ function serializeConstraint(id, constraint, table, tableIds, tablesById, dialec
 			id,
 			"dialect"
 		], options, diagnostics);
-		if (columns === void 0 || target === void 0) return void 0;
+		if (columns === void 0 || target === void 0) return;
 		return {
 			...common,
 			kind: "foreign-key",
@@ -306,7 +307,7 @@ function serializeConstraint(id, constraint, table, tableIds, tablesById, dialec
 			id,
 			"dialect"
 		], options, diagnostics);
-		if (expression === void 0) return void 0;
+		if (expression === void 0) return;
 		return {
 			...common,
 			kind: "check",
@@ -372,7 +373,7 @@ function resolveForeignKeyTarget(constraint, tableIds, tablesById, path, diagnos
 		return;
 	}
 	const targetColumns = serializeColumns(target.columns, target.table, [...path, "columns"], diagnostics);
-	if (targetColumns === void 0) return void 0;
+	if (targetColumns === void 0) return;
 	return {
 		table: targetId,
 		columns: targetColumns
@@ -404,7 +405,7 @@ function serializeIndex(id, indexMetadata, table, dialect, options, diagnostics)
 		id,
 		"dialect"
 	], options, diagnostics);
-	if (terms.length !== indexMetadata.terms.length || indexMetadata.includedColumns !== void 0 && includedColumns === void 0) return void 0;
+	if (terms.length !== indexMetadata.terms.length || indexMetadata.includedColumns !== void 0 && includedColumns === void 0) return;
 	return {
 		id,
 		kind: "index",
@@ -503,7 +504,7 @@ function encodeExpression(expression, mode, dialect, path, options, diagnostics)
 	}
 }
 function encodeExtension(extension, dialect, path, options, diagnostics) {
-	if (extension === void 0) return void 0;
+	if (extension === void 0) return;
 	if (extension.dialect !== dialect.name) {
 		diagnostics.push({
 			code: "dialect-mismatch",
@@ -553,4 +554,317 @@ 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 };
+//#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, encodeSnapshot as d, serializeSchema as f, sqliteSnapshotDialect as i, digestSchemaSnapshot as l, sqliteSchemaDialect as n, tryCreateSqliteSchemaSnapshot as o, tryCreateSchemaSnapshot as p, sqliteSnapshotAdapter as r, SnapshotSerializationError as s, createSqliteSchemaSnapshot as t, encodeSchemaSnapshot as u };

package/dist/sqlite.d.mts

@@ -1,4 +1,4 @@
-import { An as excluded, Cn as ConflictTarget, Dn as OnConflictClause, En as ExcludedSource, On as doNothing, Sn as ConflictAction, Tn as DoUpdateAction, V as Dialect, jn as onConflict, kn as doUpdate, wn as DoNothingAction } from "./types-Deo_q43Y.mjs";
+import { V as Dialect, _n as doNothing, bn as onConflict, dn as ConflictAction, fn as ConflictTarget, gn as OnConflictClause, hn as ExcludedSource, mn as DoUpdateAction, pn as DoNothingAction, vn as doUpdate, yn as excluded } from "./types-BK1COGZe.mjs";
 //#region src/dialects/sqlite.d.ts
 declare function sqliteDialect(): Dialect<"json" | "on-conflict">;
 //#endregion

package/dist/sqlite.mjs

@@ -1,6 +1,6 @@
-import { o as createDialect, r as sqliteJson } from "./json-CUZlv4HT.mjs";
+import { o as createDialect, r as sqliteJson } from "./json-Db7XRD91.mjs";
 import { r as sqliteExplain } from "./explain-CkIK13L_.mjs";
-import { i as onConflict, n as doUpdate, r as excluded, t as doNothing } from "./on-conflict-4MOBl51J.mjs";
+import { i as onConflict, n as doUpdate, r as excluded, t as doNothing } from "./on-conflict-hfPW0KmQ.mjs";
 //#region src/dialects/sqlite.ts
 function renderSqliteSchemaLiteral(value) {
 	if (value === null) return "NULL";

package/dist/{standard-BTVYKh_F.mjs → standard-DfcZEVOj.mjs}

@@ -1,4 +1,4 @@
-import { i as standardJson, o as createDialect } from "./json-CUZlv4HT.mjs";
+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() {

package/dist/{table-D6rcs8SB.mjs → table-Bp5irMSj.mjs}

@@ -1,6 +1,5 @@
-import { F as resultValueOf, N as resultShapeValue, T as parenthesize, i as identifier, m as resolveSqlNames, p as materializeSchemaObjectRecord, t as createColumnReference } from "./column-D-8OqGuV.mjs";
-import { a as columnResultValue } from "./column-LV7oGQde.mjs";
-import { r as exposeColumns, t as createSource } from "./source-DGO3DRgg.mjs";
+import { I as materializeSchemaObjectRecord, J as parenthesize, L as resolveSqlNames, i as identifier, it as resultValueOf, nt as resultShapeValue, t as createColumnReference, u as columnResultValue } from "./column-hqKr7-1I.mjs";
+import { r as exposeColumns, t as createSource } from "./source-BcS2AsIg.mjs";
 //#region src/schema/alias.ts
 function alias(sourceOrQuery, name) {
 	const input = sourceOrQuery;