@better-auth/kysely-adapter 1.7.0-beta.0 → 1.7.0-beta.10

package/dist/{bun-sqlite-dialect-na--YwnN.mjs → bun-sqlite-dialect-PuE7pPr-.mjs}

@@ -57,7 +57,14 @@ var BunSqliteConnection = class {
 	executeQuery(compiledQuery) {
 		const { sql, parameters } = compiledQuery;
 		const stmt = this.#db.prepare(sql);
-		return Promise.resolve({ rows: stmt.all(parameters) });
+		const params = parameters;
+		if (stmt.columnNames.length > 0) return Promise.resolve({ rows: stmt.all(...params) });
+		const { changes, lastInsertRowid } = stmt.run(...params);
+		return Promise.resolve({
+			rows: [],
+			numAffectedRows: BigInt(changes),
+			insertId: typeof lastInsertRowid === "bigint" ? lastInsertRowid : BigInt(lastInsertRowid)
+		});
 	}
 	async *streamQuery() {
 		throw new Error("Streaming query is not supported by SQLite driver.");
@@ -113,7 +120,7 @@ var BunSqliteIntrospector = class {
 				isAutoIncrementing: col.name === autoIncrementCol,
 				hasDefaultValue: col.dflt_value != null
 			})),
-			isView: true
+			isView: false
 		};
 	}
 };

package/dist/index.d.mts

@@ -21,6 +21,19 @@ declare const createKyselyAdapter: (config: BetterAuthOptions) => Promise<{
 interface KyselyAdapterConfig {
   /**
    * Database type.
+   *
+   * For `"mysql"`, this adapter depends on the driver returning
+   * "rows matched" counts from `UPDATE`/`DELETE` operations (in
+   * mysql2: `affectedRows`, exposed by Kysely as `numUpdatedRows`).
+   * By default, `mysql2` enables this via the `FOUND_ROWS` client
+   * flag.
+   *
+   * Do not disable this flag. If you remove it (e.g. with
+   * `flags: '-FOUND_ROWS'` in your pool config), MySQL will report
+   * "rows changed" semantics: an idempotent `UPDATE` (where the new
+   * value equals the old value) will show zero affected rows, causing
+   * adapter methods like `update`, `incrementOne`, or `updateMany` to
+   * return `null` or `0` even if a row matched the predicate.
    */
   type?: KyselyDatabaseType | undefined;
   /**

package/dist/index.mjs

@@ -1,5 +1,6 @@
 import { Kysely, MssqlDialect, MysqlDialect, PostgresDialect, SqliteDialect, sql } from "kysely";
 import { createAdapterFactory } from "@better-auth/core/db/adapter";
+import { logger } from "@better-auth/core/env";
 import { capitalizeFirstLetter } from "@better-auth/core/utils/string";
 //#region src/dialect.ts
 function getKyselyDatabaseType(db) {
@@ -43,7 +44,7 @@ const createKyselyAdapter = async (config) => {
 	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-na--YwnN.mjs");
+		const { BunSqliteDialect } = await import("./bun-sqlite-dialect-PuE7pPr-.mjs");
 		dialect = new BunSqliteDialect({ database: db });
 	}
 	if ("createSession" in db) {
@@ -124,8 +125,13 @@ function insensitiveNe(columnRef, value) {
 //#region src/kysely-adapter.ts
 const kyselyAdapter = (db, config) => {
 	let lazyOptions = null;
-	const createCustomAdapter = (db) => {
-		return ({ getFieldName, schema, getDefaultFieldName, getDefaultModelName, getFieldAttributes, getModelName }) => {
+	let mysqlNoIdWarned = false;
+	const createCustomAdapter = (db, inTransaction = false) => {
+		return ({ getFieldName, schema, getDefaultFieldName, getDefaultModelName, getFieldAttributes, getModelName, options }) => {
+			if (config?.type === "mysql" && options.advanced?.database?.generateId === false && !mysqlNoIdWarned) {
+				mysqlNoIdWarned = true;
+				logger.warn("[Kysely Adapter] MySQL does not support INSERT...RETURNING. With generateId set to false, the adapter uses best-effort fallback strategies (unique columns, full-field match) to retrieve inserted rows. For reliable behavior, use Better Auth's default ID generation, a custom generateId function, or generateId: \"serial\" for auto-increment.");
+			}
 			const selectAllJoins = (join) => {
 				const allSelects = [];
 				const allSelectsStr = [];
@@ -149,33 +155,71 @@ const kyselyAdapter = (db, config) => {
 				};
 			};
 			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.selectFrom(model).selectAll().orderBy(getFieldName({
+					if (where.length > 0) {
+						const updateResult = await builder.executeTakeFirst();
+						if (!updateResult || Number(updateResult.numUpdatedRows ?? 0) === 0) return null;
+						const idEqualityWhere = where.find((w) => w.field === "id" && (w.operator === void 0 || w.operator === "eq") && w.connector !== "OR" && w.value !== void 0 && w.value !== null);
+						let reselectField;
+						let reselectValue;
+						if (values.id !== void 0 && values.id !== null) {
+							reselectField = "id";
+							reselectValue = values.id;
+						} else if (idEqualityWhere) {
+							reselectField = "id";
+							reselectValue = idEqualityWhere.value;
+						} else if (where[0]?.field) {
+							reselectField = where[0].field;
+							reselectValue = values[reselectField] !== void 0 ? values[reselectField] : where[0].value;
+						} else return null;
+						return await db.selectFrom(model).selectAll().where(getFieldName({
 							model,
-							field
-						}), "desc").limit(1).executeTakeFirst();
-						return res;
+							field: reselectField
+						}), reselectValue === null ? "is" : "=", reselectValue).limit(1).executeTakeFirst();
 					}
-					const value = values[field] !== void 0 ? values[field] : where[0]?.value;
-					res = await db.selectFrom(model).selectAll().orderBy(getFieldName({
-						model,
-						field
-					}), "desc").where(getFieldName({
-						model,
-						field
-					}), value === null ? "is" : "=", value).limit(1).executeTakeFirst();
-					return res;
-				}
-				if (config?.type === "mssql") {
-					res = await builder.outputAll("inserted").executeTakeFirst();
-					return res;
+					await builder.execute();
+					const fetchInserted = async (trx) => {
+						if (values.id) return await trx.selectFrom(model).selectAll().where(getFieldName({
+							model,
+							field: "id"
+						}), "=", values.id).limit(1).executeTakeFirst();
+						if (options.advanced?.database?.generateId === "serial") {
+							const lastId = (await sql`SELECT LAST_INSERT_ID() as id`.execute(trx)).rows[0]?.id;
+							if (lastId) return await trx.selectFrom(model).selectAll().where(getFieldName({
+								model,
+								field: "id"
+							}), "=", lastId).limit(1).executeTakeFirst();
+						}
+						const modelSchema = schema[getDefaultModelName(model)]?.fields;
+						if (modelSchema) for (const [fieldKey, fieldAttr] of Object.entries(modelSchema)) {
+							if (!fieldAttr.unique) continue;
+							const dbFieldName = getFieldName({
+								model,
+								field: fieldKey
+							});
+							const val = values[dbFieldName];
+							if (val === void 0 || val === null) continue;
+							const row = await trx.selectFrom(model).selectAll().where(dbFieldName, "=", val).limit(1).executeTakeFirst();
+							if (row) return row;
+						}
+						let query = trx.selectFrom(model).selectAll();
+						let hasConditions = false;
+						for (const [key, val] of Object.entries(values)) {
+							if (val === void 0) continue;
+							query = query.where(key, val === null ? "is" : "=", val);
+							hasConditions = true;
+						}
+						if (hasConditions) {
+							const rows = await query.limit(2).execute();
+							if (rows.length === 1) return rows[0];
+						}
+						logger.warn(`[Kysely Adapter] Unable to safely identify the inserted "${model}" row on MySQL. Enable Better Auth ID generation or use generateId: "serial" for reliable behavior.`);
+						return null;
+					};
+					return inTransaction ? fetchInserted(db) : db.transaction().execute(fetchInserted);
 				}
-				res = await builder.returningAll().executeTakeFirst();
-				return res;
+				if (config?.type === "mssql") return await builder.outputAll("inserted").executeTakeFirst();
+				return await builder.returningAll().executeTakeFirst();
 			};
 			function convertWhereClause(model, w) {
 				if (!w) return {
@@ -386,6 +430,7 @@ const kyselyAdapter = (db, config) => {
 					return res;
 				},
 				async update({ model, where, update: values }) {
+					if (where.length === 0) return null;
 					const { and, or } = convertWhereClause(model, where);
 					let query = db.updateTable(model).set(values);
 					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
@@ -425,6 +470,75 @@ const kyselyAdapter = (db, config) => {
 					const res = (await query.executeTakeFirst()).numDeletedRows;
 					return res > Number.MAX_SAFE_INTEGER ? Number.MAX_SAFE_INTEGER : Number(res);
 				},
+				async consumeOne({ model, where }) {
+					const { and, or } = convertWhereClause(model, where);
+					const applyWhere = (query) => {
+						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 query;
+					};
+					const idField = getFieldName({
+						model,
+						field: "id"
+					});
+					const deleteSelectedRow = async (db, row) => {
+						const targetId = row[idField] ?? row.id;
+						if (targetId === void 0 || targetId === null) return null;
+						const query = db.deleteFrom(model).where(`${model}.${idField}`, "=", targetId);
+						if (config?.type === "mysql") {
+							const result = await query.executeTakeFirst();
+							return Number(result.numDeletedRows) > 0 ? row : null;
+						}
+						if (config?.type === "mssql") return await query.outputAll("deleted").executeTakeFirst() ?? null;
+						return await query.returningAll().executeTakeFirst() ?? null;
+					};
+					const deleteWithReturning = async (query) => {
+						if (config?.type === "mssql") return await query.outputAll("deleted").executeTakeFirst() ?? null;
+						return await query.returningAll().executeTakeFirst() ?? null;
+					};
+					if (config?.type === "mysql") {
+						const claimFromTransaction = async (trx) => {
+							const row = await applyWhere(trx.selectFrom(model).selectAll().forUpdate()).limit(1).executeTakeFirst();
+							if (!row) return null;
+							return deleteSelectedRow(trx, row);
+						};
+						return inTransaction ? claimFromTransaction(db) : db.transaction().execute(claimFromTransaction);
+					}
+					const selectIds = applyWhere(db.selectFrom(model).select(`${model}.${idField}`));
+					const targetIds = config?.type === "mssql" ? selectIds.top(1) : selectIds.limit(1);
+					return deleteWithReturning(db.deleteFrom(model).where(`${model}.${idField}`, "in", targetIds));
+				},
+				async incrementOne({ model, where, increment, set }) {
+					const { and, or } = convertWhereClause(model, where);
+					const applyWhere = (query) => {
+						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 query;
+					};
+					const assignments = { ...set ?? {} };
+					for (const [field, delta] of Object.entries(increment)) assignments[field] = sql`${sql.ref(field)} + ${delta}`;
+					const idField = getFieldName({
+						model,
+						field: "id"
+					});
+					if (config?.type === "mysql") {
+						const incrementInTransaction = async (trx) => {
+							const target = await applyWhere(trx.selectFrom(model).select(`${model}.${idField}`).forUpdate()).limit(1).executeTakeFirst();
+							if (!target) return null;
+							const targetId = target[idField] ?? target.id;
+							if (targetId === void 0 || targetId === null) return null;
+							const updated = await applyWhere(trx.updateTable(model).set(assignments)).where(`${model}.${idField}`, "=", targetId).executeTakeFirst();
+							if (Number(updated.numUpdatedRows) === 0) return null;
+							return await trx.selectFrom(model).selectAll().where(`${model}.${idField}`, "=", targetId).limit(1).executeTakeFirst() ?? null;
+						};
+						return inTransaction ? incrementInTransaction(db) : db.transaction().execute(incrementInTransaction);
+					}
+					const selectIds = applyWhere(db.selectFrom(model).select(`${model}.${idField}`));
+					const targetIds = config?.type === "mssql" ? selectIds.top(1) : selectIds.limit(1);
+					const updateQuery = applyWhere(db.updateTable(model).set(assignments)).where(`${model}.${idField}`, "in", targetIds);
+					if (config?.type === "mssql") return await updateQuery.outputAll("inserted").executeTakeFirst() ?? null;
+					return await updateQuery.returningAll().executeTakeFirst() ?? null;
+				},
 				options: config
 			};
 		};
@@ -443,8 +557,11 @@ const kyselyAdapter = (db, config) => {
 			supportsUUIDs: config?.type === "postgres" ? true : false,
 			transaction: config?.transaction ? (cb) => db.transaction().execute((trx) => {
 				return cb(createAdapterFactory({
-					config: adapterOptions.config,
-					adapter: createCustomAdapter(trx)
+					config: {
+						...adapterOptions.config,
+						transaction: false
+					},
+					adapter: createCustomAdapter(trx, true)
 				})(lazyOptions));
 			}) : false
 		},

package/dist/node-sqlite-dialect.mjs

@@ -56,8 +56,15 @@ var NodeSqliteConnection = class {
 	}
 	executeQuery(compiledQuery) {
 		const { sql, parameters } = compiledQuery;
-		const rows = this.#db.prepare(sql).all(...parameters);
-		return Promise.resolve({ rows });
+		const stmt = this.#db.prepare(sql);
+		const params = parameters;
+		if (stmt.columns().length > 0) return Promise.resolve({ rows: stmt.all(...params) });
+		const { changes, lastInsertRowid } = stmt.run(...params);
+		return Promise.resolve({
+			rows: [],
+			numAffectedRows: BigInt(changes),
+			insertId: typeof lastInsertRowid === "bigint" ? lastInsertRowid : BigInt(lastInsertRowid)
+		});
 	}
 	async *streamQuery() {
 		throw new Error("Streaming query is not supported by SQLite driver.");
@@ -113,7 +120,7 @@ var NodeSqliteIntrospector = class {
 				isAutoIncrementing: col.name === autoIncrementCol,
 				hasDefaultValue: col.dflt_value != null
 			})),
-			isView: true
+			isView: false
 		};
 	}
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@better-auth/kysely-adapter",
-  "version": "1.7.0-beta.0",
+  "version": "1.7.0-beta.10",
   "description": "Kysely adapter for Better Auth",
   "type": "module",
   "license": "MIT",
@@ -40,9 +40,9 @@
     }
   },
   "peerDependencies": {
-    "@better-auth/utils": "0.4.0",
-    "kysely": "^0.27.0 || ^0.28.0",
-    "@better-auth/core": "^1.7.0-beta.0"
+    "@better-auth/utils": "0.4.2",
+    "kysely": "^0.28.17 || ^0.29.0",
+    "@better-auth/core": "^1.7.0-beta.10"
   },
   "peerDependenciesMeta": {
     "kysely": {
@@ -50,12 +50,12 @@
     }
   },
   "devDependencies": {
+    "@better-auth/utils": "0.4.2",
     "@cloudflare/workers-types": "^4.20250121.0",
-    "@better-auth/utils": "0.4.0",
-    "kysely": "^0.28.14",
+    "kysely": "^0.28.17 || ^0.29.0",
     "tsdown": "0.21.1",
     "typescript": "^5.9.3",
-    "@better-auth/core": "1.7.0-beta.0"
+    "@better-auth/core": "1.7.0-beta.10"
   },
   "scripts": {
     "build": "tsdown",