@better-auth/kysely-adapter 1.5.0-beta.9

package/dist/node-sqlite-dialect.mjs

@@ -0,0 +1,155 @@
+import { CompiledQuery, DEFAULT_MIGRATION_LOCK_TABLE, DEFAULT_MIGRATION_TABLE, DefaultQueryCompiler, sql } from "kysely";
+
+//#region src/node-sqlite-dialect.ts
+var NodeSqliteAdapter = class {
+	get supportsCreateIfNotExists() {
+		return true;
+	}
+	get supportsTransactionalDdl() {
+		return false;
+	}
+	get supportsReturning() {
+		return true;
+	}
+	async acquireMigrationLock() {}
+	async releaseMigrationLock() {}
+	get supportsOutput() {
+		return true;
+	}
+};
+var NodeSqliteDriver = class {
+	#config;
+	#connectionMutex = new ConnectionMutex();
+	#db;
+	#connection;
+	constructor(config) {
+		this.#config = { ...config };
+	}
+	async init() {
+		this.#db = this.#config.database;
+		this.#connection = new NodeSqliteConnection(this.#db);
+		if (this.#config.onCreateConnection) await this.#config.onCreateConnection(this.#connection);
+	}
+	async acquireConnection() {
+		await this.#connectionMutex.lock();
+		return this.#connection;
+	}
+	async beginTransaction(connection) {
+		await connection.executeQuery(CompiledQuery.raw("begin"));
+	}
+	async commitTransaction(connection) {
+		await connection.executeQuery(CompiledQuery.raw("commit"));
+	}
+	async rollbackTransaction(connection) {
+		await connection.executeQuery(CompiledQuery.raw("rollback"));
+	}
+	async releaseConnection() {
+		this.#connectionMutex.unlock();
+	}
+	async destroy() {
+		this.#db?.close();
+	}
+};
+var NodeSqliteConnection = class {
+	#db;
+	constructor(db) {
+		this.#db = db;
+	}
+	executeQuery(compiledQuery) {
+		const { sql: sql$1, parameters } = compiledQuery;
+		const rows = this.#db.prepare(sql$1).all(...parameters);
+		return Promise.resolve({ rows });
+	}
+	async *streamQuery() {
+		throw new Error("Streaming query is not supported by SQLite driver.");
+	}
+};
+var ConnectionMutex = class {
+	#promise;
+	#resolve;
+	async lock() {
+		while (this.#promise !== void 0) await this.#promise;
+		this.#promise = new Promise((resolve) => {
+			this.#resolve = resolve;
+		});
+	}
+	unlock() {
+		const resolve = this.#resolve;
+		this.#promise = void 0;
+		this.#resolve = void 0;
+		resolve?.();
+	}
+};
+var NodeSqliteIntrospector = class {
+	#db;
+	constructor(db) {
+		this.#db = db;
+	}
+	async getSchemas() {
+		return [];
+	}
+	async getTables(options = { withInternalKyselyTables: false }) {
+		let query = this.#db.selectFrom("sqlite_schema").where("type", "=", "table").where("name", "not like", "sqlite_%").select("name").$castTo();
+		if (!options.withInternalKyselyTables) query = query.where("name", "!=", DEFAULT_MIGRATION_TABLE).where("name", "!=", DEFAULT_MIGRATION_LOCK_TABLE);
+		const tables = await query.execute();
+		return Promise.all(tables.map(({ name }) => this.#getTableMetadata(name)));
+	}
+	async getMetadata(options) {
+		return { tables: await this.getTables(options) };
+	}
+	async #getTableMetadata(table) {
+		const db = this.#db;
+		const autoIncrementCol = (await db.selectFrom("sqlite_master").where("name", "=", table).select("sql").$castTo().execute())[0]?.sql?.split(/[\(\),]/)?.find((it) => it.toLowerCase().includes("autoincrement"))?.split(/\s+/)?.[0]?.replace(/["`]/g, "");
+		return {
+			name: table,
+			columns: (await db.selectFrom(sql`pragma_table_info(${table})`.as("table_info")).select([
+				"name",
+				"type",
+				"notnull",
+				"dflt_value"
+			]).execute()).map((col) => ({
+				name: col.name,
+				dataType: col.type,
+				isNullable: !col.notnull,
+				isAutoIncrementing: col.name === autoIncrementCol,
+				hasDefaultValue: col.dflt_value != null
+			})),
+			isView: true
+		};
+	}
+};
+var NodeSqliteQueryCompiler = class extends DefaultQueryCompiler {
+	getCurrentParameterPlaceholder() {
+		return "?";
+	}
+	getLeftIdentifierWrapper() {
+		return "\"";
+	}
+	getRightIdentifierWrapper() {
+		return "\"";
+	}
+	getAutoIncrement() {
+		return "autoincrement";
+	}
+};
+var NodeSqliteDialect = class {
+	#config;
+	constructor(config) {
+		this.#config = { ...config };
+	}
+	createDriver() {
+		return new NodeSqliteDriver(this.#config);
+	}
+	createQueryCompiler() {
+		return new NodeSqliteQueryCompiler();
+	}
+	createAdapter() {
+		return new NodeSqliteAdapter();
+	}
+	createIntrospector(db) {
+		return new NodeSqliteIntrospector(db);
+	}
+};
+
+//#endregion
+export { NodeSqliteDialect };

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@better-auth/kysely-adapter",
+  "version": "1.5.0-beta.9",
+  "description": "Kysely adapter for Better Auth",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/better-auth/better-auth.git",
+    "directory": "packages/kysely-adapter"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "dev-source": "./src/index.ts",
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./node-sqlite-dialect": {
+      "dev-source": "./src/node-sqlite-dialect.ts",
+      "types": "./dist/node-sqlite-dialect.d.mts",
+      "default": "./dist/node-sqlite-dialect.mjs"
+    }
+  },
+  "peerDependencies": {
+    "@better-auth/utils": "^0.3.0",
+    "kysely": "^0.27.0 || ^0.28.0",
+    "@better-auth/core": "1.5.0-beta.9"
+  },
+  "devDependencies": {
+    "@better-auth/utils": "^0.3.0",
+    "kysely": "^0.28.10",
+    "tsdown": "^0.19.0",
+    "typescript": "^5.9.3",
+    "@better-auth/core": "1.5.0-beta.9"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/bun-sqlite-dialect.ts

@@ -0,0 +1,300 @@
+/**
+ * @see {@link https://github.com/dylanblokhuis/kysely-bun-sqlite} - Fork of the original kysely-bun-sqlite package by @dylanblokhuis
+ */
+
+import type { Database } from "bun:sqlite";
+import type {
+	DatabaseConnection,
+	DatabaseIntrospector,
+	DatabaseMetadata,
+	DatabaseMetadataOptions,
+	Dialect,
+	DialectAdapter,
+	DialectAdapterBase,
+	Driver,
+	Kysely,
+	QueryCompiler,
+	QueryResult,
+	SchemaMetadata,
+	TableMetadata,
+} from "kysely";
+import {
+	CompiledQuery,
+	DEFAULT_MIGRATION_LOCK_TABLE,
+	DEFAULT_MIGRATION_TABLE,
+	DefaultQueryCompiler,
+	sql,
+} from "kysely";
+
+class BunSqliteAdapter implements DialectAdapterBase {
+	get supportsCreateIfNotExists(): boolean {
+		return true;
+	}
+
+	get supportsTransactionalDdl(): boolean {
+		return false;
+	}
+
+	get supportsReturning(): boolean {
+		return true;
+	}
+
+	async acquireMigrationLock(): Promise<void> {
+		// SQLite only has one connection that's reserved by the migration system
+		// for the whole time between acquireMigrationLock and releaseMigrationLock.
+		// We don't need to do anything here.
+	}
+
+	async releaseMigrationLock(): Promise<void> {
+		// SQLite only has one connection that's reserved by the migration system
+		// for the whole time between acquireMigrationLock and releaseMigrationLock.
+		// We don't need to do anything here.
+	}
+	get supportsOutput(): boolean {
+		return true;
+	}
+}
+
+/**
+ * Config for the SQLite dialect.
+ */
+export interface BunSqliteDialectConfig {
+	/**
+	 * An sqlite Database instance or a function that returns one.
+	 */
+	database: Database;
+
+	/**
+	 * Called once when the first query is executed.
+	 */
+	onCreateConnection?:
+		| ((connection: DatabaseConnection) => Promise<void>)
+		| undefined;
+}
+
+class BunSqliteDriver implements Driver {
+	readonly #config: BunSqliteDialectConfig;
+	readonly #connectionMutex = new ConnectionMutex();
+
+	#db?: Database;
+	#connection?: DatabaseConnection;
+
+	constructor(config: BunSqliteDialectConfig) {
+		this.#config = { ...config };
+	}
+
+	async init(): Promise<void> {
+		this.#db = this.#config.database;
+
+		this.#connection = new BunSqliteConnection(this.#db);
+
+		if (this.#config.onCreateConnection) {
+			await this.#config.onCreateConnection(this.#connection);
+		}
+	}
+
+	async acquireConnection(): Promise<DatabaseConnection> {
+		// SQLite only has one single connection. We use a mutex here to wait
+		// until the single connection has been released.
+		await this.#connectionMutex.lock();
+		return this.#connection!;
+	}
+
+	async beginTransaction(connection: DatabaseConnection): Promise<void> {
+		await connection.executeQuery(CompiledQuery.raw("begin"));
+	}
+
+	async commitTransaction(connection: DatabaseConnection): Promise<void> {
+		await connection.executeQuery(CompiledQuery.raw("commit"));
+	}
+
+	async rollbackTransaction(connection: DatabaseConnection): Promise<void> {
+		await connection.executeQuery(CompiledQuery.raw("rollback"));
+	}
+
+	async releaseConnection(): Promise<void> {
+		this.#connectionMutex.unlock();
+	}
+
+	async destroy(): Promise<void> {
+		this.#db?.close();
+	}
+}
+
+class BunSqliteConnection implements DatabaseConnection {
+	readonly #db: Database;
+
+	constructor(db: Database) {
+		this.#db = db;
+	}
+
+	executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResult<O>> {
+		const { sql, parameters } = compiledQuery;
+		const stmt = this.#db.prepare(sql);
+
+		return Promise.resolve({
+			rows: stmt.all(parameters as any) as O[],
+		});
+	}
+
+	async *streamQuery() {
+		throw new Error("Streaming query is not supported by SQLite driver.");
+	}
+}
+
+class ConnectionMutex {
+	#promise?: Promise<void>;
+	#resolve?: () => void;
+
+	async lock(): Promise<void> {
+		while (this.#promise !== undefined) {
+			await this.#promise;
+		}
+
+		this.#promise = new Promise((resolve) => {
+			this.#resolve = resolve;
+		});
+	}
+
+	unlock(): void {
+		const resolve = this.#resolve;
+
+		this.#promise = undefined;
+		this.#resolve = undefined;
+
+		resolve?.();
+	}
+}
+
+class BunSqliteIntrospector implements DatabaseIntrospector {
+	readonly #db: Kysely<unknown>;
+
+	constructor(db: Kysely<unknown>) {
+		this.#db = db;
+	}
+
+	async getSchemas(): Promise<SchemaMetadata[]> {
+		// Sqlite doesn't support schemas.
+		return [];
+	}
+
+	async getTables(
+		options: DatabaseMetadataOptions = { withInternalKyselyTables: false },
+	): Promise<TableMetadata[]> {
+		let query = this.#db
+			// @ts-expect-error
+			.selectFrom("sqlite_schema")
+			// @ts-expect-error
+			.where("type", "=", "table")
+			// @ts-expect-error
+			.where("name", "not like", "sqlite_%")
+			.select("name")
+			.$castTo<{ name: string }>();
+
+		if (!options.withInternalKyselyTables) {
+			query = query
+				// @ts-expect-error
+				.where("name", "!=", DEFAULT_MIGRATION_TABLE)
+				// @ts-expect-error
+				.where("name", "!=", DEFAULT_MIGRATION_LOCK_TABLE);
+		}
+
+		const tables = await query.execute();
+		return Promise.all(tables.map(({ name }) => this.#getTableMetadata(name)));
+	}
+
+	async getMetadata(
+		options?: DatabaseMetadataOptions | undefined,
+	): Promise<DatabaseMetadata> {
+		return {
+			tables: await this.getTables(options),
+		};
+	}
+
+	async #getTableMetadata(table: string): Promise<TableMetadata> {
+		const db = this.#db;
+
+		// Get the SQL that was used to create the table.
+		const createSql = await db
+			// @ts-expect-error
+			.selectFrom("sqlite_master")
+			// @ts-expect-error
+			.where("name", "=", table)
+			.select("sql")
+			.$castTo<{ sql: string | undefined }>()
+			.execute();
+
+		// Try to find the name of the column that has `autoincrement` 🤦
+		const autoIncrementCol = createSql[0]?.sql
+			?.split(/[\(\),]/)
+			?.find((it) => it.toLowerCase().includes("autoincrement"))
+			?.split(/\s+/)?.[0]
+			?.replace(/["`]/g, "");
+
+		const columns = await db
+			.selectFrom(
+				sql<{
+					name: string;
+					type: string;
+					notnull: 0 | 1;
+					dflt_value: any;
+				}>`pragma_table_info(${table})`.as("table_info"),
+			)
+			.select(["name", "type", "notnull", "dflt_value"])
+			.execute();
+
+		return {
+			name: table,
+			columns: columns.map((col) => ({
+				name: col.name,
+				dataType: col.type,
+				isNullable: !col.notnull,
+				isAutoIncrementing: col.name === autoIncrementCol,
+				hasDefaultValue: col.dflt_value != null,
+			})),
+			isView: true,
+		};
+	}
+}
+
+class BunSqliteQueryCompiler extends DefaultQueryCompiler {
+	protected override getCurrentParameterPlaceholder() {
+		return "?";
+	}
+
+	protected override getLeftIdentifierWrapper(): string {
+		return '"';
+	}
+
+	protected override getRightIdentifierWrapper(): string {
+		return '"';
+	}
+
+	protected override getAutoIncrement() {
+		return "autoincrement";
+	}
+}
+
+export class BunSqliteDialect implements Dialect {
+	readonly #config: BunSqliteDialectConfig;
+
+	constructor(config: BunSqliteDialectConfig) {
+		this.#config = { ...config };
+	}
+
+	createDriver(): Driver {
+		return new BunSqliteDriver(this.#config);
+	}
+
+	createQueryCompiler(): QueryCompiler {
+		return new BunSqliteQueryCompiler();
+	}
+
+	createAdapter(): DialectAdapter {
+		return new BunSqliteAdapter();
+	}
+
+	createIntrospector(db: Kysely<any>): DatabaseIntrospector {
+		return new BunSqliteIntrospector(db);
+	}
+}

package/src/dialect.ts

@@ -0,0 +1,148 @@
+import type { BetterAuthOptions } from "@better-auth/core";
+import type { Dialect } from "kysely";
+import {
+	Kysely,
+	MssqlDialect,
+	MysqlDialect,
+	PostgresDialect,
+	SqliteDialect,
+} from "kysely";
+import type { KyselyDatabaseType } from "./types";
+
+export function getKyselyDatabaseType(
+	db: BetterAuthOptions["database"],
+): KyselyDatabaseType | null {
+	if (!db) {
+		return null;
+	}
+	if ("dialect" in db) {
+		return getKyselyDatabaseType(db.dialect as Dialect);
+	}
+	if ("createDriver" in db) {
+		if (db instanceof SqliteDialect) {
+			return "sqlite";
+		}
+		if (db instanceof MysqlDialect) {
+			return "mysql";
+		}
+		if (db instanceof PostgresDialect) {
+			return "postgres";
+		}
+		if (db instanceof MssqlDialect) {
+			return "mssql";
+		}
+	}
+	if ("aggregate" in db) {
+		return "sqlite";
+	}
+
+	if ("getConnection" in db) {
+		return "mysql";
+	}
+	if ("connect" in db) {
+		return "postgres";
+	}
+	if ("fileControl" in db) {
+		return "sqlite";
+	}
+	if ("open" in db && "close" in db && "prepare" in db) {
+		return "sqlite";
+	}
+	return null;
+}
+
+export const createKyselyAdapter = async (config: BetterAuthOptions) => {
+	const db = config.database;
+
+	if (!db) {
+		return {
+			kysely: null,
+			databaseType: null,
+			transaction: undefined,
+		};
+	}
+
+	if ("db" in db) {
+		return {
+			kysely: db.db,
+			databaseType: db.type,
+			transaction: db.transaction,
+		};
+	}
+
+	if ("dialect" in db) {
+		return {
+			kysely: new Kysely<any>({ dialect: db.dialect }),
+			databaseType: db.type,
+			transaction: db.transaction,
+		};
+	}
+
+	let dialect: Dialect | undefined = undefined;
+
+	const databaseType = getKyselyDatabaseType(db);
+
+	if ("createDriver" in db) {
+		dialect = db;
+	}
+
+	if ("aggregate" in db && !("createSession" in db)) {
+		dialect = new SqliteDialect({
+			database: db,
+		});
+	}
+
+	if ("getConnection" in db) {
+		// @ts-expect-error - mysql2/promise
+		dialect = new MysqlDialect(db);
+	}
+
+	if ("connect" in db) {
+		dialect = new PostgresDialect({
+			pool: db,
+		});
+	}
+
+	if ("fileControl" in db) {
+		const { BunSqliteDialect } = await import("./bun-sqlite-dialect");
+		dialect = new BunSqliteDialect({
+			database: db,
+		});
+	}
+
+	if ("createSession" in db && typeof window === "undefined") {
+		let DatabaseSync: typeof import("node:sqlite").DatabaseSync | undefined =
+			undefined;
+		try {
+			const nodeSqlite: string = "node:sqlite";
+			// Ignore both Vite and Webpack for dynamic import as they both try to pre-bundle 'node:sqlite' which might fail
+			// It's okay because we are in a try-catch block
+			({ DatabaseSync } = await import(
+				/* @vite-ignore */
+				/* webpackIgnore: true */
+				nodeSqlite
+			));
+		} catch (error: unknown) {
+			if (
+				error !== null &&
+				typeof error === "object" &&
+				"code" in error &&
+				error.code !== "ERR_UNKNOWN_BUILTIN_MODULE"
+			) {
+				throw error;
+			}
+		}
+		if (DatabaseSync && db instanceof DatabaseSync) {
+			const { NodeSqliteDialect } = await import("./node-sqlite-dialect");
+			dialect = new NodeSqliteDialect({
+				database: db,
+			});
+		}
+	}
+
+	return {
+		kysely: dialect ? new Kysely<any>({ dialect }) : null,
+		databaseType,
+		transaction: undefined,
+	};
+};

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from "./dialect";
+export * from "./kysely-adapter";
+export * from "./types";
+// Don't export node:sqlite by default, as it is not production ready.
+// export * from "./node-sqlite";

package/src/kysely-adapter.test.ts

@@ -0,0 +1,24 @@
+import { Kysely, SqliteDialect } from "kysely";
+import { describe, expect, it } from "vitest";
+import { kyselyAdapter } from "./kysely-adapter";
+
+describe("kysely-adapter", () => {
+	it("should create kysely adapter", () => {
+		const db = new Kysely({
+			dialect: new SqliteDialect({
+				database: {
+					close: () => {},
+					prepare: () =>
+						({
+							all: () => [],
+							run: () => {},
+							get: () => {},
+							iterate: () => [],
+						}) as any,
+				} as any,
+			}),
+		});
+		const adapter = kyselyAdapter(db);
+		expect(adapter).toBeDefined();
+	});
+});