elseware-nodejs 1.8.7 → 1.9.0

package/dist/index.js

@@ -1,5 +1,5 @@
-import mongoose from 'mongoose';
 import dotenv from 'dotenv';
+import mongoose from 'mongoose';
 import { BlobServiceClient, StorageSharedKeyCredential, generateBlobSASQueryParameters, BlobSASPermissions } from '@azure/storage-blob';
 import fs3 from 'fs';
 import cloudinaryModule from 'cloudinary';
@@ -10,252 +10,7 @@ import juice from 'juice';
 import jwt from 'jsonwebtoken';
 import multer from 'multer';
 
-// src/errors/appError.ts
-var AppError = class extends Error {
-  statusCode;
-  status;
-  isOperational;
-  code;
-  details;
-  constructor(message, statusCode = 500, options) {
-    super(message);
-    this.statusCode = statusCode;
-    this.status = `${statusCode}`.startsWith("4") ? "fail" : "error";
-    this.isOperational = true;
-    this.code = options?.code;
-    this.details = options?.details;
-    Error.captureStackTrace(this, this.constructor);
-  }
-};
-
-// src/api/apiResponse.ts
-var APIResponse = class _APIResponse {
-  static send(res, options) {
-    const {
-      statusCode = 200,
-      success = true,
-      message = "Success",
-      data,
-      meta
-    } = options;
-    if (statusCode === 204) {
-      return res.status(204).send();
-    }
-    const body = {
-      success,
-      message,
-      ...data !== void 0 && { data },
-      ...meta !== void 0 && { meta }
-    };
-    return res.status(statusCode).json(body);
-  }
-  static ok(res, data, message = "Success", meta) {
-    return _APIResponse.send(res, { statusCode: 200, data, message, meta });
-  }
-  static created(res, data, message = "Resource created successfully") {
-    return _APIResponse.send(res, { statusCode: 201, data, message });
-  }
-  static noContent(res) {
-    return _APIResponse.send(res, { statusCode: 204 });
-  }
-  static error(res, message = "Internal Server Error", statusCode = 500, meta) {
-    return _APIResponse.send(res, {
-      success: false,
-      statusCode,
-      message,
-      meta
-    });
-  }
-  static paginated(res, data, options, message = "Data fetched successfully") {
-    return _APIResponse.ok(res, data, message, {
-      total: options.total,
-      page: options.page,
-      limit: options.limit,
-      totalPages: Math.ceil(options.total / options.limit)
-    });
-  }
-};
-
-// src/api/asyncHandler.ts
-var asyncHandler = (fn) => (req, res, next) => Promise.resolve(fn(req, res, next)).catch(next);
-
-// src/api/apiFeatures.ts
-var APIFeatures = class {
-  query;
-  queryString;
-  page;
-  limit;
-  constructor(query, queryString) {
-    this.query = query;
-    this.queryString = queryString;
-    this.page = 1;
-    this.limit = 100;
-  }
-  filter() {
-    const queryObj = { ...this.queryString };
-    ["page", "sort", "limit", "fields"].forEach((el) => delete queryObj[el]);
-    let queryStr = JSON.stringify(queryObj);
-    queryStr = queryStr.replace(
-      /\b(gte|gt|lte|lt|in)\b/g,
-      (match) => `$${match}`
-    );
-    this.query = this.query.find(JSON.parse(queryStr));
-    return this;
-  }
-  sort() {
-    if (this.queryString.sort) {
-      const sortBy = String(this.queryString.sort).split(",").join(" ");
-      this.query = this.query.sort(sortBy);
-    } else {
-      this.query = this.query.sort("-createdAt");
-    }
-    return this;
-  }
-  limitFields() {
-    if (this.queryString.fields) {
-      const fields = String(this.queryString.fields).split(",").join(" ");
-      this.query = this.query.select(fields);
-    } else {
-      this.query = this.query.select("-__v");
-    }
-    return this;
-  }
-  paginate() {
-    this.page = Number(this.queryString.page) || 1;
-    this.limit = Number(this.queryString.limit) || 100;
-    const skip = (this.page - 1) * this.limit;
-    this.query = this.query.skip(skip).limit(this.limit);
-    return this;
-  }
-  populate(populateOptions) {
-    if (populateOptions) {
-      this.query = this.query.populate(populateOptions);
-    }
-    return this;
-  }
-};
-var apiFeatures_default = APIFeatures;
-
-// src/api/apiFactory.ts
-var APIFactory = class {
-  static getAll(Model, options = {}) {
-    return asyncHandler(async (req, res) => {
-      const filter = options.filter ? options.filter(req) : {};
-      const features = new apiFeatures_default(Model.find(filter), req.query).filter().sort().limitFields().paginate().populate(options.populate);
-      const docs = await features.query;
-      APIResponse.ok(
-        res,
-        docs,
-        options.message ?? "Records fetched successfully",
-        {
-          count: docs.length,
-          page: features.page,
-          limit: features.limit
-        }
-      );
-    });
-  }
-  static getOne(Model, options = {}) {
-    return asyncHandler(async (req, res) => {
-      let query = Model.findById(req.params.id);
-      if (options.populate) {
-        query = query.populate(
-          options.populate
-        );
-      }
-      const doc = await query;
-      if (!doc) {
-        throw new AppError(
-          options.notFoundMessage ?? "Resource not found",
-          404,
-          { code: "RESOURCE_NOT_FOUND" }
-        );
-      }
-      APIResponse.ok(res, doc);
-    });
-  }
-  static createOne(Model, options = {}) {
-    return asyncHandler(async (req, res) => {
-      const doc = await Model.create(req.body);
-      APIResponse.created(
-        res,
-        doc,
-        options.message ?? "Resource created successfully"
-      );
-    });
-  }
-  static updateOne(Model, options = {}) {
-    return asyncHandler(async (req, res) => {
-      const doc = await Model.findByIdAndUpdate(
-        req.params.id,
-        req.body,
-        {
-          new: true,
-          runValidators: true
-        }
-      );
-      if (!doc) {
-        throw new AppError(
-          options.notFoundMessage ?? "Resource not found",
-          404
-        );
-      }
-      APIResponse.ok(
-        res,
-        doc,
-        options.message ?? "Resource updated successfully"
-      );
-    });
-  }
-  static deleteOne(Model, options = {}) {
-    return asyncHandler(async (req, res) => {
-      const doc = await Model.findByIdAndDelete(req.params.id);
-      if (!doc) {
-        throw new AppError(
-          options.notFoundMessage ?? "Resource not found",
-          404
-        );
-      }
-      APIResponse.noContent(res);
-    });
-  }
-};
-
-// src/api/pickFields.ts
-function pickFields(obj, fields, options = {}) {
-  const removeUndefined = options.removeUndefined ?? false;
-  const removeNull = options.removeNull ?? false;
-  const removeEmptyString = options.removeEmptyString ?? false;
-  const strict = options.strict ?? false;
-  const defaults = options.defaults ?? {};
-  const rename = options.rename ?? {};
-  const transform = options.transform ?? {};
-  const result = {};
-  if (strict) {
-    for (const key of Object.keys(obj)) {
-      if (!fields.includes(key)) {
-        throw new Error(`Unknown field: ${key}`);
-      }
-    }
-  }
-  for (const field of fields) {
-    let value = obj[field];
-    if (value === void 0 && field in defaults) {
-      value = defaults[field];
-    }
-    if (removeUndefined && value === void 0) continue;
-    if (removeNull && value === null) continue;
-    if (removeEmptyString && value === "") continue;
-    if (transform[field]) {
-      value = transform[field](value);
-    }
-    const outputKey = rename[field] ?? field;
-    if (Object.prototype.hasOwnProperty.call(obj, field) || field in defaults) {
-      result[outputKey] = value;
-    }
-  }
-  return result;
-}
+// src/configs/env.ts
 
 // src/utils/errorToString.ts
 function errorToString(error) {
@@ -314,25 +69,7 @@ ${errorToString(error)}`);
 };
 var logger = new Logger();
 
-// src/configs/database.ts
-async function connectMongoDB(config) {
-  try {
-    mongoose.set("strictQuery", true);
-    await mongoose.connect(config.uri);
-    logger.success("Database connected successfully");
-    process.on("SIGINT", async () => {
-      await mongoose.connection.close();
-      logger.success("Database connection closed");
-      process.exit(0);
-    });
-  } catch (error) {
-    logger.danger("Database connection failed");
-    if (error instanceof Error) {
-      logger.danger(error.message);
-    }
-    process.exit(1);
-  }
-}
+// src/configs/env.ts
 dotenv.config({ quiet: true });
 function loadEnv(options) {
   const result = options.schema.safeParse(process.env);
@@ -2167,6 +1904,7 @@ var CircularQueue = class {
     }
     this.data = new Array(capacity);
   }
+  capacity;
   data;
   head = 0;
   tail = 0;
@@ -5087,22 +4825,403 @@ var SegmentTree = class {
   }
 };
 
-// src/middlewares/auth.middleware.ts
+// src/database/DatabaseManager.ts
+var DatabaseManager = class {
+  constructor(provider, options = {
+    enableShutdownHooks: true
+  }) {
+    this.provider = provider;
+    this.options = options;
+  }
+  provider;
+  options;
+  async connect() {
+    try {
+      await this.provider.connect();
+      logger.success("Database connected successfully");
+      if (this.options.enableShutdownHooks) {
+        this.registerShutdownHooks();
+      }
+    } catch (error) {
+      logger.danger("Database connection failed", error);
+      throw error;
+    }
+  }
+  async disconnect() {
+    try {
+      await this.provider.disconnect();
+      logger.success("Database connection closed");
+    } catch (error) {
+      logger.danger("Database disconnect failed", error);
+      throw error;
+    }
+  }
+  isConnected() {
+    return this.provider.isConnected();
+  }
+  getConnectionState() {
+    return this.provider.getConnectionState();
+  }
+  registerShutdownHooks() {
+    process.once("SIGINT", async () => {
+      await this.disconnect();
+      process.exit(0);
+    });
+    process.once("SIGTERM", async () => {
+      await this.disconnect();
+      process.exit(0);
+    });
+  }
+};
+var MongoDatabaseProvider = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  async connect() {
+    mongoose.set("strictQuery", this.config.strictQuery ?? true);
+    await mongoose.connect(this.config.uri);
+  }
+  async disconnect() {
+    await mongoose.disconnect();
+  }
+  isConnected() {
+    return mongoose.connection.readyState === 1;
+  }
+  getConnectionState() {
+    switch (mongoose.connection.readyState) {
+      case 0:
+        return "disconnected";
+      case 1:
+        return "connected";
+      case 2:
+        return "connecting";
+      case 3:
+        return "disconnecting";
+      default:
+        return "unknown";
+    }
+  }
+};
+
+// src/errors/appError.ts
+var AppError = class extends Error {
+  statusCode;
+  status;
+  isOperational;
+  code;
+  details;
+  constructor(message, statusCode = 500, options) {
+    super(message);
+    this.statusCode = statusCode;
+    this.status = `${statusCode}`.startsWith("4") ? "fail" : "error";
+    this.isOperational = true;
+    this.code = options?.code;
+    this.details = options?.details;
+    Error.captureStackTrace(this, this.constructor);
+  }
+};
+
+// src/http/handlers/AsyncHandler.ts
+var AsyncHandler = (fn) => (req, res, next) => {
+  Promise.resolve(fn(req, res, next)).catch(next);
+};
+
+// src/http/query/QueryConstants.ts
+var QUERY_RESERVED_FIELDS = [
+  "page",
+  "limit",
+  "sort",
+  "fields",
+  "populate"
+];
+var DEFAULT_PAGE = 1;
+var DEFAULT_LIMIT = 100;
+var DEFAULT_SORT_DIRECTION = "asc";
+var SUPPORTED_OPERATORS = [
+  "eq",
+  "ne",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "in",
+  "nin",
+  "contains",
+  "startsWith",
+  "endsWith"
+];
+
+// src/http/query/ApiFeatures.ts
+var ApiFeatures = class {
+  static parse(query) {
+    return {
+      filters: this.parseFilters(query),
+      sort: this.parseSort(query),
+      fields: this.parseFields(query),
+      pagination: this.parsePagination(query),
+      populate: this.parsePopulate(query)
+    };
+  }
+  static parseFilters(query) {
+    const filters = [];
+    Object.entries(query).forEach(([key, value]) => {
+      if (QUERY_RESERVED_FIELDS.includes(key)) {
+        return;
+      }
+      const match = key.match(
+        /^(.+)\[(eq|ne|gt|gte|lt|lte|in|nin|contains|startsWith|endsWith)\]$/
+      );
+      if (match) {
+        filters.push({
+          field: match[1],
+          operator: match[2],
+          value
+        });
+        return;
+      }
+      filters.push({
+        field: key,
+        operator: "eq",
+        value
+      });
+    });
+    return filters;
+  }
+  static parseSort(query) {
+    const sort = query.sort?.toString();
+    if (!sort) {
+      return [];
+    }
+    return sort.split(",").filter(Boolean).map((item) => {
+      if (item.startsWith("-")) {
+        return {
+          field: item.substring(1),
+          direction: "desc"
+        };
+      }
+      return {
+        field: item,
+        direction: "asc"
+      };
+    });
+  }
+  static parseFields(query) {
+    const fields = query.fields?.toString();
+    if (!fields) {
+      return [];
+    }
+    return fields.split(",").map((field) => field.trim()).filter(Boolean);
+  }
+  static parsePopulate(query) {
+    const populate = query.populate?.toString();
+    if (!populate) {
+      return [];
+    }
+    return populate.split(",").map((field) => field.trim()).filter(Boolean);
+  }
+  static parsePagination(query) {
+    const page = Number(query.page) || DEFAULT_PAGE;
+    const limit = Number(query.limit) || DEFAULT_LIMIT;
+    return {
+      page,
+      limit
+    };
+  }
+};
+
+// src/http/responses/ApiResponse.ts
+var ApiResponse = class _ApiResponse {
+  static send(res, options) {
+    const {
+      statusCode = 200,
+      success = true,
+      message = "Success",
+      data,
+      meta
+    } = options;
+    if (statusCode === 204) {
+      return res.status(204).send();
+    }
+    const body = {
+      success,
+      message
+    };
+    if (data !== void 0) {
+      body.data = data;
+    }
+    if (meta !== void 0) {
+      body.meta = meta;
+    }
+    return res.status(statusCode).json(body);
+  }
+  static ok(res, data, message = "Success", meta) {
+    return _ApiResponse.send(res, {
+      statusCode: 200,
+      success: true,
+      message,
+      data,
+      meta
+    });
+  }
+  static created(res, data, message = "Resource created successfully") {
+    return _ApiResponse.send(res, {
+      statusCode: 201,
+      success: true,
+      message,
+      data
+    });
+  }
+  static accepted(res, data, message = "Request accepted") {
+    return _ApiResponse.send(res, {
+      statusCode: 202,
+      success: true,
+      message,
+      data
+    });
+  }
+  static noContent(res) {
+    return _ApiResponse.send(res, {
+      statusCode: 204
+    });
+  }
+  static error(res, message = "Internal Server Error", statusCode = 500, meta) {
+    return _ApiResponse.send(res, {
+      success: false,
+      statusCode,
+      message,
+      meta
+    });
+  }
+  static paginated(res, data, options, message = "Data fetched successfully") {
+    const meta = {
+      total: options.total,
+      page: options.page,
+      limit: options.limit,
+      totalPages: Math.ceil(options.total / options.limit)
+    };
+    return _ApiResponse.ok(res, data, message, meta);
+  }
+};
+
+// src/http/controllers/CrudControllerFactory.ts
+var CrudControllerFactory = class {
+  static create(repository, options = {}) {
+    const resourceName = options.resourceName ?? "Resource";
+    return {
+      /**
+       * GET /
+       */
+      getAll: AsyncHandler(async (req, res) => {
+        const parsed = ApiFeatures.parse(req.query);
+        const baseFilter = options.filter?.(req) ?? {};
+        const filter = {
+          ...baseFilter
+        };
+        parsed.filters.forEach((item) => {
+          if (item.operator === "eq") {
+            filter[item.field] = item.value;
+          }
+        });
+        const queryOptions = {
+          limit: parsed.pagination.limit,
+          skip: (parsed.pagination.page - 1) * parsed.pagination.limit,
+          populate: parsed.populate
+        };
+        if (parsed.sort.length > 0) {
+          queryOptions.sort = Object.fromEntries(
+            parsed.sort.map((item) => [
+              item.field,
+              item.direction === "asc" ? 1 : -1
+            ])
+          );
+        }
+        if (parsed.fields.length > 0) {
+          queryOptions.select = parsed.fields;
+        }
+        const docs = await repository.findAll(filter, queryOptions);
+        const total = await repository.count(filter);
+        return ApiResponse.paginated(
+          res,
+          docs,
+          {
+            total,
+            page: parsed.pagination.page,
+            limit: parsed.pagination.limit
+          },
+          `${resourceName} list fetched successfully`
+        );
+      }),
+      /**
+       * GET /:id
+       */
+      getOne: AsyncHandler(async (req, res) => {
+        const id = String(req.params.id);
+        const doc = await repository.findById(id);
+        if (!doc) {
+          throw new AppError(`${resourceName} not found`, 404, {
+            code: "RESOURCE_NOT_FOUND"
+          });
+        }
+        return ApiResponse.ok(res, doc, `${resourceName} fetched successfully`);
+      }),
+      /**
+       * POST /
+       */
+      create: AsyncHandler(async (req, res) => {
+        const doc = await repository.create(req.body);
+        return ApiResponse.created(
+          res,
+          doc,
+          `${resourceName} created successfully`
+        );
+      }),
+      /**
+       * PATCH /:id
+       */
+      update: AsyncHandler(async (req, res) => {
+        const id = String(req.params.id);
+        const doc = await repository.updateById(id, req.body);
+        if (!doc) {
+          throw new AppError(`${resourceName} not found`, 404, {
+            code: "RESOURCE_NOT_FOUND"
+          });
+        }
+        return ApiResponse.ok(res, doc, `${resourceName} updated successfully`);
+      }),
+      /**
+       * DELETE /:id
+       */
+      delete: AsyncHandler(async (req, res) => {
+        const id = String(req.params.id);
+        const doc = await repository.deleteById(id);
+        if (!doc) {
+          throw new AppError(`${resourceName} not found`, 404, {
+            code: "RESOURCE_NOT_FOUND"
+          });
+        }
+        return ApiResponse.noContent(res);
+      })
+    };
+  }
+};
+
+// src/http/middleware/AuthMiddleware.ts
 var authMiddleware = (_req, _res, next) => {
   next();
 };
 
-// src/middlewares/error.middleware.ts
-var handleCastErrorDB = (err) => new AppError(`Invalid ${err.path}: ${err.value}`, 400, {
+// src/http/middleware/ErrorMiddleware.ts
+var handleCastError = (err) => new AppError(`Invalid ${err.path}: ${err.value}`, 400, {
   code: "INVALID_ID"
 });
-var handleDuplicateFieldsDB = (err) => {
+var handleDuplicateKey = (err) => {
   const field = err.keyValue ? Object.keys(err.keyValue)[0] : "field";
   return new AppError(`${field} already exists`, 400, {
     code: "DUPLICATE_FIELD"
   });
 };
-var handleValidationErrorDB = (err) => {
+var handleValidationError = (err) => {
   const errors = Object.entries(err.errors).reduce(
     (acc, [key, value]) => {
       acc[key] = value.message;
@@ -5113,12 +5232,11 @@ var handleValidationErrorDB = (err) => {
   return new AppError("Validation failed", 400, {
     code: "VALIDATION_ERROR",
     details: errors
-    // structured field errors
   });
 };
-var handleJWTError = () => new AppError("Invalid token. Please log in again.", 401);
-var handleJWTExpiredError = () => new AppError("Your token has expired. Please log in again.", 401);
-var GlobalErrorHandler = (isProd = false) => (err, _req, res, _next) => {
+var handleJWTError = () => new AppError("Invalid token", 401);
+var handleJWTExpiredError = () => new AppError("Token expired", 401);
+var ErrorMiddleware = (isProduction = false) => (err, _req, res, _next) => {
   let error;
   if (err instanceof AppError) {
     error = err;
@@ -5130,15 +5248,15 @@ var GlobalErrorHandler = (isProd = false) => (err, _req, res, _next) => {
     error.isOperational = false;
   }
   if (err && err.name === "CastError") {
-    error = handleCastErrorDB(err);
+    error = handleCastError(err);
   }
   if (err && typeof err === "object" && err.code === 11e3) {
-    error = handleDuplicateFieldsDB(
+    error = handleDuplicateKey(
       err
     );
   }
   if (err && err.name === "ValidationError") {
-    error = handleValidationErrorDB(err);
+    error = handleValidationError(err);
   }
   if (err?.name === "JsonWebTokenError") {
     error = handleJWTError();
@@ -5149,9 +5267,11 @@ var GlobalErrorHandler = (isProd = false) => (err, _req, res, _next) => {
   if (!error.isOperational) {
     logger.danger("Programming error", err);
   } else {
-    logger.danger("Operational error", { message: error.message });
+    logger.danger("Operational error", {
+      message: error.message
+    });
   }
-  const baseResponse = {
+  const response = {
     success: false,
     message: error.isOperational ? error.message : "Something went wrong",
     ...error.details && {
@@ -5160,32 +5280,144 @@ var GlobalErrorHandler = (isProd = false) => (err, _req, res, _next) => {
       }
     }
   };
-  if (!isProd) {
-    return APIResponse.send(res, {
+  if (!isProduction) {
+    return ApiResponse.send(res, {
       statusCode: error.statusCode,
-      ...baseResponse,
+      ...response,
       data: {
         stack: err?.stack
       }
     });
   }
-  return APIResponse.send(res, {
+  return ApiResponse.send(res, {
     statusCode: error.statusCode,
-    ...baseResponse
+    ...response
   });
 };
 
-// src/middlewares/validate.middleware.ts
+// src/http/validation/Validator.ts
+var isJoiSchema = (schema) => {
+  return typeof schema === "object" && schema !== null && "validate" in schema;
+};
+var isZodSchema = (schema) => {
+  return typeof schema === "object" && schema !== null && "safeParse" in schema;
+};
+
+// src/http/validation/JoiValidator.ts
+var JoiValidator = class {
+  constructor(schema) {
+    this.schema = schema;
+  }
+  schema;
+  validate(data) {
+    const result = this.schema.validate(data, {
+      abortEarly: false,
+      stripUnknown: true
+    });
+    if (result.error) {
+      const errors = {};
+      result.error.details.forEach((detail) => {
+        const field = detail.path.join(".");
+        errors[field] = detail.message;
+      });
+      return {
+        success: false,
+        errors
+      };
+    }
+    return {
+      success: true,
+      data: result.value
+    };
+  }
+};
+
+// src/http/validation/ZodValidator.ts
+var ZodValidator = class {
+  constructor(schema) {
+    this.schema = schema;
+  }
+  schema;
+  validate(data) {
+    const result = this.schema.safeParse(data);
+    if (!result.success) {
+      const errors = {};
+      result.error.issues.forEach((issue) => {
+        const field = issue.path.join(".");
+        errors[field] = issue.message;
+      });
+      return {
+        success: false,
+        errors
+      };
+    }
+    return {
+      success: true,
+      data: result.data
+    };
+  }
+};
+
+// src/http/middleware/ValidationMiddleware.ts
 var validate = (schema) => (req, _res, next) => {
-  const { error } = schema.validate(req.body);
-  if (error) {
-    return next(error);
+  let result;
+  if (isJoiSchema(schema)) {
+    result = new JoiValidator(schema).validate(req.body);
+  } else if (isZodSchema(schema)) {
+    result = new ZodValidator(schema).validate(req.body);
+  } else {
+    return next(new AppError("Unsupported validation schema", 500));
+  }
+  if (!result.success) {
+    return next(
+      new AppError("Validation failed", 400, {
+        code: "VALIDATION_ERROR",
+        details: result.errors
+      })
+    );
   }
+  req.body = result.data;
   next();
 };
 
-// src/repositories/providers/mongo.repository.ts
-var BaseMongoRepository = class {
+// src/http/utils/PickFields.ts
+function pickFields(obj, fields, options = {}) {
+  const removeUndefined = options.removeUndefined ?? false;
+  const removeNull = options.removeNull ?? false;
+  const removeEmptyString = options.removeEmptyString ?? false;
+  const strict = options.strict ?? false;
+  const defaults = options.defaults ?? {};
+  const rename = options.rename ?? {};
+  const transform = options.transform ?? {};
+  const result = {};
+  if (strict) {
+    for (const key of Object.keys(obj)) {
+      if (!fields.includes(key)) {
+        throw new Error(`Unknown field: ${key}`);
+      }
+    }
+  }
+  for (const field of fields) {
+    let value = obj[field];
+    if (value === void 0 && field in defaults) {
+      value = defaults[field];
+    }
+    if (removeUndefined && value === void 0) continue;
+    if (removeNull && value === null) continue;
+    if (removeEmptyString && value === "") continue;
+    if (transform[field]) {
+      value = transform[field](value);
+    }
+    const outputKey = rename[field] ?? field;
+    if (Object.prototype.hasOwnProperty.call(obj, field) || field in defaults) {
+      result[outputKey] = value;
+    }
+  }
+  return result;
+}
+
+// src/repositories/providers/MongoRepository.ts
+var MongoRepository = class {
   model;
   constructor(model) {
     this.model = model;
@@ -5739,6 +5971,6 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-export { APIFactory, apiFeatures_default as APIFeatures, APIResponse, AVLTree, AdjacencyList, AdjacencyMatrix, AppError, AzureBlobStorageService, BPlusTree, BTree, BaseMongoRepository, BinaryHeap, BinarySearchTree, BinaryTree, BloomFilter, CircularArray, CircularLinkedList, CircularQueue, CloudinaryService, ConsistentHash, CountMinSketch, Deque, DirectedGraph, DisjointSetUnion, DoublyLinkedList, DynamicArray, EmailService, FenwickTree, FibNode, FibonacciHeap, GlobalErrorHandler, Graph, HashMap, HashSet, HyperLogLog, IntervalTree, JWTService, KDTree, LFUCache, LRUCache, MaxHeap, MaxStack, MinHeap, MinStack, MulterFileHandlerService, MultiSet, Node, OrderedSet, PairingHeap, PairingNode, PriorityQueue, QuadTree, Queue, RadixTree, RedBlackTree, SMTPProvider, SegmentTree, Set2 as Set, SinglyLinkedList, SparseTable, SplayTree, Stack, StaticArray, SuffixArray, SuffixTree, TemplateEngine, TernarySearchTree, TreeNode, Trie, asyncHandler, authMiddleware, connectMongoDB, createAllowedOrigins, createCorsOptions, days, errorToString, hours, loadEnv, logger, milliseconds, minutes, pickFields, seconds, sleep, toHours, toMinutes, toSeconds, validate };
+export { AVLTree, AdjacencyList, AdjacencyMatrix, ApiFeatures, ApiResponse, AppError, AsyncHandler, AzureBlobStorageService, BPlusTree, BTree, BinaryHeap, BinarySearchTree, BinaryTree, BloomFilter, CircularArray, CircularLinkedList, CircularQueue, CloudinaryService, ConsistentHash, CountMinSketch, CrudControllerFactory, DEFAULT_LIMIT, DEFAULT_PAGE, DEFAULT_SORT_DIRECTION, DatabaseManager, Deque, DirectedGraph, DisjointSetUnion, DoublyLinkedList, DynamicArray, EmailService, ErrorMiddleware, FenwickTree, FibNode, FibonacciHeap, Graph, HashMap, HashSet, HyperLogLog, IntervalTree, JWTService, JoiValidator, KDTree, LFUCache, LRUCache, MaxHeap, MaxStack, MinHeap, MinStack, MongoDatabaseProvider, MongoRepository, MulterFileHandlerService, MultiSet, Node, OrderedSet, PairingHeap, PairingNode, PriorityQueue, QUERY_RESERVED_FIELDS, QuadTree, Queue, RadixTree, RedBlackTree, SMTPProvider, SUPPORTED_OPERATORS, SegmentTree, Set2 as Set, SinglyLinkedList, SparseTable, SplayTree, Stack, StaticArray, SuffixArray, SuffixTree, TemplateEngine, TernarySearchTree, TreeNode, Trie, ZodValidator, authMiddleware, createAllowedOrigins, createCorsOptions, days, errorToString, hours, isJoiSchema, isZodSchema, loadEnv, logger, milliseconds, minutes, pickFields, seconds, sleep, toHours, toMinutes, toSeconds, validate };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map