@shivaedev/platform 0.3.8 → 0.4.0

package/src/better-auth/adapter.ts

@@ -1,18 +1,10 @@
-import type { AnyDatabase, DatabaseServiceOf } from "@shivaedev/effect-prisma";
-import type { BetterAuthOptions, DBAdapterInstance, Where } from "better-auth";
-import { type CustomAdapter, createAdapterFactory } from "better-auth/adapters";
-import { Effect, Option } from "effect";
-import type { PlatformRuntime } from "../runtime/types.js";
-import { type DynamicRelation, refineRelation } from "./relation.js";
-
-type CleanedWhere = Required<Where>;
-type FindOneInput = Parameters<CustomAdapter["findOne"]>[0];
-type FindManyInput = Parameters<CustomAdapter["findMany"]>[0];
-type UpdateInput<Value> = {
-	readonly model: string;
-	readonly update: Value;
-	readonly where: CleanedWhere[];
-};
+import type { AnyDatabase } from "@shivaedev/effect-prisma";
+import type { BetterAuthOptions, DBAdapterInstance } from "better-auth";
+import { createAdapterFactory } from "better-auth/adapters";
+import { Effect } from "effect";
+import type { PlatformRuntime } from "../runtime/types.ts";
+import { type DynamicRelation, refineRelation } from "./relation.ts";
+import { makeRowAdapter, type RelationQuery } from "./row-adapter.ts";
 
 export interface EffectPrismaAdapterOptions {
 	readonly debugLogs?: boolean;
@@ -21,54 +13,55 @@ export interface EffectPrismaAdapterOptions {
 	readonly usePlural?: boolean;
 }
 
-interface DynamicDatabase<Requirements> {
-	readonly transaction: <A, E, R>(
-		program: Effect.Effect<A, E, R>,
-	) => Effect.Effect<A, E | unknown, R | Requirements>;
-	readonly [model: string]: DynamicRelation<Requirements> | unknown;
+interface DynamicDatabase {
+	readonly transaction: <A, E, R>(program: Effect.Effect<A, E, R>) => Effect.Effect<A, unknown, unknown>;
 }
 
-const modelRelation = <Requirements>(
-	database: DynamicDatabase<Requirements>,
-	model: string,
-	mapModelName: (model: string) => string,
-): DynamicRelation<Requirements> =>
-	Reflect.get(database, mapModelName(model)) as DynamicRelation<Requirements>;
+const isFunction = (value: unknown, key: string): boolean =>
+	((typeof value === "object" && value !== null) || typeof value === "function") && typeof Reflect.get(value, key) === "function";
 
-const defaultModelName = (model: string): string =>
-	model.length === 0 ? model : `${model[0]?.toUpperCase()}${model.slice(1)}`;
+const isDynamicDatabase = (value: unknown): value is DynamicDatabase => isFunction(value, "transaction");
 
-const rejectJoin = (join: unknown): void => {
-	if (join !== undefined) {
-		throw new TypeError(
-			"The Effect Prisma Better Auth adapter does not support experimental native joins",
-		);
+const isDynamicRelation = (value: unknown): value is DynamicRelation<unknown> => isFunction(value, "where") && isFunction(value, "select");
+
+const modelRelation = (database: DynamicDatabase, model: string): DynamicRelation<unknown> => {
+	const relation: unknown = Reflect.get(database, model);
+	if (!isDynamicRelation(relation)) {
+		throw new TypeError(`Unknown database model: ${model}`);
 	}
+	return relation;
 };
 
-export const effectPrismaAdapter =
-	<Database extends AnyDatabase, Services, BuildError>(
-		databaseTag: Database,
-		runtime: PlatformRuntime<Services, BuildError>,
-		adapterOptions: EffectPrismaAdapterOptions = {},
-	): DBAdapterInstance =>
-	(authOptions: BetterAuthOptions) => {
+const defaultModelName = (model: string): string => (model.length === 0 ? model : `${model[0]?.toUpperCase()}${model.slice(1)}`);
+
+export function effectPrismaAdapter<Database extends AnyDatabase, Services, BuildError>(
+	databaseTag: Database,
+	runtime: PlatformRuntime<Services, BuildError>,
+	adapterOptions?: EffectPrismaAdapterOptions,
+): DBAdapterInstance;
+export function effectPrismaAdapter(
+	databaseTag: AnyDatabase,
+	runtime: PlatformRuntime<unknown, unknown>,
+	adapterOptions: EffectPrismaAdapterOptions = {},
+): DBAdapterInstance {
+	return (authOptions: BetterAuthOptions) => {
 		const mapModelName = adapterOptions.modelName ?? defaultModelName;
-		const databaseEffect = databaseTag as Effect.Effect<
-			DatabaseServiceOf<Database>,
-			never,
-			Services
-		>;
+		const databaseEffect = Effect.flatMap(databaseTag, (database) =>
+			isDynamicDatabase(database) ? Effect.succeed(database) : Effect.die(new TypeError("The database service has no transaction")),
+		);
+
+		const run = <Value>(operation: (database: DynamicDatabase) => Effect.Effect<Value, unknown, unknown>): Promise<Value> =>
+			runtime.runPromise(Effect.flatMap(databaseEffect, operation));
 
-		const run = <Value>(
-			operation: (
-				database: DynamicDatabase<Services>,
-			) => Effect.Effect<Value, unknown, Services>,
-		): Promise<Value> =>
-			runtime.runPromise(
-				Effect.flatMap(databaseEffect, (database) =>
-					operation(database as DynamicDatabase<Services>),
-				),
+		const query: RelationQuery = (model, refinement, use) =>
+			run((database) => use(refineRelation(modelRelation(database, mapModelName(model)), refinement)));
+
+		const inTransaction = <Value>(callback: () => Promise<Value>): Effect.Effect<Value, unknown, unknown> =>
+			Effect.flatMap(Effect.context<unknown>(), (services) =>
+				Effect.tryPromise({
+					try: () => runtime.runWithServices(services, callback),
+					catch: (error) => error,
+				}),
 			);
 
 		let factory: ReturnType<typeof createAdapterFactory>;
@@ -83,144 +76,11 @@ export const effectPrismaAdapter =
 				supportsJSON: true,
 				supportsNumericIds: true,
 				supportsUUIDs: true,
-				transaction: (callback) =>
-					run((database) =>
-						database.transaction(
-							Effect.flatMap(Effect.context<Services>(), (services) =>
-								Effect.tryPromise({
-									try: () =>
-										runtime.runWithServices(services, () =>
-											callback(factory(authOptions)),
-										),
-									catch: (error) => error,
-								}),
-							),
-						),
-					),
+				transaction: (callback) => run((database) => database.transaction(inTransaction(() => callback(factory(authOptions))))),
 			},
-			adapter: ({ debugLog, getFieldAttributes }) => ({
-				create: async ({ data, model, select }) => {
-					debugLog("create", { model });
-					return (await run((database) =>
-						refineRelation(modelRelation(database, model, mapModelName), {
-							select,
-						}).create(data),
-					)) as typeof data;
-				},
-				findOne: async <Value>({
-					join,
-					model,
-					select,
-					where,
-				}: FindOneInput) => {
-					rejectJoin(join);
-					return (await run((database) =>
-						Effect.map(
-							refineRelation(modelRelation(database, model, mapModelName), {
-								select,
-								where,
-							}).first(),
-							Option.getOrNull,
-						),
-					)) as Value | null;
-				},
-				findMany: async <Value>({
-					join,
-					limit,
-					model,
-					offset,
-					select,
-					sortBy,
-					where,
-				}: FindManyInput) => {
-					rejectJoin(join);
-					return (await run(
-						(database) =>
-							refineRelation(modelRelation(database, model, mapModelName), {
-								limit,
-								offset,
-								select,
-								sortBy,
-								where,
-							}) as unknown as Effect.Effect<
-								ReadonlyArray<Record<string, unknown>>,
-								unknown,
-								Services
-							>,
-					)) as Value[];
-				},
-				update: async <Value>({ model, update, where }: UpdateInput<Value>) => {
-					if (where.length === 0) return null;
-					const hasUniqueCondition = where.some(
-						(condition) =>
-							condition.connector !== "OR" &&
-							condition.operator === "eq" &&
-							condition.mode !== "insensitive" &&
-							(condition.field === "id" ||
-								getFieldAttributes({
-									field: condition.field,
-									model,
-								}).unique === true),
-					);
-					return (await run((database) => {
-						const relation = refineRelation(
-							modelRelation(database, model, mapModelName),
-							{ where },
-						);
-						return hasUniqueCondition
-							? relation.update(update as Record<string, unknown>)
-							: Effect.map(
-									relation.updateAll(update as Record<string, unknown>),
-									(rows) => rows[0] ?? null,
-								);
-					})) as Value | null;
-				},
-				updateMany: ({ model, update, where }) =>
-					run((database) =>
-						Effect.map(
-							refineRelation(modelRelation(database, model, mapModelName), {
-								where,
-							}).updateAll(update),
-							(rows) => rows.length,
-						),
-					),
-				delete: ({ model, where }) => {
-					const hasId = where.some(
-						(condition) =>
-							condition.connector !== "OR" &&
-							condition.field === "id" &&
-							condition.operator === "eq",
-					);
-					return run((database) => {
-						const relation = refineRelation(
-							modelRelation(database, model, mapModelName),
-							{ where },
-						);
-						return hasId
-							? Effect.asVoid(relation.delete())
-							: Effect.asVoid(relation.deleteAll());
-					});
-				},
-				deleteMany: ({ model, where }) =>
-					run((database) =>
-						Effect.map(
-							refineRelation(modelRelation(database, model, mapModelName), {
-								where,
-							}).deleteAll(),
-							(rows) => rows.length,
-						),
-					),
-				count: ({ model, where }) =>
-					run((database) =>
-						refineRelation(modelRelation(database, model, mapModelName), {
-							where: where as CleanedWhere[] | undefined,
-						}).count(),
-					),
-				options: {
-					usePlural: adapterOptions.usePlural ?? false,
-				},
-			}),
+			adapter: makeRowAdapter(query, adapterOptions.usePlural ?? false),
 		});
 
 		return factory(authOptions);
 	};
+}

package/src/better-auth/relation.ts

@@ -1,177 +1,35 @@
-import { all, and, not, or } from "@shivaedev/effect-prisma";
-import type { Where } from "better-auth";
+import { all } from "@shivaedev/effect-prisma";
 import type { Effect, Option } from "effect";
+import { type CleanedWhere, type DynamicField, type Expression, whereExpression } from "./where.ts";
 
-type CleanedWhere = Required<Where>;
-type Expression = Parameters<typeof and>[number];
-
-interface DynamicField {
-	eq(value: unknown): Expression;
-	neq(value: unknown): Expression;
-	gt(value: unknown): Expression;
-	gte(value: unknown): Expression;
-	lt(value: unknown): Expression;
-	lte(value: unknown): Expression;
-	in(value: ReadonlyArray<unknown>): Expression;
-	notIn(value: ReadonlyArray<unknown>): Expression;
-	like(value: string): Expression;
-	ilike?(value: string): Expression;
-	isNull(): Expression;
-	isNotNull(): Expression;
-	asc(): unknown;
-	desc(): unknown;
-}
-
-export interface DynamicRelation<Requirements> {
-	where(
-		predicate: (fields: Record<string, DynamicField>) => Expression,
-	): DynamicRelation<Requirements>;
-	orderBy(
-		ordering: (fields: Record<string, DynamicField>) => unknown,
-	): DynamicRelation<Requirements>;
+export interface DynamicRelation<Requirements> extends Effect.Effect<ReadonlyArray<Record<string, unknown>>, unknown, Requirements> {
+	where(predicate: (fields: Record<string, DynamicField>) => Expression): DynamicRelation<Requirements>;
+	orderBy(ordering: (fields: Record<string, DynamicField>) => unknown): DynamicRelation<Requirements>;
 	take(count: number): DynamicRelation<Requirements>;
 	skip(count: number): DynamicRelation<Requirements>;
 	select(...fields: ReadonlyArray<string>): DynamicRelation<Requirements>;
-	first(): Effect.Effect<
-		Option.Option<Record<string, unknown>>,
-		unknown,
-		Requirements
-	>;
+	first(): Effect.Effect<Option.Option<Record<string, unknown>>, unknown, Requirements>;
 	count(): Effect.Effect<number, unknown, Requirements>;
-	create(
-		data: Record<string, unknown>,
-	): Effect.Effect<Record<string, unknown>, unknown, Requirements>;
-	update(
-		data: Record<string, unknown>,
-	): Effect.Effect<Record<string, unknown> | null, unknown, Requirements>;
-	updateAll(
-		data: Record<string, unknown>,
-	): Effect.Effect<
-		ReadonlyArray<Record<string, unknown>>,
-		unknown,
-		Requirements
-	>;
-	delete(): Effect.Effect<
-		Record<string, unknown> | null,
-		unknown,
-		Requirements
-	>;
-	deleteAll(): Effect.Effect<
-		ReadonlyArray<Record<string, unknown>>,
-		unknown,
-		Requirements
-	>;
+	create(data: Record<string, unknown>): Effect.Effect<Record<string, unknown>, unknown, Requirements>;
+	update(data: Record<string, unknown>): Effect.Effect<Record<string, unknown> | null, unknown, Requirements>;
+	updateAll(data: Record<string, unknown>): Effect.Effect<ReadonlyArray<Record<string, unknown>>, unknown, Requirements>;
+	delete(): Effect.Effect<Record<string, unknown> | null, unknown, Requirements>;
+	deleteAll(): Effect.Effect<ReadonlyArray<Record<string, unknown>>, unknown, Requirements>;
 }
 
-const escapeLike = (value: string): string =>
-	value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
-
-const comparison = (
-	field: DynamicField,
-	where: CleanedWhere,
-): Expression | undefined => {
-	const value = where.value;
-	if (
-		where.mode === "insensitive" &&
-		typeof value === "string" &&
-		field.ilike !== undefined
-	) {
-		if (where.operator === "eq") return field.ilike(escapeLike(value));
-		if (where.operator === "ne") return not(field.ilike(escapeLike(value)));
-	}
-	switch (where.operator) {
-		case "eq":
-			return value === null ? field.isNull() : field.eq(value);
-		case "ne":
-			return value === null ? field.isNotNull() : field.neq(value);
-		case "lt":
-			return field.lt(value);
-		case "lte":
-			return field.lte(value);
-		case "gt":
-			return field.gt(value);
-		case "gte":
-			return field.gte(value);
-		case "in": {
-			const values = (Array.isArray(value) ? value : [value]).filter(
-				(item) => item !== null,
-			);
-			const ilike = field.ilike;
-			return values.length === 0
-				? and(field.isNull(), field.isNotNull())
-				: where.mode === "insensitive" &&
-						ilike !== undefined &&
-						values.every((item) => typeof item === "string")
-					? or(...values.map((item) => ilike(escapeLike(String(item)))))
-					: field.in(values);
-		}
-		case "not_in": {
-			const values = (Array.isArray(value) ? value : [value]).filter(
-				(item) => item !== null,
-			);
-			if (values.length === 0) return undefined;
-			const ilike = field.ilike;
-			return where.mode === "insensitive" &&
-				ilike !== undefined &&
-				values.every((item) => typeof item === "string")
-				? and(...values.map((item) => not(ilike(escapeLike(String(item))))))
-				: field.notIn(values);
-		}
-		case "contains":
-		case "starts_with":
-		case "ends_with": {
-			if (typeof value !== "string") {
-				throw new TypeError(`${where.operator} requires a string value`);
-			}
-			const escaped = escapeLike(value);
-			const pattern =
-				where.operator === "contains"
-					? `%${escaped}%`
-					: where.operator === "starts_with"
-						? `${escaped}%`
-						: `%${escaped}`;
-			return where.mode === "insensitive" && field.ilike !== undefined
-				? field.ilike(pattern)
-				: field.like(pattern);
-		}
-	}
-};
-
-const whereExpression = (
-	fields: Record<string, DynamicField>,
-	where: ReadonlyArray<CleanedWhere>,
-): Expression | undefined => {
-	const conjunctions: Expression[] = [];
-	const disjunctions: Expression[] = [];
-
-	for (const condition of where) {
-		const field = fields[condition.field];
-		if (field === undefined) {
-			throw new TypeError(`Unknown database field: ${condition.field}`);
-		}
-		const expression = comparison(field, condition);
-		if (expression === undefined) continue;
-		(condition.connector === "OR" ? disjunctions : conjunctions).push(
-			expression,
-		);
-	}
-
-	if (disjunctions.length > 0) conjunctions.push(or(...disjunctions));
-	if (conjunctions.length === 0) return all();
-	return conjunctions.length === 1 ? conjunctions[0] : and(...conjunctions);
-};
-
 export const refineRelation = <Requirements>(
 	relation: DynamicRelation<Requirements>,
 	options: {
-		readonly where?: ReadonlyArray<CleanedWhere>;
-		readonly select?: ReadonlyArray<string>;
-		readonly limit?: number;
-		readonly offset?: number;
-		readonly sortBy?: {
-			readonly direction: "asc" | "desc";
-			readonly field: string;
-		};
+		readonly where?: ReadonlyArray<CleanedWhere> | undefined;
+		readonly select?: ReadonlyArray<string> | undefined;
+		readonly limit?: number | undefined;
+		readonly offset?: number | undefined;
+		readonly sortBy?:
+			| {
+					readonly direction: "asc" | "desc";
+					readonly field: string;
+			  }
+			| undefined;
 	},
 ): DynamicRelation<Requirements> => {
 	let refined = relation;

package/src/better-auth/row-adapter.ts

@@ -0,0 +1,78 @@
+import type { Where } from "better-auth";
+import type { AdapterFactoryCustomizeAdapterCreator, CustomAdapter } from "better-auth/adapters";
+import { Effect, Option } from "effect";
+import type { DynamicRelation, refineRelation } from "./relation.ts";
+
+type CleanedWhere = Required<Where>;
+type FindOneInput = Parameters<CustomAdapter["findOne"]>[0];
+type FindManyInput = Parameters<CustomAdapter["findMany"]>[0];
+type Row = Record<string, unknown>;
+type RowMethod = "create" | "findMany" | "findOne" | "update";
+type Refinement = Parameters<typeof refineRelation>[1];
+
+interface RowMethods {
+	readonly create: (input: { readonly data: Row; readonly model: string; readonly select?: string[] | undefined }) => Promise<Row>;
+	readonly findOne: (input: FindOneInput) => Promise<Row | null>;
+	readonly findMany: (input: FindManyInput) => Promise<ReadonlyArray<Row>>;
+	readonly update: (input: { readonly model: string; readonly update: Row; readonly where: CleanedWhere[] }) => Promise<Row | null>;
+}
+
+export type RelationQuery = <Value>(
+	model: string,
+	refinement: Refinement,
+	use: (relation: DynamicRelation<unknown>) => Effect.Effect<Value, unknown, unknown>,
+) => Promise<Value>;
+
+// Better Auth lets each call declare its row type; the rows are whatever its generated schema stored.
+function rowTyped(adapter: Omit<CustomAdapter, RowMethod> & RowMethods): CustomAdapter;
+function rowTyped(adapter: unknown): unknown {
+	return adapter;
+}
+
+const rejectJoin = (join: unknown): void => {
+	if (join !== undefined) {
+		throw new TypeError("The Effect Prisma Better Auth adapter does not support experimental native joins");
+	}
+};
+
+const namesId = (condition: CleanedWhere): boolean => condition.connector !== "OR" && condition.field === "id" && condition.operator === "eq";
+
+export const makeRowAdapter =
+	(query: RelationQuery, usePlural: boolean): AdapterFactoryCustomizeAdapterCreator =>
+	({ debugLog, getFieldAttributes }) => {
+		const isUnique = (model: string, condition: CleanedWhere): boolean =>
+			condition.connector !== "OR" &&
+			condition.operator === "eq" &&
+			condition.mode !== "insensitive" &&
+			(condition.field === "id" || getFieldAttributes({ field: condition.field, model }).unique === true);
+
+		return rowTyped({
+			create: ({ data, model, select }) => {
+				debugLog("create", { model });
+				return query(model, { select }, (relation) => relation.create(data));
+			},
+			findOne: ({ join, model, select, where }) => {
+				rejectJoin(join);
+				return query(model, { select, where }, (relation) => Effect.map(relation.first(), Option.getOrNull));
+			},
+			findMany: ({ join, limit, model, offset, select, sortBy, where }) => {
+				rejectJoin(join);
+				return query(model, { limit, offset, select, sortBy, where }, (relation) => relation);
+			},
+			update: ({ model, update, where }) => {
+				if (where.length === 0) return Promise.resolve(null);
+				const unique = where.some((condition) => isUnique(model, condition));
+				return query(model, { where }, (relation) =>
+					unique ? relation.update(update) : Effect.map(relation.updateAll(update), (rows) => rows[0] ?? null),
+				);
+			},
+			updateMany: ({ model, update, where }) => query(model, { where }, (relation) => Effect.map(relation.updateAll(update), (rows) => rows.length)),
+			delete: ({ model, where }) => {
+				const byId = where.some(namesId);
+				return query(model, { where }, (relation) => (byId ? Effect.asVoid(relation.delete()) : Effect.asVoid(relation.deleteAll())));
+			},
+			deleteMany: ({ model, where }) => query(model, { where }, (relation) => Effect.map(relation.deleteAll(), (rows) => rows.length)),
+			count: ({ model, where }) => query(model, { where }, (relation) => relation.count()),
+			options: { usePlural },
+		});
+	};

package/src/better-auth/where.ts

@@ -0,0 +1,118 @@
+import { all, and, not, or } from "@shivaedev/effect-prisma";
+import type { Where } from "better-auth";
+
+export type CleanedWhere = Required<Where>;
+export type Expression = Parameters<typeof and>[number];
+
+export interface DynamicField {
+	eq(value: unknown): Expression;
+	neq(value: unknown): Expression;
+	gt(value: unknown): Expression;
+	gte(value: unknown): Expression;
+	lt(value: unknown): Expression;
+	lte(value: unknown): Expression;
+	in(value: ReadonlyArray<unknown>): Expression;
+	notIn(value: ReadonlyArray<unknown>): Expression;
+	like(value: string): Expression;
+	ilike?(value: string): Expression;
+	isNull(): Expression;
+	isNotNull(): Expression;
+	asc(): unknown;
+	desc(): unknown;
+}
+
+const escapeLike = (value: string): string => value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
+
+const nonNullValues = (value: unknown): ReadonlyArray<unknown> => (Array.isArray(value) ? value : [value]).filter((item) => item !== null);
+
+const insensitiveStrings = (field: DynamicField, where: CleanedWhere, values: ReadonlyArray<unknown>) => {
+	const ilike = field.ilike;
+	if (where.mode !== "insensitive" || ilike === undefined || !values.every((item) => typeof item === "string")) {
+		return undefined;
+	}
+	return values.map((item) => ilike(escapeLike(String(item))));
+};
+
+const membership = (field: DynamicField, where: CleanedWhere): Expression => {
+	const values = nonNullValues(where.value);
+	if (values.length === 0) {
+		return and(field.isNull(), field.isNotNull());
+	}
+	const matches = insensitiveStrings(field, where, values);
+	return matches === undefined ? field.in(values) : or(...matches);
+};
+
+const exclusion = (field: DynamicField, where: CleanedWhere): Expression | undefined => {
+	const values = nonNullValues(where.value);
+	if (values.length === 0) {
+		return undefined;
+	}
+	const matches = insensitiveStrings(field, where, values);
+	return matches === undefined ? field.notIn(values) : and(...matches.map((match) => not(match)));
+};
+
+const likePattern = (operator: CleanedWhere["operator"], escaped: string): string => {
+	if (operator === "contains") return `%${escaped}%`;
+	return operator === "starts_with" ? `${escaped}%` : `%${escaped}`;
+};
+
+const pattern = (field: DynamicField, where: CleanedWhere): Expression => {
+	if (typeof where.value !== "string") {
+		throw new TypeError(`${where.operator} requires a string value`);
+	}
+	const text = likePattern(where.operator, escapeLike(where.value));
+	return where.mode === "insensitive" && field.ilike !== undefined ? field.ilike(text) : field.like(text);
+};
+
+const insensitiveEquality = (field: DynamicField, where: CleanedWhere): Expression | undefined => {
+	const value = where.value;
+	if (where.mode !== "insensitive" || typeof value !== "string" || field.ilike === undefined) return undefined;
+	if (where.operator === "eq") return field.ilike(escapeLike(value));
+	if (where.operator === "ne") return not(field.ilike(escapeLike(value)));
+	return undefined;
+};
+
+const comparison = (field: DynamicField, where: CleanedWhere): Expression | undefined => {
+	const value = where.value;
+	switch (where.operator) {
+		case "eq":
+			return value === null ? field.isNull() : field.eq(value);
+		case "ne":
+			return value === null ? field.isNotNull() : field.neq(value);
+		case "lt":
+			return field.lt(value);
+		case "lte":
+			return field.lte(value);
+		case "gt":
+			return field.gt(value);
+		case "gte":
+			return field.gte(value);
+		case "in":
+			return membership(field, where);
+		case "not_in":
+			return exclusion(field, where);
+		case "contains":
+		case "starts_with":
+		case "ends_with":
+			return pattern(field, where);
+	}
+};
+
+export const whereExpression = (fields: Record<string, DynamicField>, where: ReadonlyArray<CleanedWhere>): Expression | undefined => {
+	const conjunctions: Expression[] = [];
+	const disjunctions: Expression[] = [];
+
+	for (const condition of where) {
+		const field = fields[condition.field];
+		if (field === undefined) {
+			throw new TypeError(`Unknown database field: ${condition.field}`);
+		}
+		const expression = insensitiveEquality(field, condition) ?? comparison(field, condition);
+		if (expression === undefined) continue;
+		(condition.connector === "OR" ? disjunctions : conjunctions).push(expression);
+	}
+
+	if (disjunctions.length > 0) conjunctions.push(or(...disjunctions));
+	if (conjunctions.length === 0) return all();
+	return conjunctions.length === 1 ? conjunctions[0] : and(...conjunctions);
+};

package/src/better-auth.ts

@@ -1,4 +1,4 @@
 export {
 	type EffectPrismaAdapterOptions,
 	effectPrismaAdapter,
-} from "./better-auth/adapter.js";
+} from "./better-auth/adapter.ts";

package/src/errors/rejected-field.ts

@@ -0,0 +1,13 @@
+import { Option, Schema } from "effect";
+
+export interface RejectedField {
+	readonly field: string;
+	readonly message: string;
+}
+
+const Rejected = Schema.Struct({ _tag: Schema.String, field: Schema.String, message: Schema.String });
+
+const decode = Schema.decodeUnknownOption(Rejected);
+
+export const rejectedField = (error: unknown): Option.Option<RejectedField> =>
+	Option.map(decode(error), ({ field, message }) => ({ field, message }));