@gatwech/auth 1.0.0-beta.18

package/dist/adapters/drizzle-adapter/index.mjs

@@ -0,0 +1,208 @@
+import "../../utils-SOMB4Px5.mjs";
+import "../../json-D0TBLy4q.mjs";
+import "../../crypto-Bb42eMrH.mjs";
+import "../../jwt-CmxZAGe2.mjs";
+import "../../get-tables-BQP7YW9c.mjs";
+import "../../misc-beA1w3XV.mjs";
+import { t as createAdapterFactory } from "../../adapter-factory-BZ2Qiqpn.mjs";
+import { PayvoAuthError } from "@gatwech/core/error";
+import { and, asc, count, desc, eq, gt, gte, inArray, like, lt, lte, ne, notInArray, or, sql } from "drizzle-orm";
+
+//#region src/adapters/drizzle-adapter/drizzle-adapter.ts
+const drizzleAdapter = (db, config) => {
+	let lazyOptions = null;
+	const createCustomAdapter = (db$1) => ({ getFieldName, debugLog }) => {
+		function getSchema(model) {
+			const schema = config.schema || db$1._.fullSchema;
+			if (!schema) throw new PayvoAuthError("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 PayvoAuthError(`[# 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 PayvoAuthError(`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 PayvoAuthError(`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 PayvoAuthError(`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 PayvoAuthError(`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 PayvoAuthError(`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 PayvoAuthError(`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 PayvoAuthError(`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 PayvoAuthError(`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 PayvoAuthError("Drizzle adapter failed to initialize. Schema not found. Please provide a schema object in the adapter options object.");
+			for (const key in values) if (!schema[key]) throw new PayvoAuthError(`The field "${key}" does not exist in the "${model}" schema. Please update your drizzle schema or re-generate using "npx @gatwech/cli 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 }) {
+				const schemaModel = getSchema(model);
+				const clause = convertWhereClause(where, model);
+				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 }) {
+				const schemaModel = getSchema(model);
+				const clause = where ? convertWhereClause(where, model) : [];
+				const sortFn = sortBy?.direction === "desc" ? desc : asc;
+				const builder = db$1.select().from(schemaModel).limit(limit || 100).offset(offset || 0);
+				if (sortBy?.field) 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);
+				return await db$1.delete(schemaModel).where(...clause);
+			},
+			options: config
+		};
+	};
+	let adapterOptions = null;
+	adapterOptions = {
+		config: {
+			adapterId: "drizzle",
+			adapterName: "Drizzle Adapter",
+			usePlural: config.usePlural ?? false,
+			debugLogs: config.debugLogs ?? 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/dist/adapters/index.d.mts

@@ -0,0 +1,132 @@
+import { u as Prettify } from "../helper-tmxW3BHj.mjs";
+import { A as Where$1 } from "../index-Cxi7TbLE.mjs";
+import "../types-B1OL7hyf.mjs";
+import "../index-65G5U5DB-DSdjzreF.mjs";
+import "../plugins-hFZT3hmK.mjs";
+import { PayvoAuthOptions } from "@gatwech/core";
+import { DBFieldAttribute, PayvoAuthDBSchema } from "@gatwech/core/db";
+import { CustomAdapter, CustomAdapter as CustomAdapter$1, DBAdapter, DBAdapterFactoryConfig, DBAdapterFactoryConfig as DBAdapterFactoryConfig$1, DBAdapterSchemaCreation, DBTransactionAdapter } from "@gatwech/core/db/adapter";
+export * from "@gatwech/core/db/adapter";
+
+//#region src/adapters/adapter-factory/types.d.ts
+type AdapterFactoryOptions = {
+  config: DBAdapterFactoryConfig$1;
+  adapter: AdapterFactoryCustomizeAdapterCreator;
+};
+type AdapterFactoryCustomizeAdapterCreator = (config: {
+  options: PayvoAuthOptions;
+  /**
+   * The schema of the user's Payvo-Auth instance.
+   */
+  schema: PayvoAuthDBSchema;
+  /**
+   * The debug log function.
+   *
+   * If the config has defined `debugLogs` as `false`, no logs will be shown.
+   */
+  debugLog: (...args: any[]) => void;
+  /**
+   * Get the model name which is expected to be saved in the database based on the user's schema.
+   */
+  getModelName: (model: string) => string;
+  /**
+   * Get the field name which is expected to be saved in the database based on the user's schema.
+   */
+  getFieldName: ({
+    model,
+    field
+  }: {
+    model: string;
+    field: string;
+  }) => string;
+  /**
+   * This function helps us get the default model name from the schema defined by devs.
+   * Often times, the user will be using the `modelName` which could had been customized by the users.
+   * This function helps us get the actual model name useful to match against the schema. (eg: schema[model])
+   *
+   * If it's still unclear what this does:
+   *
+   * 1. User can define a custom modelName.
+   * 2. When using a custom modelName, doing something like `schema[model]` will not work.
+   * 3. Using this function helps us get the actual model name based on the user's defined custom modelName.
+   * 4. Thus allowing us to use `schema[model]`.
+   */
+  getDefaultModelName: (model: string) => string;
+  /**
+   * This function helps us get the default field name from the schema defined by devs.
+   * Often times, the user will be using the `fieldName` which could had been customized by the users.
+   * This function helps us get the actual field name useful to match against the schema. (eg: schema[model].fields[field])
+   *
+   * If it's still unclear what this does:
+   *
+   * 1. User can define a custom fieldName.
+   * 2. When using a custom fieldName, doing something like `schema[model].fields[field]` will not work.
+   *
+   */
+  getDefaultFieldName: ({
+    model,
+    field
+  }: {
+    model: string;
+    field: string;
+  }) => string;
+  /**
+   * Get the field attributes for a given model and field.
+   *
+   * Note: any model name or field name is allowed, whether default to schema or not.
+   */
+  getFieldAttributes: ({
+    model,
+    field
+  }: {
+    model: string;
+    field: string;
+  }) => DBFieldAttribute;
+  transformInput: (data: Record<string, any>, defaultModelName: string, action: "create" | "update", forceAllowId?: boolean | undefined) => Promise<Record<string, any>>;
+  transformOutput: (data: Record<string, any>, defaultModelName: string, select?: string[] | undefined) => Promise<Record<string, any>>;
+  transformWhereClause: <W extends Where$1[] | undefined>({
+    model,
+    where
+  }: {
+    where: W;
+    model: string;
+  }) => W extends undefined ? undefined : CleanedWhere[];
+}) => CustomAdapter$1;
+/**
+ * @deprecated Use `CleanedWhere` from `@gatwech/core/db/adapter` instead.
+ */
+type CleanedWhere = Prettify<Required<Where$1>>;
+type AdapterTestDebugLogs = {
+  resetDebugLogs: () => void;
+  printDebugLogs: () => void;
+};
+//#endregion
+//#region src/adapters/adapter-factory/index.d.ts
+type AdapterFactory = (options: PayvoAuthOptions) => DBAdapter<PayvoAuthOptions>;
+declare const createAdapterFactory: ({
+  adapter: customAdapter,
+  config: cfg
+}: AdapterFactoryOptions) => AdapterFactory;
+//#endregion
+//#region src/adapters/index.d.ts
+/**
+ * @deprecated Use `createAdapterFactory` instead. This export will be removed in the next major version.
+ */
+declare const createAdapter: ({
+  adapter: customAdapter,
+  config: cfg
+}: AdapterFactoryOptions) => AdapterFactory;
+/**
+ * @deprecated Use `AdapterFactoryOptions` instead. This export will be removed in the next major version.
+ */
+type CreateAdapterOptions = AdapterFactoryOptions;
+/**
+ * @deprecated Use `AdapterFactoryConfig` instead. This export will be removed in the next major version.
+ */
+type AdapterConfig = DBAdapterFactoryConfig;
+/**
+ * @deprecated Use `AdapterFactoryCustomizeAdapterCreator` instead. This export will be removed in the next major version.
+ */
+type CreateCustomAdapter = AdapterFactoryCustomizeAdapterCreator;
+//#endregion
+export { AdapterConfig, type AdapterFactory, type AdapterFactoryCustomizeAdapterCreator, type AdapterFactoryOptions, type AdapterTestDebugLogs, CreateAdapterOptions, CreateCustomAdapter, type CustomAdapter, type DBAdapterFactoryConfig, createAdapter, createAdapterFactory };

package/dist/adapters/index.mjs

@@ -0,0 +1,18 @@
+import "../utils-SOMB4Px5.mjs";
+import "../json-D0TBLy4q.mjs";
+import "../crypto-Bb42eMrH.mjs";
+import "../jwt-CmxZAGe2.mjs";
+import "../get-tables-BQP7YW9c.mjs";
+import "../misc-beA1w3XV.mjs";
+import { t as createAdapterFactory } from "../adapter-factory-BZ2Qiqpn.mjs";
+
+export * from "@gatwech/core/db/adapter"
+
+//#region src/adapters/index.ts
+/**
+* @deprecated Use `createAdapterFactory` instead. This export will be removed in the next major version.
+*/
+const createAdapter = createAdapterFactory;
+
+//#endregion
+export { createAdapter, createAdapterFactory };

package/dist/adapters/kysely-adapter/index.d.mts

@@ -0,0 +1,47 @@
+import { t as KyselyDatabaseType } from "../../types-B1OL7hyf.mjs";
+import { PayvoAuthOptions } from "@gatwech/core";
+import { Kysely } from "kysely";
+import { DBAdapter, DBAdapterDebugLogOption } from "@gatwech/core/db/adapter";
+
+//#region src/adapters/kysely-adapter/dialect.d.ts
+declare function getKyselyDatabaseType(db: PayvoAuthOptions["database"]): KyselyDatabaseType | null;
+declare const createKyselyAdapter: (config: PayvoAuthOptions) => Promise<{
+  kysely: Kysely<any>;
+  databaseType: "postgres" | "mysql" | "sqlite" | "mssql";
+  transaction: boolean | undefined;
+} | {
+  kysely: Kysely<any> | null;
+  databaseType: KyselyDatabaseType | null;
+  transaction: undefined;
+}>;
+//#endregion
+//#region src/adapters/kysely-adapter/kysely-adapter.d.ts
+interface KyselyAdapterConfig {
+  /**
+   * Database type.
+   */
+  type?: KyselyDatabaseType | undefined;
+  /**
+   * Enable debug logs for the adapter
+   *
+   * @default false
+   */
+  debugLogs?: DBAdapterDebugLogOption | undefined;
+  /**
+   * Use plural for 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;
+}
+declare const kyselyAdapter: (db: Kysely<any>, config?: KyselyAdapterConfig | undefined) => (options: PayvoAuthOptions) => DBAdapter<PayvoAuthOptions>;
+//#endregion
+export { KyselyDatabaseType, createKyselyAdapter, getKyselyDatabaseType, kyselyAdapter };

package/dist/adapters/kysely-adapter/index.mjs

@@ -0,0 +1,11 @@
+import "../../utils-SOMB4Px5.mjs";
+import "../../json-D0TBLy4q.mjs";
+import "../../crypto-Bb42eMrH.mjs";
+import "../../jwt-CmxZAGe2.mjs";
+import { n as getKyselyDatabaseType, t as createKyselyAdapter } from "../../dialect-CeddeGHf.mjs";
+import "../../get-tables-BQP7YW9c.mjs";
+import "../../misc-beA1w3XV.mjs";
+import "../../adapter-factory-BZ2Qiqpn.mjs";
+import { t as kyselyAdapter } from "../../kysely-adapter-DpzYO8Yf.mjs";
+
+export { createKyselyAdapter, getKyselyDatabaseType, kyselyAdapter };

package/dist/adapters/memory-adapter/index.d.mts

@@ -0,0 +1,14 @@
+import { t as DBAdapter$1 } from "../../index-65G5U5DB-DSdjzreF.mjs";
+import { PayvoAuthOptions } from "@gatwech/core";
+import { DBAdapterDebugLogOption } from "@gatwech/core/db/adapter";
+
+//#region src/adapters/memory-adapter/memory-adapter.d.ts
+interface MemoryDB {
+  [key: string]: any[];
+}
+interface MemoryAdapterConfig {
+  debugLogs?: DBAdapterDebugLogOption | undefined;
+}
+declare const memoryAdapter: (db: MemoryDB, config?: MemoryAdapterConfig | undefined) => (options: PayvoAuthOptions) => DBAdapter$1<PayvoAuthOptions>;
+//#endregion
+export { MemoryAdapterConfig, MemoryDB, memoryAdapter };

package/dist/adapters/memory-adapter/index.mjs

@@ -0,0 +1,154 @@
+import "../../utils-SOMB4Px5.mjs";
+import "../../json-D0TBLy4q.mjs";
+import "../../crypto-Bb42eMrH.mjs";
+import "../../jwt-CmxZAGe2.mjs";
+import "../../get-tables-BQP7YW9c.mjs";
+import "../../misc-beA1w3XV.mjs";
+import { t as createAdapterFactory } from "../../adapter-factory-BZ2Qiqpn.mjs";
+import { logger } from "@gatwech/core/env";
+
+//#region src/adapters/memory-adapter/memory-adapter.ts
+const memoryAdapter = (db, config) => {
+	let lazyOptions = null;
+	let adapterCreator = createAdapterFactory({
+		config: {
+			adapterId: "memory",
+			adapterName: "Memory Adapter",
+			usePlural: false,
+			debugLogs: config?.debugLogs || false,
+			customTransformInput(props) {
+				if (props.options.advanced?.database?.useNumberId && props.field === "id" && props.action === "create") return db[props.model].length + 1;
+				return props.data;
+			},
+			transaction: async (cb) => {
+				let 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, debugLog }) => {
+			function convertWhereClause(where, model) {
+				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, 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.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;
+				});
+			}
+			return {
+				create: async ({ model, data }) => {
+					if (options.advanced?.database?.useNumberId) data.id = db[model].length + 1;
+					if (!db[model]) db[model] = [];
+					db[model].push(data);
+					return data;
+				},
+				findOne: async ({ model, where }) => {
+					return convertWhereClause(where, model)[0] || null;
+				},
+				findMany: async ({ model, where, sortBy, limit, offset }) => {
+					let table = db[model];
+					if (where) table = convertWhereClause(where, model);
+					if (sortBy) table = table.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;
+					});
+					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/dist/adapters/mongodb-adapter/index.d.mts

@@ -0,0 +1,35 @@
+import { PayvoAuthOptions } from "@gatwech/core";
+import { DBAdapter, DBAdapterDebugLogOption } from "@gatwech/core/db/adapter";
+import { Db, MongoClient } from "mongodb";
+
+//#region src/adapters/mongodb-adapter/mongodb-adapter.d.ts
+interface MongoDBAdapterConfig {
+  /**
+   * MongoDB client instance
+   * If not provided, Database transactions won't be enabled.
+   */
+  client?: MongoClient | undefined;
+  /**
+   * 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;
+}
+declare const mongodbAdapter: (db: Db, config?: MongoDBAdapterConfig | undefined) => (options: PayvoAuthOptions) => DBAdapter<PayvoAuthOptions>;
+//#endregion
+export { MongoDBAdapterConfig, mongodbAdapter };