qubu 0.0.0 → 0.3.4

package/dist/runtime-BTr-MTlo.mjs

@@ -0,0 +1,193 @@
+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);
+	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/schema.d.mts

@@ -0,0 +1,2 @@
+import { $o as SourceConstraint, $r as SchemaOptions, $s as boolean, $t as SqliteIndexExtension, Ac as ResolvedColumnBehavior, As as ColumnStorageDeclarationOf, At as createSource, Bc as SchemaDialectName, Bo as ConstraintTiming, Br as SchemaRenderContext, Bs as NativeStorage, Bt as TableMetadataCallback, Cc as GeneratedColumnMode, Cs as ColumnIsGenerated, Ct as SourceIdentity, Dc as IdentityGeneration, Ds as ColumnOutput, Dt as SourceSqlTypeMap, Ec as IdentityDialectExtension, Es as ColumnOptions, Et as SourceRow, Fc as externalGeneratedColumn, Fo as CatalogCheckSql, Fr as RenderedSchemaExpression, Fs as ColumnStorageType, Ft as Table, Gc as assertSchemaDialectSupport, Go as ForeignKeyOptions, Gr as normalizeSchemaSql, Gs as PortableStorageType, Gt as table, Hc as SchemaMetadataValidationError, Ho as FieldLikeOptions, Hr as UnsafeSchemaSqlExpression, Hs as PortableColumnStorage, Ht as TableRow, Ic as generatedColumn, Io as CheckConstraint, Ir as SchemaExpressionError, Is as ColumnStorageTypeOf, It as TableColumns, Jc as generatedSchemaObjectName, Jo as KeyConstraint, Jr as schemaExpression, Js as StorageDialectOf, Jt as IndexTerm, Kc as dialectMismatchDiagnostic, Ko as ForeignKeyTarget, Kr as renderSchemaExpression, Ks as StorageDeclarationOf, Kt as IndexDialectExtension, Lc as identityColumn, Lo as CheckConstraintOptions, Lr as SchemaExpressionErrorCode, Ls as ColumnUpdateInput, Lt as TableDefinitions, Mc as SqliteIdentityExtension, Mr as SchemaDialect, Ms as ColumnStorageDialectOf, Mt as exposeColumns, Nc as canonicalLiteral, No as AnyKeyColumn, Nr as SchemaDialectHooks, Ns as ColumnStorageKindOf, Nt as sourceIdentity, Oc as LiteralDefaultDescriptor, Os as ColumnSqlType, Ot as SourceSqlTypes, Pc as externalDefault, Po as CatalogCheckExpression, Pr as createSchemaDialect, Ps as ColumnStorageOf, Pt as AnyTable, Qo as ReferentialAction, Qr as SchemaNamingPolicy, Qs as binary, Qt as SourceIndexesRecord, Rc as resolveColumnBehavior, Ro as ConstraintDialectExtension, Rr as SchemaExpressionInput, Rs as DialectNativeStorage, Rt as TableIdentity, Sc as GeneratedColumnDescriptor, Ss as ColumnInsertInput, St as SourceConstraints, Tc as IdentityDescriptor, Ts as ColumnOnUpdateOf, Tt as SourceProvision, Uc as SchemaObjectIdentity, Uo as ForeignKeyConstraint, Ur as defineSchemaExpression, Us as PortableStorage, Ut as TableSqlTypes, Vc as SchemaMetadataDiagnostic, Vo as FieldLike, Vr as SchemaRenderOptions, Vs as NativeStorageDescriptor, Vt as TableOptions, Wc as SchemaObjectNameOptions, Wo as ForeignKeyMatch, Wr as isUnsafeSchemaSql, Ws as PortableStorageDescriptor, Wt as TableUpdateInput, Xc as materializeSchemaObjectIdentity, Xo as MysqlConstraintExtension, Xr as Schema, Xs as StorageTypeOf, Xt as PostgresIndexExtension, Yc as isValidSchemaObjectName, Yo as KeyConstraintOptions, Yr as unsafeSchemaSql, Ys as StorageOf, Yt as MysqlIndexExtension, Zc as materializeSchemaObjectRecord, Zo as PostgresConstraintExtension, Zr as SchemaDiagnostic, Zs as bigint, Zt as SourceIndex, _c as DefaultDescriptor, _s as ColumnDefinition, _t as CustomSourceOptions, ac as nativeStorage, ai as defaultSchemaNamingPolicy, as as UniqueConstraintOptions, bc as ExternalDefaultDescriptor, bs as ColumnHasDefault, bt as Source, cc as portableStorage, ci as schemaNamingPolicyVersion, cs as catalogForeignKey, dc as uuid, di as LateralIdentity, ds as primaryKey, ec as column, ei as SchemaTableEntry, en as TableIndex, es as SourceConstraintsRecord, fc as CanonicalLiteral, fi as LateralSource, fs as references, gc as ColumnDefaultInput, gi as lateral, gs as ColumnDefaultOf, gt as CustomSource, hc as ColumnDefault, hi as alias, hs as validateConstraintDialect, ht as AnySource, ic as nativeColumn, ii as SchemaValidationError, is as UniqueConstraint, jc as SchemaLiteralValue, js as ColumnStorageDescriptor, jt as customSource, kc as MysqlIdentityExtension, ks as ColumnStorage, kt as UnknownSourceSqlTypes, lc as text, li as AliasIdentity, ls as check, mc as ColumnBehaviorErrorCode, mi as QuerySource, ms as uniqueConstraint, nc as integer, ni as SchemaTableRecord, nn as validateIndexDialect, ns as SqliteConstraintExtension, oc as nullable, oi as generatedTableName, os as UniqueNullSemantics, pc as ColumnBehaviorError, pi as QueryAliasIdentity, ps as unique, qc as freezeSchemaMetadata, qo as ForeignKeyTargetInput, qr as renderSchemaSql, qs as StorageDescriptor, qt as IndexOptions, rc as json, ri as SchemaTableRegistry, rs as TableLike, sc as numeric, si as schema, ss as catalogCheck, tc as date, ti as SchemaTableNames, tn as index, ts as SourceLike, uc as timestamp, ui as AliasedSource, us as foreignKey, vc as ExpressionDefaultDescriptor, vs as ColumnFromOptions, vt as ProvidedSourceIdentity, wc as GeneratedDescriptor, ws as ColumnIsNullable, wt as SourceKind, xc as ExternalGeneratedColumnDescriptor, xs as ColumnIdentityOf, xt as SourceColumns, yc as ExpressionGeneratedColumnDescriptor, ys as ColumnGeneratedOf, yt as ProvidedSourceRow, zc as SchemaDialectExtension, zo as ConstraintOptions, zr as SchemaExpressionMode, zs as NativeColumnStorage, zt as TableInsertInput } from "./types-4Q076HKo.mjs";
+export { AliasIdentity, AliasedSource, AnyKeyColumn, AnySource, AnyTable, CanonicalLiteral, CatalogCheckExpression, CatalogCheckSql, CheckConstraint, CheckConstraintOptions, ColumnBehaviorError, ColumnBehaviorErrorCode, ColumnDefault, ColumnDefaultInput, ColumnDefaultOf, ColumnDefinition, ColumnFromOptions, ColumnGeneratedOf, ColumnHasDefault, ColumnIdentityOf, ColumnInsertInput, ColumnIsGenerated, ColumnIsNullable, ColumnOnUpdateOf, ColumnOptions, ColumnOutput, ColumnSqlType, ColumnStorage, ColumnStorageDeclarationOf, ColumnStorageDescriptor, ColumnStorageDialectOf, ColumnStorageKindOf, ColumnStorageOf, ColumnStorageType, ColumnStorageTypeOf, ColumnUpdateInput, ConstraintDialectExtension, ConstraintOptions, ConstraintTiming, CustomSource, CustomSourceOptions, DefaultDescriptor, DialectNativeStorage, ExpressionDefaultDescriptor, ExpressionGeneratedColumnDescriptor, ExternalDefaultDescriptor, ExternalGeneratedColumnDescriptor, FieldLike, FieldLikeOptions, ForeignKeyConstraint, ForeignKeyMatch, ForeignKeyOptions, ForeignKeyTarget, ForeignKeyTargetInput, GeneratedColumnDescriptor, GeneratedColumnMode, GeneratedDescriptor, IdentityDescriptor, IdentityDialectExtension, IdentityGeneration, IndexDialectExtension, IndexOptions, IndexTerm, KeyConstraint, KeyConstraintOptions, LateralIdentity, LateralSource, LiteralDefaultDescriptor, MysqlConstraintExtension, MysqlIdentityExtension, MysqlIndexExtension, NativeColumnStorage, NativeStorage, NativeStorageDescriptor, PortableColumnStorage, PortableStorage, PortableStorageDescriptor, PortableStorageType, PostgresConstraintExtension, PostgresIndexExtension, ProvidedSourceIdentity, ProvidedSourceRow, QueryAliasIdentity, QuerySource, ReferentialAction, RenderedSchemaExpression, ResolvedColumnBehavior, Schema, SchemaDiagnostic, SchemaDialect, SchemaDialectExtension, SchemaDialectHooks, SchemaDialectName, SchemaExpressionError, SchemaExpressionErrorCode, SchemaExpressionInput, SchemaExpressionMode, SchemaLiteralValue, SchemaMetadataDiagnostic, SchemaMetadataValidationError, SchemaNamingPolicy, SchemaObjectIdentity, SchemaObjectNameOptions, SchemaOptions, SchemaRenderContext, SchemaRenderOptions, SchemaTableEntry, SchemaTableNames, SchemaTableRecord, SchemaTableRegistry, SchemaValidationError, Source, SourceColumns, SourceConstraint, SourceConstraints, SourceConstraintsRecord, SourceIdentity, SourceIndex, SourceIndexesRecord, SourceKind, SourceLike, SourceProvision, SourceRow, SourceSqlTypeMap, SourceSqlTypes, SqliteConstraintExtension, SqliteIdentityExtension, SqliteIndexExtension, StorageDeclarationOf, StorageDescriptor, StorageDialectOf, StorageOf, StorageTypeOf, Table, TableColumns, TableDefinitions, TableIdentity, TableIndex, TableInsertInput, TableLike, TableMetadataCallback, TableOptions, TableRow, TableSqlTypes, TableUpdateInput, UniqueConstraint, UniqueConstraintOptions, UniqueNullSemantics, UnknownSourceSqlTypes, UnsafeSchemaSqlExpression, alias, assertSchemaDialectSupport, bigint, binary, boolean, canonicalLiteral, catalogCheck, catalogForeignKey, check, column, createSchemaDialect, createSource, customSource, date, defaultSchemaNamingPolicy, defineSchemaExpression, dialectMismatchDiagnostic, exposeColumns, externalDefault, externalGeneratedColumn, foreignKey, freezeSchemaMetadata, generatedColumn, generatedSchemaObjectName, generatedTableName, identityColumn, index, integer, isUnsafeSchemaSql, isValidSchemaObjectName, json, lateral, materializeSchemaObjectIdentity, materializeSchemaObjectRecord, nativeColumn, nativeStorage, normalizeSchemaSql, nullable, numeric, portableStorage, primaryKey, references, renderSchemaExpression, renderSchemaSql, resolveColumnBehavior, schema, schemaExpression, schemaNamingPolicyVersion, sourceIdentity, table, text, timestamp, unique, uniqueConstraint, unsafeSchemaSql, uuid, validateConstraintDialect, validateIndexDialect };

package/dist/schema.mjs

@@ -0,0 +1,5 @@
+import { i as sourceIdentity, n as customSource, r as exposeColumns, t as createSource } from "./source-DUoJVXmL.mjs";
+import { C as resolveColumnBehavior, S as identityColumn, T as lateral, _ as ColumnBehaviorError, a as column, b as externalGeneratedColumn, c as json, d as nullable, f as numeric, g as uuid, h as timestamp, i as boolean, l as nativeColumn, m as text, n as bigint, o as date, p as portableStorage, r as binary, s as integer, t as table, u as nativeStorage, v as canonicalLiteral, w as alias, x as generatedColumn, y as externalDefault } from "./table-llv9tsZ8.mjs";
+import { A as isValidSchemaObjectName, C as index, D as dialectMismatchDiagnostic, E as assertSchemaDialectSupport, M as materializeSchemaObjectRecord, O as freezeSchemaMetadata, S as unsafeSchemaSql, T as SchemaMetadataValidationError, _ as isUnsafeSchemaSql, a as schemaNamingPolicyVersion, b as renderSchemaSql, c as check, d as references, f as unique, g as defineSchemaExpression, h as SchemaExpressionError, i as schema, j as materializeSchemaObjectIdentity, k as generatedSchemaObjectName, l as foreignKey, m as validateConstraintDialect, n as defaultSchemaNamingPolicy, o as catalogCheck, p as uniqueConstraint, r as generatedTableName, s as catalogForeignKey, t as SchemaValidationError, u as primaryKey, v as normalizeSchemaSql, w as validateIndexDialect, x as schemaExpression, y as renderSchemaExpression } from "./registry-BufIskVN.mjs";
+import { t as createSchemaDialect } from "./dialect-b2-Z6uBF.mjs";
+export { ColumnBehaviorError, SchemaExpressionError, SchemaMetadataValidationError, SchemaValidationError, alias, assertSchemaDialectSupport, bigint, binary, boolean, canonicalLiteral, catalogCheck, catalogForeignKey, check, column, createSchemaDialect, createSource, customSource, date, defaultSchemaNamingPolicy, defineSchemaExpression, dialectMismatchDiagnostic, exposeColumns, externalDefault, externalGeneratedColumn, foreignKey, freezeSchemaMetadata, generatedColumn, generatedSchemaObjectName, generatedTableName, identityColumn, index, integer, isUnsafeSchemaSql, isValidSchemaObjectName, json, lateral, materializeSchemaObjectIdentity, materializeSchemaObjectRecord, nativeColumn, nativeStorage, normalizeSchemaSql, nullable, numeric, portableStorage, primaryKey, references, renderSchemaExpression, renderSchemaSql, resolveColumnBehavior, schema, schemaExpression, schemaNamingPolicyVersion, sourceIdentity, table, text, timestamp, unique, uniqueConstraint, unsafeSchemaSql, uuid, validateConstraintDialect, validateIndexDialect };