@revojs/storage 0.1.58

package/dist/index.js

@@ -0,0 +1,842 @@
+import { defineContext, getContext, setContext } from "revojs";
+//#region src/index.ts
+var Parameter = class {
+	value;
+	constructor(value) {
+		this.value = value;
+	}
+};
+var Sql = class Sql {
+	$chunks;
+	constructor(...chunks) {
+		this.$chunks = chunks;
+	}
+	push(...chunks) {
+		chunks.forEach((chunk) => {
+			if (chunk instanceof Sql && this.$chunks.at(-1) instanceof Sql) this.$chunks.push(" ");
+			this.$chunks.push(chunk);
+		});
+		return this;
+	}
+	toQuery() {
+		const queries = this.$chunks.map((chunk) => {
+			if (typeof chunk === "string") return {
+				sql: chunk,
+				parameters: []
+			};
+			if (chunk instanceof Parameter) return {
+				sql: "?",
+				parameters: [chunk.value]
+			};
+			if (chunk instanceof Sql || chunk instanceof Table || chunk instanceof Column) return chunk.toSql().toQuery();
+			return {
+				sql: "?",
+				parameters: [chunk]
+			};
+		});
+		return {
+			sql: queries.map((query) => query.sql).join(""),
+			parameters: queries.flatMap((query) => query.parameters)
+		};
+	}
+	toSql() {
+		return this;
+	}
+};
+var Statement = class extends Sql {
+	$session;
+	$fields;
+	constructor(session, value, ...chunks) {
+		super(...chunks);
+		this.$session = session;
+		this.$fields = Object.entries(value instanceof Table ? value.$columns : value);
+	}
+	async then(onfulfilled, onrejected) {
+		let value;
+		try {
+			value = (await this.$session.all(this.toQuery())).map((row) => this.mapRow(row));
+		} catch (error) {
+			if (onrejected) return onrejected(error);
+			throw error;
+		}
+		return onfulfilled ? onfulfilled(value) : value;
+	}
+	mapRow(row) {
+		const result = {};
+		this.$fields.forEach(([key, column], index) => {
+			const value = row[index];
+			result[key] = value === null ? null : column.fromDriverValue(value);
+		});
+		return result;
+	}
+};
+var SelectStatement = class extends Statement {
+	$value;
+	$selection;
+	$baseNullable = false;
+	$joins = new Array();
+	constructor(session, value) {
+		super(session, value);
+		this.$value = value;
+		this.$selection = combine(this.$fields.map(([, column]) => column), ", ");
+		this.push(sql`SELECT ${this.$selection}`);
+	}
+	from(table) {
+		this.push(sql`FROM ${table}`);
+		return this;
+	}
+	leftJoin(table, on) {
+		this.push(sql`LEFT JOIN ${table} ON ${on}`);
+		if (this.$value instanceof Table) {
+			this.$selection.push(", ", combine(Object.values(table.$columns), ", "));
+			this.$joins.push({
+				table,
+				nullable: true
+			});
+		}
+		return this;
+	}
+	rightJoin(table, on) {
+		this.push(sql`RIGHT JOIN ${table} ON ${on}`);
+		if (this.$value instanceof Table) {
+			this.$selection.push(", ", combine(Object.values(table.$columns), ", "));
+			this.$baseNullable = true;
+			this.$joins.forEach((join) => join.nullable = true);
+			this.$joins.push({
+				table,
+				nullable: false
+			});
+		}
+		return this;
+	}
+	innerJoin(table, on) {
+		this.push(sql`INNER JOIN ${table} ON ${on}`);
+		if (this.$value instanceof Table) {
+			this.$selection.push(", ", combine(Object.values(table.$columns), ", "));
+			this.$joins.push({
+				table,
+				nullable: false
+			});
+		}
+		return this;
+	}
+	crossJoin(table) {
+		this.push(sql`CROSS JOIN ${table}`);
+		if (this.$value instanceof Table) {
+			this.$selection.push(", ", combine(Object.values(table.$columns), ", "));
+			this.$joins.push({
+				table,
+				nullable: false
+			});
+		}
+		return this;
+	}
+	where(chunk) {
+		this.push(sql`WHERE ${chunk}`);
+		return this;
+	}
+	groupBy(...columns) {
+		this.push(sql`GROUP BY ${combine(columns, ", ")}`);
+		return this;
+	}
+	having(chunk) {
+		this.push(sql`HAVING ${chunk}`);
+		return this;
+	}
+	orderBy(...chunks) {
+		this.push(sql`ORDER BY ${combine(chunks, ", ")}`);
+		return this;
+	}
+	limit(count) {
+		this.push(sql`LIMIT ${new Parameter(count)}`);
+		return this;
+	}
+	offset(count) {
+		this.push(sql`OFFSET ${new Parameter(count)}`);
+		return this;
+	}
+	mapRow(row) {
+		if (!(this.$value instanceof Table) || this.$joins.length === 0) return super.mapRow(row);
+		const result = {};
+		let offset = 0;
+		for (const { table, nullable } of [{
+			table: this.$value,
+			nullable: this.$baseNullable
+		}, ...this.$joins]) {
+			const fields = Object.entries(table.$columns);
+			const values = row.slice(offset, offset + fields.length);
+			if (nullable && values.every((value) => value === null)) {
+				result[table.$name] = null;
+				offset += fields.length;
+				continue;
+			}
+			result[table.$name] = Object.fromEntries(fields.map(([key, column], index) => [key, values[index] === null ? null : column.fromDriverValue(values[index])]));
+			offset += fields.length;
+		}
+		return result;
+	}
+};
+var InsertStatement = class extends Statement {
+	$table;
+	constructor(session, table) {
+		super(session, table, sql`INSERT INTO ${table}`);
+		this.$table = table;
+	}
+	values(value) {
+		const columns = this.$table.$columns;
+		const rows = Array.isArray(value) ? value : [value];
+		const keys = Object.entries(columns).filter(([key, column]) => column.$defaultValue !== void 0 || rows.some((row) => Object.hasOwn(row, key))).map(([key]) => key);
+		this.push(sql`(${combine(keys.map((key) => columns[key].toSqlName()), ", ")}) VALUES ${combine(rows.map((row) => sql`(${combine(keys.map((key) => {
+			const column = columns[key];
+			const rowValue = row[key];
+			if (rowValue !== void 0) return toParameter(column, rowValue);
+			return toParameter(column, typeof column.$defaultValue === "function" ? column.$defaultValue() : column.$defaultValue ?? null);
+		}), ", ")})`), ", ")}`);
+		return this;
+	}
+	onConflictDoNothing() {
+		this.push(sql`ON CONFLICT DO NOTHING`);
+		return this;
+	}
+	returning() {
+		this.push(sql`RETURNING ${combine(this.$fields.map(([, column]) => column.toSqlName()), ", ")}`);
+		return this;
+	}
+};
+var UpdateStatement = class extends Statement {
+	$table;
+	constructor(session, table) {
+		super(session, table, sql`UPDATE ${table} SET`);
+		this.$table = table;
+	}
+	set(value) {
+		const columns = this.$table.$columns;
+		this.push(combine(Object.entries(value).map(([key, chunk]) => sql`${columns[key].toSqlName()} = ${toParameter(columns[key], chunk ?? null)}`), ", "));
+		return this;
+	}
+	where(chunk) {
+		this.push(sql`WHERE ${chunk}`);
+		return this;
+	}
+	returning() {
+		this.push(sql`RETURNING ${combine(this.$fields.map(([, column]) => column.toSqlName()), ", ")}`);
+		return this;
+	}
+};
+var DeleteStatement = class extends Statement {
+	$table;
+	constructor(session, table) {
+		super(session, table, sql`DELETE FROM ${table}`);
+		this.$table = table;
+	}
+	where(chunk) {
+		this.push(sql`WHERE ${chunk}`);
+		return this;
+	}
+	returning() {
+		this.push(sql`RETURNING ${combine(this.$fields.map(([, column]) => column.toSqlName()), ", ")}`);
+		return this;
+	}
+};
+var PreparedQuery = class {
+	$query;
+	constructor(query) {
+		this.$query = query;
+	}
+	getQuery() {
+		return this.$query;
+	}
+};
+var Session = class {
+	run(query) {
+		return this.prepareQuery(query).run(query.parameters);
+	}
+	all(query) {
+		return this.prepareQuery(query).all(query.parameters);
+	}
+	get(query) {
+		return this.prepareQuery(query).get(query.parameters);
+	}
+	values(query) {
+		return this.prepareQuery(query).values(query.parameters);
+	}
+};
+var Migration = class {
+	toSql(changes, current) {
+		if (current.dialect !== this.$dialect) throw new Error(`Unable to create ${this.$dialect} migration for ${current.dialect} metadata`);
+		return this.render({
+			changes,
+			current
+		});
+	}
+	render({ changes }) {
+		return changes.flatMap((change) => this.renderChange(change));
+	}
+	diff(previous, current) {
+		if (previous && previous.dialect !== current.dialect) throw new Error(`Storage dialect changed from "${previous.dialect}" to "${current.dialect}"`);
+		const changes = new Array();
+		const previousTables = new Map((previous?.tables ?? []).map((table) => [table.name, table]));
+		const currentTables = new Map(current.tables.map((table) => [table.name, table]));
+		for (const [name, table] of currentTables) {
+			const previousTable = previousTables.get(name);
+			if (!previousTable) {
+				changes.push({
+					kind: "createTable",
+					table
+				});
+				for (const definition of table.definitions) if (definition.kind === "index" || definition.kind === "uniqueIndex") changes.push({
+					kind: "createIndex",
+					table: table.name,
+					index: definition
+				});
+				continue;
+			}
+			const previousDefinitions = this.splitDefinitions(previousTable.definitions);
+			const currentDefinitions = this.splitDefinitions(table.definitions);
+			const previousColumns = new Map(Object.entries(previousTable.columns));
+			const currentColumns = new Map(Object.entries(table.columns));
+			changes.push(...this.diffValues(previousColumns, currentColumns, {
+				create: (column) => ({
+					kind: "createColumn",
+					table: name,
+					column
+				}),
+				update: (previous, column) => ({
+					kind: "updateColumn",
+					table: name,
+					before: previous,
+					after: column
+				}),
+				delete: (column) => ({
+					kind: "deleteColumn",
+					table: name,
+					column
+				})
+			}));
+			changes.push(...this.diffValues(previousDefinitions.constraints, currentDefinitions.constraints, {
+				create: (constraint) => ({
+					kind: "createConstraint",
+					table: name,
+					constraint
+				}),
+				delete: (constraint) => ({
+					kind: "deleteConstraint",
+					table: name,
+					constraint
+				})
+			}));
+			changes.push(...this.diffValues(previousDefinitions.indexes, currentDefinitions.indexes, {
+				create: (index) => ({
+					kind: "createIndex",
+					table: name,
+					index
+				}),
+				delete: (index) => ({
+					kind: "deleteIndex",
+					table: name,
+					index
+				})
+			}));
+		}
+		for (const [name, table] of previousTables) if (!currentTables.has(name)) changes.push({
+			kind: "deleteTable",
+			table
+		});
+		return changes;
+	}
+	diffValues(before, after, factory) {
+		const changes = new Array();
+		for (const [key, value] of before) if (!after.has(key)) changes.push(factory.delete(value));
+		for (const [key, value] of after) {
+			const previous = before.get(key);
+			if (previous === void 0) changes.push(factory.create(value));
+			else if (!this.equals(previous, value)) {
+				if (factory.update) changes.push(factory.update(previous, value));
+				else changes.push(factory.delete(previous), factory.create(value));
+			}
+		}
+		return changes;
+	}
+	splitDefinitions(definitions) {
+		const constraints = /* @__PURE__ */ new Map();
+		const indexes = /* @__PURE__ */ new Map();
+		for (const definition of definitions) if (definition.kind === "index" || definition.kind === "uniqueIndex") indexes.set(this.definitionFingerprint(definition), definition);
+		else constraints.set(this.definitionFingerprint(definition), definition);
+		return {
+			constraints,
+			indexes
+		};
+	}
+	definitionFingerprint(definition) {
+		if (definition.kind === "check") return `${definition.kind}:${definition.sql}:${JSON.stringify(definition.parameters)}`;
+		if (definition.kind === "foreignKey") return `${definition.kind}:${definition.columns.join(",")}:${definition.foreignTable}:${definition.foreignColumns.join(",")}:${definition.onDelete}:${definition.onUpdate}`;
+		return `${definition.kind}:${definition.columns.join(",")}`;
+	}
+	renderChange(change) {
+		switch (change.kind) {
+			case "createTable": return this.toCreateTableChange(change);
+			case "deleteTable": return this.toDeleteTableChange(change);
+			case "createColumn": return this.toCreateColumnChange(change);
+			case "updateColumn": return this.toUpdateColumnChange(change);
+			case "deleteColumn": return this.toDeleteColumnChange(change);
+			case "createConstraint": return this.toCreateConstraintChange(change);
+			case "deleteConstraint": return this.toDeleteConstraintChange(change);
+			case "createIndex": return this.toCreateIndexChange(change);
+			case "deleteIndex": return this.toDeleteIndexChange(change);
+		}
+	}
+	toCreateTableChange(change, name = change.table.name) {
+		const definitions = new Array();
+		for (const column of Object.values(change.table.columns)) {
+			definitions.push(...this.toCreateColumnChange({
+				kind: "createColumn",
+				table: change.table.name,
+				column
+			}, true));
+			for (const constraint of this.columnConstraints(column)) definitions.push(...this.toCreateConstraintChange({
+				kind: "createConstraint",
+				table: change.table.name,
+				constraint
+			}, true));
+		}
+		for (const definition of change.table.definitions) if (definition.kind !== "index" && definition.kind !== "uniqueIndex") definitions.push(...this.toCreateConstraintChange({
+			kind: "createConstraint",
+			table: change.table.name,
+			constraint: definition
+		}, true));
+		return [`CREATE TABLE ${this.quoteIdentifier(name)} (\n${definitions.map((definition) => `    ${definition}`).join(",\n")}\n);`];
+	}
+	toDeleteTableChange(change) {
+		return [`DROP TABLE ${this.quoteIdentifier(change.table.name)};`];
+	}
+	toCreateColumnChange(change, inline = false) {
+		const definition = `${this.quoteIdentifier(change.column.name)} ${change.column.type}${change.column.notNull ? " NOT NULL" : ""}`;
+		if (inline) return [definition];
+		const statements = [this.alterTable(change.table, `ADD COLUMN ${definition}`)];
+		for (const constraint of this.columnConstraints(change.column)) statements.push(...this.toCreateConstraintChange({
+			kind: "createConstraint",
+			table: change.table,
+			constraint
+		}));
+		return statements;
+	}
+	toUpdateColumnChange(change) {
+		const statements = new Array();
+		if (change.before.type !== change.after.type) statements.push(this.alterTable(change.table, `ALTER COLUMN ${this.quoteIdentifier(change.after.name)} TYPE ${change.after.type}`));
+		if (change.before.notNull !== change.after.notNull) statements.push(this.alterTable(change.table, `ALTER COLUMN ${this.quoteIdentifier(change.after.name)} ${change.after.notNull ? "SET" : "DROP"} NOT NULL`));
+		statements.push(...this.updateColumnConstraints(change.table, change.before, change.after));
+		return statements;
+	}
+	toDeleteColumnChange(change) {
+		const statements = new Array();
+		for (const constraint of this.columnConstraints(change.column)) statements.push(...this.toDeleteConstraintChange({
+			kind: "deleteConstraint",
+			table: change.table,
+			constraint
+		}));
+		statements.push(this.alterTable(change.table, `DROP COLUMN ${this.quoteIdentifier(change.column.name)}`));
+		return statements;
+	}
+	toCreateConstraintChange(change, inline = false) {
+		const constraint = change.constraint;
+		const name = this.quoteIdentifier(this.constraintName(change.table, constraint));
+		let definition;
+		if (constraint.kind === "check") {
+			let index = 0;
+			const sql = constraint.sql.replaceAll("?", () => {
+				if (index >= constraint.parameters.length) throw new Error("Check constraint parameter count does not match its SQL placeholders");
+				return this.serializeLiteral(constraint.parameters[index++]);
+			});
+			if (index !== constraint.parameters.length) throw new Error("Check constraint parameter count does not match its SQL placeholders");
+			definition = `CONSTRAINT ${name} CHECK (${sql})`;
+		} else {
+			const columns = this.quoteIdentifiers(constraint.columns);
+			if (constraint.kind === "primaryKey") definition = `CONSTRAINT ${name} PRIMARY KEY (${columns})`;
+			else if (constraint.kind === "unique") definition = `CONSTRAINT ${name} UNIQUE (${columns})`;
+			else {
+				let actions = "";
+				if (constraint.onDelete) actions += ` ON DELETE ${constraint.onDelete.toUpperCase()}`;
+				if (constraint.onUpdate) actions += ` ON UPDATE ${constraint.onUpdate.toUpperCase()}`;
+				definition = `CONSTRAINT ${name} FOREIGN KEY (${columns}) REFERENCES ${this.quoteIdentifier(constraint.foreignTable)} (${this.quoteIdentifiers(constraint.foreignColumns)})${actions}`;
+			}
+		}
+		return inline ? [definition] : [this.alterTable(change.table, `ADD ${definition}`)];
+	}
+	toDeleteConstraintChange(change) {
+		return [this.alterTable(change.table, `DROP CONSTRAINT ${this.quoteIdentifier(this.constraintName(change.table, change.constraint))}`)];
+	}
+	toCreateIndexChange(change) {
+		return [`CREATE ${change.index.kind === "uniqueIndex" ? "UNIQUE " : ""}INDEX ${this.quoteIdentifier(this.indexName(change.table, change.index))} ON ${this.quoteIdentifier(change.table)} (${this.quoteIdentifiers(change.index.columns)});`];
+	}
+	toDeleteIndexChange(change) {
+		return [`DROP INDEX ${this.quoteIdentifier(this.indexName(change.table, change.index))};`];
+	}
+	columnConstraints(column) {
+		const constraints = new Array();
+		if (column.primaryKey) constraints.push({
+			kind: "primaryKey",
+			columns: [column.name]
+		});
+		if (column.unique) constraints.push({
+			kind: "unique",
+			columns: [column.name]
+		});
+		if (column.references) constraints.push({
+			kind: "foreignKey",
+			columns: [column.name],
+			foreignTable: column.references.table,
+			foreignColumns: [column.references.column],
+			onDelete: column.references.onDelete,
+			onUpdate: column.references.onUpdate
+		});
+		return constraints;
+	}
+	updateColumnConstraints(table, before, after) {
+		const statements = new Array();
+		const beforeConstraints = new Map(this.columnConstraints(before).map((constraint) => [constraint.kind, constraint]));
+		const afterConstraints = new Map(this.columnConstraints(after).map((constraint) => [constraint.kind, constraint]));
+		for (const [kind, constraint] of beforeConstraints) {
+			const next = afterConstraints.get(kind);
+			if (!next || !this.equals(constraint, next)) statements.push(...this.toDeleteConstraintChange({
+				kind: "deleteConstraint",
+				table,
+				constraint
+			}));
+		}
+		for (const [kind, constraint] of afterConstraints) {
+			const previous = beforeConstraints.get(kind);
+			if (!previous || !this.equals(previous, constraint)) statements.push(...this.toCreateConstraintChange({
+				kind: "createConstraint",
+				table,
+				constraint
+			}));
+		}
+		return statements;
+	}
+	constraintName(table, constraint) {
+		if (constraint.kind === "check") return this.generatedName([
+			table,
+			this.hash(`${constraint.sql}:${JSON.stringify(constraint.parameters)}`),
+			"check"
+		]);
+		return this.generatedName([
+			table,
+			...constraint.columns,
+			constraint.kind
+		]);
+	}
+	indexName(table, index) {
+		return this.generatedName([
+			table,
+			...index.columns,
+			index.kind
+		]);
+	}
+	generatedName(parts) {
+		const value = parts.join("_").replaceAll(/[^a-zA-Z0-9_]/g, "_");
+		return value.length <= 54 ? value : `${value.slice(0, 45)}_${this.hash(value)}`;
+	}
+	hash(value) {
+		let result = 2166136261;
+		for (const character of value) {
+			result ^= character.charCodeAt(0);
+			result = Math.imul(result, 16777619);
+		}
+		return (result >>> 0).toString(16).padStart(8, "0");
+	}
+	quoteIdentifiers(values) {
+		return values.map((value) => this.quoteIdentifier(value)).join(", ");
+	}
+	alterTable(table, value) {
+		return `ALTER TABLE ${this.quoteIdentifier(table)} ${value};`;
+	}
+	equals(left, right) {
+		return JSON.stringify(left) === JSON.stringify(right);
+	}
+	serializeLiteral(value) {
+		if (value === null) return "NULL";
+		if (typeof value === "number") {
+			if (!Number.isFinite(value)) throw new Error("Unable to serialize non-finite check constraint number");
+			return String(value);
+		}
+		if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+		return `'${value.replaceAll("'", "''")}'`;
+	}
+};
+var Database = class {
+	$schema;
+	$session;
+	get $dialect() {
+		return this.$migration.$dialect;
+	}
+	constructor(session, schema) {
+		this.$session = session;
+		this.$schema = schema;
+	}
+	toMeta() {
+		return {
+			dialect: this.$dialect,
+			tables: Object.values(this.$schema).map((table) => table.toMeta())
+		};
+	}
+};
+var Table = class {
+	$name;
+	$columns;
+	$definitions;
+	constructor(name, columns, definitions) {
+		this.$name = name;
+		this.$columns = columns;
+		this.$definitions = definitions;
+		for (const column of Object.values(columns)) column.$table = this;
+	}
+	toMeta() {
+		return {
+			name: this.$name,
+			columns: Object.fromEntries(Object.values(this.$columns).map((column) => [column.$name, column.toMeta()])),
+			definitions: this.$definitions.map((definition) => definition.toMeta())
+		};
+	}
+	toSql() {
+		return new Sql(`"${this.$name}"`);
+	}
+};
+var Column = class {
+	$name;
+	$table;
+	$notNull;
+	$primaryKey;
+	$unique;
+	$defaultValue;
+	$references;
+	$onDelete;
+	$onUpdate;
+	constructor(name) {
+		this.$name = name;
+		this.$notNull = false;
+		this.$primaryKey = false;
+		this.$unique = false;
+	}
+	default(defaultValue) {
+		this.$defaultValue = defaultValue;
+		return this;
+	}
+	notNull() {
+		this.$notNull = true;
+		return this;
+	}
+	unique() {
+		this.$unique = true;
+		return this;
+	}
+	primaryKey() {
+		this.$primaryKey = true;
+		return this;
+	}
+	references(references, actions) {
+		this.$references = references;
+		this.$onDelete = actions?.onDelete;
+		this.$onUpdate = actions?.onUpdate;
+		return this;
+	}
+	fromDriverValue(value) {
+		return value;
+	}
+	toDriverValue(value) {
+		return value;
+	}
+	toSql() {
+		return this.$table ? new Sql(this.$table, ".", this.toSqlName()) : this.toSqlName();
+	}
+	toSqlName() {
+		return new Sql(`"${this.$name}"`);
+	}
+	toMeta() {
+		const foreignColumn = this.$references?.();
+		if (foreignColumn && !foreignColumn.$table) throw new Error(`Referenced column "${foreignColumn.$name}" does not belong to a table`);
+		return {
+			name: this.$name,
+			type: this.toSqlType(),
+			notNull: this.$notNull,
+			primaryKey: this.$primaryKey,
+			unique: this.$unique,
+			references: foreignColumn ? {
+				table: foreignColumn.$table.$name,
+				column: foreignColumn.$name,
+				onDelete: this.$onDelete,
+				onUpdate: this.$onUpdate
+			} : void 0
+		};
+	}
+};
+var UniqueConstraint = class {
+	$columns;
+	constructor(...columns) {
+		this.$columns = columns;
+	}
+	on(...columns) {
+		this.$columns = columns;
+		return this;
+	}
+	toMeta() {
+		return {
+			kind: "unique",
+			columns: this.$columns.map((column) => column.$name)
+		};
+	}
+};
+var CheckConstraint = class {
+	$value;
+	$query;
+	constructor(value) {
+		this.$value = value;
+		this.$query = value.toQuery();
+	}
+	toMeta() {
+		return {
+			kind: "check",
+			sql: this.$query.sql,
+			parameters: this.$query.parameters.map((parameter) => {
+				if (typeof parameter === "bigint") return parameter.toString();
+				if (typeof parameter === "symbol") throw new Error("Unable to serialize symbol parameters");
+				return parameter ?? null;
+			})
+		};
+	}
+};
+var PrimaryKeyConstraint = class {
+	$columns;
+	constructor(...columns) {
+		this.$columns = columns;
+	}
+	toMeta() {
+		return {
+			kind: "primaryKey",
+			columns: this.$columns.map((column) => column.$name)
+		};
+	}
+};
+var ForeignKeyConstraint = class {
+	$columns;
+	$foreignColumns;
+	constructor(columns, foreignColumns) {
+		this.$columns = columns;
+		this.$foreignColumns = foreignColumns;
+	}
+	toMeta() {
+		const foreignTables = new Set(this.$foreignColumns.map((column) => column.$table?.$name));
+		if (foreignTables.size !== 1 || foreignTables.has(void 0)) throw new Error("Foreign key columns must belong to the same table");
+		return {
+			kind: "foreignKey",
+			columns: this.$columns.map((column) => column.$name),
+			foreignTable: [...foreignTables][0],
+			foreignColumns: this.$foreignColumns.map((column) => column.$name)
+		};
+	}
+};
+var Index = class {
+	$columns;
+	constructor(...columns) {
+		this.$columns = columns;
+	}
+	on(...columns) {
+		this.$columns = columns;
+		return this;
+	}
+	toMeta() {
+		return {
+			kind: "index",
+			columns: this.$columns.map((column) => column.$name)
+		};
+	}
+};
+var UniqueIndex = class {
+	$columns;
+	constructor(...columns) {
+		this.$columns = columns;
+	}
+	on(...columns) {
+		this.$columns = columns;
+		return this;
+	}
+	toMeta() {
+		return {
+			kind: "uniqueIndex",
+			columns: this.$columns.map((column) => column.$name)
+		};
+	}
+};
+function toParameter(column, value) {
+	if (value instanceof Parameter || value instanceof Sql || value instanceof Table || value instanceof Column) return value;
+	return new Parameter(column.toDriverValue(value));
+}
+function combine(chunks, separator) {
+	const result = [];
+	chunks.forEach((chunk, index) => {
+		if (index > 0) result.push(separator);
+		result.push(chunk);
+	});
+	return new Sql(...result);
+}
+function sql(tokens, ...values) {
+	const chunks = [tokens[0]];
+	values.forEach((value, index) => {
+		chunks.push(value === void 0 ? null : value, tokens[index + 1]);
+	});
+	return new Sql(...chunks);
+}
+function equals(column, right) {
+	return sql`${column} = ${toParameter(column, right)}`;
+}
+function greater(column, right) {
+	return sql`${column} > ${toParameter(column, right)}`;
+}
+function greaterEquals(column, right) {
+	return sql`${column} >= ${toParameter(column, right)}`;
+}
+function lower(column, right) {
+	return sql`${column} < ${toParameter(column, right)}`;
+}
+function lowerEquals(column, right) {
+	return sql`${column} <= ${toParameter(column, right)}`;
+}
+function like(column, right) {
+	return sql`${column} LIKE ${toParameter(column, right)}`;
+}
+function contains(column, values) {
+	return sql`${column} IN (${combine(values.map((value) => toParameter(column, value)), ", ")})`;
+}
+function nullish(chunk) {
+	return sql`${chunk} IS NULL`;
+}
+function not(chunk) {
+	return sql`NOT ${chunk}`;
+}
+function exists(chunk) {
+	return sql`EXISTS (${chunk})`;
+}
+function between(column, from, to) {
+	return sql`${column} BETWEEN ${toParameter(column, from)} AND ${toParameter(column, to)}`;
+}
+function and(...chunks) {
+	return sql`(${combine(chunks, " AND ")})`;
+}
+function or(...chunks) {
+	return sql`(${combine(chunks, " OR ")})`;
+}
+function asc(chunk) {
+	return sql`${chunk} ASC`;
+}
+function desc(chunk) {
+	return sql`${chunk} DESC`;
+}
+function useStorage(scope, scopeName) {
+	const storages = getContext(scope, STORAGE_CONTEXT);
+	const storage = storages[scopeName] ?? {};
+	storages[scopeName] = storage;
+	setContext(scope, STORAGE_CONTEXT, storages);
+	return storage;
+}
+var STORAGE_CONTEXT = defineContext("STORAGE_CONTEXT");
+//#endregion
+export { CheckConstraint, Column, Database, DeleteStatement, ForeignKeyConstraint, Index, InsertStatement, Migration, Parameter, PreparedQuery, PrimaryKeyConstraint, STORAGE_CONTEXT, SelectStatement, Session, Sql, Statement, Table, UniqueConstraint, UniqueIndex, UpdateStatement, and, asc, between, combine, contains, desc, equals, exists, greater, greaterEquals, like, lower, lowerEquals, not, nullish, or, sql, toParameter, useStorage };