qubu 0.4.0 → 0.4.2

package/dist/runtime-Cn_Xgzta.mjs

@@ -1,193 +0,0 @@
-import { t as DrizzleSchemaConversionError } from "./errors-BGCoLe_r.mjs";
-import { getTableColumns, sql } from "drizzle-orm";
-//#region src/drizzle/runtime.ts
-/** Build Drizzle tables using one dialect adapter supplied by a leaf entrypoint. */
-function convertDrizzleSchema(schema, adapter) {
-	const snapshot = adapter.createSnapshot(schema);
-	assertRepresentableMetadata(snapshot, adapter.dialect);
-	const tables = {};
-	const tableFactory = adapter.createTableFactory(schema.namespace);
-	const snapshotTables = new Map(snapshot.tables.map((table) => [table.id, table]));
-	for (const [tableId, entry] of Object.entries(schema.registry)) {
-		const snapshotTable = snapshotTables.get(tableId);
-		if (snapshotTable === void 0) continue;
-		const columns = createColumns(entry.table, snapshotTable, adapter);
-		tables[snapshotTable.id] = tableFactory(snapshotTable.physicalName, columns, (drizzleColumns) => createExtraConfig(snapshotTable, drizzleColumns, tables, adapter));
-	}
-	return Object.freeze({ ...tables });
-}
-function createColumns(table, snapshotTable, adapter) {
-	const definitions = table.definitions;
-	const snapshotColumns = new Map(snapshotTable.columns.map((column) => [column.id, column]));
-	return Object.fromEntries(Object.entries(definitions).map(([columnId, definition]) => {
-		const snapshotColumn = snapshotColumns.get(columnId);
-		if (snapshotColumn === void 0) throw new DrizzleSchemaConversionError("missing-storage", `Qubu column "${snapshotTable.id}.${columnId}" has no snapshot definition`, [
-			"tables",
-			snapshotTable.id,
-			"columns",
-			columnId
-		]);
-		return [snapshotColumn.id, createColumnBuilder(definition, snapshotColumn, snapshotTable, adapter)];
-	}));
-}
-function createColumnBuilder(definition, column, table, adapter) {
-	const declaration = column.storage?.type;
-	if (declaration === void 0) throw new DrizzleSchemaConversionError("missing-storage", `Qubu column "${table.id}.${column.id}" needs physical storage before it can become a Drizzle column`, [
-		"tables",
-		table.id,
-		"columns",
-		column.id,
-		"storage"
-	]);
-	const portableType = definition.storage?.kind === "portable" ? definition.storage.type : void 0;
-	let builder = adapter.createStorageBuilder(portableType, column.physicalName, declaration, definition);
-	if (!column.nullable) builder = builder.notNull();
-	if (column.default?.kind === "literal") builder = builder.default(decodeSnapshotLiteral(column.default.value));
-	else if (column.default?.kind === "expression") builder = builder.default(sql.raw(column.default.expression.sql));
-	if (column.generatedColumn?.kind === "expression") builder = builder.generatedAlwaysAs(sql.raw(column.generatedColumn.expression.sql), { mode: column.generatedColumn.mode });
-	if (column.onUpdate !== void 0) builder = builder.$onUpdateFn(() => sql.raw(column.onUpdate?.sql ?? ""));
-	if (column.identity !== void 0) builder = adapter.applyIdentity(builder, definition, column, table);
-	return builder;
-}
-function decodeSnapshotLiteral(value) {
-	switch (value.kind) {
-		case "null": return null;
-		case "boolean":
-		case "string": return value.value;
-		case "number": return Number(value.value);
-		case "bigint": return BigInt(value.value);
-	}
-}
-function createExtraConfig(table, columns, tables, adapter) {
-	return [...table.constraints.flatMap((constraint) => createConstraint(constraint, columns, tables, adapter)), ...table.indexes.map((index) => createIndex(index, columns, adapter))];
-}
-function createConstraint(constraint, columns, tables, adapter) {
-	const localColumns = constraint.kind === "check" ? [] : constraint.columns.map((column) => columns[column]);
-	if (constraint.kind !== "check" && localColumns.some((value) => !value)) throw unsupportedMetadata(`Drizzle could not resolve every column in constraint "${constraint.id}"`, [
-		"constraints",
-		constraint.id,
-		"columns"
-	]);
-	if (constraint.kind === "primary-key") {
-		if (adapter.dialect === "sqlite" && localColumns.length === 1 && localColumns[0]?.primary === true) return [];
-		return [adapter.createPrimaryKey(constraint.physicalName, localColumns)];
-	}
-	if (constraint.kind === "unique" || constraint.kind === "unique-constraint") return [adapter.createUniqueConstraint(constraint.physicalName, localColumns, constraint.kind === "unique-constraint" && constraint.nulls === "not-distinct")];
-	if (constraint.kind === "check") return [adapter.createCheck(constraint.physicalName, sql.raw(constraint.expression.sql))];
-	if (constraint.kind !== "foreign-key") throw unsupportedMetadata(`Drizzle cannot represent constraint kind "${constraint.kind}"`, [
-		"constraints",
-		constraint.id,
-		"kind"
-	]);
-	const foreignTable = tables[constraint.target.table];
-	const foreignColumns = foreignTable ? constraint.target.columns.map((column) => getTableColumns(foreignTable)[column]) : [];
-	if (foreignColumns.length !== constraint.target.columns.length || foreignColumns.some((value) => !value)) throw unsupportedMetadata(`Drizzle could not resolve the target of foreign key "${constraint.id}"`, [
-		"constraints",
-		constraint.id,
-		"target"
-	]);
-	let builder = adapter.createForeignKey(constraint.physicalName, localColumns, foreignColumns);
-	if (constraint.onUpdate) builder = builder.onUpdate(toDrizzleAction(constraint.onUpdate));
-	if (constraint.onDelete) builder = builder.onDelete(toDrizzleAction(constraint.onDelete));
-	return [builder];
-}
-function createIndex(index, columns, adapter) {
-	const terms = index.terms.map((term) => createIndexTerm(term, columns));
-	const predicate = index.predicate ? sql.raw(index.predicate.sql) : void 0;
-	return adapter.createIndex(index, terms, predicate);
-}
-function createIndexTerm(term, columns) {
-	if (term.kind !== "order") return createIndexTermExpression(term, columns);
-	const expression = createIndexTermExpression(term.expression, columns);
-	const suffix = [term.direction, term.nulls && `NULLS ${term.nulls}`].filter((value) => value !== void 0).join(" ");
-	return suffix.length === 0 ? expression : sql`${expression} ${sql.raw(suffix)}`;
-}
-function createIndexTermExpression(term, columns) {
-	if (term.kind === "expression") return sql.raw(term.expression.sql);
-	const column = columns[term.column];
-	if (column === void 0) throw unsupportedMetadata(`Drizzle could not resolve index column "${term.column}"`, [
-		"indexes",
-		"terms",
-		term.column
-	]);
-	return column;
-}
-function toDrizzleAction(action) {
-	return action.replace("-", " ");
-}
-function assertRepresentableMetadata(snapshot, dialect) {
-	for (const table of snapshot.tables) {
-		for (const constraint of table.constraints) {
-			const path = [
-				"tables",
-				table.id,
-				"constraints",
-				constraint.id
-			];
-			if (constraint.deferrable === true || constraint.initially !== void 0) throw unsupportedMetadata(`Drizzle cannot represent deferred constraint "${constraint.id}"`, path);
-			if (constraint.kind === "foreign-key" && constraint.match !== void 0 && constraint.match !== "simple") throw unsupportedMetadata(`Drizzle cannot represent MATCH ${constraint.match.toUpperCase()} on foreign key "${constraint.id}"`, [...path, "match"]);
-			assertConstraintExtension(constraint.dialect, dialect, path);
-		}
-		for (const index of table.indexes) {
-			const path = [
-				"tables",
-				table.id,
-				"indexes",
-				index.id
-			];
-			if (index.includedColumns && index.includedColumns.length > 0) throw unsupportedMetadata(`Drizzle ${dialect} indexes cannot represent included columns`, [...path, "includedColumns"]);
-			assertIndexExtension(index.dialect, dialect, path);
-		}
-	}
-}
-function assertConstraintExtension(extension, dialect, path) {
-	const data = extensionData(extension);
-	const unsupported = Object.entries(data).find(([key, value]) => {
-		if (value === void 0) return false;
-		if (dialect === "postgresql" && key === "notValid") return value === true;
-		if (dialect === "mysql" && key === "enforced") return value === false;
-		if (dialect === "sqlite" && key === "onConflict") return true;
-		if (value === false) return false;
-		return true;
-	});
-	if (unsupported) throw unsupportedMetadata(`Drizzle cannot represent constraint option "${unsupported[0]}"`, [
-		...path,
-		"dialect",
-		unsupported[0]
-	]);
-}
-function assertIndexExtension(extension, dialect, path) {
-	const data = extensionData(extension);
-	const supported = dialect === "postgresql" ? /* @__PURE__ */ new Set([
-		"method",
-		"concurrently",
-		"storageParameters"
-	]) : dialect === "mysql" ? /* @__PURE__ */ new Set([
-		"using",
-		"algorithm",
-		"lock"
-	]) : /* @__PURE__ */ new Set();
-	const unsupported = Object.entries(data).find(([key, value]) => value !== void 0 && value !== false && !supported.has(key));
-	if (unsupported) throw unsupportedMetadata(`Drizzle cannot represent index option "${unsupported[0]}"`, [
-		...path,
-		"dialect",
-		unsupported[0]
-	]);
-}
-function extensionData(extension) {
-	const data = extension?.data;
-	return data !== null && typeof data === "object" && !Array.isArray(data) ? data : {};
-}
-function stringExtension(data, key) {
-	const value = data[key];
-	return typeof value === "string" ? value : void 0;
-}
-function recordExtension(data, key) {
-	const value = data[key];
-	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
-}
-function unsupportedMetadata(message, path) {
-	return new DrizzleSchemaConversionError("unsupported-metadata", message, path);
-}
-//#endregion
-export { stringExtension as i, extensionData as n, recordExtension as r, convertDrizzleSchema as t };

package/dist/sqlite-CrsK0Fza.mjs

@@ -1,320 +0,0 @@
-import { d as isValidSchemaObjectName, r as isColumnReference } from "./column-D-8OqGuV.mjs";
-import { _ as isUnsafeSchemaSql, m as validateConstraintDialect, w as validateIndexDialect, y as renderSchemaExpression } from "./registry-CXV8u7Pt.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-CFtYYAdk.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/types-DZsueVoI.d.mts

@@ -1,45 +0,0 @@
-import { As as ColumnInsertInput, Fs as ColumnOutput, Gs as ColumnUpdateInput, Hs as ColumnStorageOf, Os as ColumnHasDefault, Xs as PortableColumnStorage, js as ColumnIsGenerated, ks as ColumnIdentityOf, oi as SchemaTableRecord, qs as NativeColumnStorage } from "./types-Deo_q43Y.mjs";
-//#region src/drizzle/types.d.ts
-/** SQL engines supported by the Qubu-to-Drizzle runtime adapter. */
-type DrizzleDialect = 'postgresql' | 'mysql' | 'sqlite';
-type IsAny<T> = 0 extends 1 & T ? true : false;
-type SameType<TLeft, TRight> = IsAny<TLeft> extends true ? true : IsAny<TRight> extends true ? true : (<T>() => T extends TLeft ? 1 : 2) extends (<T>() => T extends TRight ? 1 : 2) ? (<T>() => T extends TRight ? 1 : 2) extends (<T>() => T extends TLeft ? 1 : 2) ? true : false : false;
-type HasCompatibleValueTypes<TDefinition> = SameType<ColumnOutput<TDefinition>, ColumnInsertInput<TDefinition>> extends true ? SameType<ColumnOutput<TDefinition>, ColumnUpdateInput<TDefinition>> : false;
-type HasCompatibleStorage<TDefinition, TDialect extends DrizzleDialect> = ColumnStorageOf<TDefinition> extends (infer TStorage) ? TStorage extends PortableColumnStorage ? true : TStorage extends NativeColumnStorage<infer TStorageDialect, string> ? TDialect extends TStorageDialect ? true : false : false : false;
-type InvalidValueTypeColumns<TTables extends SchemaTableRecord> = { [TTableKey in keyof TTables & string]: { [TColumnKey in keyof TTables[TTableKey]['definitions'] & string]: HasCompatibleValueTypes<TTables[TTableKey]['definitions'][TColumnKey]> extends true ? never : `${TTableKey}.${TColumnKey}`; }[keyof TTables[TTableKey]['definitions'] & string]; }[keyof TTables & string];
-type InvalidStorageColumns<TTables extends SchemaTableRecord, TDialect extends DrizzleDialect> = { [TTableKey in keyof TTables & string]: { [TColumnKey in keyof TTables[TTableKey]['definitions'] & string]: HasCompatibleStorage<TTables[TTableKey]['definitions'][TColumnKey], TDialect> extends true ? never : `${TTableKey}.${TColumnKey}`; }[keyof TTables[TTableKey]['definitions'] & string]; }[keyof TTables & string];
-type DrizzleSchemaValidation<TTables extends SchemaTableRecord, TDialect extends DrizzleDialect> = ([InvalidValueTypeColumns<TTables>] extends [never] ? unknown : {
-  readonly __drizzle_requires_one_value_type__: InvalidValueTypeColumns<TTables>;
-}) & ([InvalidStorageColumns<TTables, TDialect>] extends [never] ? unknown : {
-  readonly __drizzle_requires_compatible_storage__: InvalidStorageColumns<TTables, TDialect>;
-});
-type DrizzleColumnIdentity<TDefinition> = ColumnIdentityOf<TDefinition> extends {
-  readonly generation: infer TGeneration;
-} ? TGeneration extends 'always' ? 'always' : TGeneration extends 'by-default' ? 'byDefault' : undefined : undefined;
-type DrizzleColumnGenerated<TDefinition> = ColumnIsGenerated<TDefinition> extends true ? {
-  readonly as: ColumnOutput<TDefinition>;
-  readonly type: 'always';
-} : undefined;
-type DrizzleColumnHasDefault<TDefinition> = ColumnIsGenerated<TDefinition> extends true ? true : ColumnHasDefault<TDefinition>;
-type DrizzleColumnConfig<TTableName extends string, TDefinition> = {
-  readonly name: string;
-  readonly tableName: TTableName;
-  readonly dataType: 'custom';
-  readonly data: ColumnOutput<TDefinition>;
-  readonly driverParam: ColumnInsertInput<TDefinition>;
-  readonly enumValues: undefined;
-  /**
-   * Qubu makes nullable columns required on insert unless they have a default.
-   * Keeping this flag true and carrying null in `data` preserves that rule in
-   * Drizzle's single-axis column model.
-   */
-  readonly notNull: true;
-  readonly hasDefault: DrizzleColumnHasDefault<TDefinition>;
-  readonly isPrimaryKey: false;
-  readonly isAutoincrement: false;
-  readonly hasRuntimeDefault: false;
-  readonly identity: DrizzleColumnIdentity<TDefinition>;
-  readonly generated: DrizzleColumnGenerated<TDefinition>;
-};
-//#endregion
-export { DrizzleDialect as n, DrizzleSchemaValidation as r, DrizzleColumnConfig as t };