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

package/.turbo/turbo-build.log

@@ -0,0 +1,13 @@
+
+> @better-auth/drizzle-adapter@1.5.0-beta.9 build /home/runner/work/better-auth/better-auth/packages/drizzle-adapter
+> tsdown
+
+ℹ tsdown v0.19.0 powered by rolldown v1.0.0-beta.59
+ℹ config file: /home/runner/work/better-auth/better-auth/packages/drizzle-adapter/tsdown.config.ts 
+ℹ entry: src/index.ts
+ℹ tsconfig: tsconfig.json
+ℹ Build start
+ℹ dist/index.mjs    13.87 kB │ gzip: 2.88 kB
+ℹ dist/index.d.mts   1.46 kB │ gzip: 0.65 kB
+ℹ 2 files, total: 15.32 kB
+✔ Build complete in 8555ms

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/index.d.mts

@@ -0,0 +1,47 @@
+import { DBAdapter, DBAdapterDebugLogOption } from "@better-auth/core/db/adapter";
+import { BetterAuthOptions } from "@better-auth/core";
+
+//#region src/drizzle-adapter.d.ts
+interface DB {
+  [key: string]: any;
+}
+interface DrizzleAdapterConfig {
+  /**
+   * The schema object that defines the tables and fields
+   */
+  schema?: Record<string, any> | undefined;
+  /**
+   * The database provider
+   */
+  provider: "pg" | "mysql" | "sqlite";
+  /**
+   * If the table names in the schema are plural
+   * set this to true. For example, if the schema
+   * has an object with a key "users" instead of "user"
+   */
+  usePlural?: boolean | undefined;
+  /**
+   * Enable debug logs for the adapter
+   *
+   * @default false
+   */
+  debugLogs?: DBAdapterDebugLogOption | undefined;
+  /**
+   * By default snake case is used for table and field names
+   * when the CLI is used to generate the schema. If you want
+   * to use camel case, set this to true.
+   * @default false
+   */
+  camelCase?: 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 drizzleAdapter: (db: DB, config: DrizzleAdapterConfig) => (options: BetterAuthOptions) => DBAdapter<BetterAuthOptions>;
+//#endregion
+export { DB, DrizzleAdapterConfig, drizzleAdapter };

package/dist/index.mjs

@@ -0,0 +1,285 @@
+import { createAdapterFactory } from "@better-auth/core/db/adapter";
+import { logger } from "@better-auth/core/env";
+import { BetterAuthError } from "@better-auth/core/error";
+import { and, asc, count, desc, eq, gt, gte, inArray, like, lt, lte, ne, notInArray, or, sql } from "drizzle-orm";
+
+//#region src/drizzle-adapter.ts
+const drizzleAdapter = (db, config) => {
+	let lazyOptions = null;
+	const createCustomAdapter = (db$1) => ({ getFieldName, options }) => {
+		function getSchema(model) {
+			const schema = config.schema || db$1._.fullSchema;
+			if (!schema) throw new BetterAuthError("Drizzle adapter failed to initialize. Schema not found. Please provide a schema object in the adapter options object.");
+			const schemaModel = schema[model];
+			if (!schemaModel) throw new BetterAuthError(`[# Drizzle Adapter]: The model "${model}" was not found in the schema object. Please pass the schema directly to the adapter options.`);
+			return schemaModel;
+		}
+		const withReturning = async (model, builder, data, where) => {
+			if (config.provider !== "mysql") return (await builder.returning())[0];
+			await builder.execute();
+			const schemaModel = getSchema(model);
+			const builderVal = builder.config?.values;
+			if (where?.length) {
+				const clause = convertWhereClause(where.map((w) => {
+					if (data[w.field] !== void 0) return {
+						...w,
+						value: data[w.field]
+					};
+					return w;
+				}), model);
+				return (await db$1.select().from(schemaModel).where(...clause))[0];
+			} else if (builderVal && builderVal[0]?.id?.value) {
+				let tId = builderVal[0]?.id?.value;
+				if (!tId) tId = (await db$1.select({ id: sql`LAST_INSERT_ID()` }).from(schemaModel).orderBy(desc(schemaModel.id)).limit(1))[0].id;
+				return (await db$1.select().from(schemaModel).where(eq(schemaModel.id, tId)).limit(1).execute())[0];
+			} else if (data.id) return (await db$1.select().from(schemaModel).where(eq(schemaModel.id, data.id)).limit(1).execute())[0];
+			else {
+				if (!("id" in schemaModel)) throw new BetterAuthError(`The model "${model}" does not have an "id" field. Please use the "id" field as your primary key.`);
+				return (await db$1.select().from(schemaModel).orderBy(desc(schemaModel.id)).limit(1).execute())[0];
+			}
+		};
+		function convertWhereClause(where, model) {
+			const schemaModel = getSchema(model);
+			if (!where) return [];
+			if (where.length === 1) {
+				const w = where[0];
+				if (!w) return [];
+				const field = getFieldName({
+					model,
+					field: w.field
+				});
+				if (!schemaModel[field]) throw new BetterAuthError(`The field "${w.field}" does not exist in the schema for the model "${model}". Please update your schema.`);
+				if (w.operator === "in") {
+					if (!Array.isArray(w.value)) throw new BetterAuthError(`The value for the field "${w.field}" must be an array when using the "in" operator.`);
+					return [inArray(schemaModel[field], w.value)];
+				}
+				if (w.operator === "not_in") {
+					if (!Array.isArray(w.value)) throw new BetterAuthError(`The value for the field "${w.field}" must be an array when using the "not_in" operator.`);
+					return [notInArray(schemaModel[field], w.value)];
+				}
+				if (w.operator === "contains") return [like(schemaModel[field], `%${w.value}%`)];
+				if (w.operator === "starts_with") return [like(schemaModel[field], `${w.value}%`)];
+				if (w.operator === "ends_with") return [like(schemaModel[field], `%${w.value}`)];
+				if (w.operator === "lt") return [lt(schemaModel[field], w.value)];
+				if (w.operator === "lte") return [lte(schemaModel[field], w.value)];
+				if (w.operator === "ne") return [ne(schemaModel[field], w.value)];
+				if (w.operator === "gt") return [gt(schemaModel[field], w.value)];
+				if (w.operator === "gte") return [gte(schemaModel[field], w.value)];
+				return [eq(schemaModel[field], w.value)];
+			}
+			const andGroup = where.filter((w) => w.connector === "AND" || !w.connector);
+			const orGroup = where.filter((w) => w.connector === "OR");
+			const andClause = and(...andGroup.map((w) => {
+				const field = getFieldName({
+					model,
+					field: w.field
+				});
+				if (w.operator === "in") {
+					if (!Array.isArray(w.value)) throw new BetterAuthError(`The value for the field "${w.field}" must be an array when using the "in" operator.`);
+					return inArray(schemaModel[field], w.value);
+				}
+				if (w.operator === "not_in") {
+					if (!Array.isArray(w.value)) throw new BetterAuthError(`The value for the field "${w.field}" must be an array when using the "not_in" operator.`);
+					return notInArray(schemaModel[field], w.value);
+				}
+				if (w.operator === "contains") return like(schemaModel[field], `%${w.value}%`);
+				if (w.operator === "starts_with") return like(schemaModel[field], `${w.value}%`);
+				if (w.operator === "ends_with") return like(schemaModel[field], `%${w.value}`);
+				if (w.operator === "lt") return lt(schemaModel[field], w.value);
+				if (w.operator === "lte") return lte(schemaModel[field], w.value);
+				if (w.operator === "gt") return gt(schemaModel[field], w.value);
+				if (w.operator === "gte") return gte(schemaModel[field], w.value);
+				if (w.operator === "ne") return ne(schemaModel[field], w.value);
+				return eq(schemaModel[field], w.value);
+			}));
+			const orClause = or(...orGroup.map((w) => {
+				const field = getFieldName({
+					model,
+					field: w.field
+				});
+				if (w.operator === "in") {
+					if (!Array.isArray(w.value)) throw new BetterAuthError(`The value for the field "${w.field}" must be an array when using the "in" operator.`);
+					return inArray(schemaModel[field], w.value);
+				}
+				if (w.operator === "not_in") {
+					if (!Array.isArray(w.value)) throw new BetterAuthError(`The value for the field "${w.field}" must be an array when using the "not_in" operator.`);
+					return notInArray(schemaModel[field], w.value);
+				}
+				if (w.operator === "contains") return like(schemaModel[field], `%${w.value}%`);
+				if (w.operator === "starts_with") return like(schemaModel[field], `${w.value}%`);
+				if (w.operator === "ends_with") return like(schemaModel[field], `%${w.value}`);
+				if (w.operator === "lt") return lt(schemaModel[field], w.value);
+				if (w.operator === "lte") return lte(schemaModel[field], w.value);
+				if (w.operator === "gt") return gt(schemaModel[field], w.value);
+				if (w.operator === "gte") return gte(schemaModel[field], w.value);
+				if (w.operator === "ne") return ne(schemaModel[field], w.value);
+				return eq(schemaModel[field], w.value);
+			}));
+			const clause = [];
+			if (andGroup.length) clause.push(andClause);
+			if (orGroup.length) clause.push(orClause);
+			return clause;
+		}
+		function checkMissingFields(schema, model, values) {
+			if (!schema) throw new BetterAuthError("Drizzle adapter failed to initialize. Drizzle Schema not found. Please provide a schema object in the adapter options object.");
+			for (const key in values) if (!schema[key]) throw new BetterAuthError(`The field "${key}" does not exist in the "${model}" Drizzle schema. Please update your drizzle schema or re-generate using "npx @better-auth/cli@latest generate".`);
+		}
+		return {
+			async create({ model, data: values }) {
+				const schemaModel = getSchema(model);
+				checkMissingFields(schemaModel, model, values);
+				return await withReturning(model, db$1.insert(schemaModel).values(values), values);
+			},
+			async findOne({ model, where, join }) {
+				const schemaModel = getSchema(model);
+				const clause = convertWhereClause(where, model);
+				if (options.experimental?.joins) if (!db$1.query || !db$1.query[model]) {
+					logger.error(`[# Drizzle Adapter]: The model "${model}" was not found in the query object. Please update your Drizzle schema to include relations or re-generate using "npx @better-auth/cli@latest generate".`);
+					logger.info("Falling back to regular query");
+				} else {
+					let includes;
+					const pluralJoinResults = [];
+					if (join) {
+						includes = {};
+						const joinEntries = Object.entries(join);
+						for (const [model$1, joinAttr] of joinEntries) {
+							const limit = joinAttr.limit ?? options.advanced?.database?.defaultFindManyLimit ?? 100;
+							const isUnique = joinAttr.relation === "one-to-one";
+							const pluralSuffix = isUnique || config.usePlural ? "" : "s";
+							includes[`${model$1}${pluralSuffix}`] = isUnique ? true : { limit };
+							if (!isUnique) pluralJoinResults.push(`${model$1}${pluralSuffix}`);
+						}
+					}
+					const res$1 = await db$1.query[model].findFirst({
+						where: clause[0],
+						with: includes
+					});
+					if (res$1) for (const pluralJoinResult of pluralJoinResults) {
+						const singularKey = !config.usePlural ? pluralJoinResult.slice(0, -1) : pluralJoinResult;
+						res$1[singularKey] = res$1[pluralJoinResult];
+						if (pluralJoinResult !== singularKey) delete res$1[pluralJoinResult];
+					}
+					return res$1;
+				}
+				const res = await db$1.select().from(schemaModel).where(...clause);
+				if (!res.length) return null;
+				return res[0];
+			},
+			async findMany({ model, where, sortBy, limit, offset, join }) {
+				const schemaModel = getSchema(model);
+				const clause = where ? convertWhereClause(where, model) : [];
+				const sortFn = sortBy?.direction === "desc" ? desc : asc;
+				if (options.experimental?.joins) if (!db$1.query[model]) {
+					logger.error(`[# Drizzle Adapter]: The model "${model}" was not found in the query object. Please update your Drizzle schema to include relations or re-generate using "npx @better-auth/cli@latest generate".`);
+					logger.info("Falling back to regular query");
+				} else {
+					let includes;
+					const pluralJoinResults = [];
+					if (join) {
+						includes = {};
+						const joinEntries = Object.entries(join);
+						for (const [model$1, joinAttr] of joinEntries) {
+							const isUnique = joinAttr.relation === "one-to-one";
+							const limit$1 = joinAttr.limit ?? options.advanced?.database?.defaultFindManyLimit ?? 100;
+							const pluralSuffix = isUnique || config.usePlural ? "" : "s";
+							includes[`${model$1}${pluralSuffix}`] = isUnique ? true : { limit: limit$1 };
+							if (!isUnique) pluralJoinResults.push(`${model$1}${pluralSuffix}`);
+						}
+					}
+					let orderBy = void 0;
+					if (sortBy?.field) orderBy = [sortFn(schemaModel[getFieldName({
+						model,
+						field: sortBy?.field
+					})])];
+					const res = await db$1.query[model].findMany({
+						where: clause[0],
+						with: includes,
+						limit: limit ?? 100,
+						offset: offset ?? 0,
+						orderBy
+					});
+					if (res) for (const item of res) for (const pluralJoinResult of pluralJoinResults) {
+						const singularKey = !config.usePlural ? pluralJoinResult.slice(0, -1) : pluralJoinResult;
+						if (singularKey === pluralJoinResult) continue;
+						item[singularKey] = item[pluralJoinResult];
+						delete item[pluralJoinResult];
+					}
+					return res;
+				}
+				let builder = db$1.select().from(schemaModel);
+				const effectiveLimit = limit;
+				const effectiveOffset = offset;
+				if (typeof effectiveLimit !== "undefined") builder = builder.limit(effectiveLimit);
+				if (typeof effectiveOffset !== "undefined") builder = builder.offset(effectiveOffset);
+				if (sortBy?.field) builder = builder.orderBy(sortFn(schemaModel[getFieldName({
+					model,
+					field: sortBy?.field
+				})]));
+				return await builder.where(...clause);
+			},
+			async count({ model, where }) {
+				const schemaModel = getSchema(model);
+				const clause = where ? convertWhereClause(where, model) : [];
+				return (await db$1.select({ count: count() }).from(schemaModel).where(...clause))[0].count;
+			},
+			async update({ model, where, update: values }) {
+				const schemaModel = getSchema(model);
+				const clause = convertWhereClause(where, model);
+				return await withReturning(model, db$1.update(schemaModel).set(values).where(...clause), values, where);
+			},
+			async updateMany({ model, where, update: values }) {
+				const schemaModel = getSchema(model);
+				const clause = convertWhereClause(where, model);
+				return await db$1.update(schemaModel).set(values).where(...clause);
+			},
+			async delete({ model, where }) {
+				const schemaModel = getSchema(model);
+				const clause = convertWhereClause(where, model);
+				return await db$1.delete(schemaModel).where(...clause);
+			},
+			async deleteMany({ model, where }) {
+				const schemaModel = getSchema(model);
+				const clause = convertWhereClause(where, model);
+				const res = await db$1.delete(schemaModel).where(...clause);
+				let count$1 = 0;
+				if (res && "rowCount" in res) count$1 = res.rowCount;
+				else if (Array.isArray(res)) count$1 = res.length;
+				else if (res && ("affectedRows" in res || "rowsAffected" in res || "changes" in res)) count$1 = res.affectedRows ?? res.rowsAffected ?? res.changes;
+				if (typeof count$1 !== "number") logger.error("[Drizzle Adapter] The result of the deleteMany operation is not a number. This is likely a bug in the adapter. Please report this issue to the Better Auth team.", {
+					res,
+					model,
+					where
+				});
+				return count$1;
+			},
+			options: config
+		};
+	};
+	let adapterOptions = null;
+	adapterOptions = {
+		config: {
+			adapterId: "drizzle",
+			adapterName: "Drizzle Adapter",
+			usePlural: config.usePlural ?? false,
+			debugLogs: config.debugLogs ?? false,
+			supportsUUIDs: config.provider === "pg" ? true : false,
+			supportsJSON: config.provider === "pg" ? true : false,
+			supportsArrays: config.provider === "pg" ? true : false,
+			transaction: config.transaction ?? false ? (cb) => db.transaction((tx) => {
+				return cb(createAdapterFactory({
+					config: adapterOptions.config,
+					adapter: createCustomAdapter(tx)
+				})(lazyOptions));
+			}) : false
+		},
+		adapter: createCustomAdapter(db)
+	};
+	const adapter = createAdapterFactory(adapterOptions);
+	return (options) => {
+		lazyOptions = options;
+		return adapter(options);
+	};
+};
+
+//#endregion
+export { drizzleAdapter };

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@better-auth/drizzle-adapter",
+  "version": "1.5.0-beta.9",
+  "description": "Drizzle adapter for Better Auth",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/better-auth/better-auth.git",
+    "directory": "packages/drizzle-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"
+    }
+  },
+  "peerDependencies": {
+    "@better-auth/utils": "^0.3.0",
+    "drizzle-orm": "^0.30.0",
+    "@better-auth/core": "1.5.0-beta.9"
+  },
+  "devDependencies": {
+    "@better-auth/utils": "^0.3.0",
+    "drizzle-orm": "^0.30.0",
+    "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/drizzle-adapter.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from "vitest";
+import { drizzleAdapter } from "./drizzle-adapter";
+
+describe("drizzle-adapter", () => {
+	it("should create drizzle adapter", () => {
+		const db = {
+			_: {
+				fullSchema: {},
+			},
+		} as any;
+		const config = {
+			provider: "sqlite" as const,
+		};
+		const adapter = drizzleAdapter(db, config);
+		expect(adapter).toBeDefined();
+	});
+});

package/src/drizzle-adapter.ts

@@ -0,0 +1,606 @@
+import type { BetterAuthOptions } from "@better-auth/core";
+import type {
+	AdapterFactoryCustomizeAdapterCreator,
+	AdapterFactoryOptions,
+	DBAdapter,
+	DBAdapterDebugLogOption,
+	Where,
+} from "@better-auth/core/db/adapter";
+import { createAdapterFactory } from "@better-auth/core/db/adapter";
+import { logger } from "@better-auth/core/env";
+import { BetterAuthError } from "@better-auth/core/error";
+import type { SQL } from "drizzle-orm";
+import {
+	and,
+	asc,
+	count,
+	desc,
+	eq,
+	gt,
+	gte,
+	inArray,
+	like,
+	lt,
+	lte,
+	ne,
+	notInArray,
+	or,
+	sql,
+} from "drizzle-orm";
+
+export interface DB {
+	[key: string]: any;
+}
+
+export interface DrizzleAdapterConfig {
+	/**
+	 * The schema object that defines the tables and fields
+	 */
+	schema?: Record<string, any> | undefined;
+	/**
+	 * The database provider
+	 */
+	provider: "pg" | "mysql" | "sqlite";
+	/**
+	 * If the table names in the schema are plural
+	 * set this to true. For example, if the schema
+	 * has an object with a key "users" instead of "user"
+	 */
+	usePlural?: boolean | undefined;
+	/**
+	 * Enable debug logs for the adapter
+	 *
+	 * @default false
+	 */
+	debugLogs?: DBAdapterDebugLogOption | undefined;
+	/**
+	 * By default snake case is used for table and field names
+	 * when the CLI is used to generate the schema. If you want
+	 * to use camel case, set this to true.
+	 * @default false
+	 */
+	camelCase?: 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;
+}
+
+export const drizzleAdapter = (db: DB, config: DrizzleAdapterConfig) => {
+	let lazyOptions: BetterAuthOptions | null = null;
+	const createCustomAdapter =
+		(db: DB): AdapterFactoryCustomizeAdapterCreator =>
+		({ getFieldName, options }) => {
+			function getSchema(model: string) {
+				const schema = config.schema || db._.fullSchema;
+				if (!schema) {
+					throw new BetterAuthError(
+						"Drizzle adapter failed to initialize. Schema not found. Please provide a schema object in the adapter options object.",
+					);
+				}
+				const schemaModel = schema[model];
+				if (!schemaModel) {
+					throw new BetterAuthError(
+						`[# Drizzle Adapter]: The model "${model}" was not found in the schema object. Please pass the schema directly to the adapter options.`,
+					);
+				}
+				return schemaModel;
+			}
+			const withReturning = async (
+				model: string,
+				builder: any,
+				data: Record<string, any>,
+				where?: Where[] | undefined,
+			) => {
+				if (config.provider !== "mysql") {
+					const c = await builder.returning();
+					return c[0];
+				}
+				await builder.execute();
+				const schemaModel = getSchema(model);
+				const builderVal = builder.config?.values;
+				if (where?.length) {
+					// If we're updating a field that's in the where clause, use the new value
+					const updatedWhere = where.map((w) => {
+						// If this field was updated, use the new value for lookup
+						if (data[w.field] !== undefined) {
+							return { ...w, value: data[w.field] };
+						}
+						return w;
+					});
+
+					const clause = convertWhereClause(updatedWhere, model);
+					const res = await db
+						.select()
+						.from(schemaModel)
+						.where(...clause);
+					return res[0];
+				} else if (builderVal && builderVal[0]?.id?.value) {
+					let tId = builderVal[0]?.id?.value;
+					if (!tId) {
+						//get last inserted id
+						const lastInsertId = await db
+							.select({ id: sql`LAST_INSERT_ID()` })
+							.from(schemaModel)
+							.orderBy(desc(schemaModel.id))
+							.limit(1);
+						tId = lastInsertId[0].id;
+					}
+					const res = await db
+						.select()
+						.from(schemaModel)
+						.where(eq(schemaModel.id, tId))
+						.limit(1)
+						.execute();
+					return res[0];
+				} else if (data.id) {
+					const res = await db
+						.select()
+						.from(schemaModel)
+						.where(eq(schemaModel.id, data.id))
+						.limit(1)
+						.execute();
+					return res[0];
+				} else {
+					// If the user doesn't have `id` as a field, then this will fail.
+					// We expect that they defined `id` in all of their models.
+					if (!("id" in schemaModel)) {
+						throw new BetterAuthError(
+							`The model "${model}" does not have an "id" field. Please use the "id" field as your primary key.`,
+						);
+					}
+					const res = await db
+						.select()
+						.from(schemaModel)
+						.orderBy(desc(schemaModel.id))
+						.limit(1)
+						.execute();
+					return res[0];
+				}
+			};
+			function convertWhereClause(where: Where[], model: string) {
+				const schemaModel = getSchema(model);
+				if (!where) return [];
+				if (where.length === 1) {
+					const w = where[0];
+					if (!w) {
+						return [];
+					}
+					const field = getFieldName({ model, field: w.field });
+					if (!schemaModel[field]) {
+						throw new BetterAuthError(
+							`The field "${w.field}" does not exist in the schema for the model "${model}". Please update your schema.`,
+						);
+					}
+					if (w.operator === "in") {
+						if (!Array.isArray(w.value)) {
+							throw new BetterAuthError(
+								`The value for the field "${w.field}" must be an array when using the "in" operator.`,
+							);
+						}
+						return [inArray(schemaModel[field], w.value)];
+					}
+
+					if (w.operator === "not_in") {
+						if (!Array.isArray(w.value)) {
+							throw new BetterAuthError(
+								`The value for the field "${w.field}" must be an array when using the "not_in" operator.`,
+							);
+						}
+						return [notInArray(schemaModel[field], w.value)];
+					}
+
+					if (w.operator === "contains") {
+						return [like(schemaModel[field], `%${w.value}%`)];
+					}
+
+					if (w.operator === "starts_with") {
+						return [like(schemaModel[field], `${w.value}%`)];
+					}
+
+					if (w.operator === "ends_with") {
+						return [like(schemaModel[field], `%${w.value}`)];
+					}
+
+					if (w.operator === "lt") {
+						return [lt(schemaModel[field], w.value)];
+					}
+
+					if (w.operator === "lte") {
+						return [lte(schemaModel[field], w.value)];
+					}
+
+					if (w.operator === "ne") {
+						return [ne(schemaModel[field], w.value)];
+					}
+
+					if (w.operator === "gt") {
+						return [gt(schemaModel[field], w.value)];
+					}
+
+					if (w.operator === "gte") {
+						return [gte(schemaModel[field], w.value)];
+					}
+
+					return [eq(schemaModel[field], w.value)];
+				}
+				const andGroup = where.filter(
+					(w) => w.connector === "AND" || !w.connector,
+				);
+				const orGroup = where.filter((w) => w.connector === "OR");
+
+				const andClause = and(
+					...andGroup.map((w) => {
+						const field = getFieldName({ model, field: w.field });
+						if (w.operator === "in") {
+							if (!Array.isArray(w.value)) {
+								throw new BetterAuthError(
+									`The value for the field "${w.field}" must be an array when using the "in" operator.`,
+								);
+							}
+							return inArray(schemaModel[field], w.value);
+						}
+						if (w.operator === "not_in") {
+							if (!Array.isArray(w.value)) {
+								throw new BetterAuthError(
+									`The value for the field "${w.field}" must be an array when using the "not_in" operator.`,
+								);
+							}
+							return notInArray(schemaModel[field], w.value);
+						}
+						if (w.operator === "contains") {
+							return like(schemaModel[field], `%${w.value}%`);
+						}
+						if (w.operator === "starts_with") {
+							return like(schemaModel[field], `${w.value}%`);
+						}
+						if (w.operator === "ends_with") {
+							return like(schemaModel[field], `%${w.value}`);
+						}
+						if (w.operator === "lt") {
+							return lt(schemaModel[field], w.value);
+						}
+						if (w.operator === "lte") {
+							return lte(schemaModel[field], w.value);
+						}
+						if (w.operator === "gt") {
+							return gt(schemaModel[field], w.value);
+						}
+						if (w.operator === "gte") {
+							return gte(schemaModel[field], w.value);
+						}
+						if (w.operator === "ne") {
+							return ne(schemaModel[field], w.value);
+						}
+						return eq(schemaModel[field], w.value);
+					}),
+				);
+				const orClause = or(
+					...orGroup.map((w) => {
+						const field = getFieldName({ model, field: w.field });
+						if (w.operator === "in") {
+							if (!Array.isArray(w.value)) {
+								throw new BetterAuthError(
+									`The value for the field "${w.field}" must be an array when using the "in" operator.`,
+								);
+							}
+							return inArray(schemaModel[field], w.value);
+						}
+						if (w.operator === "not_in") {
+							if (!Array.isArray(w.value)) {
+								throw new BetterAuthError(
+									`The value for the field "${w.field}" must be an array when using the "not_in" operator.`,
+								);
+							}
+							return notInArray(schemaModel[field], w.value);
+						}
+						if (w.operator === "contains") {
+							return like(schemaModel[field], `%${w.value}%`);
+						}
+						if (w.operator === "starts_with") {
+							return like(schemaModel[field], `${w.value}%`);
+						}
+						if (w.operator === "ends_with") {
+							return like(schemaModel[field], `%${w.value}`);
+						}
+						if (w.operator === "lt") {
+							return lt(schemaModel[field], w.value);
+						}
+						if (w.operator === "lte") {
+							return lte(schemaModel[field], w.value);
+						}
+						if (w.operator === "gt") {
+							return gt(schemaModel[field], w.value);
+						}
+						if (w.operator === "gte") {
+							return gte(schemaModel[field], w.value);
+						}
+						if (w.operator === "ne") {
+							return ne(schemaModel[field], w.value);
+						}
+						return eq(schemaModel[field], w.value);
+					}),
+				);
+
+				const clause: SQL<unknown>[] = [];
+
+				if (andGroup.length) clause.push(andClause!);
+				if (orGroup.length) clause.push(orClause!);
+				return clause;
+			}
+			function checkMissingFields(
+				schema: Record<string, any>,
+				model: string,
+				values: Record<string, any>,
+			) {
+				if (!schema) {
+					throw new BetterAuthError(
+						"Drizzle adapter failed to initialize. Drizzle Schema not found. Please provide a schema object in the adapter options object.",
+					);
+				}
+				for (const key in values) {
+					if (!schema[key]) {
+						throw new BetterAuthError(
+							`The field "${key}" does not exist in the "${model}" Drizzle schema. Please update your drizzle schema or re-generate using "npx @better-auth/cli@latest generate".`,
+						);
+					}
+				}
+			}
+
+			return {
+				async create({ model, data: values }) {
+					const schemaModel = getSchema(model);
+					checkMissingFields(schemaModel, model, values);
+					const builder = db.insert(schemaModel).values(values);
+					const returned = await withReturning(model, builder, values);
+					return returned;
+				},
+				async findOne({ model, where, join }) {
+					const schemaModel = getSchema(model);
+					const clause = convertWhereClause(where, model);
+
+					if (options.experimental?.joins) {
+						if (!db.query || !db.query[model]) {
+							logger.error(
+								`[# Drizzle Adapter]: The model "${model}" was not found in the query object. Please update your Drizzle schema to include relations or re-generate using "npx @better-auth/cli@latest generate".`,
+							);
+							logger.info("Falling back to regular query");
+						} else {
+							let includes:
+								| Record<string, { limit: number } | boolean>
+								| undefined;
+
+							const pluralJoinResults: string[] = [];
+							if (join) {
+								includes = {};
+								const joinEntries = Object.entries(join);
+								for (const [model, joinAttr] of joinEntries) {
+									const limit =
+										joinAttr.limit ??
+										options.advanced?.database?.defaultFindManyLimit ??
+										100;
+									const isUnique = joinAttr.relation === "one-to-one";
+									const pluralSuffix = isUnique || config.usePlural ? "" : "s";
+									includes[`${model}${pluralSuffix}`] = isUnique
+										? true
+										: { limit };
+									if (!isUnique) {
+										pluralJoinResults.push(`${model}${pluralSuffix}`);
+									}
+								}
+							}
+							const query = db.query[model].findFirst({
+								where: clause[0],
+								with: includes,
+							});
+							const res = await query;
+
+							if (res) {
+								for (const pluralJoinResult of pluralJoinResults) {
+									const singularKey = !config.usePlural
+										? pluralJoinResult.slice(0, -1)
+										: pluralJoinResult;
+									res[singularKey] = res[pluralJoinResult];
+									if (pluralJoinResult !== singularKey) {
+										delete res[pluralJoinResult];
+									}
+								}
+							}
+							return res;
+						}
+					}
+
+					const query = db
+						.select()
+						.from(schemaModel)
+						.where(...clause);
+
+					const res = await query;
+
+					if (!res.length) return null;
+					return res[0];
+				},
+				async findMany({ model, where, sortBy, limit, offset, join }) {
+					const schemaModel = getSchema(model);
+					const clause = where ? convertWhereClause(where, model) : [];
+					const sortFn = sortBy?.direction === "desc" ? desc : asc;
+
+					if (options.experimental?.joins) {
+						if (!db.query[model]) {
+							logger.error(
+								`[# Drizzle Adapter]: The model "${model}" was not found in the query object. Please update your Drizzle schema to include relations or re-generate using "npx @better-auth/cli@latest generate".`,
+							);
+							logger.info("Falling back to regular query");
+						} else {
+							let includes:
+								| Record<string, { limit: number } | boolean>
+								| undefined;
+
+							const pluralJoinResults: string[] = [];
+							if (join) {
+								includes = {};
+								const joinEntries = Object.entries(join);
+								for (const [model, joinAttr] of joinEntries) {
+									const isUnique = joinAttr.relation === "one-to-one";
+									const limit =
+										joinAttr.limit ??
+										options.advanced?.database?.defaultFindManyLimit ??
+										100;
+									const pluralSuffix = isUnique || config.usePlural ? "" : "s";
+									includes[`${model}${pluralSuffix}`] = isUnique
+										? true
+										: { limit };
+									if (!isUnique)
+										pluralJoinResults.push(`${model}${pluralSuffix}`);
+								}
+							}
+							let orderBy: SQL<unknown>[] | undefined = undefined;
+							if (sortBy?.field) {
+								orderBy = [
+									sortFn(
+										schemaModel[getFieldName({ model, field: sortBy?.field })],
+									),
+								];
+							}
+							const query = db.query[model].findMany({
+								where: clause[0],
+								with: includes,
+								limit: limit ?? 100,
+								offset: offset ?? 0,
+								orderBy,
+							});
+							const res = await query;
+							if (res) {
+								for (const item of res) {
+									for (const pluralJoinResult of pluralJoinResults) {
+										const singularKey = !config.usePlural
+											? pluralJoinResult.slice(0, -1)
+											: pluralJoinResult;
+										if (singularKey === pluralJoinResult) continue;
+										item[singularKey] = item[pluralJoinResult];
+										delete item[pluralJoinResult];
+									}
+								}
+							}
+							return res;
+						}
+					}
+
+					let builder = db.select().from(schemaModel);
+
+					const effectiveLimit = limit;
+					const effectiveOffset = offset;
+
+					if (typeof effectiveLimit !== "undefined") {
+						builder = builder.limit(effectiveLimit);
+					}
+
+					if (typeof effectiveOffset !== "undefined") {
+						builder = builder.offset(effectiveOffset);
+					}
+
+					if (sortBy?.field) {
+						builder = builder.orderBy(
+							sortFn(
+								schemaModel[getFieldName({ model, field: sortBy?.field })],
+							),
+						);
+					}
+
+					const res = await builder.where(...clause);
+					return res;
+				},
+				async count({ model, where }) {
+					const schemaModel = getSchema(model);
+					const clause = where ? convertWhereClause(where, model) : [];
+					const res = await db
+						.select({ count: count() })
+						.from(schemaModel)
+						.where(...clause);
+					return res[0].count;
+				},
+				async update({ model, where, update: values }) {
+					const schemaModel = getSchema(model);
+					const clause = convertWhereClause(where, model);
+					const builder = db
+						.update(schemaModel)
+						.set(values)
+						.where(...clause);
+					return await withReturning(model, builder, values as any, where);
+				},
+				async updateMany({ model, where, update: values }) {
+					const schemaModel = getSchema(model);
+					const clause = convertWhereClause(where, model);
+					const builder = db
+						.update(schemaModel)
+						.set(values)
+						.where(...clause);
+					return await builder;
+				},
+				async delete({ model, where }) {
+					const schemaModel = getSchema(model);
+					const clause = convertWhereClause(where, model);
+					const builder = db.delete(schemaModel).where(...clause);
+					return await builder;
+				},
+				async deleteMany({ model, where }) {
+					const schemaModel = getSchema(model);
+					const clause = convertWhereClause(where, model);
+					const builder = db.delete(schemaModel).where(...clause);
+					const res = await builder;
+					let count = 0;
+					if (res && "rowCount" in res) count = res.rowCount;
+					else if (Array.isArray(res)) count = res.length;
+					else if (
+						res &&
+						("affectedRows" in res || "rowsAffected" in res || "changes" in res)
+					)
+						count = res.affectedRows ?? res.rowsAffected ?? res.changes;
+					if (typeof count !== "number") {
+						logger.error(
+							"[Drizzle Adapter] The result of the deleteMany operation is not a number. This is likely a bug in the adapter. Please report this issue to the Better Auth team.",
+							{ res, model, where },
+						);
+					}
+					return count;
+				},
+				options: config,
+			};
+		};
+	let adapterOptions: AdapterFactoryOptions | null = null;
+	adapterOptions = {
+		config: {
+			adapterId: "drizzle",
+			adapterName: "Drizzle Adapter",
+			usePlural: config.usePlural ?? false,
+			debugLogs: config.debugLogs ?? false,
+			supportsUUIDs: config.provider === "pg" ? true : false,
+			supportsJSON:
+				config.provider === "pg" // even though mysql also supports it, mysql requires to pass stringified json anyway.
+					? true
+					: false,
+			supportsArrays: config.provider === "pg" ? true : false,
+			transaction:
+				(config.transaction ?? false)
+					? (cb) =>
+							db.transaction((tx: DB) => {
+								const adapter = createAdapterFactory({
+									config: adapterOptions!.config,
+									adapter: createCustomAdapter(tx),
+								})(lazyOptions!);
+								return cb(adapter);
+							})
+					: false,
+		},
+		adapter: createCustomAdapter(db),
+	};
+	const adapter = createAdapterFactory(adapterOptions);
+	return (options: BetterAuthOptions): DBAdapter<BetterAuthOptions> => {
+		lazyOptions = options;
+		return adapter(options);
+	};
+};

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./drizzle-adapter";

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "include": ["./src"],
+  "references": [
+    {
+      "path": "../core/tsconfig.json"
+    }
+  ]
+}

package/tsdown.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+	dts: { build: true, incremental: true },
+	format: ["esm"],
+	entry: ["./src/index.ts"],
+});

package/vitest.config.ts

@@ -0,0 +1,3 @@
+import { defineProject } from "vitest/config";
+
+export default defineProject({});