@gatwech/auth 1.0.0-beta.18

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

@@ -0,0 +1,315 @@
+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 { createLogger } from "@gatwech/core/env";
+import { ObjectId } from "mongodb";
+
+//#region src/adapters/mongodb-adapter/mongodb-adapter.ts
+const mongodbAdapter = (db, config) => {
+	let lazyOptions;
+	const getCustomIdGenerator = (options) => {
+		const generator = options.advanced?.database?.generateId || options.advanced?.generateId;
+		if (typeof generator === "function") return generator;
+	};
+	const createCustomAdapter = (db$1, session) => ({ options, getFieldName, schema, getDefaultModelName }) => {
+		const customIdGen = getCustomIdGenerator(options);
+		createLogger(options.logger);
+		function serializeID({ field, value, model }) {
+			if (customIdGen) return value;
+			model = getDefaultModelName(model);
+			if (field === "id" || field === "_id" || schema[model].fields[field]?.references?.field === "id") {
+				if (value === null || value === void 0) return value;
+				if (typeof value !== "string") {
+					if (value instanceof ObjectId) return value;
+					if (Array.isArray(value)) return value.map((v) => {
+						if (v === null || v === void 0) return v;
+						if (typeof v === "string") try {
+							return new ObjectId(v);
+						} catch (e) {
+							return v;
+						}
+						if (v instanceof ObjectId) return v;
+						throw new Error("Invalid id value");
+					});
+					throw new Error("Invalid id value");
+				}
+				try {
+					return new ObjectId(value);
+				} catch (e) {
+					return value;
+				}
+			}
+			return value;
+		}
+		function convertWhereClause({ where, model }) {
+			if (!where.length) return {};
+			const conditions = where.map((w) => {
+				const { field: field_, value, operator = "eq", connector = "AND" } = w;
+				let condition;
+				let field = getFieldName({
+					model,
+					field: field_
+				});
+				if (field === "id") field = "_id";
+				switch (operator.toLowerCase()) {
+					case "eq":
+						condition = { [field]: serializeID({
+							field,
+							value,
+							model
+						}) };
+						break;
+					case "in":
+						condition = { [field]: { $in: Array.isArray(value) ? value.map((v) => serializeID({
+							field,
+							value: v,
+							model
+						})) : [serializeID({
+							field,
+							value,
+							model
+						})] } };
+						break;
+					case "not_in":
+						condition = { [field]: { $nin: Array.isArray(value) ? value.map((v) => serializeID({
+							field,
+							value: v,
+							model
+						})) : [serializeID({
+							field,
+							value,
+							model
+						})] } };
+						break;
+					case "gt":
+						condition = { [field]: { $gt: serializeID({
+							field,
+							value,
+							model
+						}) } };
+						break;
+					case "gte":
+						condition = { [field]: { $gte: serializeID({
+							field,
+							value,
+							model
+						}) } };
+						break;
+					case "lt":
+						condition = { [field]: { $lt: serializeID({
+							field,
+							value,
+							model
+						}) } };
+						break;
+					case "lte":
+						condition = { [field]: { $lte: serializeID({
+							field,
+							value,
+							model
+						}) } };
+						break;
+					case "ne":
+						condition = { [field]: { $ne: serializeID({
+							field,
+							value,
+							model
+						}) } };
+						break;
+					case "contains":
+						condition = { [field]: { $regex: `.*${escapeForMongoRegex(value)}.*` } };
+						break;
+					case "starts_with":
+						condition = { [field]: { $regex: `^${escapeForMongoRegex(value)}` } };
+						break;
+					case "ends_with":
+						condition = { [field]: { $regex: `${escapeForMongoRegex(value)}$` } };
+						break;
+					default: throw new Error(`Unsupported operator: ${operator}`);
+				}
+				return {
+					condition,
+					connector
+				};
+			});
+			if (conditions.length === 1) return conditions[0].condition;
+			const andConditions = conditions.filter((c) => c.connector === "AND").map((c) => c.condition);
+			const orConditions = conditions.filter((c) => c.connector === "OR").map((c) => c.condition);
+			let clause = {};
+			if (andConditions.length) clause = {
+				...clause,
+				$and: andConditions
+			};
+			if (orConditions.length) clause = {
+				...clause,
+				$or: orConditions
+			};
+			return clause;
+		}
+		return {
+			async create({ model, data: values }) {
+				return {
+					_id: (await db$1.collection(model).insertOne(values, { session })).insertedId.toString(),
+					...values
+				};
+			},
+			async findOne({ model, where, select }) {
+				const clause = convertWhereClause({
+					where,
+					model
+				});
+				const projection = select ? Object.fromEntries(select.map((field) => [getFieldName({
+					field,
+					model
+				}), 1])) : void 0;
+				const res = await db$1.collection(model).findOne(clause, {
+					session,
+					projection
+				});
+				if (!res) return null;
+				return res;
+			},
+			async findMany({ model, where, limit, offset, sortBy }) {
+				const clause = where ? convertWhereClause({
+					where,
+					model
+				}) : {};
+				const cursor = db$1.collection(model).find(clause, { session });
+				if (limit) cursor.limit(limit);
+				if (offset) cursor.skip(offset);
+				if (sortBy) cursor.sort(getFieldName({
+					field: sortBy.field,
+					model
+				}), sortBy.direction === "desc" ? -1 : 1);
+				return await cursor.toArray();
+			},
+			async count({ model, where }) {
+				const clause = where ? convertWhereClause({
+					where,
+					model
+				}) : {};
+				return await db$1.collection(model).countDocuments(clause, { session });
+			},
+			async update({ model, where, update: values }) {
+				const clause = convertWhereClause({
+					where,
+					model
+				});
+				const res = await db$1.collection(model).findOneAndUpdate(clause, { $set: values }, {
+					session,
+					returnDocument: "after"
+				});
+				if (!res) return null;
+				return res;
+			},
+			async updateMany({ model, where, update: values }) {
+				const clause = convertWhereClause({
+					where,
+					model
+				});
+				return (await db$1.collection(model).updateMany(clause, { $set: values }, { session })).modifiedCount;
+			},
+			async delete({ model, where }) {
+				const clause = convertWhereClause({
+					where,
+					model
+				});
+				await db$1.collection(model).deleteOne(clause, { session });
+			},
+			async deleteMany({ model, where }) {
+				const clause = convertWhereClause({
+					where,
+					model
+				});
+				return (await db$1.collection(model).deleteMany(clause, { session })).deletedCount;
+			}
+		};
+	};
+	let lazyAdapter = null;
+	let adapterOptions = null;
+	adapterOptions = {
+		config: {
+			adapterId: "mongodb-adapter",
+			adapterName: "MongoDB Adapter",
+			usePlural: config?.usePlural ?? false,
+			debugLogs: config?.debugLogs ?? false,
+			mapKeysTransformInput: { id: "_id" },
+			mapKeysTransformOutput: { _id: "id" },
+			supportsNumericIds: false,
+			transaction: config?.client && (config?.transaction ?? true) ? async (cb) => {
+				if (!config.client) return cb(lazyAdapter(lazyOptions));
+				const session = config.client.startSession();
+				try {
+					session.startTransaction();
+					const result = await cb(createAdapterFactory({
+						config: adapterOptions.config,
+						adapter: createCustomAdapter(db, session)
+					})(lazyOptions));
+					await session.commitTransaction();
+					return result;
+				} catch (err) {
+					await session.abortTransaction();
+					throw err;
+				} finally {
+					await session.endSession();
+				}
+			} : false,
+			customTransformInput({ action, data, field, fieldAttributes, schema, model, options }) {
+				const customIdGen = getCustomIdGenerator(options);
+				if (field === "_id" || fieldAttributes.references?.field === "id") {
+					if (customIdGen) return data;
+					if (action === "update") return data;
+					if (Array.isArray(data)) return data.map((v) => new ObjectId());
+					if (typeof data === "string") try {
+						return new ObjectId(data);
+					} catch (error) {
+						return new ObjectId();
+					}
+					if (fieldAttributes?.references?.field === "id" && !fieldAttributes?.required && data === null) return null;
+					return new ObjectId();
+				}
+				return data;
+			},
+			customTransformOutput({ data, field, fieldAttributes }) {
+				if (field === "id" || fieldAttributes.references?.field === "id") {
+					if (data instanceof ObjectId) return data.toHexString();
+					if (Array.isArray(data)) return data.map((v) => {
+						if (v instanceof ObjectId) return v.toHexString();
+						return v;
+					});
+					return data;
+				}
+				return data;
+			},
+			customIdGenerator() {
+				return new ObjectId().toString();
+			}
+		},
+		adapter: createCustomAdapter(db)
+	};
+	lazyAdapter = createAdapterFactory(adapterOptions);
+	return (options) => {
+		lazyOptions = options;
+		return lazyAdapter(options);
+	};
+};
+/**
+* Safely escape user input for use in a MongoDB regex.
+* This ensures the resulting pattern is treated as literal text,
+* and not as a regex with special syntax.
+*
+* @param input - The input string to escape. Any type that isn't a string will be converted to an empty string.
+* @param maxLength - The maximum length of the input string to escape. Defaults to 256. This is to prevent DOS attacks.
+* @returns The escaped string.
+*/
+function escapeForMongoRegex(input, maxLength = 256) {
+	if (typeof input !== "string") return "";
+	return input.slice(0, maxLength).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+//#endregion
+export { mongodbAdapter };

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

@@ -0,0 +1,34 @@
+import { PayvoAuthOptions } from "@gatwech/core";
+import { DBAdapter, DBAdapterDebugLogOption } from "@gatwech/core/db/adapter";
+
+//#region src/adapters/prisma-adapter/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: PayvoAuthOptions) => DBAdapter<PayvoAuthOptions>;
+//#endregion
+export { PrismaConfig, prismaAdapter };

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

@@ -0,0 +1,159 @@
+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";
+
+//#region src/adapters/prisma-adapter/prisma-adapter.ts
+const prismaAdapter = (prisma, config) => {
+	let lazyOptions = null;
+	const createCustomAdapter = (prisma$1) => ({ getFieldName }) => {
+		const db = prisma$1;
+		const convertSelect = (select, model) => {
+			if (!select || !model) return void 0;
+			return select.reduce((prev, cur) => {
+				return {
+					...prev,
+					[getFieldName({
+						model,
+						field: cur
+					})]: true
+				};
+			}, {});
+		};
+		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 = (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 {};
+				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 (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 PayvoAuthError(`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 }) {
+				const whereClause = convertWhereClause(model, where);
+				if (!db[model]) throw new PayvoAuthError(`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].findFirst({
+					where: whereClause,
+					select: convertSelect(select, model)
+				});
+			},
+			async findMany({ model, where, limit, offset, sortBy }) {
+				const whereClause = convertWhereClause(model, where);
+				if (!db[model]) throw new PayvoAuthError(`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].findMany({
+					where: whereClause,
+					take: limit || 100,
+					skip: offset || 0,
+					...sortBy?.field ? { orderBy: { [getFieldName({
+						model,
+						field: sortBy.field
+					})]: sortBy.direction === "desc" ? "desc" : "asc" } } : {}
+				});
+			},
+			async count({ model, where }) {
+				const whereClause = convertWhereClause(model, where);
+				if (!db[model]) throw new PayvoAuthError(`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 PayvoAuthError(`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);
+				return await db[model].update({
+					where: whereClause,
+					data: update
+				});
+			},
+			async updateMany({ model, where, update }) {
+				const whereClause = convertWhereClause(model, where);
+				const result = await db[model].updateMany({
+					where: whereClause,
+					data: update
+				});
+				return result ? result.count : 0;
+			},
+			async delete({ model, where }) {
+				const whereClause = convertWhereClause(model, where);
+				try {
+					await db[model].delete({ where: whereClause });
+				} catch (e) {
+					if (e?.meta?.cause === "Record to delete does not exist.") return;
+					console.log(e);
+				}
+			},
+			async deleteMany({ model, where }) {
+				const whereClause = convertWhereClause(model, where);
+				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,
+			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/dist/adapters/test.d.mts

@@ -0,0 +1,81 @@
+import { PayvoAuthOptions } from "@gatwech/core";
+import { DBAdapter } from "@gatwech/core/db/adapter";
+
+//#region src/adapters/test.d.ts
+interface AdapterTestOptions {
+  getAdapter: (customOptions?: Omit<PayvoAuthOptions, "database">) => Promise<DBAdapter<PayvoAuthOptions>> | DBAdapter<PayvoAuthOptions>;
+  disableTests?: Partial<Record<keyof typeof adapterTests, boolean>>;
+  testPrefix?: string;
+}
+interface NumberIdAdapterTestOptions {
+  getAdapter: (customOptions?: Omit<PayvoAuthOptions, "database">) => Promise<DBAdapter<PayvoAuthOptions>>;
+  disableTests?: Partial<Record<keyof typeof numberIdAdapterTests, boolean>>;
+  testPrefix?: string;
+}
+declare const adapterTests: {
+  readonly CREATE_MODEL: "create model";
+  readonly CREATE_MODEL_SHOULD_ALWAYS_RETURN_AN_ID: "create model should always return an id";
+  readonly FIND_MODEL: "find model";
+  readonly FIND_MODEL_WITHOUT_ID: "find model without id";
+  readonly FIND_MODEL_WITH_SELECT: "find model with select";
+  readonly FIND_MODEL_WITH_MODIFIED_FIELD_NAME: "find model with modified field name";
+  readonly UPDATE_MODEL: "update model";
+  readonly SHOULD_FIND_MANY: "should find many";
+  readonly SHOULD_FIND_MANY_WITH_WHERE: "should find many with where";
+  readonly SHOULD_FIND_MANY_WITH_OPERATORS: "should find many with operators";
+  readonly SHOULD_WORK_WITH_REFERENCE_FIELDS: "should work with reference fields";
+  readonly SHOULD_FIND_MANY_WITH_NOT_IN_OPERATOR: "should find many with not in operator";
+  readonly SHOULD_FIND_MANY_WITH_SORT_BY: "should find many with sortBy";
+  readonly SHOULD_FIND_MANY_WITH_LIMIT: "should find many with limit";
+  readonly SHOULD_FIND_MANY_WITH_OFFSET: "should find many with offset";
+  readonly SHOULD_UPDATE_WITH_MULTIPLE_WHERE: "should update with multiple where";
+  readonly DELETE_MODEL: "delete model";
+  readonly SHOULD_DELETE_MANY: "should delete many";
+  readonly SHOULD_NOT_THROW_ON_DELETE_RECORD_NOT_FOUND: "shouldn't throw on delete record not found";
+  readonly SHOULD_NOT_THROW_ON_RECORD_NOT_FOUND: "shouldn't throw on record not found";
+  readonly SHOULD_FIND_MANY_WITH_CONTAINS_OPERATOR: "should find many with contains operator";
+  readonly SHOULD_SEARCH_USERS_WITH_STARTS_WITH: "should search users with startsWith";
+  readonly SHOULD_SEARCH_USERS_WITH_ENDS_WITH: "should search users with endsWith";
+  readonly SHOULD_PREFER_GENERATE_ID_IF_PROVIDED: "should prefer generateId if provided";
+  readonly SHOULD_ROLLBACK_FAILING_TRANSACTION: "should rollback failing transaction";
+  readonly SHOULD_RETURN_TRANSACTION_RESULT: "should return transaction result";
+  readonly SHOULD_FIND_MANY_WITH_CONNECTORS: "should find many with connectors";
+};
+declare const numberIdAdapterTests: {
+  SHOULD_RETURN_A_NUMBER_ID_AS_A_RESULT: string;
+  SHOULD_INCREMENT_THE_ID_BY_1: string;
+  CREATE_MODEL: "create model";
+  CREATE_MODEL_SHOULD_ALWAYS_RETURN_AN_ID: "create model should always return an id";
+  FIND_MODEL: "find model";
+  FIND_MODEL_WITHOUT_ID: "find model without id";
+  FIND_MODEL_WITH_SELECT: "find model with select";
+  FIND_MODEL_WITH_MODIFIED_FIELD_NAME: "find model with modified field name";
+  UPDATE_MODEL: "update model";
+  SHOULD_FIND_MANY: "should find many";
+  SHOULD_FIND_MANY_WITH_WHERE: "should find many with where";
+  SHOULD_FIND_MANY_WITH_OPERATORS: "should find many with operators";
+  SHOULD_WORK_WITH_REFERENCE_FIELDS: "should work with reference fields";
+  SHOULD_FIND_MANY_WITH_NOT_IN_OPERATOR: "should find many with not in operator";
+  SHOULD_FIND_MANY_WITH_SORT_BY: "should find many with sortBy";
+  SHOULD_FIND_MANY_WITH_LIMIT: "should find many with limit";
+  SHOULD_FIND_MANY_WITH_OFFSET: "should find many with offset";
+  SHOULD_UPDATE_WITH_MULTIPLE_WHERE: "should update with multiple where";
+  DELETE_MODEL: "delete model";
+  SHOULD_DELETE_MANY: "should delete many";
+  SHOULD_NOT_THROW_ON_DELETE_RECORD_NOT_FOUND: "shouldn't throw on delete record not found";
+  SHOULD_NOT_THROW_ON_RECORD_NOT_FOUND: "shouldn't throw on record not found";
+  SHOULD_FIND_MANY_WITH_CONTAINS_OPERATOR: "should find many with contains operator";
+  SHOULD_SEARCH_USERS_WITH_STARTS_WITH: "should search users with startsWith";
+  SHOULD_SEARCH_USERS_WITH_ENDS_WITH: "should search users with endsWith";
+  SHOULD_PREFER_GENERATE_ID_IF_PROVIDED: "should prefer generateId if provided";
+  SHOULD_ROLLBACK_FAILING_TRANSACTION: "should rollback failing transaction";
+  SHOULD_RETURN_TRANSACTION_RESULT: "should return transaction result";
+  SHOULD_FIND_MANY_WITH_CONNECTORS: "should find many with connectors";
+};
+declare function runAdapterTest(opts: AdapterTestOptions): void;
+declare function runNumberIdAdapterTest(opts: NumberIdAdapterTestOptions): void;
+declare function recoverProcessTZ(): {
+  [Symbol.dispose]: () => void;
+};
+//#endregion
+export { recoverProcessTZ, runAdapterTest, runNumberIdAdapterTest };