@revojs/storage 0.2.8 → 0.2.9

package/dist/commands/generate.d.ts

@@ -2,6 +2,7 @@ declare const _default: import("revojs/module").Command<{
     readonly directory: {
         readonly type: "string";
         readonly short: "d";
+        readonly default: "migrations";
         readonly description: "Migration output directory";
     };
 }>;

package/dist/commands/generate.js

@@ -1,45 +1,63 @@
-import { VARIABLE_CONTEXT } from "revojs";
-import storage from "#storage";
+import { STORAGE_CONTEXT } from "../index.js";
+import { getContext } from "revojs";
 import { defineCommand } from "revojs/module";
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
 import { join, resolve } from "path";
-import { loadEnv } from "vite";
 //#region src/commands/generate.ts
 var generate_default = defineCommand({
 	description: "Generate migration files from the storage schema",
 	arguments: { directory: {
 		type: "string",
 		short: "d",
+		default: "migrations",
 		description: "Migration output directory"
 	} },
-	async run({ arguments: { directory: output = "migrations" }, environment }) {
-		const databases = Object.values(storage).flatMap((source) => Object.entries(source));
+	async run(scope, context) {
+		const databases = new Array();
+		const names = /* @__PURE__ */ new Set();
+		for (const files of Object.values(getContext(scope, STORAGE_CONTEXT))) for (const [name, database] of Object.entries(files)) {
+			if (names.has(name)) throw new Error("Migration database names must be unique across storage scopes.");
+			names.add(name);
+			databases.push({
+				name,
+				database
+			});
+		}
 		if (databases.length === 0) {
 			console.log("No storage databases found.");
 			return;
 		}
-		const scope = {
-			hooks: {},
-			context: { [VARIABLE_CONTEXT]: loadEnv(environment.config.mode, environment.config.envDir, "") }
-		};
-		for (const [name, load] of databases) {
-			const database = (await load())(scope);
+		for (const { name, database } of databases) {
 			const current = database.toMeta();
-			const directory = resolve(output, name);
-			const snapshot = (existsSync(directory) ? readdirSync(directory) : []).sort().reverse().map((entry) => join(directory, entry, "meta.json")).find((path) => existsSync(path));
+			const directory = resolve(context.arguments.directory, name);
+			let snapshot;
+			if (existsSync(directory)) {
+				const entries = readdirSync(directory).sort();
+				for (let index = entries.length - 1; index >= 0; index--) {
+					const path = join(directory, entries[index], "meta.json");
+					if (existsSync(path)) {
+						snapshot = path;
+						break;
+					}
+				}
+			}
 			const changes = database.$migration.diff(snapshot ? JSON.parse(readFileSync(snapshot, "utf8")) : void 0, current);
 			if (changes.length === 0) {
 				console.log(`No schema changes detected for "${name}".`);
 				continue;
 			}
+			const statements = database.$migration.toSql(changes, current);
+			if (statements.length === 0) {
+				console.log(`No SQL schema changes detected for "${name}".`);
+				continue;
+			}
 			const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/\D/g, "").slice(0, 14);
 			let order = timestamp;
 			for (let index = 2; existsSync(join(directory, order)); index++) order = `${timestamp}-${index}`;
 			const target = join(directory, order);
-			const statements = database.$migration.toSql(changes, current);
 			mkdirSync(target, { recursive: true });
 			writeFileSync(join(target, "meta.json"), `${JSON.stringify(current, null, 4)}\n`);
-			writeFileSync(join(target, "migration.sql"), statements.length ? `${statements.join("\n\n")}\n` : "");
+			writeFileSync(join(target, "migration.sql"), `${statements.join("\n\n")}\n`);
 			console.log(`Created migration "${name}/${order}" with ${changes.length} change(s).`);
 		}
 	}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { type Scope, type Source, type SourceScope, type SourceValue } from "revojs";
-import type { Primitive } from "revojs/shared";
+import { type Resolvable, type Scope, type Source, type SourceScope, type SourceValue } from "revojs";
+import type { Awaitable, Primitive } from "revojs/shared";
 export type DefaultValue<T> = undefined | T | (() => T);
 export type References = undefined | (() => Column);
 export type ReferentialAction = "cascade" | "restrict" | "no action" | "set null" | "set default";
@@ -165,6 +165,7 @@ export declare abstract class Statement<T = unknown> extends Sql<T> {
     protected $session: Session;
     protected $fields: Array<[string, Column]>;
     constructor(session: Session, value: Table | Record<string, Column>, ...chunks: Array<Chunk>);
+    run(): unknown;
     then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
     protected mapRow(row: Array<unknown>): Record<string, unknown>;
 }
@@ -176,6 +177,8 @@ export declare class SelectStatement<TSelection = Table | Record<string, Column>
         table: Table;
         nullable: boolean;
     }[];
+    protected $limit: Sql | undefined;
+    protected $offset: Sql | undefined;
     constructor(session: Session, value: TSelection);
     from(table: Table): this & Record<"from", never>;
     leftJoin<TTable extends Table>(table: TTable, on: Chunk): SelectStatement<AppendToSelection<TSelection, TTable, TMode>, TMode extends "partial" ? "partial" : "multiple", AppendToNullabilityMap<TNullability, TTable, "left">>;
@@ -187,6 +190,7 @@ export declare class SelectStatement<TSelection = Table | Record<string, Column>
     having(chunk: Chunk): this & Record<"having", never>;
     orderBy(...chunks: Array<Chunk>): this & Record<"orderBy", never>;
     limit(count: number): this & Record<"limit", never>;
+    first(): Promise<SelectResult<TSelection, TMode, TNullability> | undefined>;
     offset(count: number): this & Record<"offset", never>;
     protected mapRow(row: Array<unknown>): Record<string, unknown>;
 }
@@ -220,6 +224,7 @@ export declare abstract class PreparedQuery {
     abstract values(parameters: Array<Primitive>): unknown;
 }
 export declare abstract class Session {
+    transaction<T>(run: (session: Session) => Awaitable<T>): Promise<T>;
     run(query: Query): unknown;
     all(query: Query): unknown;
     get(query: Query): unknown;
@@ -270,14 +275,17 @@ export declare abstract class Database<T extends Record<string, Table> = Record<
     abstract insert<TValue extends Table>(table: TValue): InsertStatement<TValue>;
     abstract update<TValue extends Table>(table: TValue): UpdateStatement<TValue>;
     abstract delete<TValue extends Table>(table: TValue): DeleteStatement<TValue>;
+    abstract transaction<TResult>(run: (database: Database<T>) => Awaitable<TResult>): Promise<TResult>;
 }
 export declare abstract class Table<TName extends string = string, TColumns extends Record<string, Column> = Record<string, Column>> {
     readonly $name: TName;
     readonly $columns: TColumns;
     readonly $definitions: Array<Definition>;
+    readonly $base: Table | undefined;
     constructor(name: TName, columns: TColumns, definitions: Array<Definition>);
     toMeta(): TableMeta;
     toSql(): Sql<unknown>;
+    hasReference(reference: Table): boolean;
 }
 export declare abstract class Column<TDataType = unknown> {
     $name: string;
@@ -322,7 +330,11 @@ export declare class PrimaryKeyConstraint {
 export declare class ForeignKeyConstraint {
     $columns: Array<Column>;
     $foreignColumns: Array<Column>;
+    $onDelete: ReferentialAction | undefined;
+    $onUpdate: ReferentialAction | undefined;
     constructor(columns: Array<Column>, foreignColumns: Array<Column>);
+    onDelete(action: ReferentialAction): this;
+    onUpdate(action: ReferentialAction): this;
     toMeta(): ForeignKeyConstraintMeta;
 }
 export declare class Index {
@@ -355,6 +367,11 @@ export declare function and<T>(...chunks: Array<Chunk>): Sql<T>;
 export declare function or<T>(...chunks: Array<Chunk>): Sql<T>;
 export declare function asc<T>(chunk: Chunk): Sql<T>;
 export declare function desc<T>(chunk: Chunk): Sql<T>;
-export declare function useStorage<TSource extends Source<(scope: Scope) => Database> = typeof import("#storage").default, TScope extends SourceScope<TSource> = SourceScope<TSource>>(scope: Scope, scopeName: TScope): { [TKey in SourceValue<TSource, TScope>]: ReturnType<Awaited<ReturnType<TSource[TScope][TKey]>>>; };
+export declare function mergeTable<TTable extends Table, TColumns extends Record<string, Column>>(table: TTable, columns: TColumns, definitions?: (columns: TTable["$columns"] & TColumns) => Array<Definition>): TTable & TColumns & {
+    readonly $columns: TTable["$columns"] & TColumns;
+};
+export declare function useReferenceStorage<TSchema extends Record<string, Table>>(scope: Scope, references: TSchema): Database<TSchema>;
+export declare function useStorageProvider<TProvider>(scope: Scope, providers: ReadonlyArray<TProvider>, getReferences: (provider: TProvider) => Record<string, Table>): TProvider;
+export declare function useStorage<TSource extends Source<Resolvable<Awaitable<Database>>> = typeof import("#storage").default, TScope extends SourceScope<TSource> = SourceScope<TSource>>(scope: Scope, scopeName: TScope): { [TKey in SourceValue<TSource, TScope>]: Awaited<ReturnType<Awaited<ReturnType<TSource[TScope][TKey]>>>>; };
 export declare const STORAGE_CONTEXT: import("revojs").Descriptor<Record<string, Record<string, Database<Record<string, Table<string, Record<string, Column<unknown>>>>>>>>;
 export {};

package/dist/index.js

@@ -51,6 +51,9 @@ var Statement = class extends Sql {
 		this.$session = session;
 		this.$fields = Object.entries(value instanceof Table ? value.$columns : value);
 	}
+	run() {
+		return this.$session.run(this.toQuery());
+	}
 	async then(onfulfilled, onrejected) {
 		let value;
 		try {
@@ -75,6 +78,8 @@ var SelectStatement = class extends Statement {
 	$selection;
 	$baseNullable = false;
 	$joins = new Array();
+	$limit;
+	$offset;
 	constructor(session, value) {
 		super(session, value);
 		this.$value = value;
@@ -148,11 +153,18 @@ var SelectStatement = class extends Statement {
 		return this;
 	}
 	limit(count) {
-		this.push(sql`LIMIT ${new Parameter(count)}`);
+		this.$limit = sql`LIMIT ${new Parameter(count)}`;
+		this.push(this.$limit);
 		return this;
 	}
+	async first() {
+		const query = this.$limit ? this.toQuery() : new Sql(...this.$chunks.filter((chunk) => chunk !== this.$offset)).push(sql`LIMIT ${new Parameter(1)}`, ...this.$offset ? [this.$offset] : []).toQuery();
+		const row = await this.$session.get(query);
+		return row ? this.mapRow(row) : void 0;
+	}
 	offset(count) {
-		this.push(sql`OFFSET ${new Parameter(count)}`);
+		this.$offset = sql`OFFSET ${new Parameter(count)}`;
+		this.push(this.$offset);
 		return this;
 	}
 	mapRow(row) {
@@ -248,6 +260,9 @@ var PreparedQuery = class {
 	}
 };
 var Session = class {
+	async transaction(run) {
+		throw new Error("This storage provider does not support interactive transactions.");
+	}
 	run(query) {
 		return this.prepareQuery(query).run(query.parameters);
 	}
@@ -387,18 +402,16 @@ var Migration = class {
 	}
 	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 column of Object.values(change.table.columns)) definitions.push(...this.toCreateColumnChange({
+			kind: "createColumn",
+			table: change.table.name,
+			column
+		}, true));
+		for (const column of Object.values(change.table.columns)) 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,
@@ -584,6 +597,7 @@ var Table = class {
 	$name;
 	$columns;
 	$definitions;
+	$base;
 	constructor(name, columns, definitions) {
 		this.$name = name;
 		this.$columns = columns;
@@ -600,6 +614,15 @@ var Table = class {
 	toSql() {
 		return new Sql(`"${this.$name}"`);
 	}
+	hasReference(reference) {
+		if (this === reference) return true;
+		let table = this.$base;
+		while (table) {
+			if (table === reference) return true;
+			table = table.$base;
+		}
+		return false;
+	}
 };
 var Column = class {
 	$name;
@@ -719,10 +742,20 @@ var PrimaryKeyConstraint = class {
 var ForeignKeyConstraint = class {
 	$columns;
 	$foreignColumns;
+	$onDelete;
+	$onUpdate;
 	constructor(columns, foreignColumns) {
 		this.$columns = columns;
 		this.$foreignColumns = foreignColumns;
 	}
+	onDelete(action) {
+		this.$onDelete = action;
+		return this;
+	}
+	onUpdate(action) {
+		this.$onUpdate = action;
+		return this;
+	}
 	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");
@@ -730,7 +763,9 @@ var ForeignKeyConstraint = class {
 			kind: "foreignKey",
 			columns: this.$columns.map((column) => column.$name),
 			foreignTable: [...foreignTables][0],
-			foreignColumns: this.$foreignColumns.map((column) => column.$name)
+			foreignColumns: this.$foreignColumns.map((column) => column.$name),
+			onDelete: this.$onDelete,
+			onUpdate: this.$onUpdate
 		};
 	}
 };
@@ -830,6 +865,64 @@ function asc(chunk) {
 function desc(chunk) {
 	return sql`${chunk} DESC`;
 }
+function mergeTable(table, columns, definitions) {
+	const mergedColumns = {};
+	const names = /* @__PURE__ */ new Set();
+	for (const [key, column] of Object.entries(table.$columns)) {
+		mergedColumns[key] = Object.assign(Object.create(Object.getPrototypeOf(column)), column);
+		names.add(column.$name);
+	}
+	for (const [key, column] of Object.entries(columns)) {
+		if (key in table) throw new Error(`Cannot replace table field "${key}" when extending "${table.$name}".`);
+		if (names.has(column.$name)) throw new Error(`Duplicate SQL column "${column.$name}" when extending "${table.$name}".`);
+		mergedColumns[key] = Object.assign(Object.create(Object.getPrototypeOf(column)), column);
+		names.add(column.$name);
+	}
+	const merged = Object.create(Object.getPrototypeOf(table));
+	Object.assign(merged, table, mergedColumns, {
+		$base: table,
+		$columns: mergedColumns,
+		$definitions: [...table.$definitions]
+	});
+	for (const column of Object.values(mergedColumns)) column.$table = merged;
+	if (definitions) merged.$definitions.push(...definitions(merged.$columns));
+	return merged;
+}
+function useReferenceStorage(scope, references) {
+	const tables = Object.values(references);
+	if (tables.length === 0) throw new Error("Expected at least one table reference.");
+	const databases = new Array();
+	for (const files of Object.values(getContext(scope, STORAGE_CONTEXT))) for (const database of Object.values(files)) {
+		let matches = true;
+		for (const reference of tables) {
+			let found = false;
+			for (const table of Object.values(database.$schema)) if (table.hasReference(reference)) {
+				found = true;
+				break;
+			}
+			if (!found) {
+				matches = false;
+				break;
+			}
+		}
+		if (matches) databases.push(database);
+	}
+	if (databases.length !== 1) throw new Error(`Expected one initialized storage containing tables ${tables.map((table) => `"${table.$name}"`).join(", ")}, found ${databases.length}.`);
+	for (const [key, table] of Object.entries(references)) if (!databases[0].$schema[key]?.hasReference(table)) throw new Error(`Storage schema key "${key}" does not contain the supplied table reference.`);
+	return databases[0];
+}
+function useStorageProvider(scope, providers, getReferences) {
+	const databases = Object.values(getContext(scope, STORAGE_CONTEXT)).flatMap((files) => Object.values(files));
+	const matches = new Array();
+	for (const provider of providers) {
+		const tables = Object.values(getReferences(provider));
+		if (tables.length === 0) throw new Error("Expected at least one table reference.");
+		for (const database of databases) if (tables.every((reference) => Object.values(database.$schema).some((table) => table.hasReference(reference)))) matches.push(provider);
+	}
+	if (matches.length !== 1) throw new Error(`Expected one initialized storage matching a provider, found ${matches.length}.`);
+	useReferenceStorage(scope, getReferences(matches[0]));
+	return matches[0];
+}
 function useStorage(scope, scopeName) {
 	const storages = getContext(scope, STORAGE_CONTEXT);
 	const storage = storages[scopeName] ?? {};
@@ -839,4 +932,4 @@ function useStorage(scope, scopeName) {
 }
 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 };
+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, mergeTable, not, nullish, or, sql, toParameter, useReferenceStorage, useStorage, useStorageProvider };

package/dist/module/index.d.ts

@@ -1,3 +1,14 @@
-export type StorageConfig = Record<string, never>;
-declare const _default: import("revojs/module").Module<"storage", StorageConfig, []>;
+declare const _default: import("revojs/module").Module<"storage", {
+    storage: {
+        match: ("!**/*.d.ts" | "**/*.js" | "**/*.ts")[];
+        from: "./storage"[];
+        format: "object";
+    };
+    plugins: {
+        from: string[];
+    };
+    commands: {
+        from: string[];
+    };
+}, []>;
 export default _default;

package/dist/module/index.js

@@ -2,12 +2,15 @@ import { defineModule, useModule } from "revojs/module";
 //#region src/module/index.ts
 var module_default = defineModule({
 	name: "storage",
-	config: () => ({}),
 	setup() {
 		const { fromModule } = useModule(import.meta.url);
 		return { sources: {
 			storage: {
-				match: ["**/*.js", "**/*.ts"],
+				match: [
+					"**/*.js",
+					"**/*.ts",
+					"!**/*.d.ts"
+				],
 				from: ["./storage"],
 				format: "object"
 			},

package/dist/plugins/index.js

@@ -1,15 +1,20 @@
 import { STORAGE_CONTEXT } from "../index.js";
 import { definePlugin, getContext, setContext } from "revojs";
-import storage from "#storage";
+import { isServer } from "#variables";
 //#region src/plugins/index.ts
 var plugins_default = definePlugin({ async setup(scope) {
-	const storages = getContext(scope, STORAGE_CONTEXT);
-	for (const [scopeName, files] of Object.entries(storage)) {
-		const databases = storages[scopeName] ?? {};
-		for (const [key, resolve] of Object.entries(files)) databases[key] = (await resolve())(scope);
-		storages[scopeName] = databases;
+	if (isServer) {
+		const databases = getContext(scope, STORAGE_CONTEXT);
+		for (const [scopeName, files] of Object.entries((await import("#storage")).default)) {
+			const entries = databases[scopeName] ?? {};
+			for (const [name, resolve] of Object.entries(files)) {
+				if (entries[name]) continue;
+				entries[name] = await (await resolve())(scope);
+			}
+			databases[scopeName] = entries;
+		}
+		setContext(scope, STORAGE_CONTEXT, databases);
 	}
-	setContext(scope, STORAGE_CONTEXT, storages);
 } });
 //#endregion
 export { plugins_default as default };

package/dist/protocols/mysql.d.ts

@@ -1,4 +1,5 @@
-import { CheckConstraint, Column, Database, DeleteStatement, ForeignKeyConstraint, Index, InsertStatement, Migration, PrimaryKeyConstraint, SelectStatement, Table, UniqueConstraint, UniqueIndex, UpdateStatement, type Definition, type DeleteConstraintChange, type DeleteIndexChange, type Session, type Sql, type UpdateColumnChange } from "../index";
+import type { Awaitable } from "revojs/shared";
+import { CheckConstraint, Column, Database, DeleteStatement, ForeignKeyConstraint, Index, InsertStatement, Migration, PrimaryKeyConstraint, SelectStatement, Sql, Table, UniqueConstraint, UniqueIndex, UpdateStatement, type Definition, type DeleteConstraintChange, type DeleteIndexChange, type Session, type UpdateColumnChange } from "../index";
 export interface CharOptions {
     length?: number;
 }
@@ -12,6 +13,7 @@ export interface VarcharOptions {
 export declare abstract class MysqlColumn<TDataType = unknown> extends Column<TDataType> {
     autoincrement<This extends MysqlColumn>(this: This): This & Record<"autoincrement", never>;
     type<TData>(): this & Record<"$type", TData>;
+    toSqlName(): Sql<unknown>;
 }
 export declare class BigintColumn extends MysqlColumn<bigint> {
     toSqlType(): string;
@@ -31,6 +33,8 @@ export declare class DateColumn extends MysqlColumn<Date> {
     toSqlType(): string;
 }
 export declare class DatetimeColumn extends MysqlColumn<Date> {
+    fromDriverValue(value: unknown): Date;
+    toDriverValue(value: Date): string;
     toSqlType(): string;
 }
 export declare class DecimalColumn extends MysqlColumn<string> {
@@ -124,6 +128,7 @@ export declare class MysqlUpdateStatement<T extends Table> extends UpdateStateme
 export declare class MysqlDeleteStatement<T extends Table> extends DeleteStatement<T> {
 }
 export declare class MysqlTable<TName extends string = string, TColumns extends Record<string, MysqlColumn> = Record<string, MysqlColumn>> extends Table<TName, TColumns> {
+    toSql(): Sql<unknown>;
 }
 export declare class MysqlMigration extends Migration {
     readonly $dialect = "mysql";
@@ -139,6 +144,7 @@ export declare class MysqlDatabase<T extends Record<string, MysqlTable>> extends
     insert<T extends Table>(table: T): MysqlInsertStatement<T>;
     update<T extends Table>(table: T): MysqlUpdateStatement<T>;
     delete<T extends Table>(table: T): MysqlDeleteStatement<T>;
+    transaction<TResult>(run: (database: MysqlDatabase<T>) => Awaitable<TResult>): Promise<TResult>;
 }
 export declare function bigint(name: string): BigintColumn;
 export declare function binary(name: string): BinaryColumn;

package/dist/protocols/mysql.js

@@ -1,4 +1,4 @@
-import { CheckConstraint, Column, Database, DeleteStatement, ForeignKeyConstraint, Index, InsertStatement, Migration, PrimaryKeyConstraint, SelectStatement, Table, UniqueConstraint, UniqueIndex, UpdateStatement } from "../index.js";
+import { CheckConstraint, Column, Database, DeleteStatement, ForeignKeyConstraint, Index, InsertStatement, Migration, PrimaryKeyConstraint, SelectStatement, Sql, Table, UniqueConstraint, UniqueIndex, UpdateStatement } from "../index.js";
 //#region src/protocols/mysql.ts
 var MysqlColumn = class extends Column {
 	autoincrement() {
@@ -7,6 +7,9 @@ var MysqlColumn = class extends Column {
 	type() {
 		return this;
 	}
+	toSqlName() {
+		return new Sql(`\`${this.$name.replaceAll("`", "``")}\``);
+	}
 };
 var BigintColumn = class extends MysqlColumn {
 	toSqlType() {
@@ -39,6 +42,12 @@ var DateColumn = class extends MysqlColumn {
 	}
 };
 var DatetimeColumn = class extends MysqlColumn {
+	fromDriverValue(value) {
+		return value instanceof Date ? value : new Date(String(value).replace(/^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2}(?:\.\d+)?)$/, "$1T$2Z"));
+	}
+	toDriverValue(value) {
+		return value.toISOString().slice(0, 19).replace("T", " ");
+	}
 	toSqlType() {
 		return "datetime";
 	}
@@ -183,7 +192,11 @@ var MysqlSelectStatement = class extends SelectStatement {};
 var MysqlInsertStatement = class extends InsertStatement {};
 var MysqlUpdateStatement = class extends UpdateStatement {};
 var MysqlDeleteStatement = class extends DeleteStatement {};
-var MysqlTable = class extends Table {};
+var MysqlTable = class extends Table {
+	toSql() {
+		return new Sql(`\`${this.$name.replaceAll("`", "``")}\``);
+	}
+};
 var MysqlMigration = class extends Migration {
 	$dialect = "mysql";
 	toUpdateColumnChange(change) {
@@ -205,7 +218,7 @@ var MysqlMigration = class extends Migration {
 		return `\`${value.replaceAll("`", "``")}\``;
 	}
 };
-var MysqlDatabase = class extends Database {
+var MysqlDatabase = class MysqlDatabase extends Database {
 	$migration;
 	constructor(session, schema) {
 		super(session, schema);
@@ -223,6 +236,9 @@ var MysqlDatabase = class extends Database {
 	delete(table) {
 		return new MysqlDeleteStatement(this.$session, table);
 	}
+	transaction(run) {
+		return this.$session.transaction((session) => run(new MysqlDatabase(session, this.$schema)));
+	}
 };
 function bigint(name) {
 	return new BigintColumn(name);

package/dist/protocols/postgresql.d.ts

@@ -1,3 +1,4 @@
+import type { Awaitable } from "revojs/shared";
 import { CheckConstraint, Column, Database, DeleteStatement, ForeignKeyConstraint, Index, InsertStatement, Migration, PrimaryKeyConstraint, SelectStatement, Table, UniqueConstraint, UniqueIndex, UpdateStatement, type AppendToNullabilityMap, type AppendToSelection, type Definition, type SelectMode, type Session, type Sql } from "../index";
 export type TimestampMode = "date" | "string";
 export interface CharOptions {
@@ -111,6 +112,8 @@ export declare class TimeColumn extends PostgresqlColumn<string> {
 export declare class TimestampColumn extends PostgresqlColumn<Date> {
     protected $options: TimestampOptions | undefined;
     constructor(name: string, options?: TimestampOptions);
+    fromDriverValue(value: unknown): Date;
+    toDriverValue(value: Date): string;
     toSqlType(): string;
 }
 export declare class UuidColumn extends PostgresqlColumn<string> {
@@ -166,6 +169,7 @@ export declare class PostgresqlDatabase<T extends Record<string, PostgresqlTable
     insert<T extends Table>(table: T): PostgresqlInsertStatement<T>;
     update<T extends Table>(table: T): PostgresqlUpdateStatement<T>;
     delete<T extends Table>(table: T): PostgresqlDeleteStatement<T>;
+    transaction<TResult>(run: (database: PostgresqlDatabase<T>) => Awaitable<TResult>): Promise<TResult>;
 }
 export declare function bigint(name: string): BigintColumn;
 export declare function bigserial(name: string): BigserialColumn;

package/dist/protocols/postgresql.js

@@ -159,6 +159,12 @@ var TimestampColumn = class extends PostgresqlColumn {
 		super(name);
 		this.$options = options;
 	}
+	fromDriverValue(value) {
+		return value instanceof Date ? value : new Date(String(value).replace(/^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2}(?:\.\d+)?)$/, "$1T$2Z"));
+	}
+	toDriverValue(value) {
+		return value.toISOString().replace("T", " ").replace("Z", "");
+	}
 	toSqlType() {
 		return this.$options?.precision === void 0 ? "timestamp" : `timestamp(${this.$options.precision})`;
 	}
@@ -245,7 +251,7 @@ var PostgresqlMigration = class extends Migration {
 		return `"${value.replaceAll("\"", "\"\"")}"`;
 	}
 };
-var PostgresqlDatabase = class extends Database {
+var PostgresqlDatabase = class PostgresqlDatabase extends Database {
 	$migration;
 	constructor(session, schema) {
 		super(session, schema);
@@ -263,6 +269,9 @@ var PostgresqlDatabase = class extends Database {
 	delete(table) {
 		return new PostgresqlDeleteStatement(this.$session, table);
 	}
+	transaction(run) {
+		return this.$session.transaction((session) => run(new PostgresqlDatabase(session, this.$schema)));
+	}
 };
 function bigint(name) {
 	return new BigintColumn(name);

package/dist/protocols/sqlite.d.ts

@@ -1,4 +1,4 @@
-import type { Primitive } from "revojs/shared";
+import type { Awaitable, Primitive } from "revojs/shared";
 import { CheckConstraint, Column, Database, DeleteStatement, ForeignKeyConstraint, Index, InsertStatement, Migration, PrimaryKeyConstraint, SelectStatement, Table, UniqueConstraint, UniqueIndex, UpdateStatement, type AppendToNullabilityMap, type AppendToSelection, type ColumnMeta, type Definition, type DeleteConstraintChange, type MigrationContext, type SelectMode, type Session, type Sql, type UpdateColumnChange } from "../index";
 export type IntegerMode = "number" | "timestamp" | "timestamp_ms" | "boolean";
 export type IntegerData<TMode> = TMode extends "timestamp" | "timestamp_ms" ? Date : TMode extends "boolean" ? boolean : number;
@@ -81,6 +81,7 @@ export declare class SqliteDatabase<T extends Record<string, SqliteTable>> exten
     insert<T extends Table>(table: T): SqliteInsertStatement<T>;
     update<T extends Table>(table: T): SqliteUpdateStatement<T>;
     delete<T extends Table>(table: T): SqliteDeleteStatement<T>;
+    transaction<TResult>(run: (database: SqliteDatabase<T>) => Awaitable<TResult>): Promise<TResult>;
 }
 export declare function blob(name: string): BlobColumn;
 export declare function integer<TMode extends IntegerMode = "number">(name: string, options?: IntegerOptions<TMode>): IntegerColumn<TMode>;

package/dist/protocols/sqlite.js

@@ -158,7 +158,7 @@ var SqliteMigration = class extends Migration {
 		return super.serializeLiteral(value);
 	}
 };
-var SqliteDatabase = class extends Database {
+var SqliteDatabase = class SqliteDatabase extends Database {
 	$migration;
 	constructor(session, schema) {
 		super(session, schema);
@@ -176,6 +176,9 @@ var SqliteDatabase = class extends Database {
 	delete(table) {
 		return new SqliteDeleteStatement(this.$session, table);
 	}
+	transaction(run) {
+		return this.$session.transaction((session) => run(new SqliteDatabase(session, this.$schema)));
+	}
 };
 function blob(name) {
 	return new BlobColumn(name);

package/dist/providers/bun-sqlite.d.ts

@@ -1,18 +1,33 @@
 import type { Database, Statement } from "bun:sqlite";
-import type { Primitive } from "revojs/shared";
+import { AsyncLocalStorage } from "node:async_hooks";
+import type { Awaitable, Primitive } from "revojs/shared";
 import { PreparedQuery, Session, type Query } from "../index";
 import { SqliteDatabase, type SqliteTable } from "../protocols/sqlite";
+interface BunSqliteTransaction {
+    active: boolean;
+}
+interface BunSqliteConnection {
+    context: AsyncLocalStorage<BunSqliteTransaction>;
+    queue: Promise<void>;
+    error?: Error;
+}
 export declare class BunSqlitePreparedQuery extends PreparedQuery {
     protected $statement: Statement;
-    constructor(query: Query, statement: Statement);
-    run(parameters: Array<Primitive>): import("bun:sqlite").Changes;
-    all(parameters: Array<Primitive>): (string | number | bigint | boolean | Uint8Array<ArrayBufferLike>)[][];
-    get(parameters: Array<Primitive>): (string | number | bigint | boolean | Uint8Array<ArrayBufferLike>)[];
-    values(parameters: Array<Primitive>): (string | number | bigint | boolean | Uint8Array<ArrayBufferLike>)[][];
+    protected $session: BunSqliteSession;
+    constructor(query: Query, statement: Statement, session: BunSqliteSession);
+    run(parameters: Array<Primitive>): Promise<import("bun:sqlite").Changes>;
+    all(parameters: Array<Primitive>): Promise<(string | number | bigint | boolean | Uint8Array<ArrayBufferLike>)[][]>;
+    get(parameters: Array<Primitive>): Promise<(string | number | bigint | boolean | Uint8Array<ArrayBufferLike>)[]>;
+    values(parameters: Array<Primitive>): Promise<(string | number | bigint | boolean | Uint8Array<ArrayBufferLike>)[][]>;
 }
 export declare class BunSqliteSession extends Session {
     protected $client: Database;
-    constructor(client: Database);
+    protected $connection: BunSqliteConnection;
+    protected $transaction: BunSqliteTransaction | undefined;
+    constructor(client: Database, transaction?: BunSqliteTransaction);
+    execute<T>(run: () => Awaitable<T>): Promise<T>;
+    transaction<T>(run: (session: Session) => Awaitable<T>): Promise<T>;
     prepareQuery(query: Query): BunSqlitePreparedQuery;
 }
 export declare function bunSqlite<T extends Record<string, SqliteTable>>(client: Database, schema: T): SqliteDatabase<T>;
+export {};

package/dist/providers/bun-sqlite.js

@@ -1,37 +1,94 @@
 import { PreparedQuery, Session } from "../index.js";
 import { SqliteDatabase } from "../protocols/sqlite.js";
+import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/providers/bun-sqlite.ts
 var BunSqlitePreparedQuery = class extends PreparedQuery {
 	$statement;
-	constructor(query, statement) {
+	$session;
+	constructor(query, statement, session) {
 		super(query);
 		this.$statement = statement;
+		this.$session = session;
 	}
 	run(parameters) {
-		return this.$statement.run(...parameters);
+		return this.$session.execute(() => this.$statement.run(...parameters));
 	}
 	all(parameters) {
-		return this.$statement.values(...parameters);
+		return this.$session.execute(() => this.$statement.values(...parameters));
 	}
 	get(parameters) {
-		return this.$statement.values(...parameters)[0];
+		return this.$session.execute(() => this.$statement.values(...parameters)[0]);
 	}
 	values(parameters) {
-		return this.$statement.values(...parameters);
+		return this.$session.execute(() => this.$statement.values(...parameters));
 	}
 };
-var BunSqliteSession = class extends Session {
+var BunSqliteSession = class BunSqliteSession extends Session {
 	$client;
-	constructor(client) {
+	$connection;
+	$transaction;
+	constructor(client, transaction) {
 		super();
 		this.$client = client;
+		this.$transaction = transaction;
+		const connection = connections.get(client) ?? {
+			context: new AsyncLocalStorage(),
+			queue: Promise.resolve()
+		};
+		connections.set(client, connection);
+		this.$connection = connection;
+	}
+	async execute(run) {
+		if (this.$connection.error) throw this.$connection.error;
+		const transaction = this.$transaction ?? this.$connection.context.getStore();
+		if (transaction) {
+			if (!transaction.active) throw new Error("This transaction has already completed.");
+			return run();
+		}
+		const previous = this.$connection.queue;
+		const { promise, resolve } = Promise.withResolvers();
+		this.$connection.queue = promise;
+		await previous;
+		try {
+			if (this.$connection.error) throw this.$connection.error;
+			return await run();
+		} finally {
+			resolve();
+		}
+	}
+	async transaction(run) {
+		if (this.$transaction || this.$connection.context.getStore()) throw new Error("Nested Bun SQLite transactions are not supported.");
+		return this.execute(async () => {
+			if (this.$client.inTransaction) throw new Error("The Bun SQLite connection already has an externally managed transaction.");
+			this.$client.run("BEGIN IMMEDIATE");
+			const transaction = { active: true };
+			try {
+				const result = await this.$connection.context.run(transaction, () => run(new BunSqliteSession(this.$client, transaction)));
+				this.$client.run("COMMIT");
+				return result;
+			} catch (error) {
+				try {
+					this.$client.run("ROLLBACK");
+				} catch (rollbackError) {
+					this.$connection.error = new AggregateError([error, rollbackError], "Bun SQLite rollback failed; this connection can no longer be used safely.");
+					throw this.$connection.error;
+				}
+				throw error;
+			} finally {
+				transaction.active = false;
+			}
+		});
 	}
 	prepareQuery(query) {
-		return new BunSqlitePreparedQuery(query, this.$client.prepare(query.sql));
+		if (this.$connection.error) throw this.$connection.error;
+		const transaction = this.$transaction ?? this.$connection.context.getStore();
+		if (transaction && !transaction.active) throw new Error("This transaction has already completed.");
+		return new BunSqlitePreparedQuery(query, this.$client.prepare(query.sql), this);
 	}
 };
 function bunSqlite(client, schema) {
 	return new SqliteDatabase(new BunSqliteSession(client), schema);
 }
+var connections = /* @__PURE__ */ new WeakMap();
 //#endregion
 export { BunSqlitePreparedQuery, BunSqliteSession, bunSqlite };

package/dist/providers/d1.d.ts

@@ -1,5 +1,5 @@
 import type { D1Database, D1DatabaseSession, D1PreparedStatement } from "@cloudflare/workers-types";
-import type { Primitive } from "revojs/shared";
+import type { Awaitable, Primitive } from "revojs/shared";
 import { PreparedQuery, Session, type Query } from "../index";
 import { SqliteDatabase, type SqliteTable } from "../protocols/sqlite";
 export declare class D1PreparedQuery extends PreparedQuery {
@@ -13,6 +13,7 @@ export declare class D1PreparedQuery extends PreparedQuery {
 export declare class D1Session extends Session {
     protected $client: D1Database | D1DatabaseSession;
     constructor(client: D1Database | D1DatabaseSession);
+    transaction<T>(run: (session: Session) => Awaitable<T>): Promise<T>;
     prepareQuery(query: Query): D1PreparedQuery;
 }
 export declare function d1<T extends Record<string, SqliteTable>>(client: D1Database | D1DatabaseSession, schema: T): SqliteDatabase<T>;

package/dist/providers/d1.js

@@ -26,6 +26,9 @@ var D1Session = class extends Session {
 		super();
 		this.$client = client;
 	}
+	async transaction(run) {
+		throw new Error("Cloudflare D1 does not support interactive transactions; use its atomic batch API instead.");
+	}
 	prepareQuery(query) {
 		return new D1PreparedQuery(query, this.$client.prepare(query.sql));
 	}

package/dist/types/index.d.ts

@@ -1,14 +1,8 @@
-declare module "#config/storage" {
-    import type { StorageConfig } from "@revojs/storage/module";
-
-    const config: StorageConfig;
-    export default config;
-}
-
 declare module "#storage" {
     import type { Database } from "../index";
-    import type { Scope, Source } from "revojs";
+    import type { Resolvable, Source } from "revojs";
+    import type { Awaitable } from "revojs/shared";
 
-    const entries: Source<(scope: Scope) => Database>;
+    const entries: Source<Resolvable<Awaitable<Database>>>;
     export default entries;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@revojs/storage",
-    "version": "0.2.8",
+    "version": "0.2.9",
     "license": "MIT",
     "repository": {
         "type": "git",
@@ -33,6 +33,7 @@
     },
     "scripts": {
         "build": "vite build",
+        "typecheck": "tsc --noEmit -p tsconfig.json",
         "watch": "vite build --watch"
     },
     "dependencies": {
@@ -42,7 +43,7 @@
         "@revojs/tsconfig": "*"
     },
     "optionalDependencies": {
-        "@cloudflare/workers-types": "^5.20261004.1",
+        "@cloudflare/workers-types": "^5.20261009.1",
         "@types/bun": "^1.4.2"
     }
 }