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

package/.turbo/turbo-build.log

@@ -0,0 +1,16 @@
+
+> @better-auth/kysely-adapter@1.5.0-beta.9 build /home/runner/work/better-auth/better-auth/packages/kysely-adapter
+> tsdown
+
+ℹ tsdown v0.19.0 powered by rolldown v1.0.0-beta.59
+ℹ config file: /home/runner/work/better-auth/better-auth/packages/kysely-adapter/tsdown.config.ts 
+ℹ entry: src/index.ts, src/node-sqlite-dialect.ts
+ℹ tsconfig: tsconfig.json
+ℹ Build start
+ℹ dist/index.mjs                        15.21 kB │ gzip: 3.58 kB
+ℹ dist/node-sqlite-dialect.mjs           4.12 kB │ gzip: 1.41 kB
+ℹ dist/bun-sqlite-dialect-deBGXcrd.mjs   4.11 kB │ gzip: 1.41 kB
+ℹ dist/index.d.mts                       1.61 kB │ gzip: 0.60 kB
+ℹ dist/node-sqlite-dialect.d.mts         0.89 kB │ gzip: 0.44 kB
+ℹ 5 files, total: 25.95 kB
+✔ Build complete in 9280ms

package/LICENSE.md

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+Copyright (c) 2024 - present, Bereket Engida
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the “Software”), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

package/dist/bun-sqlite-dialect-deBGXcrd.mjs

@@ -0,0 +1,155 @@
+import { CompiledQuery, DEFAULT_MIGRATION_LOCK_TABLE, DEFAULT_MIGRATION_TABLE, DefaultQueryCompiler, sql } from "kysely";
+
+//#region src/bun-sqlite-dialect.ts
+var BunSqliteAdapter = class {
+	get supportsCreateIfNotExists() {
+		return true;
+	}
+	get supportsTransactionalDdl() {
+		return false;
+	}
+	get supportsReturning() {
+		return true;
+	}
+	async acquireMigrationLock() {}
+	async releaseMigrationLock() {}
+	get supportsOutput() {
+		return true;
+	}
+};
+var BunSqliteDriver = class {
+	#config;
+	#connectionMutex = new ConnectionMutex();
+	#db;
+	#connection;
+	constructor(config) {
+		this.#config = { ...config };
+	}
+	async init() {
+		this.#db = this.#config.database;
+		this.#connection = new BunSqliteConnection(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 BunSqliteConnection = class {
+	#db;
+	constructor(db) {
+		this.#db = db;
+	}
+	executeQuery(compiledQuery) {
+		const { sql: sql$1, parameters } = compiledQuery;
+		const stmt = this.#db.prepare(sql$1);
+		return Promise.resolve({ rows: stmt.all(parameters) });
+	}
+	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 BunSqliteIntrospector = 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 BunSqliteQueryCompiler = class extends DefaultQueryCompiler {
+	getCurrentParameterPlaceholder() {
+		return "?";
+	}
+	getLeftIdentifierWrapper() {
+		return "\"";
+	}
+	getRightIdentifierWrapper() {
+		return "\"";
+	}
+	getAutoIncrement() {
+		return "autoincrement";
+	}
+};
+var BunSqliteDialect = class {
+	#config;
+	constructor(config) {
+		this.#config = { ...config };
+	}
+	createDriver() {
+		return new BunSqliteDriver(this.#config);
+	}
+	createQueryCompiler() {
+		return new BunSqliteQueryCompiler();
+	}
+	createAdapter() {
+		return new BunSqliteAdapter();
+	}
+	createIntrospector(db) {
+		return new BunSqliteIntrospector(db);
+	}
+};
+
+//#endregion
+export { BunSqliteDialect };

package/dist/index.d.mts

@@ -0,0 +1,49 @@
+import { Kysely } from "kysely";
+import { DBAdapter, DBAdapterDebugLogOption } from "@better-auth/core/db/adapter";
+import { BetterAuthOptions } from "@better-auth/core";
+
+//#region src/types.d.ts
+type KyselyDatabaseType = "postgres" | "mysql" | "sqlite" | "mssql";
+//#endregion
+//#region src/dialect.d.ts
+declare function getKyselyDatabaseType(db: BetterAuthOptions["database"]): KyselyDatabaseType | null;
+declare const createKyselyAdapter: (config: BetterAuthOptions) => Promise<{
+  kysely: Kysely<any>;
+  databaseType: "postgres" | "mysql" | "sqlite" | "mssql";
+  transaction: boolean | undefined;
+} | {
+  kysely: Kysely<any> | null;
+  databaseType: KyselyDatabaseType | null;
+  transaction: undefined;
+}>;
+//#endregion
+//#region src/kysely-adapter.d.ts
+interface KyselyAdapterConfig {
+  /**
+   * Database type.
+   */
+  type?: KyselyDatabaseType | undefined;
+  /**
+   * Enable debug logs for the adapter
+   *
+   * @default false
+   */
+  debugLogs?: DBAdapterDebugLogOption | undefined;
+  /**
+   * Use plural for table names.
+   *
+   * @default false
+   */
+  usePlural?: boolean | undefined;
+  /**
+   * Whether to execute multiple operations in a transaction.
+   *
+   * If the database doesn't support transactions,
+   * set this to `false` and operations will be executed sequentially.
+   * @default false
+   */
+  transaction?: boolean | undefined;
+}
+declare const kyselyAdapter: (db: Kysely<any>, config?: KyselyAdapterConfig | undefined) => (options: BetterAuthOptions) => DBAdapter<BetterAuthOptions>;
+//#endregion
+export { KyselyDatabaseType, createKyselyAdapter, getKyselyDatabaseType, kyselyAdapter };

package/dist/index.mjs

@@ -0,0 +1,364 @@
+import { Kysely, MssqlDialect, MysqlDialect, PostgresDialect, SqliteDialect, sql } from "kysely";
+import { createAdapterFactory } from "@better-auth/core/db/adapter";
+
+//#region src/dialect.ts
+function getKyselyDatabaseType(db) {
+	if (!db) return null;
+	if ("dialect" in db) return getKyselyDatabaseType(db.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;
+}
+const createKyselyAdapter = async (config) => {
+	const db = config.database;
+	if (!db) return {
+		kysely: null,
+		databaseType: null,
+		transaction: void 0
+	};
+	if ("db" in db) return {
+		kysely: db.db,
+		databaseType: db.type,
+		transaction: db.transaction
+	};
+	if ("dialect" in db) return {
+		kysely: new Kysely({ dialect: db.dialect }),
+		databaseType: db.type,
+		transaction: db.transaction
+	};
+	let dialect = void 0;
+	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) dialect = new MysqlDialect(db);
+	if ("connect" in db) dialect = new PostgresDialect({ pool: db });
+	if ("fileControl" in db) {
+		const { BunSqliteDialect } = await import("./bun-sqlite-dialect-deBGXcrd.mjs");
+		dialect = new BunSqliteDialect({ database: db });
+	}
+	if ("createSession" in db && typeof window === "undefined") {
+		let DatabaseSync = void 0;
+		try {
+			const nodeSqlite = "node:sqlite";
+			({DatabaseSync} = await import(
+				/* @vite-ignore */
+				/* webpackIgnore: true */
+				nodeSqlite
+));
+		} catch (error) {
+			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.mjs");
+			dialect = new NodeSqliteDialect({ database: db });
+		}
+	}
+	return {
+		kysely: dialect ? new Kysely({ dialect }) : null,
+		databaseType,
+		transaction: void 0
+	};
+};
+
+//#endregion
+//#region src/kysely-adapter.ts
+const kyselyAdapter = (db, config) => {
+	let lazyOptions = null;
+	const createCustomAdapter = (db$1) => {
+		return ({ getFieldName, schema, getDefaultFieldName, getDefaultModelName, getFieldAttributes, getModelName }) => {
+			const selectAllJoins = (join) => {
+				const allSelects = [];
+				const allSelectsStr = [];
+				if (join) for (const [joinModel, _] of Object.entries(join)) {
+					const fields = schema[getDefaultModelName(joinModel)]?.fields;
+					const [_joinModelSchema, joinModelName] = joinModel.includes(".") ? joinModel.split(".") : [void 0, joinModel];
+					if (!fields) continue;
+					fields.id = { type: "string" };
+					for (const [field, fieldAttr] of Object.entries(fields)) {
+						allSelects.push(sql`${sql.ref(`join_${joinModelName}`)}.${sql.ref(fieldAttr.fieldName || field)} as ${sql.ref(`_joined_${joinModelName}_${fieldAttr.fieldName || field}`)}`);
+						allSelectsStr.push({
+							joinModel,
+							joinModelRef: joinModelName,
+							fieldName: fieldAttr.fieldName || field
+						});
+					}
+				}
+				return {
+					allSelectsStr,
+					allSelects
+				};
+			};
+			const withReturning = async (values, builder, model, where) => {
+				let res;
+				if (config?.type === "mysql") {
+					await builder.execute();
+					const field = values.id ? "id" : where.length > 0 && where[0]?.field ? where[0].field : "id";
+					if (!values.id && where.length === 0) {
+						res = await db$1.selectFrom(model).selectAll().orderBy(getFieldName({
+							model,
+							field
+						}), "desc").limit(1).executeTakeFirst();
+						return res;
+					}
+					const value = values[field] || where[0]?.value;
+					res = await db$1.selectFrom(model).selectAll().orderBy(getFieldName({
+						model,
+						field
+					}), "desc").where(getFieldName({
+						model,
+						field
+					}), "=", value).limit(1).executeTakeFirst();
+					return res;
+				}
+				if (config?.type === "mssql") {
+					res = await builder.outputAll("inserted").executeTakeFirst();
+					return res;
+				}
+				res = await builder.returningAll().executeTakeFirst();
+				return res;
+			};
+			function convertWhereClause(model, w) {
+				if (!w) return {
+					and: null,
+					or: null
+				};
+				const conditions = {
+					and: [],
+					or: []
+				};
+				w.forEach((condition) => {
+					const { field: _field, value: _value, operator = "=", connector = "AND" } = condition;
+					const value = _value;
+					const field = getFieldName({
+						model,
+						field: _field
+					});
+					const expr = (eb) => {
+						const f = `${model}.${field}`;
+						if (operator.toLowerCase() === "in") return eb(f, "in", Array.isArray(value) ? value : [value]);
+						if (operator.toLowerCase() === "not_in") return eb(f, "not in", Array.isArray(value) ? value : [value]);
+						if (operator === "contains") return eb(f, "like", `%${value}%`);
+						if (operator === "starts_with") return eb(f, "like", `${value}%`);
+						if (operator === "ends_with") return eb(f, "like", `%${value}`);
+						if (operator === "eq") return eb(f, "=", value);
+						if (operator === "ne") return eb(f, "<>", value);
+						if (operator === "gt") return eb(f, ">", value);
+						if (operator === "gte") return eb(f, ">=", value);
+						if (operator === "lt") return eb(f, "<", value);
+						if (operator === "lte") return eb(f, "<=", value);
+						return eb(f, operator, value);
+					};
+					if (connector === "OR") conditions.or.push(expr);
+					else conditions.and.push(expr);
+				});
+				return {
+					and: conditions.and.length ? conditions.and : null,
+					or: conditions.or.length ? conditions.or : null
+				};
+			}
+			function processJoinedResults(rows, joinConfig, allSelectsStr) {
+				if (!joinConfig || !rows.length) return rows;
+				const groupedByMainId = /* @__PURE__ */ new Map();
+				for (const currentRow of rows) {
+					const mainModelFields = {};
+					const joinedModelFields = {};
+					for (const [joinModel] of Object.entries(joinConfig)) joinedModelFields[getModelName(joinModel)] = {};
+					for (const [key, value] of Object.entries(currentRow)) {
+						const keyStr = String(key);
+						let assigned = false;
+						for (const { joinModel, fieldName, joinModelRef } of allSelectsStr) if (keyStr === `_joined_${joinModelRef}_${fieldName}`) {
+							joinedModelFields[getModelName(joinModel)][getFieldName({
+								model: joinModel,
+								field: fieldName
+							})] = value;
+							assigned = true;
+							break;
+						}
+						if (!assigned) mainModelFields[key] = value;
+					}
+					const mainId = mainModelFields.id;
+					if (!mainId) continue;
+					if (!groupedByMainId.has(mainId)) {
+						const entry$1 = { ...mainModelFields };
+						for (const [joinModel, joinAttr] of Object.entries(joinConfig)) entry$1[getModelName(joinModel)] = joinAttr.relation === "one-to-one" ? null : [];
+						groupedByMainId.set(mainId, entry$1);
+					}
+					const entry = groupedByMainId.get(mainId);
+					for (const [joinModel, joinAttr] of Object.entries(joinConfig)) {
+						const isUnique = joinAttr.relation === "one-to-one";
+						const limit = joinAttr.limit ?? 100;
+						const joinedObj = joinedModelFields[getModelName(joinModel)];
+						const hasData = joinedObj && Object.keys(joinedObj).length > 0 && Object.values(joinedObj).some((value) => value !== null && value !== void 0);
+						if (isUnique) entry[getModelName(joinModel)] = hasData ? joinedObj : null;
+						else {
+							const joinModelName = getModelName(joinModel);
+							if (Array.isArray(entry[joinModelName]) && hasData) {
+								if (entry[joinModelName].length >= limit) continue;
+								const idFieldName = getFieldName({
+									model: joinModel,
+									field: "id"
+								});
+								const joinedId = joinedObj[idFieldName];
+								if (joinedId) {
+									if (!entry[joinModelName].some((item) => item[idFieldName] === joinedId) && entry[joinModelName].length < limit) entry[joinModelName].push(joinedObj);
+								} else if (entry[joinModelName].length < limit) entry[joinModelName].push(joinedObj);
+							}
+						}
+					}
+				}
+				const result = Array.from(groupedByMainId.values());
+				for (const entry of result) for (const [joinModel, joinAttr] of Object.entries(joinConfig)) if (joinAttr.relation !== "one-to-one") {
+					const joinModelName = getModelName(joinModel);
+					if (Array.isArray(entry[joinModelName])) {
+						const limit = joinAttr.limit ?? 100;
+						if (entry[joinModelName].length > limit) entry[joinModelName] = entry[joinModelName].slice(0, limit);
+					}
+				}
+				return result;
+			}
+			return {
+				async create({ data, model }) {
+					return await withReturning(data, db$1.insertInto(model).values(data), model, []);
+				},
+				async findOne({ model, where, select, join }) {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$1.selectFrom((eb) => {
+						let b = eb.selectFrom(model);
+						if (and) b = b.where((eb$1) => eb$1.and(and.map((expr) => expr(eb$1))));
+						if (or) b = b.where((eb$1) => eb$1.or(or.map((expr) => expr(eb$1))));
+						return b.selectAll().as("primary");
+					}).selectAll("primary");
+					if (join) for (const [joinModel, joinAttr] of Object.entries(join)) {
+						const [_joinModelSchema, joinModelName] = joinModel.includes(".") ? joinModel.split(".") : [void 0, joinModel];
+						query = query.leftJoin(`${joinModel} as join_${joinModelName}`, (join$1) => join$1.onRef(`join_${joinModelName}.${joinAttr.on.to}`, "=", `primary.${joinAttr.on.from}`));
+					}
+					const { allSelectsStr, allSelects } = selectAllJoins(join);
+					query = query.select(allSelects);
+					const res = await query.execute();
+					if (!res || !Array.isArray(res) || res.length === 0) return null;
+					const row = res[0];
+					if (join) return processJoinedResults(res, join, allSelectsStr)[0];
+					return row;
+				},
+				async findMany({ model, where, limit, offset, sortBy, join }) {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$1.selectFrom((eb) => {
+						let b = eb.selectFrom(model);
+						if (config?.type === "mssql") {
+							if (offset !== void 0) {
+								if (!sortBy) b = b.orderBy(getFieldName({
+									model,
+									field: "id"
+								}));
+								b = b.offset(offset).fetch(limit || 100);
+							} else if (limit !== void 0) b = b.top(limit);
+						} else {
+							if (limit !== void 0) b = b.limit(limit);
+							if (offset !== void 0) b = b.offset(offset);
+						}
+						if (sortBy?.field) b = b.orderBy(`${getFieldName({
+							model,
+							field: sortBy.field
+						})}`, sortBy.direction);
+						if (and) b = b.where((eb$1) => eb$1.and(and.map((expr) => expr(eb$1))));
+						if (or) b = b.where((eb$1) => eb$1.or(or.map((expr) => expr(eb$1))));
+						return b.selectAll().as("primary");
+					}).selectAll("primary");
+					if (join) for (const [joinModel, joinAttr] of Object.entries(join)) {
+						const [_joinModelSchema, joinModelName] = joinModel.includes(".") ? joinModel.split(".") : [void 0, joinModel];
+						query = query.leftJoin(`${joinModel} as join_${joinModelName}`, (join$1) => join$1.onRef(`join_${joinModelName}.${joinAttr.on.to}`, "=", `primary.${joinAttr.on.from}`));
+					}
+					const { allSelectsStr, allSelects } = selectAllJoins(join);
+					query = query.select(allSelects);
+					if (sortBy?.field) query = query.orderBy(`${getFieldName({
+						model,
+						field: sortBy.field
+					})}`, sortBy.direction);
+					const res = await query.execute();
+					if (!res) return [];
+					if (join) return processJoinedResults(res, join, allSelectsStr);
+					return res;
+				},
+				async update({ model, where, update: values }) {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$1.updateTable(model).set(values);
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					return await withReturning(values, query, model, where);
+				},
+				async updateMany({ model, where, update: values }) {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$1.updateTable(model).set(values);
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					const res = (await query.executeTakeFirst()).numUpdatedRows;
+					return res > Number.MAX_SAFE_INTEGER ? Number.MAX_SAFE_INTEGER : Number(res);
+				},
+				async count({ model, where }) {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$1.selectFrom(model).select(db$1.fn.count("id").as("count"));
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					const res = await query.execute();
+					if (typeof res[0].count === "number") return res[0].count;
+					if (typeof res[0].count === "bigint") return Number(res[0].count);
+					return parseInt(res[0].count);
+				},
+				async delete({ model, where }) {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$1.deleteFrom(model);
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					await query.execute();
+				},
+				async deleteMany({ model, where }) {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$1.deleteFrom(model);
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					const res = (await query.executeTakeFirst()).numDeletedRows;
+					return res > Number.MAX_SAFE_INTEGER ? Number.MAX_SAFE_INTEGER : Number(res);
+				},
+				options: config
+			};
+		};
+	};
+	let adapterOptions = null;
+	adapterOptions = {
+		config: {
+			adapterId: "kysely",
+			adapterName: "Kysely Adapter",
+			usePlural: config?.usePlural,
+			debugLogs: config?.debugLogs,
+			supportsBooleans: config?.type === "sqlite" || config?.type === "mssql" || config?.type === "mysql" || !config?.type ? false : true,
+			supportsDates: config?.type === "sqlite" || config?.type === "mssql" || !config?.type ? false : true,
+			supportsJSON: config?.type === "postgres" ? true : false,
+			supportsArrays: false,
+			supportsUUIDs: config?.type === "postgres" ? true : false,
+			transaction: config?.transaction ? (cb) => db.transaction().execute((trx) => {
+				return cb(createAdapterFactory({
+					config: adapterOptions.config,
+					adapter: createCustomAdapter(trx)
+				})(lazyOptions));
+			}) : false
+		},
+		adapter: createCustomAdapter(db)
+	};
+	const adapter = createAdapterFactory(adapterOptions);
+	return (options) => {
+		lazyOptions = options;
+		return adapter(options);
+	};
+};
+
+//#endregion
+export { createKyselyAdapter, getKyselyDatabaseType, kyselyAdapter };

package/dist/node-sqlite-dialect.d.mts

@@ -0,0 +1,28 @@
+import { DatabaseConnection, DatabaseIntrospector, Dialect, DialectAdapter, Driver, Kysely, QueryCompiler } from "kysely";
+import { DatabaseSync } from "node:sqlite";
+
+//#region src/node-sqlite-dialect.d.ts
+
+/**
+ * Config for the SQLite dialect.
+ */
+interface NodeSqliteDialectConfig {
+  /**
+   * A sqlite DatabaseSync instance or a function that returns one.
+   */
+  database: DatabaseSync;
+  /**
+   * Called once when the first query is executed.
+   */
+  onCreateConnection?: ((connection: DatabaseConnection) => Promise<void>) | undefined;
+}
+declare class NodeSqliteDialect implements Dialect {
+  #private;
+  constructor(config: NodeSqliteDialectConfig);
+  createDriver(): Driver;
+  createQueryCompiler(): QueryCompiler;
+  createAdapter(): DialectAdapter;
+  createIntrospector(db: Kysely<any>): DatabaseIntrospector;
+}
+//#endregion
+export { NodeSqliteDialect, NodeSqliteDialectConfig };