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

package/.turbo/turbo-build.log

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

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,14 @@
+import * as _better_auth_core_db_adapter0 from "@better-auth/core/db/adapter";
+import { DBAdapterDebugLogOption } from "@better-auth/core/db/adapter";
+import { BetterAuthOptions } from "@better-auth/core";
+
+//#region src/memory-adapter.d.ts
+interface MemoryDB {
+  [key: string]: any[];
+}
+interface MemoryAdapterConfig {
+  debugLogs?: DBAdapterDebugLogOption | undefined;
+}
+declare const memoryAdapter: (db: MemoryDB, config?: MemoryAdapterConfig | undefined) => (options: BetterAuthOptions) => _better_auth_core_db_adapter0.DBAdapter<BetterAuthOptions>;
+//#endregion
+export { type MemoryAdapterConfig, type MemoryDB, memoryAdapter };

package/dist/index.mjs

@@ -0,0 +1,213 @@
+import { createAdapterFactory } from "@better-auth/core/db/adapter";
+import { logger } from "@better-auth/core/env";
+
+//#region src/memory-adapter.ts
+const memoryAdapter = (db, config) => {
+	let lazyOptions = null;
+	const adapterCreator = createAdapterFactory({
+		config: {
+			adapterId: "memory",
+			adapterName: "Memory Adapter",
+			usePlural: false,
+			debugLogs: config?.debugLogs || false,
+			supportsArrays: true,
+			customTransformInput(props) {
+				if ((props.options.advanced?.database?.useNumberId || props.options.advanced?.database?.generateId === "serial") && props.field === "id" && props.action === "create") return db[props.model].length + 1;
+				return props.data;
+			},
+			transaction: async (cb) => {
+				const clone = structuredClone(db);
+				try {
+					return await cb(adapterCreator(lazyOptions));
+				} catch (error) {
+					Object.keys(db).forEach((key) => {
+						db[key] = clone[key];
+					});
+					throw error;
+				}
+			}
+		},
+		adapter: ({ getFieldName, options, getModelName }) => {
+			const applySortToRecords = (records, sortBy, model) => {
+				if (!sortBy) return records;
+				return records.sort((a, b) => {
+					const field = getFieldName({
+						model,
+						field: sortBy.field
+					});
+					const aValue = a[field];
+					const bValue = b[field];
+					let comparison = 0;
+					if (aValue == null && bValue == null) comparison = 0;
+					else if (aValue == null) comparison = -1;
+					else if (bValue == null) comparison = 1;
+					else if (typeof aValue === "string" && typeof bValue === "string") comparison = aValue.localeCompare(bValue);
+					else if (aValue instanceof Date && bValue instanceof Date) comparison = aValue.getTime() - bValue.getTime();
+					else if (typeof aValue === "number" && typeof bValue === "number") comparison = aValue - bValue;
+					else if (typeof aValue === "boolean" && typeof bValue === "boolean") comparison = aValue === bValue ? 0 : aValue ? 1 : -1;
+					else comparison = String(aValue).localeCompare(String(bValue));
+					return sortBy.direction === "asc" ? comparison : -comparison;
+				});
+			};
+			function convertWhereClause(where, model, join) {
+				const execute = (where$1, model$1) => {
+					const table = db[model$1];
+					if (!table) {
+						logger.error(`[MemoryAdapter] Model ${model$1} not found in the DB`, Object.keys(db));
+						throw new Error(`Model ${model$1} not found`);
+					}
+					const evalClause = (record, clause) => {
+						const { field, value, operator } = clause;
+						switch (operator) {
+							case "in":
+								if (!Array.isArray(value)) throw new Error("Value must be an array");
+								return value.includes(record[field]);
+							case "not_in":
+								if (!Array.isArray(value)) throw new Error("Value must be an array");
+								return !value.includes(record[field]);
+							case "contains": return record[field].includes(value);
+							case "starts_with": return record[field].startsWith(value);
+							case "ends_with": return record[field].endsWith(value);
+							case "ne": return record[field] !== value;
+							case "gt": return value != null && Boolean(record[field] > value);
+							case "gte": return value != null && Boolean(record[field] >= value);
+							case "lt": return value != null && Boolean(record[field] < value);
+							case "lte": return value != null && Boolean(record[field] <= value);
+							default: return record[field] === value;
+						}
+					};
+					return table.filter((record) => {
+						if (!where$1.length || where$1.length === 0) return true;
+						let result = evalClause(record, where$1[0]);
+						for (const clause of where$1) {
+							const clauseResult = evalClause(record, clause);
+							if (clause.connector === "OR") result = result || clauseResult;
+							else result = result && clauseResult;
+						}
+						return result;
+					});
+				};
+				if (!join) return execute(where, model);
+				const baseRecords = execute(where, model);
+				const grouped = /* @__PURE__ */ new Map();
+				const seenIds = /* @__PURE__ */ new Map();
+				for (const baseRecord of baseRecords) {
+					const baseId = String(baseRecord.id);
+					if (!grouped.has(baseId)) {
+						const nested = { ...baseRecord };
+						for (const [joinModel, joinAttr] of Object.entries(join)) {
+							const joinModelName = getModelName(joinModel);
+							if (joinAttr.relation === "one-to-one") nested[joinModelName] = null;
+							else {
+								nested[joinModelName] = [];
+								seenIds.set(`${baseId}-${joinModel}`, /* @__PURE__ */ new Set());
+							}
+						}
+						grouped.set(baseId, nested);
+					}
+					const nestedEntry = grouped.get(baseId);
+					for (const [joinModel, joinAttr] of Object.entries(join)) {
+						const joinModelName = getModelName(joinModel);
+						const joinTable = db[joinModelName];
+						if (!joinTable) {
+							logger.error(`[MemoryAdapter] JoinOption model ${joinModelName} not found in the DB`, Object.keys(db));
+							throw new Error(`JoinOption model ${joinModelName} not found`);
+						}
+						const matchingRecords = joinTable.filter((joinRecord) => joinRecord[joinAttr.on.to] === baseRecord[joinAttr.on.from]);
+						if (joinAttr.relation === "one-to-one") nestedEntry[joinModelName] = matchingRecords[0] || null;
+						else {
+							const seenSet = seenIds.get(`${baseId}-${joinModel}`);
+							const limit = joinAttr.limit ?? 100;
+							let count = 0;
+							for (const matchingRecord of matchingRecords) {
+								if (count >= limit) break;
+								if (!seenSet.has(matchingRecord.id)) {
+									nestedEntry[joinModelName].push(matchingRecord);
+									seenSet.add(matchingRecord.id);
+									count++;
+								}
+							}
+						}
+					}
+				}
+				return Array.from(grouped.values());
+			}
+			return {
+				create: async ({ model, data }) => {
+					if (options.advanced?.database?.useNumberId || options.advanced?.database?.generateId === "serial") data.id = db[getModelName(model)].length + 1;
+					if (!db[model]) db[model] = [];
+					db[model].push(data);
+					return data;
+				},
+				findOne: async ({ model, where, join }) => {
+					const res = convertWhereClause(where, model, join);
+					if (join) {
+						const resArray = res;
+						if (!resArray.length) return null;
+						return resArray[0];
+					}
+					return res[0] || null;
+				},
+				findMany: async ({ model, where, sortBy, limit, offset, join }) => {
+					const res = convertWhereClause(where || [], model, join);
+					if (join) {
+						const resArray = res;
+						if (!resArray.length) return [];
+						applySortToRecords(resArray, sortBy, model);
+						let paginatedRecords = resArray;
+						if (offset !== void 0) paginatedRecords = paginatedRecords.slice(offset);
+						if (limit !== void 0) paginatedRecords = paginatedRecords.slice(0, limit);
+						return paginatedRecords;
+					}
+					let table = applySortToRecords(res, sortBy, model);
+					if (offset !== void 0) table = table.slice(offset);
+					if (limit !== void 0) table = table.slice(0, limit);
+					return table || [];
+				},
+				count: async ({ model, where }) => {
+					if (where) return convertWhereClause(where, model).length;
+					return db[model].length;
+				},
+				update: async ({ model, where, update }) => {
+					const res = convertWhereClause(where, model);
+					res.forEach((record) => {
+						Object.assign(record, update);
+					});
+					return res[0] || null;
+				},
+				delete: async ({ model, where }) => {
+					const table = db[model];
+					const res = convertWhereClause(where, model);
+					db[model] = table.filter((record) => !res.includes(record));
+				},
+				deleteMany: async ({ model, where }) => {
+					const table = db[model];
+					const res = convertWhereClause(where, model);
+					let count = 0;
+					db[model] = table.filter((record) => {
+						if (res.includes(record)) {
+							count++;
+							return false;
+						}
+						return !res.includes(record);
+					});
+					return count;
+				},
+				updateMany({ model, where, update }) {
+					const res = convertWhereClause(where, model);
+					res.forEach((record) => {
+						Object.assign(record, update);
+					});
+					return res[0] || null;
+				}
+			};
+		}
+	});
+	return (options) => {
+		lazyOptions = options;
+		return adapterCreator(options);
+	};
+};
+
+//#endregion
+export { memoryAdapter };

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@better-auth/memory-adapter",
+  "version": "1.5.0-beta.9",
+  "description": "Memory adapter for Better Auth",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/better-auth/better-auth.git",
+    "directory": "packages/memory-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",
+    "@better-auth/core": "1.5.0-beta.9"
+  },
+  "devDependencies": {
+    "@better-auth/utils": "^0.3.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,5 @@
+export {
+	type MemoryAdapterConfig,
+	type MemoryDB,
+	memoryAdapter,
+} from "./memory-adapter";

package/src/memory-adapter.ts

@@ -0,0 +1,355 @@
+import type { BetterAuthOptions } from "@better-auth/core";
+import type {
+	CleanedWhere,
+	DBAdapterDebugLogOption,
+	JoinConfig,
+} from "@better-auth/core/db/adapter";
+import { createAdapterFactory } from "@better-auth/core/db/adapter";
+import { logger } from "@better-auth/core/env";
+
+export interface MemoryDB {
+	[key: string]: any[];
+}
+
+export interface MemoryAdapterConfig {
+	debugLogs?: DBAdapterDebugLogOption | undefined;
+}
+
+export const memoryAdapter = (
+	db: MemoryDB,
+	config?: MemoryAdapterConfig | undefined,
+) => {
+	let lazyOptions: BetterAuthOptions | null = null;
+	const adapterCreator = createAdapterFactory({
+		config: {
+			adapterId: "memory",
+			adapterName: "Memory Adapter",
+			usePlural: false,
+			debugLogs: config?.debugLogs || false,
+			supportsArrays: true,
+			customTransformInput(props) {
+				const useNumberId =
+					props.options.advanced?.database?.useNumberId ||
+					props.options.advanced?.database?.generateId === "serial";
+				if (useNumberId && props.field === "id" && props.action === "create") {
+					return db[props.model]!.length + 1;
+				}
+				return props.data;
+			},
+			transaction: async (cb) => {
+				const clone = structuredClone(db);
+				try {
+					const r = await cb(adapterCreator(lazyOptions!));
+					return r;
+				} catch (error) {
+					// Rollback changes
+					Object.keys(db).forEach((key) => {
+						db[key] = clone[key]!;
+					});
+					throw error;
+				}
+			},
+		},
+		adapter: ({ getFieldName, options, getModelName }) => {
+			const applySortToRecords = (
+				records: any[],
+				sortBy: { field: string; direction: "asc" | "desc" } | undefined,
+				model: string,
+			) => {
+				if (!sortBy) return records;
+				return records.sort((a: any, b: any) => {
+					const field = getFieldName({ model, field: sortBy.field });
+					const aValue = a[field];
+					const bValue = b[field];
+
+					let comparison = 0;
+
+					// Handle null/undefined values
+					if (aValue == null && bValue == null) {
+						comparison = 0;
+					} else if (aValue == null) {
+						comparison = -1;
+					} else if (bValue == null) {
+						comparison = 1;
+					}
+					// Handle string comparison
+					else if (typeof aValue === "string" && typeof bValue === "string") {
+						comparison = aValue.localeCompare(bValue);
+					}
+					// Handle date comparison
+					else if (aValue instanceof Date && bValue instanceof Date) {
+						comparison = aValue.getTime() - bValue.getTime();
+					}
+					// Handle numeric comparison
+					else if (typeof aValue === "number" && typeof bValue === "number") {
+						comparison = aValue - bValue;
+					}
+					// Handle boolean comparison
+					else if (typeof aValue === "boolean" && typeof bValue === "boolean") {
+						comparison = aValue === bValue ? 0 : aValue ? 1 : -1;
+					}
+					// Fallback to string comparison
+					else {
+						comparison = String(aValue).localeCompare(String(bValue));
+					}
+
+					return sortBy.direction === "asc" ? comparison : -comparison;
+				});
+			};
+
+			function convertWhereClause(
+				where: CleanedWhere[],
+				model: string,
+				join?: JoinConfig,
+			): any[] {
+				const execute = (where: CleanedWhere[], model: string) => {
+					const table = db[model];
+					if (!table) {
+						logger.error(
+							`[MemoryAdapter] Model ${model} not found in the DB`,
+							Object.keys(db),
+						);
+						throw new Error(`Model ${model} not found`);
+					}
+
+					const evalClause = (record: any, clause: CleanedWhere): boolean => {
+						const { field, value, operator } = clause;
+						switch (operator) {
+							case "in":
+								if (!Array.isArray(value)) {
+									throw new Error("Value must be an array");
+								}
+								// @ts-expect-error
+								return value.includes(record[field]);
+							case "not_in":
+								if (!Array.isArray(value)) {
+									throw new Error("Value must be an array");
+								}
+								// @ts-expect-error
+								return !value.includes(record[field]);
+							case "contains":
+								return record[field].includes(value);
+							case "starts_with":
+								return record[field].startsWith(value);
+							case "ends_with":
+								return record[field].endsWith(value);
+							case "ne":
+								return record[field] !== value;
+							case "gt":
+								return value != null && Boolean(record[field] > value);
+							case "gte":
+								return value != null && Boolean(record[field] >= value);
+							case "lt":
+								return value != null && Boolean(record[field] < value);
+							case "lte":
+								return value != null && Boolean(record[field] <= value);
+							default:
+								return record[field] === value;
+						}
+					};
+
+					return table.filter((record: any) => {
+						if (!where.length || where.length === 0) {
+							return true;
+						}
+
+						let result = evalClause(record, where[0]!);
+						for (const clause of where) {
+							const clauseResult = evalClause(record, clause);
+
+							if (clause.connector === "OR") {
+								result = result || clauseResult;
+							} else {
+								result = result && clauseResult;
+							}
+						}
+
+						return result;
+					});
+				};
+
+				if (!join) return execute(where, model);
+
+				const baseRecords = execute(where, model);
+
+				// Group results by base model and nest joined data as arrays
+				const grouped = new Map<string, any>();
+				// Track seen IDs per joined model for O(1) deduplication
+				const seenIds = new Map<string, Set<string>>();
+
+				for (const baseRecord of baseRecords) {
+					const baseId = String(baseRecord.id);
+
+					if (!grouped.has(baseId)) {
+						const nested: Record<string, any> = { ...baseRecord };
+
+						// Initialize joined data structures based on isUnique
+						for (const [joinModel, joinAttr] of Object.entries(join)) {
+							const joinModelName = getModelName(joinModel);
+							if (joinAttr.relation === "one-to-one") {
+								nested[joinModelName] = null;
+							} else {
+								nested[joinModelName] = [];
+								seenIds.set(`${baseId}-${joinModel}`, new Set());
+							}
+						}
+
+						grouped.set(baseId, nested);
+					}
+
+					const nestedEntry = grouped.get(baseId)!;
+
+					// Add joined data
+					for (const [joinModel, joinAttr] of Object.entries(join)) {
+						const joinModelName = getModelName(joinModel);
+						const joinTable = db[joinModelName];
+						if (!joinTable) {
+							logger.error(
+								`[MemoryAdapter] JoinOption model ${joinModelName} not found in the DB`,
+								Object.keys(db),
+							);
+							throw new Error(`JoinOption model ${joinModelName} not found`);
+						}
+
+						const matchingRecords = joinTable.filter(
+							(joinRecord: any) =>
+								joinRecord[joinAttr.on.to] === baseRecord[joinAttr.on.from],
+						);
+
+						if (joinAttr.relation === "one-to-one") {
+							// For unique relationships, store a single object (or null)
+							nestedEntry[joinModelName] = matchingRecords[0] || null;
+						} else {
+							// For non-unique relationships, store array with limit
+							const seenSet = seenIds.get(`${baseId}-${joinModel}`)!;
+							const limit = joinAttr.limit ?? 100;
+							let count = 0;
+
+							for (const matchingRecord of matchingRecords) {
+								if (count >= limit) break;
+								if (!seenSet.has(matchingRecord.id)) {
+									nestedEntry[joinModelName].push(matchingRecord);
+									seenSet.add(matchingRecord.id);
+									count++;
+								}
+							}
+						}
+					}
+				}
+
+				return Array.from(grouped.values());
+			}
+			return {
+				create: async ({ model, data }) => {
+					const useNumberId =
+						options.advanced?.database?.useNumberId ||
+						options.advanced?.database?.generateId === "serial";
+					if (useNumberId) {
+						// @ts-expect-error
+						data.id = db[getModelName(model)]!.length + 1;
+					}
+					if (!db[model]) {
+						db[model] = [];
+					}
+					db[model]!.push(data);
+					return data;
+				},
+				findOne: async ({ model, where, join }) => {
+					const res = convertWhereClause(where, model, join);
+					if (join) {
+						// When join is present, res is an array of nested objects
+						const resArray = res as any[];
+						if (!resArray.length) {
+							return null;
+						}
+						// Return the first nested object
+						return resArray[0];
+					}
+					// Without join, res is an array
+					const resArray = res as any[];
+					const record = resArray[0] || null;
+					return record;
+				},
+				findMany: async ({ model, where, sortBy, limit, offset, join }) => {
+					const res = convertWhereClause(where || [], model, join);
+
+					if (join) {
+						// When join is present, res is an array of nested objects
+						const resArray = res as any[];
+						if (!resArray.length) {
+							return [];
+						}
+
+						// Apply sorting to nested objects
+						applySortToRecords(resArray, sortBy, model);
+
+						// Apply offset and limit
+						let paginatedRecords = resArray;
+						if (offset !== undefined) {
+							paginatedRecords = paginatedRecords.slice(offset);
+						}
+						if (limit !== undefined) {
+							paginatedRecords = paginatedRecords.slice(0, limit);
+						}
+
+						return paginatedRecords;
+					}
+
+					// Without join - original logic
+					const resArray = res as any[];
+					let table = applySortToRecords(resArray, sortBy, model);
+					if (offset !== undefined) {
+						table = table!.slice(offset);
+					}
+					if (limit !== undefined) {
+						table = table!.slice(0, limit);
+					}
+					return table || [];
+				},
+				count: async ({ model, where }) => {
+					if (where) {
+						const filteredRecords = convertWhereClause(where, model);
+						return filteredRecords.length;
+					}
+					return db[model]!.length;
+				},
+				update: async ({ model, where, update }) => {
+					const res = convertWhereClause(where, model);
+					res.forEach((record) => {
+						Object.assign(record, update);
+					});
+					return res[0] || null;
+				},
+				delete: async ({ model, where }) => {
+					const table = db[model]!;
+					const res = convertWhereClause(where, model);
+					db[model] = table.filter((record) => !res.includes(record));
+				},
+				deleteMany: async ({ model, where }) => {
+					const table = db[model]!;
+					const res = convertWhereClause(where, model);
+					let count = 0;
+					db[model] = table.filter((record) => {
+						if (res.includes(record)) {
+							count++;
+							return false;
+						}
+						return !res.includes(record);
+					});
+					return count;
+				},
+				updateMany({ model, where, update }) {
+					const res = convertWhereClause(where, model);
+					res.forEach((record) => {
+						Object.assign(record, update);
+					});
+					return res[0] || null;
+				},
+			};
+		},
+	});
+	return (options: BetterAuthOptions) => {
+		lazyOptions = options;
+		return adapterCreator(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({});