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

package/.turbo/turbo-build.log

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

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,34 @@
+import { DBAdapter, DBAdapterDebugLogOption } from "@better-auth/core/db/adapter";
+import { BetterAuthOptions } from "@better-auth/core";
+
+//#region src/prisma-adapter.d.ts
+interface PrismaConfig {
+  /**
+   * Database provider.
+   */
+  provider: "sqlite" | "cockroachdb" | "mysql" | "postgresql" | "sqlserver" | "mongodb";
+  /**
+   * Enable debug logs for the adapter
+   *
+   * @default false
+   */
+  debugLogs?: DBAdapterDebugLogOption | undefined;
+  /**
+   * Use plural 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;
+}
+interface PrismaClient {}
+declare const prismaAdapter: (prisma: PrismaClient, config: PrismaConfig) => (options: BetterAuthOptions) => DBAdapter<BetterAuthOptions>;
+//#endregion
+export { PrismaConfig, prismaAdapter };

package/dist/index.mjs

@@ -0,0 +1,285 @@
+import { createAdapterFactory } from "@better-auth/core/db/adapter";
+import { BetterAuthError } from "@better-auth/core/error";
+
+//#region src/prisma-adapter.ts
+const prismaAdapter = (prisma, config) => {
+	let lazyOptions = null;
+	const createCustomAdapter = (prisma$1) => ({ getFieldName, getModelName, getFieldAttributes, getDefaultModelName, schema }) => {
+		const db = prisma$1;
+		const convertSelect = (select, model, join) => {
+			if (!select && !join) return void 0;
+			const result = {};
+			if (select) for (const field of select) result[getFieldName({
+				model,
+				field
+			})] = true;
+			if (join) {
+				if (!select) {
+					const fields = schema[getDefaultModelName(model)]?.fields || {};
+					fields.id = { type: "string" };
+					for (const field of Object.keys(fields)) result[getFieldName({
+						model,
+						field
+					})] = true;
+				}
+				for (const [joinModel, joinAttr] of Object.entries(join)) {
+					const key = getJoinKeyName(model, getModelName(joinModel), schema);
+					if (joinAttr.relation === "one-to-one") result[key] = true;
+					else result[key] = { take: joinAttr.limit };
+				}
+			}
+			return result;
+		};
+		/**
+		* Build the join key name based on whether the foreign field is unique or not.
+		* If unique, use singular. Otherwise, pluralize (add 's').
+		*/
+		const getJoinKeyName = (baseModel, joinedModel, schema$1) => {
+			try {
+				const defaultBaseModelName = getDefaultModelName(baseModel);
+				const defaultJoinedModelName = getDefaultModelName(joinedModel);
+				const key = getModelName(joinedModel).toLowerCase();
+				let foreignKeys = Object.entries(schema$1[defaultJoinedModelName]?.fields || {}).filter(([_field, fieldAttributes]) => fieldAttributes.references && getDefaultModelName(fieldAttributes.references.model) === defaultBaseModelName);
+				if (foreignKeys.length > 0) {
+					const [_foreignKey, foreignKeyAttributes] = foreignKeys[0];
+					return foreignKeyAttributes?.unique === true || config.usePlural === true ? key : `${key}s`;
+				}
+				foreignKeys = Object.entries(schema$1[defaultBaseModelName]?.fields || {}).filter(([_field, fieldAttributes]) => fieldAttributes.references && getDefaultModelName(fieldAttributes.references.model) === defaultJoinedModelName);
+				if (foreignKeys.length > 0) return key;
+			} catch {}
+			return `${getModelName(joinedModel).toLowerCase()}s`;
+		};
+		function operatorToPrismaOperator(operator) {
+			switch (operator) {
+				case "starts_with": return "startsWith";
+				case "ends_with": return "endsWith";
+				case "ne": return "not";
+				case "not_in": return "notIn";
+				default: return operator;
+			}
+		}
+		const convertWhereClause = ({ action, model, where }) => {
+			if (!where || !where.length) return {};
+			const buildSingleCondition = (w) => {
+				const fieldName = getFieldName({
+					model,
+					field: w.field
+				});
+				if (w.operator === "ne" && w.value === null) return getFieldAttributes({
+					model,
+					field: w.field
+				})?.required !== true ? { [fieldName]: { not: null } } : {};
+				if ((w.operator === "in" || w.operator === "not_in") && Array.isArray(w.value)) {
+					const filtered = w.value.filter((v) => v != null);
+					if (filtered.length === 0) if (w.operator === "in") return { AND: [{ [fieldName]: { equals: "__never__" } }, { [fieldName]: { not: "__never__" } }] };
+					else return {};
+					const prismaOp = operatorToPrismaOperator(w.operator);
+					return { [fieldName]: { [prismaOp]: filtered } };
+				}
+				if (w.operator === "eq" || !w.operator) return { [fieldName]: w.value };
+				return { [fieldName]: { [operatorToPrismaOperator(w.operator)]: w.value } };
+			};
+			if (action === "update") {
+				const and$1 = where.filter((w) => w.connector === "AND" || !w.connector);
+				const or$1 = where.filter((w) => w.connector === "OR");
+				const andSimple = and$1.filter((w) => w.operator === "eq" || !w.operator);
+				const andComplex = and$1.filter((w) => w.operator !== "eq" && w.operator !== void 0);
+				const andSimpleClause = andSimple.map((w) => buildSingleCondition(w));
+				const andComplexClause = andComplex.map((w) => buildSingleCondition(w));
+				const orClause$1 = or$1.map((w) => buildSingleCondition(w));
+				const result = {};
+				for (const clause of andSimpleClause) Object.assign(result, clause);
+				if (andComplexClause.length > 0) result.AND = andComplexClause;
+				if (orClause$1.length > 0) result.OR = orClause$1;
+				return result;
+			}
+			if (action === "delete") {
+				const idCondition = where.find((w) => w.field === "id");
+				if (idCondition) {
+					const idFieldName = getFieldName({
+						model,
+						field: "id"
+					});
+					const idClause = buildSingleCondition(idCondition);
+					const remainingWhere = where.filter((w) => w.field !== "id");
+					if (remainingWhere.length === 0) return idClause;
+					const and$1 = remainingWhere.filter((w) => w.connector === "AND" || !w.connector);
+					const or$1 = remainingWhere.filter((w) => w.connector === "OR");
+					const andClause$1 = and$1.map((w) => buildSingleCondition(w));
+					const orClause$1 = or$1.map((w) => buildSingleCondition(w));
+					const result = {};
+					if (idFieldName in idClause) result[idFieldName] = idClause[idFieldName];
+					else Object.assign(result, idClause);
+					if (andClause$1.length > 0) result.AND = andClause$1;
+					if (orClause$1.length > 0) result.OR = orClause$1;
+					return result;
+				}
+			}
+			if (where.length === 1) {
+				const w = where[0];
+				if (!w) return;
+				return buildSingleCondition(w);
+			}
+			const and = where.filter((w) => w.connector === "AND" || !w.connector);
+			const or = where.filter((w) => w.connector === "OR");
+			const andClause = and.map((w) => buildSingleCondition(w));
+			const orClause = or.map((w) => buildSingleCondition(w));
+			return {
+				...andClause.length ? { AND: andClause } : {},
+				...orClause.length ? { OR: orClause } : {}
+			};
+		};
+		return {
+			async create({ model, data: values, select }) {
+				if (!db[model]) throw new BetterAuthError(`Model ${model} does not exist in the database. If you haven't generated the Prisma client, you need to run 'npx prisma generate'`);
+				return await db[model].create({
+					data: values,
+					select: convertSelect(select, model)
+				});
+			},
+			async findOne({ model, where, select, join }) {
+				const whereClause = convertWhereClause({
+					model,
+					where,
+					action: "findOne"
+				});
+				if (!db[model]) throw new BetterAuthError(`Model ${model} does not exist in the database. If you haven't generated the Prisma client, you need to run 'npx prisma generate'`);
+				const map = /* @__PURE__ */ new Map();
+				for (const joinModel of Object.keys(join ?? {})) {
+					const key = getJoinKeyName(model, joinModel, schema);
+					map.set(key, getModelName(joinModel));
+				}
+				const selects = convertSelect(select, model, join);
+				const result = await db[model].findFirst({
+					where: whereClause,
+					select: selects
+				});
+				if (join && result) for (const [includeKey, originalKey] of map.entries()) {
+					if (includeKey === originalKey) continue;
+					if (includeKey in result) {
+						result[originalKey] = result[includeKey];
+						delete result[includeKey];
+					}
+				}
+				return result;
+			},
+			async findMany({ model, where, limit, offset, sortBy, join }) {
+				const whereClause = convertWhereClause({
+					model,
+					where,
+					action: "findMany"
+				});
+				if (!db[model]) throw new BetterAuthError(`Model ${model} does not exist in the database. If you haven't generated the Prisma client, you need to run 'npx prisma generate'`);
+				const map = /* @__PURE__ */ new Map();
+				if (join) for (const [joinModel, _value] of Object.entries(join)) {
+					const key = getJoinKeyName(model, joinModel, schema);
+					map.set(key, getModelName(joinModel));
+				}
+				const selects = convertSelect(void 0, model, join);
+				const result = await db[model].findMany({
+					where: whereClause,
+					take: limit || 100,
+					skip: offset || 0,
+					...sortBy?.field ? { orderBy: { [getFieldName({
+						model,
+						field: sortBy.field
+					})]: sortBy.direction === "desc" ? "desc" : "asc" } } : {},
+					select: selects
+				});
+				if (join && Array.isArray(result)) for (const item of result) for (const [includeKey, originalKey] of map.entries()) {
+					if (includeKey === originalKey) continue;
+					if (includeKey in item) {
+						item[originalKey] = item[includeKey];
+						delete item[includeKey];
+					}
+				}
+				return result;
+			},
+			async count({ model, where }) {
+				const whereClause = convertWhereClause({
+					model,
+					where,
+					action: "count"
+				});
+				if (!db[model]) throw new BetterAuthError(`Model ${model} does not exist in the database. If you haven't generated the Prisma client, you need to run 'npx prisma generate'`);
+				return await db[model].count({ where: whereClause });
+			},
+			async update({ model, where, update }) {
+				if (!db[model]) throw new BetterAuthError(`Model ${model} does not exist in the database. If you haven't generated the Prisma client, you need to run 'npx prisma generate'`);
+				const whereClause = convertWhereClause({
+					model,
+					where,
+					action: "update"
+				});
+				return await db[model].update({
+					where: whereClause,
+					data: update
+				});
+			},
+			async updateMany({ model, where, update }) {
+				if (!db[model]) throw new BetterAuthError(`Model ${model} does not exist in the database. If you haven't generated the Prisma client, you need to run 'npx prisma generate'`);
+				const whereClause = convertWhereClause({
+					model,
+					where,
+					action: "updateMany"
+				});
+				const result = await db[model].updateMany({
+					where: whereClause,
+					data: update
+				});
+				return result ? result.count : 0;
+			},
+			async delete({ model, where }) {
+				if (!db[model]) throw new BetterAuthError(`Model ${model} does not exist in the database. If you haven't generated the Prisma client, you need to run 'npx prisma generate'`);
+				const whereClause = convertWhereClause({
+					model,
+					where,
+					action: "delete"
+				});
+				try {
+					await db[model].delete({ where: whereClause });
+				} catch (e) {
+					if (e?.meta?.cause === "Record to delete does not exist.") return;
+					if (e?.code === "P2025") return;
+					console.log(e);
+				}
+			},
+			async deleteMany({ model, where }) {
+				const whereClause = convertWhereClause({
+					model,
+					where,
+					action: "deleteMany"
+				});
+				const result = await db[model].deleteMany({ where: whereClause });
+				return result ? result.count : 0;
+			},
+			options: config
+		};
+	};
+	let adapterOptions = null;
+	adapterOptions = {
+		config: {
+			adapterId: "prisma",
+			adapterName: "Prisma Adapter",
+			usePlural: config.usePlural ?? false,
+			debugLogs: config.debugLogs ?? false,
+			supportsUUIDs: config.provider === "postgresql" ? true : false,
+			supportsArrays: config.provider === "postgresql" || config.provider === "mongodb" ? true : false,
+			transaction: config.transaction ?? false ? (cb) => prisma.$transaction((tx) => {
+				return cb(createAdapterFactory({
+					config: adapterOptions.config,
+					adapter: createCustomAdapter(tx)
+				})(lazyOptions));
+			}) : false
+		},
+		adapter: createCustomAdapter(prisma)
+	};
+	const adapter = createAdapterFactory(adapterOptions);
+	return (options) => {
+		lazyOptions = options;
+		return adapter(options);
+	};
+};
+
+//#endregion
+export { prismaAdapter };

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@better-auth/prisma-adapter",
+  "version": "1.5.0-beta.9",
+  "description": "Prisma adapter for Better Auth",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/better-auth/better-auth.git",
+    "directory": "packages/prisma-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"
+    }
+  },
+  "dependencies": {
+    "@prisma/client": "^5.0.0"
+  },
+  "peerDependencies": {
+    "@prisma/client": "^5.0.0 || ^6.0.0 || ^7.0.0",
+    "@better-auth/utils": "^0.3.0",
+    "prisma": "^5.0.0 || ^6.0.0 || ^7.0.0",
+    "@better-auth/core": "1.5.0-beta.9"
+  },
+  "devDependencies": {
+    "@better-auth/utils": "^0.3.0",
+    "prisma": "^5.0.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/index.ts

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

package/src/prisma-adapter.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it, vi } from "vitest";
+import { prismaAdapter } from "./prisma-adapter";
+
+describe("prisma-adapter", () => {
+	it("should create prisma adapter", () => {
+		const prisma = {
+			$transaction: vi.fn(),
+		} as any;
+		const adapter = prismaAdapter(prisma, {
+			provider: "sqlite",
+		});
+		expect(adapter).toBeDefined();
+	});
+});

package/src/prisma-adapter.ts

@@ -0,0 +1,564 @@
+import type { Awaitable, BetterAuthOptions } from "@better-auth/core";
+import type {
+	AdapterFactoryCustomizeAdapterCreator,
+	AdapterFactoryOptions,
+	DBAdapter,
+	DBAdapterDebugLogOption,
+	JoinConfig,
+	Where,
+} from "@better-auth/core/db/adapter";
+import { createAdapterFactory } from "@better-auth/core/db/adapter";
+import { BetterAuthError } from "@better-auth/core/error";
+
+export interface PrismaConfig {
+	/**
+	 * Database provider.
+	 */
+	provider:
+		| "sqlite"
+		| "cockroachdb"
+		| "mysql"
+		| "postgresql"
+		| "sqlserver"
+		| "mongodb";
+
+	/**
+	 * Enable debug logs for the adapter
+	 *
+	 * @default false
+	 */
+	debugLogs?: DBAdapterDebugLogOption | undefined;
+
+	/**
+	 * Use plural 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;
+}
+
+interface PrismaClient {}
+
+type PrismaClientInternal = {
+	$transaction: (
+		callback: (db: PrismaClient) => Awaitable<any>,
+	) => Promise<any>;
+} & {
+	[model: string]: {
+		create: (data: any) => Promise<any>;
+		findFirst: (data: any) => Promise<any>;
+		findMany: (data: any) => Promise<any>;
+		update: (data: any) => Promise<any>;
+		updateMany: (data: any) => Promise<any>;
+		delete: (data: any) => Promise<any>;
+		[key: string]: any;
+	};
+};
+
+export const prismaAdapter = (prisma: PrismaClient, config: PrismaConfig) => {
+	let lazyOptions: BetterAuthOptions | null = null;
+	const createCustomAdapter =
+		(prisma: PrismaClient): AdapterFactoryCustomizeAdapterCreator =>
+		({
+			getFieldName,
+			getModelName,
+			getFieldAttributes,
+			getDefaultModelName,
+			schema,
+		}) => {
+			const db = prisma as PrismaClientInternal;
+
+			const convertSelect = (
+				select: string[] | undefined,
+				model: string,
+				join?: JoinConfig | undefined,
+			) => {
+				if (!select && !join) return undefined;
+
+				const result: Record<string, Record<string, any> | boolean> = {};
+
+				if (select) {
+					for (const field of select) {
+						result[getFieldName({ model, field })] = true;
+					}
+				}
+
+				if (join) {
+					// when joining that has a limit, we need to use Prisma's `select` syntax to append the limit to the field
+					// because of such, it also means we need to select all base-model fields as well
+					// should check if `select` is not provided, because then we should select all base-model fields
+					if (!select) {
+						const fields = schema[getDefaultModelName(model)]?.fields || {};
+						fields.id = { type: "string" }; // make sure there is at least an id field
+						for (const field of Object.keys(fields)) {
+							result[getFieldName({ model, field })] = true;
+						}
+					}
+
+					for (const [joinModel, joinAttr] of Object.entries(join)) {
+						const key = getJoinKeyName(model, getModelName(joinModel), schema);
+						if (joinAttr.relation === "one-to-one") {
+							result[key] = true;
+						} else {
+							result[key] = { take: joinAttr.limit };
+						}
+					}
+				}
+
+				return result;
+			};
+
+			/**
+			 * Build the join key name based on whether the foreign field is unique or not.
+			 * If unique, use singular. Otherwise, pluralize (add 's').
+			 */
+			const getJoinKeyName = (
+				baseModel: string,
+				joinedModel: string,
+				schema: any,
+			): string => {
+				try {
+					const defaultBaseModelName = getDefaultModelName(baseModel);
+					const defaultJoinedModelName = getDefaultModelName(joinedModel);
+					const key = getModelName(joinedModel).toLowerCase();
+
+					// First, check if the joined model has FKs to the base model (forward join)
+					let foreignKeys = Object.entries(
+						schema[defaultJoinedModelName]?.fields || {},
+					).filter(
+						([_field, fieldAttributes]: any) =>
+							fieldAttributes.references &&
+							getDefaultModelName(fieldAttributes.references.model) ===
+								defaultBaseModelName,
+					);
+
+					if (foreignKeys.length > 0) {
+						// Forward join: joined model has FK to base model
+						// This is typically a one-to-many relationship (plural)
+						// Unless the FK is unique, then it's one-to-one (singular)
+						const [_foreignKey, foreignKeyAttributes] = foreignKeys[0] as any;
+						// Only check if field is explicitly marked as unique
+						const isUnique = foreignKeyAttributes?.unique === true;
+						return isUnique || config.usePlural === true ? key : `${key}s`;
+					}
+
+					// Check backwards: does the base model have FKs to the joined model?
+					foreignKeys = Object.entries(
+						schema[defaultBaseModelName]?.fields || {},
+					).filter(
+						([_field, fieldAttributes]: any) =>
+							fieldAttributes.references &&
+							getDefaultModelName(fieldAttributes.references.model) ===
+								defaultJoinedModelName,
+					);
+
+					if (foreignKeys.length > 0) {
+						return key;
+					}
+				} catch {
+					// Fallback to pluralizing if we can't determine uniqueness
+				}
+				return `${getModelName(joinedModel).toLowerCase()}s`;
+			};
+			function operatorToPrismaOperator(operator: string) {
+				switch (operator) {
+					case "starts_with":
+						return "startsWith";
+					case "ends_with":
+						return "endsWith";
+					case "ne":
+						return "not";
+					case "not_in":
+						return "notIn";
+					default:
+						return operator;
+				}
+			}
+			const convertWhereClause = ({
+				action,
+				model,
+				where,
+			}: {
+				model: string;
+				where?: Where[] | undefined;
+				action:
+					| "create"
+					| "update"
+					| "delete"
+					| "findOne"
+					| "findMany"
+					| "count"
+					| "updateMany"
+					| "deleteMany";
+			}) => {
+				if (!where || !where.length) return {};
+				const buildSingleCondition = (w: Where) => {
+					const fieldName = getFieldName({ model, field: w.field });
+					// Special handling for Prisma null semantics, for non-nullable fields this is a tautology. Skip condition.
+					if (w.operator === "ne" && w.value === null) {
+						const fieldAttributes = getFieldAttributes({
+							model,
+							field: w.field,
+						});
+						const isNullable = fieldAttributes?.required !== true;
+						return isNullable ? { [fieldName]: { not: null } } : {};
+					}
+					if (
+						(w.operator === "in" || w.operator === "not_in") &&
+						Array.isArray(w.value)
+					) {
+						const filtered = w.value.filter((v) => v != null);
+						if (filtered.length === 0) {
+							if (w.operator === "in") {
+								return {
+									AND: [
+										{ [fieldName]: { equals: "__never__" } },
+										{ [fieldName]: { not: "__never__" } },
+									],
+								};
+							} else {
+								return {};
+							}
+						}
+						const prismaOp = operatorToPrismaOperator(w.operator);
+						return { [fieldName]: { [prismaOp]: filtered } };
+					}
+					if (w.operator === "eq" || !w.operator) {
+						return { [fieldName]: w.value };
+					}
+					return {
+						[fieldName]: {
+							[operatorToPrismaOperator(w.operator)]: w.value,
+						},
+					};
+				};
+
+				// Special handling for update actions: extract AND conditions with eq operator to root level
+				// Prisma requires unique fields to be at root level, not nested in AND arrays
+				// Only simple equality conditions can be at root level; complex operators must stay in AND array
+				if (action === "update") {
+					const and = where.filter(
+						(w) => w.connector === "AND" || !w.connector,
+					);
+					const or = where.filter((w) => w.connector === "OR");
+
+					// Separate AND conditions into simple eq (can extract) and complex (must stay in AND)
+					const andSimple = and.filter(
+						(w) => w.operator === "eq" || !w.operator,
+					);
+					const andComplex = and.filter(
+						(w) => w.operator !== "eq" && w.operator !== undefined,
+					);
+
+					const andSimpleClause = andSimple.map((w) => buildSingleCondition(w));
+					const andComplexClause = andComplex.map((w) =>
+						buildSingleCondition(w),
+					);
+					const orClause = or.map((w) => buildSingleCondition(w));
+
+					// Extract simple equality AND conditions to root level
+					const result: Record<string, any> = {};
+					for (const clause of andSimpleClause) {
+						Object.assign(result, clause);
+					}
+					// Keep complex AND conditions in AND array
+					if (andComplexClause.length > 0) {
+						result.AND = andComplexClause;
+					}
+					if (orClause.length > 0) {
+						result.OR = orClause;
+					}
+					return result;
+				}
+
+				// Special handling for delete actions: extract id to root level
+				if (action === "delete") {
+					const idCondition = where.find((w) => w.field === "id");
+					if (idCondition) {
+						const idFieldName = getFieldName({ model, field: "id" });
+						const idClause = buildSingleCondition(idCondition);
+						const remainingWhere = where.filter((w) => w.field !== "id");
+
+						if (remainingWhere.length === 0) {
+							return idClause;
+						}
+
+						const and = remainingWhere.filter(
+							(w) => w.connector === "AND" || !w.connector,
+						);
+						const or = remainingWhere.filter((w) => w.connector === "OR");
+						const andClause = and.map((w) => buildSingleCondition(w));
+						const orClause = or.map((w) => buildSingleCondition(w));
+
+						// Extract id to root level, put other conditions in AND array
+						const result: Record<string, any> = {};
+						if (idFieldName in idClause) {
+							result[idFieldName] = (idClause as Record<string, any>)[
+								idFieldName
+							];
+						} else {
+							// Handle edge case where idClause might have special structure
+							Object.assign(result, idClause);
+						}
+						if (andClause.length > 0) {
+							result.AND = andClause;
+						}
+						if (orClause.length > 0) {
+							result.OR = orClause;
+						}
+						return result;
+					}
+				}
+
+				if (where.length === 1) {
+					const w = where[0]!;
+					if (!w) {
+						return;
+					}
+					return buildSingleCondition(w);
+				}
+				const and = where.filter((w) => w.connector === "AND" || !w.connector);
+				const or = where.filter((w) => w.connector === "OR");
+				const andClause = and.map((w) => buildSingleCondition(w));
+				const orClause = or.map((w) => buildSingleCondition(w));
+
+				return {
+					...(andClause.length ? { AND: andClause } : {}),
+					...(orClause.length ? { OR: orClause } : {}),
+				};
+			};
+
+			return {
+				async create({ model, data: values, select }) {
+					if (!db[model]) {
+						throw new BetterAuthError(
+							`Model ${model} does not exist in the database. If you haven't generated the Prisma client, you need to run 'npx prisma generate'`,
+						);
+					}
+					const result = await db[model]!.create({
+						data: values,
+						select: convertSelect(select, model),
+					});
+					return result;
+				},
+				async findOne({ model, where, select, join }) {
+					// this is just "JoinOption" type because we disabled join transformation in adapter config
+					const whereClause = convertWhereClause({
+						model,
+						where,
+						action: "findOne",
+					});
+					if (!db[model]) {
+						throw new BetterAuthError(
+							`Model ${model} does not exist in the database. If you haven't generated the Prisma client, you need to run 'npx prisma generate'`,
+						);
+					}
+
+					// transform join keys to use Prisma expected field names
+					const map = new Map<string, string>();
+					for (const joinModel of Object.keys(join ?? {})) {
+						const key = getJoinKeyName(model, joinModel, schema);
+						map.set(key, getModelName(joinModel));
+					}
+
+					const selects = convertSelect(select, model, join);
+
+					const result = await db[model]!.findFirst({
+						where: whereClause,
+						select: selects,
+					});
+
+					// transform the resulting `include` items to use better-auth expected field names
+					if (join && result) {
+						for (const [includeKey, originalKey] of map.entries()) {
+							if (includeKey === originalKey) continue;
+							if (includeKey in result) {
+								result[originalKey] = result[includeKey];
+								delete result[includeKey];
+							}
+						}
+					}
+					return result;
+				},
+				async findMany({ model, where, limit, offset, sortBy, join }) {
+					// this is just "JoinOption" type because we disabled join transformation in adapter config
+					const whereClause = convertWhereClause({
+						model,
+						where,
+						action: "findMany",
+					});
+					if (!db[model]) {
+						throw new BetterAuthError(
+							`Model ${model} does not exist in the database. If you haven't generated the Prisma client, you need to run 'npx prisma generate'`,
+						);
+					}
+					// transform join keys to use Prisma expected field names
+					const map = new Map<string, string>();
+					if (join) {
+						for (const [joinModel, _value] of Object.entries(join)) {
+							const key = getJoinKeyName(model, joinModel, schema);
+							map.set(key, getModelName(joinModel));
+						}
+					}
+
+					const selects = convertSelect(undefined, model, join);
+
+					const result = await db[model]!.findMany({
+						where: whereClause,
+						take: limit || 100,
+						skip: offset || 0,
+						...(sortBy?.field
+							? {
+									orderBy: {
+										[getFieldName({ model, field: sortBy.field })]:
+											sortBy.direction === "desc" ? "desc" : "asc",
+									},
+								}
+							: {}),
+						select: selects,
+					});
+
+					// transform the resulting join items to use better-auth expected field names
+					if (join && Array.isArray(result)) {
+						for (const item of result) {
+							for (const [includeKey, originalKey] of map.entries()) {
+								if (includeKey === originalKey) continue;
+								if (includeKey in item) {
+									item[originalKey] = item[includeKey];
+									delete item[includeKey];
+								}
+							}
+						}
+					}
+
+					return result;
+				},
+				async count({ model, where }) {
+					const whereClause = convertWhereClause({
+						model,
+						where,
+						action: "count",
+					});
+					if (!db[model]) {
+						throw new BetterAuthError(
+							`Model ${model} does not exist in the database. If you haven't generated the Prisma client, you need to run 'npx prisma generate'`,
+						);
+					}
+					return await db[model]!.count({
+						where: whereClause,
+					});
+				},
+				async update({ model, where, update }) {
+					if (!db[model]) {
+						throw new BetterAuthError(
+							`Model ${model} does not exist in the database. If you haven't generated the Prisma client, you need to run 'npx prisma generate'`,
+						);
+					}
+					const whereClause = convertWhereClause({
+						model,
+						where,
+						action: "update",
+					});
+
+					return await db[model]!.update({
+						where: whereClause,
+						data: update,
+					});
+				},
+				async updateMany({ model, where, update }) {
+					if (!db[model]) {
+						throw new BetterAuthError(
+							`Model ${model} does not exist in the database. If you haven't generated the Prisma client, you need to run 'npx prisma generate'`,
+						);
+					}
+					const whereClause = convertWhereClause({
+						model,
+						where,
+						action: "updateMany",
+					});
+					const result = await db[model]!.updateMany({
+						where: whereClause,
+						data: update,
+					});
+					return result ? (result.count as number) : 0;
+				},
+				async delete({ model, where }) {
+					if (!db[model]) {
+						throw new BetterAuthError(
+							`Model ${model} does not exist in the database. If you haven't generated the Prisma client, you need to run 'npx prisma generate'`,
+						);
+					}
+					const whereClause = convertWhereClause({
+						model,
+						where,
+						action: "delete",
+					});
+					try {
+						await db[model]!.delete({
+							where: whereClause,
+						});
+					} catch (e: any) {
+						// If the record doesn't exist, we don't want to throw an error
+						if (e?.meta?.cause === "Record to delete does not exist.") return;
+						if (e?.code === "P2025") return; // Prisma 7+
+						// otherwise if it's an unknown error, we want to just log it for debugging.
+						console.log(e);
+					}
+				},
+				async deleteMany({ model, where }) {
+					const whereClause = convertWhereClause({
+						model,
+						where,
+						action: "deleteMany",
+					});
+					const result = await db[model]!.deleteMany({
+						where: whereClause,
+					});
+					return result ? (result.count as number) : 0;
+				},
+				options: config,
+			};
+		};
+
+	let adapterOptions: AdapterFactoryOptions | null = null;
+	adapterOptions = {
+		config: {
+			adapterId: "prisma",
+			adapterName: "Prisma Adapter",
+			usePlural: config.usePlural ?? false,
+			debugLogs: config.debugLogs ?? false,
+			supportsUUIDs: config.provider === "postgresql" ? true : false,
+			supportsArrays:
+				config.provider === "postgresql" || config.provider === "mongodb"
+					? true
+					: false,
+			transaction:
+				(config.transaction ?? false)
+					? (cb) =>
+							(prisma as PrismaClientInternal).$transaction((tx) => {
+								const adapter = createAdapterFactory({
+									config: adapterOptions!.config,
+									adapter: createCustomAdapter(tx),
+								})(lazyOptions!);
+								return cb(adapter);
+							})
+					: false,
+		},
+		adapter: createCustomAdapter(prisma),
+	};
+
+	const adapter = createAdapterFactory(adapterOptions);
+	return (options: BetterAuthOptions): DBAdapter<BetterAuthOptions> => {
+		lazyOptions = options;
+		return adapter(options);
+	};
+};

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({});