faire-auth 1.0.0

package/dist/middleware-CWvRH4EW.cjs

@@ -0,0 +1,47 @@
+
+//#region src/api/factory/middleware.ts
+/**
+* Creates a hook handler.
+* @template E - The environment type.
+* @template P - The path type.
+* @template I - The input type.
+* @param handler - The hook handler function.
+* @returns The hook handler.
+*/
+const createHook = () => (handler) => handler;
+/**
+* Creates a middleware handler.
+* @template E - The environment type.
+* @template P - The path type.
+* @template I - The input type.
+* @param handler - The middleware handler function.
+* @returns The middleware handler.
+*/
+const createMiddleware = () => (handler) => handler;
+/**
+* Creates an error handler.
+* @template E - The environment type.
+* @param handler - The error handler function.
+* @returns The error handler.
+*/
+const createErrorHandler = () => (handler) => handler;
+
+//#endregion
+Object.defineProperty(exports, 'createErrorHandler', {
+  enumerable: true,
+  get: function () {
+    return createErrorHandler;
+  }
+});
+Object.defineProperty(exports, 'createHook', {
+  enumerable: true,
+  get: function () {
+    return createHook;
+  }
+});
+Object.defineProperty(exports, 'createMiddleware', {
+  enumerable: true,
+  get: function () {
+    return createMiddleware;
+  }
+});

package/dist/mongodb-adapter-C_qGQED5.mjs

@@ -0,0 +1,291 @@
+import { t as createAdapterFactory } from "./adapter-factory-BXei1QRX.mjs";
+import { ObjectId } from "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 ObjectId) return value;
+					if (Array.isArray(value)) return value.map((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: 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(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 ObjectId(data);
+						} catch (error) {
+							return data;
+						}
+						return data;
+					}
+					if (Array.isArray(data)) return data.map((v) => {
+						if (typeof v === "string") try {
+							return new ObjectId(v);
+						} catch (error) {
+							return v;
+						}
+						return v;
+					});
+					if (typeof data === "string") try {
+						return new ObjectId(data);
+					} catch (error) {
+						return new ObjectId();
+					}
+					if (data === null && fieldAttributes.references?.field === "id") 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(props) {
+				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 as t };

package/dist/mongodb-adapter-C_qfK87x.cjs

@@ -0,0 +1,297 @@
+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;
+  }
+});