qubu 0.0.0 → 0.3.4

package/dist/sqlite-BU6DBxef.mjs

@@ -0,0 +1,320 @@
+import { r as isColumnReference } from "./column-CXMxx8Hq.mjs";
+import { A as isValidSchemaObjectName, _ as isUnsafeSchemaSql, m as validateConstraintDialect, w as validateIndexDialect, y as renderSchemaExpression } from "./registry-BufIskVN.mjs";
+import { t as createSchemaDialect } from "./dialect-b2-Z6uBF.mjs";
+import { a as toSnapshotJsonValue } from "./canonical-BbnqavJm.mjs";
+import { sqliteDialect } from "./sqlite.mjs";
+import { n as createSchemaSnapshot, s as tryCreateSchemaSnapshot } from "./serialize-PF1cfH2P.mjs";
+//#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 void 0;
+	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, sqliteSnapshotDialect as i, sqliteSchemaDialect as n, tryCreateSqliteSchemaSnapshot as o, sqliteSnapshotAdapter as r, createSqliteSchemaSnapshot as t };

package/dist/sqlite.d.mts

@@ -0,0 +1,5 @@
+import { Cn as ExcludedSource, Dn as excluded, En as doUpdate, On as onConflict, Sn as DoUpdateAction, Tn as doNothing, V as Dialect, bn as ConflictTarget, wn as OnConflictClause, xn as DoNothingAction, yn as ConflictAction } from "./types-4Q076HKo.mjs";
+//#region src/dialects/sqlite.d.ts
+declare function sqliteDialect(): Dialect<"json" | "on-conflict">;
+//#endregion
+export { type ConflictAction, type ConflictTarget, type DoNothingAction, type DoUpdateAction, type ExcludedSource, type OnConflictClause, doNothing, doUpdate, excluded, onConflict, sqliteDialect };

package/dist/sqlite.mjs

@@ -0,0 +1,48 @@
+import { o as createDialect, r as sqliteJson } from "./json-CUZlv4HT.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-BxnxubMb.mjs";
+//#region src/dialects/sqlite.ts
+function renderSqliteSchemaLiteral(value) {
+	if (value === null) return "NULL";
+	if (typeof value === "boolean") return value ? "1" : "0";
+	if (typeof value === "string") return `'${value.replaceAll("'", "''")}'`;
+	if (typeof value === "bigint") return String(value);
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new TypeError("SQLite schema literals require finite numbers");
+		return Object.is(value, -0) ? "0" : String(value);
+	}
+	throw new TypeError(`Unsupported SQLite schema literal type: ${value === void 0 ? "undefined" : typeof value}`);
+}
+function renderSqlitePagination(context, parts) {
+	const fetch = parts.find((part) => part.kind === "fetch");
+	const offset = parts.find((part) => part.kind === "offset");
+	context.append("LIMIT ");
+	if (fetch) context.parameter(fetch.rows);
+	else context.append("-1");
+	if (offset) {
+		context.append(" OFFSET ");
+		context.parameter(offset.rows);
+	}
+}
+function sqliteDialect() {
+	return createDialect({
+		name: "sqlite",
+		placeholder: () => "?",
+		pagination: { render: renderSqlitePagination },
+		capabilities: ["on-conflict"],
+		json: sqliteJson,
+		castTypes: {
+			decimal: "NUMERIC",
+			boolean: "INTEGER",
+			date: "TEXT",
+			timestamp: "TEXT",
+			uuid: "TEXT",
+			json: "TEXT",
+			binary: "BLOB"
+		},
+		renderSchemaLiteral: renderSqliteSchemaLiteral,
+		explain: sqliteExplain
+	});
+}
+//#endregion
+export { doNothing, doUpdate, excluded, onConflict, sqliteDialect };

package/dist/standard-BTVYKh_F.mjs

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