@codisolutions23/node-utils 1.0.0 → 1.0.1

package/dist/index.js

@@ -0,0 +1,758 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BadRequestError: () => BadRequestError,
+  ForbiddenError: () => ForbiddenError,
+  HttpError: () => HttpError,
+  InternalServerError: () => InternalServerError,
+  NotFoundError: () => NotFoundError,
+  UnauthorizedError: () => UnauthorizedError,
+  UnprocessableEntityError: () => UnprocessableEntityError,
+  authenticateJWT: () => authenticateJWT,
+  buildCacheKey: () => buildCacheKey,
+  comparePasswords: () => comparePasswords,
+  errorHandler: () => errorHandler,
+  getTemplatePath: () => getTemplatePath,
+  hashPassword: () => hashPassword,
+  initRedisClient: () => initRedisClient,
+  logger: () => logger,
+  paginate: () => paginate,
+  renderHandlebarsTemplate: () => renderHandlebarsTemplate,
+  signJwtToken: () => signJwtToken,
+  toObjectId: () => toObjectId,
+  useAtlas: () => useAtlas,
+  useCache: () => useCache,
+  useMailer: () => useMailer,
+  useRedis: () => useRedis,
+  useRedisClient: () => useRedisClient,
+  useS3: () => useS3
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/middleware/auth.middleware.ts
+var import_jsonwebtoken = __toESM(require("jsonwebtoken"));
+
+// src/utils/logger.ts
+var winston = __toESM(require("winston"));
+var transports2 = [
+  new winston.transports.File({ filename: "error.log", level: "error" }),
+  new winston.transports.File({ filename: "combined.log" })
+];
+var logger = winston.createLogger({
+  level: "info",
+  format: winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.json()
+  ),
+  transports: transports2
+});
+
+// src/utils/http-error.ts
+var HttpError = class extends Error {
+  constructor(message, statusCode, isOperational = true) {
+    super(message);
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.statusCode = statusCode;
+    this.isOperational = isOperational;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+var BadRequestError = class extends HttpError {
+  constructor(message = "The request could not be processed. Please review your input and try again.") {
+    super(message, 400, true);
+  }
+};
+var UnauthorizedError = class extends HttpError {
+  constructor(message = "Authentication is required to access this resource.") {
+    super(message, 401, true);
+  }
+};
+var ForbiddenError = class extends HttpError {
+  constructor(message = "You do not have the necessary permissions to perform this action.") {
+    super(message, 403, true);
+  }
+};
+var NotFoundError = class extends HttpError {
+  constructor(message = "The requested resource could not be found.") {
+    super(message, 404, true);
+  }
+};
+var UnprocessableEntityError = class extends HttpError {
+  constructor(message = "The request could not be completed due to invalid or incomplete information.") {
+    super(message, 422, true);
+  }
+};
+var InternalServerError = class extends HttpError {
+  constructor(message = "An internal server error occurred. Please try again later.") {
+    super(message, 500, true);
+  }
+};
+
+// src/middleware/auth.middleware.ts
+function authenticateJWT(secretKey = "") {
+  return (req, res, next) => {
+    const authHeader = req.headers.authorization;
+    const jwtToken = authHeader && authHeader.split(" ")[1];
+    if (!jwtToken) {
+      logger.error("No access token provided in the request.");
+      return next(
+        new UnauthorizedError("Access token is required to proceed.")
+      );
+    }
+    if (!secretKey) {
+      logger.error("JWT secret key is not set in the configuration.");
+      return next(
+        new UnauthorizedError(
+          "Authentication service is not properly configured."
+        )
+      );
+    }
+    import_jsonwebtoken.default.verify(jwtToken, secretKey, (error, decodedUser) => {
+      if (error) {
+        logger.error("Failed to verify access token.", error);
+        return next(
+          new UnauthorizedError(
+            "Your session has expired or the token is invalid. Please log in again."
+          )
+        );
+      }
+      req.user = decodedUser;
+      next();
+    });
+  };
+}
+
+// src/middleware/error-handler.middleware.ts
+var errorHandler = (error, req, res, next) => {
+  if (error.isOperational) {
+    res.status(error.statusCode).json({ status: "error", message: error.message });
+  } else {
+    logger.error({ message: error.message });
+    res.status(500).json({ status: "error", message: new InternalServerError().message });
+  }
+  return;
+};
+
+// src/utils/atlas.ts
+var import_mongodb = require("mongodb");
+var useAtlas = class {
+  static connect(config2) {
+    return __async(this, null, function* () {
+      if (this.mongoClient) {
+        logger.warn(
+          "[MongoDB][Connect] Client is already connected. Skipping new connection."
+        );
+        throw new BadRequestError("A MongoDB connection is already established.");
+      }
+      const { db, uri } = config2;
+      this.mongoClient = new import_mongodb.MongoClient(uri, {
+        maxPoolSize: 10,
+        maxIdleTimeMS: 6e4,
+        connectTimeoutMS: 6e4
+      });
+      try {
+        yield this.mongoClient.connect();
+        this.mongoDb = this.mongoClient.db(db);
+        logger.info(
+          `[MongoDB][Connect] Connected to database "${this.mongoDb.databaseName}".`
+        );
+      } catch (error) {
+        this.mongoClient = null;
+        logger.error(
+          `[MongoDB][Connect] Failed to connect: ${error instanceof Error ? error.message : error}`
+        );
+        throw new InternalServerError(
+          "Failed to connect to the database. Please try again later."
+        );
+      }
+    });
+  }
+  static getClient() {
+    if (!this.mongoClient) {
+      logger.warn(`[MongoDB][GetClient] Client is not initialized.`);
+      throw new NotFoundError("MongoDB client is not initialized.");
+    }
+    return this.mongoClient;
+  }
+  static getDb() {
+    if (!this.mongoDb) {
+      logger.warn(`[MongoDB][GetDb] Database instance is not available.`);
+      throw new NotFoundError("MongoDB database instance is not available.");
+    }
+    return this.mongoDb;
+  }
+  static close() {
+    return __async(this, null, function* () {
+      if (this.mongoClient) {
+        try {
+          yield this.mongoClient.close();
+          logger.info(`[MongoDB][Close] Connection closed.`);
+        } catch (error) {
+          logger.error(
+            `[MongoDB][Close] Error closing connection: ${error instanceof Error ? error.message : error}`
+          );
+          throw new InternalServerError("Failed to close MongoDB connection.");
+        } finally {
+          this.mongoClient = null;
+          this.mongoDb = null;
+        }
+      } else {
+        logger.warn(`[MongoDB][Close] No client to disconnect.`);
+        throw new BadRequestError("No MongoDB connection exists to close.");
+      }
+    });
+  }
+};
+useAtlas.mongoClient = null;
+useAtlas.mongoDb = null;
+
+// src/utils/cache-key.ts
+function buildCacheKey(prefix, values) {
+  const query = Object.entries(values).sort(([a], [b]) => a.localeCompare(b)).map(
+    ([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`
+  ).join("&");
+  return `${prefix}:${query}`;
+}
+
+// src/utils/ioredis.ts
+var import_ioredis = __toESM(require("ioredis"));
+var redisClient = null;
+function useRedis() {
+  function initialize(options) {
+    var _a, _b, _c, _d;
+    if (redisClient) {
+      logger.info("[Redis][Init] Redis connection is already established.");
+      return redisClient;
+    }
+    options.host = (_a = options.host) != null ? _a : "localhost";
+    options.port = (_b = options.port) != null ? _b : 6379;
+    options.username = (_c = options.username) != null ? _c : "default";
+    options.password = (_d = options.password) != null ? _d : "";
+    redisClient = new import_ioredis.default(__spreadValues(__spreadValues({
+      host: options.host,
+      port: options.port
+    }, options.username && { username: options.username }), options.password && { password: options.password }));
+    redisClient.on("connect", () => {
+      logger.info(
+        `[Redis][Connect] Redis client connected at ${options.host}:${options.port}.`
+      );
+    });
+    redisClient.on("error", (error) => {
+      logger.error(
+        `[Redis][Error] Failed to connect: ${error instanceof Error ? error.message : error}`
+      );
+    });
+    return redisClient;
+  }
+  function getClient() {
+    if (!redisClient) {
+      logger.error(
+        "[Redis][GetClient] Redis connection has not been initialized."
+      );
+      throw new BadRequestError(
+        "Redis connection is not initialized. Please call initialize() first."
+      );
+    }
+    return redisClient;
+  }
+  function disconnect() {
+    if (redisClient) {
+      redisClient.quit();
+      logger.info("[Redis][Disconnect] Redis connection has been closed.");
+      redisClient = null;
+    } else {
+      logger.warn("[Redis][Disconnect] No Redis client to disconnect.");
+    }
+  }
+  return {
+    initialize,
+    getClient,
+    disconnect
+  };
+}
+
+// src/utils/cache.ts
+var DEFAULT_TTL = 300;
+function useCache() {
+  const redisClient3 = useRedis().getClient();
+  function get(cacheKey) {
+    return __async(this, null, function* () {
+      try {
+        const value = yield redisClient3.get(cacheKey);
+        return value ? JSON.parse(value) : null;
+      } catch (error) {
+        logger.error(
+          `[Cache][Get] Failed to retrieve key "${cacheKey}": ${error instanceof Error ? error.message : error}`
+        );
+        return null;
+      }
+    });
+  }
+  function set(_0, _1) {
+    return __async(this, arguments, function* (cacheKey, data, ttl = DEFAULT_TTL, group) {
+      try {
+        yield redisClient3.set(cacheKey, JSON.stringify(data), "EX", ttl);
+        logger.info(`[Cache][Set] Stored key "${cacheKey}" with TTL ${ttl}s.`);
+        if (group) yield redisClient3.sadd(`cache:group:${group}`, cacheKey);
+      } catch (error) {
+        logger.error(
+          `[Cache][Set] Failed to store key "${cacheKey}": ${error instanceof Error ? error.message : error}`
+        );
+      }
+    });
+  }
+  function remove(cacheKey) {
+    return __async(this, null, function* () {
+      try {
+        yield redisClient3.del(cacheKey);
+        logger.info(`[Cache][Remove] Key "${cacheKey}" has been deleted.`);
+      } catch (error) {
+        logger.error(
+          `[Cache][Remove] Failed to delete key "${cacheKey}": ${error instanceof Error ? error.message : error}`
+        );
+      }
+    });
+  }
+  function clearGroup(group) {
+    return __async(this, null, function* () {
+      try {
+        const keys = yield redisClient3.smembers(`cache:group:${group}`);
+        if (keys.length) yield redisClient3.del(...keys);
+        yield redisClient3.del(`cache:group:${group}`);
+        logger.info(`[Cache][ClearGroup] Cleared group "${group}" and its keys.`);
+      } catch (error) {
+        logger.error(
+          `[Cache][ClearGroup] Failed to clear group "${group}": ${error instanceof Error ? error.message : error}`
+        );
+      }
+    });
+  }
+  return {
+    get,
+    set,
+    remove,
+    clearGroup
+  };
+}
+
+// src/utils/get-template-path.ts
+var import_path = __toESM(require("path"));
+function getTemplatePath(directory, filePath) {
+  const ext = ".hbs";
+  const file = filePath.endsWith(ext) ? filePath : `${filePath}${ext}`;
+  return import_path.default.resolve(directory, file);
+}
+
+// src/utils/handlebars-compiler.ts
+var import_handlebars = __toESM(require("handlebars"));
+var import_fs = require("fs");
+var handlebarsTemplateCache = /* @__PURE__ */ new Map();
+function renderHandlebarsTemplate(_0) {
+  return __async(this, arguments, function* ({
+    context = {},
+    filePath
+  }) {
+    try {
+      let compiledTemplate = handlebarsTemplateCache.get(filePath);
+      if (!compiledTemplate) {
+        logger.info(
+          `[Template][Compile] Compiling and caching template from "${filePath}".`
+        );
+        const fileContent = yield import_fs.promises.readFile(filePath, "utf8");
+        compiledTemplate = import_handlebars.default.compile(fileContent);
+        handlebarsTemplateCache.set(filePath, compiledTemplate);
+      } else {
+        logger.info(`[Template][Cache] Using cached template for "${filePath}".`);
+      }
+      return compiledTemplate(context);
+    } catch (error) {
+      logger.error(
+        `[Template][Render] Failed to render template "${filePath}": ${error instanceof Error ? error.message : error}`
+      );
+      throw new InternalServerError("Failed to render Handlebars template.");
+    }
+  });
+}
+
+// src/utils/jwt.ts
+var import_jsonwebtoken2 = __toESM(require("jsonwebtoken"));
+function signJwtToken({
+  payload = {},
+  secretKey = "",
+  signOptions = {}
+}) {
+  if (!secretKey) {
+    logger.error(`[JWT][Sign] Secret key is missing. Cannot sign token.`);
+    throw new BadRequestError("A JWT secret key must be provided.");
+  }
+  try {
+    logger.info(`[JWT][Sign] Signing JWT token.`);
+    return import_jsonwebtoken2.default.sign(payload, secretKey, signOptions);
+  } catch (error) {
+    logger.error(
+      `[JWT][Sign] Failed to sign JWT token: ${error instanceof Error ? error.message : error}`
+    );
+    throw error;
+  }
+}
+
+// src/utils/mailer.ts
+var import_nodemailer = require("nodemailer");
+var useMailer = class {
+  constructor(config2) {
+    this.config = config2;
+    this.transporter = (0, import_nodemailer.createTransport)({
+      host: config2.host,
+      port: config2.port,
+      secure: config2.secure,
+      auth: { user: config2.email, pass: config2.password }
+    });
+  }
+  sendMail(_0) {
+    return __async(this, arguments, function* ({
+      sender,
+      to,
+      subject,
+      text,
+      html
+    }) {
+      const from = sender ? `${sender} <${this.config.email}>` : this.config.email;
+      const mailOptions = __spreadValues(__spreadValues({
+        from,
+        to,
+        subject
+      }, text && { text }), html && { html });
+      try {
+        yield this.transporter.sendMail(mailOptions);
+        logger.info(
+          `[Mailer][Send] Email sent to "${to}" with subject "${subject}".`
+        );
+        return "Mail sent successfully.";
+      } catch (error) {
+        logger.error(
+          `[Mailer][Send] Failed to send email to "${to}" with subject "${subject}": ${error instanceof Error ? error.message : error}`
+        );
+        throw new InternalServerError("Failed to send email.");
+      }
+    });
+  }
+};
+
+// src/utils/objectid-converter.ts
+var import_mongodb2 = require("mongodb");
+function toObjectId(id) {
+  if (!id) {
+    logger.error(
+      `[ObjectId][Convert] No value provided for MongoDB ObjectId conversion.`
+    );
+    throw new BadRequestError(
+      "A value must be provided for ObjectId conversion."
+    );
+  }
+  if (id instanceof import_mongodb2.ObjectId) return id;
+  if (!/^[0-9a-fA-F]{24}$/.test(id)) {
+    logger.error(
+      `[ObjectId][Convert] Provided value is not a valid 24-character hex string.`
+    );
+    throw new BadRequestError(
+      "Invalid ObjectId: must be a 24-character hexadecimal string."
+    );
+  }
+  try {
+    return new import_mongodb2.ObjectId(id);
+  } catch (err) {
+    logger.error(
+      `[ObjectId][Convert] Failed to convert value to ObjectId: ${err instanceof Error ? err.message : err}`
+    );
+    throw new BadRequestError("Failed to convert value into a valid ObjectId.");
+  }
+}
+
+// src/utils/paginate.ts
+function paginate(items, page = 0, limit = 10, total) {
+  if (total === 0) {
+    return {
+      items: [],
+      pages: 0,
+      pageRange: "0-0 of 0"
+    };
+  }
+  const startIndex = page * limit + 1;
+  const endIndex = Math.min(startIndex + items.length - 1, total);
+  return {
+    items,
+    pages: Math.ceil(total / limit),
+    pageRange: `${startIndex}-${endIndex} of ${total}`
+  };
+}
+
+// src/utils/password.ts
+var import_bcrypt = __toESM(require("bcrypt"));
+var DEFAULT_SALT_ROUNDS = 10;
+function comparePasswords(password, hashed) {
+  return __async(this, null, function* () {
+    try {
+      return yield import_bcrypt.default.compare(password, hashed);
+    } catch (error) {
+      logger.error(
+        `[Password][Compare] Failed to compare passwords: ${error instanceof Error ? error.message : error}`
+      );
+      return false;
+    }
+  });
+}
+function hashPassword(_0) {
+  return __async(this, arguments, function* (password, saltRounds = DEFAULT_SALT_ROUNDS) {
+    try {
+      return yield import_bcrypt.default.hash(password, saltRounds);
+    } catch (error) {
+      logger.error(
+        `[Password][Hash] Failed to hash password: ${error instanceof Error ? error.message : error}`
+      );
+      throw new InternalServerError("Failed to hash password.");
+    }
+  });
+}
+
+// src/utils/redis.ts
+var import_redis = require("redis");
+
+// src/config.ts
+var dotenv = __toESM(require("dotenv"));
+dotenv.config();
+function getEnv(key, fallback) {
+  const value = process.env[key];
+  if (value !== void 0) return value;
+  if (fallback !== void 0) return fallback;
+  throw new Error(`Missing required environment variable: ${key}`);
+}
+function getEnvNumber(key, fallback) {
+  const value = process.env[key];
+  if (value !== void 0) return Number(value);
+  if (fallback !== void 0) return fallback;
+  throw new Error(`Missing required environment variable: ${key}`);
+}
+function getEnvBoolean(key, fallback) {
+  const value = process.env[key];
+  if (value !== void 0) return value === "true";
+  if (fallback !== void 0) return fallback;
+  throw new Error(`Missing required environment variable: ${key}`);
+}
+var isDev = process.env.NODE_ENV !== "production";
+var PORT = getEnvNumber("PORT", 3001);
+var MONGO_URI = getEnv("MONGO_URI", "mongodb://localhost:27017");
+var MONGO_DB = getEnv("MONGO_DB", "default");
+var MONGO_DB_DEV = getEnv("MONGO_DB_DEV", `${MONGO_DB}-dev`);
+var REDIS_HOST = getEnv("REDIS_HOST");
+var REDIS_PORT = getEnvNumber("REDIS_PORT", 6379);
+var REDIS_PASSWORD = getEnv("REDIS_PASSWORD");
+var REDIS_TLS = getEnvBoolean("REDIS_TLS", true);
+var MAILER_TRANSPORT_HOST = getEnv("MAILER_TRANSPORT_HOST");
+var MAILER_TRANSPORT_PORT = getEnvNumber("MAILER_TRANSPORT_PORT", 465);
+var MAILER_TRANSPORT_SECURE = getEnvBoolean(
+  "MAILER_TRANSPORT_SECURE",
+  true
+);
+var MAILER_EMAIL = getEnv("MAILER_EMAIL");
+var MAILER_PASSWORD = getEnv("MAILER_PASSWORD");
+var SECRET_KEY = getEnv("SECRET_KEY");
+var ACCESS_TOKEN_SECRET = getEnv("ACCESS_TOKEN_SECRET");
+var REFRESH_TOKEN_SECRET = getEnv("REFRESH_TOKEN_SECRET");
+var ACCESS_TOKEN_EXPIRY = getEnv("ACCESS_TOKEN_EXPIRY", "15s");
+var REFRESH_TOKEN_EXPIRY = getEnv("REFRESH_TOKEN_EXPIRY", "30d");
+var OTP_FORGET_PASSWORD_EXPIRY = getEnv(
+  "OTP_FORGET_PASSWORD_EXPIRY",
+  "10m"
+);
+var OTP_USER_INVITE_EXPIRY = getEnv("OTP_USER_INVITE_EXPIRY", "3d");
+var APP_COUNT = getEnv("APP_ACCOUNT", "http:localhost:3000");
+
+// src/utils/redis.ts
+var redisClient2 = null;
+function initRedisClient() {
+  return __async(this, null, function* () {
+    if (redisClient2) {
+      logger.info("[Redis][Init] Redis connection is already established.");
+      return redisClient2;
+    }
+    redisClient2 = (0, import_redis.createClient)({
+      password: REDIS_PASSWORD,
+      socket: {
+        host: REDIS_HOST,
+        port: REDIS_PORT
+      }
+    });
+  });
+}
+function useRedisClient() {
+  if (!redisClient2) {
+    logger.error(
+      "[Redis][GetClient] Redis connection has not been initialized."
+    );
+    throw new Error(
+      "[Redis][GetClient] Redis connection is not initialized. Call initRedisClient() first."
+    );
+  }
+  return redisClient2;
+}
+
+// src/utils/s3.ts
+var import_client_s3 = require("@aws-sdk/client-s3");
+var import_stream = require("stream");
+var useS3 = class {
+  constructor(config2) {
+    this.config = config2;
+    this.client = new import_client_s3.S3Client({
+      endpoint: config2.endpoint,
+      region: config2.region,
+      credentials: {
+        accessKeyId: config2.accessKeyId,
+        secretAccessKey: config2.secretAccessKey
+      },
+      forcePathStyle: config2.forcePathStyle
+    });
+  }
+  uploadObject(_0) {
+    return __async(this, arguments, function* ({
+      key,
+      body,
+      metadata = {},
+      contentType
+    }) {
+      try {
+        yield this.client.send(
+          new import_client_s3.PutObjectCommand({
+            Bucket: this.config.bucket,
+            Key: key,
+            Body: typeof body === "string" || Buffer.isBuffer(body) ? body : import_stream.Readable.from(body),
+            ACL: "public-read",
+            Metadata: metadata,
+            ContentType: contentType,
+            ContentLength: typeof body === "string" ? Buffer.byteLength(body) : body.length
+          })
+        );
+        logger.info(
+          `[S3][Upload] Uploaded "${key}" to bucket "${this.config.bucket}".`
+        );
+        return "Successfully uploaded file.";
+      } catch (error) {
+        logger.error(
+          `[S3][Upload][Error] Failed to upload "${key}" to bucket "${this.config.bucket}": ${error instanceof Error ? error.message : error}`
+        );
+        throw error;
+      }
+    });
+  }
+  deleteObject(key) {
+    return __async(this, null, function* () {
+      try {
+        yield this.client.send(
+          new import_client_s3.DeleteObjectCommand({ Key: key, Bucket: this.config.bucket })
+        );
+        logger.info(
+          `[S3][Delete] Deleted "${key}" from bucket "${this.config.bucket}".`
+        );
+        return "Successfully deleted file.";
+      } catch (error) {
+        logger.error(
+          `[S3][Delete][Error] Failed to delete "${key}" from bucket "${this.config.bucket}": ${error instanceof Error ? error.message : error}`
+        );
+        throw error;
+      }
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BadRequestError,
+  ForbiddenError,
+  HttpError,
+  InternalServerError,
+  NotFoundError,
+  UnauthorizedError,
+  UnprocessableEntityError,
+  authenticateJWT,
+  buildCacheKey,
+  comparePasswords,
+  errorHandler,
+  getTemplatePath,
+  hashPassword,
+  initRedisClient,
+  logger,
+  paginate,
+  renderHandlebarsTemplate,
+  signJwtToken,
+  toObjectId,
+  useAtlas,
+  useCache,
+  useMailer,
+  useRedis,
+  useRedisClient,
+  useS3
+});
+//# sourceMappingURL=index.js.map