faire-auth 1.0.0 → 1.0.2

package/dist/mongodb-adapter-C_qfK87x.cjs

@@ -1,297 +0,0 @@
-const require_chunk = require('./chunk-oakRccI5.cjs');
-const require_adapter_factory = require('./adapter-factory-DT-_2aHJ.cjs');
-let mongodb = require("mongodb");
-
-//#region src/adapters/mongodb-adapter/mongodb-adapter.ts
-const mongodbAdapter = (db, config) => {
-	let lazyOptions;
-	const createCustomAdapter = (db$1, session) => ({ options, getFieldName, schema, getDefaultModelName }) => {
-		function serializeID({ field, value, model }) {
-			model = getDefaultModelName(model);
-			if (field === "id" || field === "_id" || schema[model].fields[field]?.references?.field === "id") {
-				if (typeof value !== "string") {
-					if (value instanceof mongodb.ObjectId) return value;
-					if (Array.isArray(value)) return value.map((v) => {
-						if (typeof v === "string") try {
-							return new mongodb.ObjectId(v);
-						} catch (e) {
-							return v;
-						}
-						if (v instanceof mongodb.ObjectId) return v;
-						throw new Error("Invalid id value");
-					});
-					throw new Error("Invalid id value");
-				}
-				try {
-					return new mongodb.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: value } };
-						break;
-					case "gte":
-						condition = { [field]: { $gte: value } };
-						break;
-					case "lt":
-						condition = { [field]: { $lt: value } };
-						break;
-					case "lte":
-						condition = { [field]: { $lte: value } };
-						break;
-					case "ne":
-						condition = { [field]: { $ne: value } };
-						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 && { 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 && { session },
-					...projection && { 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 && { 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 && { session } });
-			},
-			async update({ model, where, update: values }) {
-				const clause = convertWhereClause({
-					where,
-					model
-				});
-				const res = await db$1.collection(model).findOneAndUpdate(clause, { $set: values }, {
-					...session && { 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 && { session } })).modifiedCount;
-			},
-			async delete({ model, where }) {
-				const clause = convertWhereClause({
-					where,
-					model
-				});
-				await db$1.collection(model).deleteOne(clause, { ...session && { session } });
-			},
-			async deleteMany({ model, where }) {
-				const clause = convertWhereClause({
-					where,
-					model
-				});
-				return (await db$1.collection(model).deleteMany(clause, { ...session && { 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(require_adapter_factory.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 }) {
-				if (field === "_id" || fieldAttributes.references?.field === "id") {
-					if (action === "update") {
-						if (typeof data === "string") try {
-							return new mongodb.ObjectId(data);
-						} catch (error) {
-							return data;
-						}
-						return data;
-					}
-					if (Array.isArray(data)) return data.map((v) => {
-						if (typeof v === "string") try {
-							return new mongodb.ObjectId(v);
-						} catch (error) {
-							return v;
-						}
-						return v;
-					});
-					if (typeof data === "string") try {
-						return new mongodb.ObjectId(data);
-					} catch (error) {
-						return new mongodb.ObjectId();
-					}
-					if (data === null && fieldAttributes.references?.field === "id") return null;
-					return new mongodb.ObjectId();
-				}
-				return data;
-			},
-			customTransformOutput({ data, field, fieldAttributes }) {
-				if (field === "id" || fieldAttributes.references?.field === "id") {
-					if (data instanceof mongodb.ObjectId) return data.toHexString();
-					if (Array.isArray(data)) return data.map((v) => {
-						if (v instanceof mongodb.ObjectId) return v.toHexString();
-						return v;
-					});
-					return data;
-				}
-				return data;
-			},
-			customIdGenerator(props) {
-				return new mongodb.ObjectId().toString();
-			}
-		},
-		adapter: createCustomAdapter(db)
-	};
-	lazyAdapter = require_adapter_factory.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
-Object.defineProperty(exports, 'mongodbAdapter', {
-  enumerable: true,
-  get: function () {
-    return mongodbAdapter;
-  }
-});