elseware-nodejs 1.8.6 → 1.9.0

package/dist/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
-var mongoose = require('mongoose');
 var dotenv = require('dotenv');
+var mongoose = require('mongoose');
 var storageBlob = require('@azure/storage-blob');
 var fs3 = require('fs');
 var cloudinaryModule = require('cloudinary');
@@ -14,8 +14,8 @@ var multer = require('multer');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var mongoose__default = /*#__PURE__*/_interopDefault(mongoose);
 var dotenv__default = /*#__PURE__*/_interopDefault(dotenv);
+var mongoose__default = /*#__PURE__*/_interopDefault(mongoose);
 var fs3__default = /*#__PURE__*/_interopDefault(fs3);
 var cloudinaryModule__default = /*#__PURE__*/_interopDefault(cloudinaryModule);
 var nodemailer__default = /*#__PURE__*/_interopDefault(nodemailer);
@@ -25,252 +25,7 @@ var juice__default = /*#__PURE__*/_interopDefault(juice);
 var jwt__default = /*#__PURE__*/_interopDefault(jwt);
 var multer__default = /*#__PURE__*/_interopDefault(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) {
@@ -329,25 +84,7 @@ ${errorToString(error)}`);
 };
 var logger = new Logger();
 
-// src/configs/database.ts
-async function connectMongoDB(config) {
-  try {
-    mongoose__default.default.set("strictQuery", true);
-    await mongoose__default.default.connect(config.uri);
-    logger.success("Database connected successfully");
-    process.on("SIGINT", async () => {
-      await mongoose__default.default.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__default.default.config({ quiet: true });
 function loadEnv(options) {
   const result = options.schema.safeParse(process.env);
@@ -2182,6 +1919,7 @@ var CircularQueue = class {
     }
     this.data = new Array(capacity);
   }
+  capacity;
   data;
   head = 0;
   tail = 0;
@@ -5102,31 +4840,418 @@ 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__default.default.set("strictQuery", this.config.strictQuery ?? true);
+    await mongoose__default.default.connect(this.config.uri);
+  }
+  async disconnect() {
+    await mongoose__default.default.disconnect();
+  }
+  isConnected() {
+    return mongoose__default.default.connection.readyState === 1;
+  }
+  getConnectionState() {
+    switch (mongoose__default.default.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) => {
-  const value = err.keyValue ? JSON.stringify(err.keyValue) : "duplicate value";
-  return new AppError(`Duplicate field value: ${value}`, 400, {
+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) => {
-  const errors = Object.values(err.errors).map((el) => el.message);
-  return new AppError("Invalid input data", 400, {
+var handleValidationError = (err) => {
+  const errors = Object.entries(err.errors).reduce(
+    (acc, [key, value]) => {
+      acc[key] = value.message;
+      return acc;
+    },
+    {}
+  );
+  return new AppError("Validation failed", 400, {
     code: "VALIDATION_ERROR",
     details: 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;
@@ -5138,15 +5263,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();
@@ -5157,37 +5282,157 @@ 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
+    });
   }
-  if (!isProd) {
-    return APIResponse.send(res, {
-      success: false,
+  const response = {
+    success: false,
+    message: error.isOperational ? error.message : "Something went wrong",
+    ...error.details && {
+      meta: {
+        errors: error.details
+      }
+    }
+  };
+  if (!isProduction) {
+    return ApiResponse.send(res, {
       statusCode: error.statusCode,
-      message: error.message,
+      ...response,
       data: {
-        stack: err?.stack,
-        details: error.details
+        stack: err?.stack
       }
     });
   }
-  return APIResponse.send(res, {
-    success: false,
+  return ApiResponse.send(res, {
     statusCode: error.statusCode,
-    message: error.isOperational ? error.message : "Something went wrong"
+    ...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;
@@ -5741,17 +5986,16 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-exports.APIFactory = APIFactory;
-exports.APIFeatures = apiFeatures_default;
-exports.APIResponse = APIResponse;
 exports.AVLTree = AVLTree;
 exports.AdjacencyList = AdjacencyList;
 exports.AdjacencyMatrix = AdjacencyMatrix;
+exports.ApiFeatures = ApiFeatures;
+exports.ApiResponse = ApiResponse;
 exports.AppError = AppError;
+exports.AsyncHandler = AsyncHandler;
 exports.AzureBlobStorageService = AzureBlobStorageService;
 exports.BPlusTree = BPlusTree;
 exports.BTree = BTree;
-exports.BaseMongoRepository = BaseMongoRepository;
 exports.BinaryHeap = BinaryHeap;
 exports.BinarySearchTree = BinarySearchTree;
 exports.BinaryTree = BinaryTree;
@@ -5762,22 +6006,28 @@ exports.CircularQueue = CircularQueue;
 exports.CloudinaryService = CloudinaryService;
 exports.ConsistentHash = ConsistentHash;
 exports.CountMinSketch = CountMinSketch;
+exports.CrudControllerFactory = CrudControllerFactory;
+exports.DEFAULT_LIMIT = DEFAULT_LIMIT;
+exports.DEFAULT_PAGE = DEFAULT_PAGE;
+exports.DEFAULT_SORT_DIRECTION = DEFAULT_SORT_DIRECTION;
+exports.DatabaseManager = DatabaseManager;
 exports.Deque = Deque;
 exports.DirectedGraph = DirectedGraph;
 exports.DisjointSetUnion = DisjointSetUnion;
 exports.DoublyLinkedList = DoublyLinkedList;
 exports.DynamicArray = DynamicArray;
 exports.EmailService = EmailService;
+exports.ErrorMiddleware = ErrorMiddleware;
 exports.FenwickTree = FenwickTree;
 exports.FibNode = FibNode;
 exports.FibonacciHeap = FibonacciHeap;
-exports.GlobalErrorHandler = GlobalErrorHandler;
 exports.Graph = Graph;
 exports.HashMap = HashMap;
 exports.HashSet = HashSet;
 exports.HyperLogLog = HyperLogLog;
 exports.IntervalTree = IntervalTree;
 exports.JWTService = JWTService;
+exports.JoiValidator = JoiValidator;
 exports.KDTree = KDTree;
 exports.LFUCache = LFUCache;
 exports.LRUCache = LRUCache;
@@ -5785,6 +6035,8 @@ exports.MaxHeap = MaxHeap;
 exports.MaxStack = MaxStack;
 exports.MinHeap = MinHeap;
 exports.MinStack = MinStack;
+exports.MongoDatabaseProvider = MongoDatabaseProvider;
+exports.MongoRepository = MongoRepository;
 exports.MulterFileHandlerService = MulterFileHandlerService;
 exports.MultiSet = MultiSet;
 exports.Node = Node;
@@ -5792,11 +6044,13 @@ exports.OrderedSet = OrderedSet;
 exports.PairingHeap = PairingHeap;
 exports.PairingNode = PairingNode;
 exports.PriorityQueue = PriorityQueue;
+exports.QUERY_RESERVED_FIELDS = QUERY_RESERVED_FIELDS;
 exports.QuadTree = QuadTree;
 exports.Queue = Queue;
 exports.RadixTree = RadixTree;
 exports.RedBlackTree = RedBlackTree;
 exports.SMTPProvider = SMTPProvider;
+exports.SUPPORTED_OPERATORS = SUPPORTED_OPERATORS;
 exports.SegmentTree = SegmentTree;
 exports.Set = Set2;
 exports.SinglyLinkedList = SinglyLinkedList;
@@ -5810,14 +6064,15 @@ exports.TemplateEngine = TemplateEngine;
 exports.TernarySearchTree = TernarySearchTree;
 exports.TreeNode = TreeNode;
 exports.Trie = Trie;
-exports.asyncHandler = asyncHandler;
+exports.ZodValidator = ZodValidator;
 exports.authMiddleware = authMiddleware;
-exports.connectMongoDB = connectMongoDB;
 exports.createAllowedOrigins = createAllowedOrigins;
 exports.createCorsOptions = createCorsOptions;
 exports.days = days;
 exports.errorToString = errorToString;
 exports.hours = hours;
+exports.isJoiSchema = isJoiSchema;
+exports.isZodSchema = isZodSchema;
 exports.loadEnv = loadEnv;
 exports.logger = logger;
 exports.milliseconds = milliseconds;