@ajayjbtickets/common 1.0.9 → 1.0.11

package/dist/index.js

@@ -1,27 +1,525 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./constants/environments"), exports);
-__exportStar(require("./core/ApiError"), exports);
-__exportStar(require("./core/ApiResponse"), exports);
-__exportStar(require("./core/Logger"), exports);
-__exportStar(require("./middlewares/schemaValidator"), exports);
-__exportStar(require("./middlewares/verifyToken"), exports);
-__exportStar(require("./services/jwt.service"), exports);
-__exportStar(require("./services/password.service"), exports);
-__exportStar(require("./types/validation"), exports);
-__exportStar(require("./utils/asyncHandler"), exports);
-//# sourceMappingURL=index.js.map
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AccessTokenError: () => AccessTokenError,
+  AccessTokenErrorResponse: () => AccessTokenErrorResponse,
+  ApiError: () => ApiError,
+  ApiResponse: () => ApiResponse,
+  AuthFailureError: () => AuthFailureError,
+  BadRequestError: () => BadRequestError,
+  BadRequestResponse: () => BadRequestResponse,
+  BadTokenError: () => BadTokenError,
+  BadTokenResponse: () => BadTokenResponse,
+  ENVIRONMENTS: () => ENVIRONMENTS,
+  ErrorType: () => ErrorType,
+  ForbiddenError: () => ForbiddenError,
+  ForbiddenResponse: () => ForbiddenResponse,
+  InternalError: () => InternalError,
+  InternalErrorResponse: () => InternalErrorResponse,
+  JwtService: () => JwtService,
+  NoDataError: () => NoDataError,
+  NoEntryError: () => NoEntryError,
+  NoFoundResponse: () => NoFoundResponse,
+  NotFoundError: () => NotFoundError,
+  Password: () => Password,
+  ResponseStatusCode: () => ResponseStatusCode,
+  StatusCode: () => StatusCode,
+  SuccessResponse: () => SuccessResponse,
+  TokenExpiredError: () => TokenExpiredError,
+  ValidationSource: () => ValidationSource,
+  asyncHandler: () => asyncHandler,
+  logger: () => logger,
+  schemaValidator: () => schemaValidator,
+  verifyToken: () => verifyToken
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/constants/environments.ts
+var ENVIRONMENTS = {
+  production: "production",
+  development: "development",
+  testing: "testing"
+};
+
+// src/core/ApiResponse.ts
+var StatusCode = /* @__PURE__ */ ((StatusCode2) => {
+  StatusCode2["SUCCESS"] = "10000";
+  StatusCode2["FAILURE"] = "10001";
+  StatusCode2["RETRY"] = "10002";
+  StatusCode2["IN_VALID_ACCESS_TOKEN"] = "10003";
+  return StatusCode2;
+})(StatusCode || {});
+var ResponseStatusCode = /* @__PURE__ */ ((ResponseStatusCode2) => {
+  ResponseStatusCode2[ResponseStatusCode2["SUCCESS"] = 200] = "SUCCESS";
+  ResponseStatusCode2[ResponseStatusCode2["CREATED"] = 201] = "CREATED";
+  ResponseStatusCode2[ResponseStatusCode2["ACCEPTED"] = 202] = "ACCEPTED";
+  ResponseStatusCode2[ResponseStatusCode2["NO_CONTENT"] = 204] = "NO_CONTENT";
+  ResponseStatusCode2[ResponseStatusCode2["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
+  ResponseStatusCode2[ResponseStatusCode2["FOUND"] = 302] = "FOUND";
+  ResponseStatusCode2[ResponseStatusCode2["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
+  ResponseStatusCode2[ResponseStatusCode2["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
+  ResponseStatusCode2[ResponseStatusCode2["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
+  ResponseStatusCode2[ResponseStatusCode2["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+  ResponseStatusCode2[ResponseStatusCode2["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+  ResponseStatusCode2[ResponseStatusCode2["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
+  ResponseStatusCode2[ResponseStatusCode2["FORBIDDEN"] = 403] = "FORBIDDEN";
+  ResponseStatusCode2[ResponseStatusCode2["NOT_FOUND"] = 404] = "NOT_FOUND";
+  ResponseStatusCode2[ResponseStatusCode2["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+  ResponseStatusCode2[ResponseStatusCode2["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
+  ResponseStatusCode2[ResponseStatusCode2["CONFLICT"] = 409] = "CONFLICT";
+  ResponseStatusCode2[ResponseStatusCode2["GONE"] = 410] = "GONE";
+  ResponseStatusCode2[ResponseStatusCode2["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+  ResponseStatusCode2[ResponseStatusCode2["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+  ResponseStatusCode2[ResponseStatusCode2["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+  ResponseStatusCode2[ResponseStatusCode2["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+  ResponseStatusCode2[ResponseStatusCode2["INTERNAL_ERROR"] = 500] = "INTERNAL_ERROR";
+  ResponseStatusCode2[ResponseStatusCode2["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+  ResponseStatusCode2[ResponseStatusCode2["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+  ResponseStatusCode2[ResponseStatusCode2["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+  ResponseStatusCode2[ResponseStatusCode2["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+  return ResponseStatusCode2;
+})(ResponseStatusCode || {});
+var ApiResponse = class {
+  message;
+  statusCode;
+  status;
+  constructor(status, message, statusCode) {
+    this.message = message;
+    this.status = status;
+    if (statusCode) {
+      this.statusCode = statusCode;
+    }
+  }
+  prepare(res, response, headers = {}) {
+    for (const [key, value] of Object.entries(headers)) {
+      res.append(key, value);
+    }
+    res.status(this.status).send(this.sanitize(response));
+  }
+  send(res, headers = {}) {
+    this.prepare(res, this, headers);
+  }
+  sanitize(response) {
+    const clone = {};
+    Object.assign(clone, response);
+    delete clone["statusCode"];
+    for (const key in clone) {
+      const typedKey = key;
+      if (clone[typedKey] === void 0) {
+        delete clone[typedKey];
+      }
+    }
+    return clone;
+  }
+};
+var SuccessResponse = class extends ApiResponse {
+  constructor(responseStatusCode, message, data) {
+    super(responseStatusCode, message, "10000" /* SUCCESS */);
+    this.data = data;
+    this.data = data;
+  }
+  send(res) {
+    this.prepare(res, this, {});
+  }
+};
+var AccessTokenErrorResponse = class extends ApiResponse {
+  instruction = "refresh_token";
+  errors;
+  constructor(message, errors) {
+    super(
+      401 /* UNAUTHORIZED */,
+      message,
+      "10003" /* IN_VALID_ACCESS_TOKEN */
+    );
+    this.errors = errors || [];
+  }
+  send(res, headers = {}) {
+    headers.instruction = this.instruction;
+    this.prepare(res, this, headers);
+  }
+};
+var BadTokenResponse = class extends ApiResponse {
+  errors;
+  constructor(message, errors) {
+    super(401 /* UNAUTHORIZED */, message, "10001" /* FAILURE */);
+    this.errors = errors || [];
+  }
+};
+var BadRequestResponse = class extends ApiResponse {
+  errors;
+  constructor(message, errors) {
+    super(400 /* BAD_REQUEST */, message, "10001" /* FAILURE */);
+    this.errors = errors || [];
+  }
+};
+var InternalErrorResponse = class extends ApiResponse {
+  errors;
+  constructor(message, errors) {
+    super(500 /* INTERNAL_ERROR */, message, "10001" /* FAILURE */);
+    this.errors = errors || [];
+  }
+};
+var NoFoundResponse = class extends ApiResponse {
+  errors;
+  constructor(message, errors) {
+    super(404 /* NOT_FOUND */, message, "10001" /* FAILURE */);
+    this.errors = errors || [];
+  }
+};
+var ForbiddenResponse = class extends ApiResponse {
+  errors;
+  constructor(message, errors) {
+    super(403 /* FORBIDDEN */, message, "10001" /* FAILURE */);
+    this.errors = errors || [];
+  }
+};
+
+// src/config/config.ts
+var import_config = require("dotenv/config");
+var getConfig = () => {
+  return {
+    ENVIRONMENT: process.env.ENVIRONMENT,
+    LOG_DIR: process.env.LOG_DIR,
+    LOG_LEVEL: process.env.LOG_LEVEL,
+    SALT_ROUNDS: parseInt(process.env.SALT_ROUNDS),
+    JWT_KEY: process.env.JWT_KEY
+  };
+};
+var getSanitizedConfig = (config2) => {
+  for (const [key, value] of Object.entries(config2)) {
+    if (!value) {
+      throw new Error(`Missing key ${key} in config.env`);
+    }
+  }
+  return config2;
+};
+var config = getConfig();
+var sanitizedConfig = getSanitizedConfig(config);
+
+// src/core/ApiError.ts
+var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
+  ErrorType2["BAD_TOKEN"] = "BadTokenError";
+  ErrorType2["TOKEN_EXPIRED"] = "TokenExpiredError";
+  ErrorType2["UNAUTHORIZED"] = "AuthFailureError";
+  ErrorType2["ACCESS_TOKEN"] = "AccessTokenError";
+  ErrorType2["INTERNAL"] = "InternalError";
+  ErrorType2["NOT_FOUND"] = "NotFoundError";
+  ErrorType2["NO_ENTRY"] = "NoEntryError";
+  ErrorType2["NO_DATA"] = "NoDataError";
+  ErrorType2["BAD_REQUEST"] = "BadRequestError";
+  ErrorType2["FORBIDDEN"] = "ForbiddenError";
+  return ErrorType2;
+})(ErrorType || {});
+var ApiError = class extends Error {
+  constructor(type, message = "Error", errors) {
+    super(type);
+    this.type = type;
+    this.message = message;
+    this.errors = errors;
+    this.type = type;
+    this.message = message;
+    this.errors = errors;
+  }
+  static handle(err, res) {
+    switch (err.type) {
+      case "BadTokenError" /* BAD_TOKEN */:
+      case "TokenExpiredError" /* TOKEN_EXPIRED */:
+      case "AuthFailureError" /* UNAUTHORIZED */:
+        new BadTokenResponse(err.message, err.errors).send(res);
+        break;
+      case "AccessTokenError" /* ACCESS_TOKEN */:
+        new AccessTokenErrorResponse(err.message, err.errors).send(res);
+        break;
+      case "InternalError" /* INTERNAL */:
+        new InternalErrorResponse(err.message, err.errors).send(res);
+        break;
+      case "NotFoundError" /* NOT_FOUND */:
+      case "NoEntryError" /* NO_ENTRY */:
+      case "NoDataError" /* NO_DATA */:
+        new NoFoundResponse(err.message, err.errors).send(res);
+        break;
+      case "BadRequestError" /* BAD_REQUEST */:
+        new BadRequestResponse(err.message, err.errors).send(res);
+        break;
+      case "ForbiddenError" /* FORBIDDEN */:
+        new ForbiddenResponse(err.message, err.errors).send(res);
+        break;
+      default:
+        let messsage = err.message;
+        messsage = sanitizedConfig.ENVIRONMENT !== ENVIRONMENTS.production ? messsage : "Something went wrong!";
+        new InternalErrorResponse(messsage, err.errors).send(res);
+        break;
+    }
+  }
+};
+var BadTokenError = class extends ApiError {
+  constructor(message = "Invalid token", errors = []) {
+    super("BadTokenError" /* BAD_TOKEN */, message, errors);
+  }
+};
+var TokenExpiredError = class extends ApiError {
+  constructor(message = "Token expired", errors = []) {
+    super("TokenExpiredError" /* TOKEN_EXPIRED */, message, errors);
+  }
+};
+var AuthFailureError = class extends ApiError {
+  constructor(message = "Invalid Credentials", errors = []) {
+    super("AuthFailureError" /* UNAUTHORIZED */, message, errors);
+  }
+};
+var AccessTokenError = class extends ApiError {
+  constructor(message = "Invalid access token", errors = []) {
+    super("AccessTokenError" /* ACCESS_TOKEN */, message, errors);
+  }
+};
+var InternalError = class extends ApiError {
+  constructor(message = "Internal error", errors = []) {
+    message = sanitizedConfig.ENVIRONMENT !== ENVIRONMENTS.production ? message : "Something went wrong!";
+    super("InternalError" /* INTERNAL */, message, errors);
+  }
+};
+var NotFoundError = class extends ApiError {
+  constructor(message = "Not found", errors = []) {
+    super("NotFoundError" /* NOT_FOUND */, message, errors);
+  }
+};
+var NoEntryError = class extends ApiError {
+  constructor(message = "Entry don't exists", errors = []) {
+    super("NoEntryError" /* NO_ENTRY */, message, errors);
+  }
+};
+var NoDataError = class extends ApiError {
+  constructor(message = "No data", errors = []) {
+    super("NoDataError" /* NO_DATA */, message, errors);
+  }
+};
+var BadRequestError = class extends ApiError {
+  constructor(message = "Bad request", errors = []) {
+    super("BadRequestError" /* BAD_REQUEST */, message, errors);
+  }
+};
+var ForbiddenError = class extends ApiError {
+  constructor(message = "Permission denied", errors = []) {
+    super("ForbiddenError" /* FORBIDDEN */, message, errors);
+  }
+};
+
+// src/core/Logger.ts
+var import_winston = __toESM(require("winston"));
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_winston_daily_rotate_file = __toESM(require("winston-daily-rotate-file"));
+var dir = sanitizedConfig.LOG_DIR;
+if (!dir) {
+  dir = import_path.default.resolve("logs");
+}
+if (!import_fs.default.existsSync(dir)) {
+  import_fs.default.mkdirSync(dir);
+}
+var logfileRotateTransport = new import_winston_daily_rotate_file.default({
+  level: sanitizedConfig.LOG_LEVEL,
+  // @ts-ignore
+  filename: dir + "/%DATE%.log",
+  datePattern: "YYYY-MM-DD",
+  zippedArchive: true,
+  handleExceptions: true,
+  maxSize: "20m",
+  maxFiles: "14d",
+  format: import_winston.format.combine(
+    import_winston.format.errors({ stack: true }),
+    import_winston.format.timestamp(),
+    import_winston.format.json()
+  )
+});
+var consoleTransport = new import_winston.default.transports.Console({
+  level: process.env.LOG_LEVEL,
+  format: import_winston.format.combine(
+    import_winston.format.colorize({ all: true }),
+    import_winston.format.timestamp({
+      format: "YYYY-MM-DD hh:mm:ss.SSS A"
+    }),
+    import_winston.format.align(),
+    import_winston.format.printf(
+      (info) => `[${info.timestamp}] ${info.level}: ${info.message}`
+    )
+  )
+});
+var logger = import_winston.default.createLogger({
+  transports: [consoleTransport, logfileRotateTransport],
+  exceptionHandlers: [logfileRotateTransport],
+  exitOnError: false
+});
+
+// src/middlewares/schemaValidator.ts
+var schemaValidator = (type, schema) => {
+  return (req, res, next) => {
+    const result = schema.safeParse(req[type]);
+    if (!result.success) {
+      const errors = Object.entries(result.error.flatten().fieldErrors).map(
+        ([key, value]) => ({
+          field: key,
+          message: value
+        })
+      );
+      next(new BadRequestError("Bad request", errors));
+    } else {
+      next();
+    }
+  };
+};
+
+// src/middlewares/verifyToken.ts
+var import_jsonwebtoken2 = __toESM(require("jsonwebtoken"));
+
+// src/services/jwt.service.ts
+var import_jsonwebtoken = __toESM(require("jsonwebtoken"));
+var JwtService = class {
+  static sign(payload, signOptions = {}) {
+    const token = import_jsonwebtoken.default.sign(
+      payload,
+      sanitizedConfig.JWT_KEY,
+      signOptions
+    );
+    return token;
+  }
+  static verify(token, verifyOptions) {
+    const decoded = import_jsonwebtoken.default.verify(
+      token,
+      sanitizedConfig.JWT_KEY,
+      verifyOptions
+    );
+    return decoded;
+  }
+  static generatePayload(user) {
+    return {
+      _id: user._id.toString(),
+      email: user.email
+    };
+  }
+};
+
+// src/middlewares/verifyToken.ts
+var verifyToken = async (req, res, next) => {
+  try {
+    const { token } = req?.session;
+    if (!token) {
+      next(new BadTokenError("Authentication token is missing"));
+    }
+    const decoded = JwtService.verify(token);
+    req.user = decoded;
+    next();
+  } catch (error) {
+    if (error instanceof import_jsonwebtoken2.default.TokenExpiredError) {
+      next(new TokenExpiredError());
+    } else if (error instanceof import_jsonwebtoken2.default.JsonWebTokenError) {
+      next(new BadTokenError());
+    } else {
+      next(new BadTokenError());
+    }
+  }
+};
+
+// src/services/password.service.ts
+var import_bcrypt = __toESM(require("bcrypt"));
+var Password = class {
+  static hashPassword(password) {
+    return new Promise((resolve, reject) => {
+      import_bcrypt.default.hash(password, sanitizedConfig.SALT_ROUNDS, function(err, hash) {
+        if (err) {
+          reject(err.message);
+        }
+        resolve(hash);
+      });
+    });
+  }
+  static comparePassword(password, hashedPassword) {
+    return new Promise((resolve, reject) => {
+      import_bcrypt.default.compare(password, hashedPassword, function(err, result) {
+        if (err) {
+          reject(err.message);
+        }
+        resolve(result);
+      });
+    });
+  }
+};
+
+// src/types/validation.ts
+var ValidationSource = /* @__PURE__ */ ((ValidationSource2) => {
+  ValidationSource2["BODY"] = "body";
+  ValidationSource2["HEADER"] = "headers";
+  ValidationSource2["QUERY"] = "query";
+  ValidationSource2["PARAM"] = "params";
+  return ValidationSource2;
+})(ValidationSource || {});
+
+// src/utils/asyncHandler.ts
+var asyncHandler = (execution) => async (req, res, next) => {
+  try {
+    await execution(req, res, next);
+  } catch (err) {
+    next(err);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccessTokenError,
+  AccessTokenErrorResponse,
+  ApiError,
+  ApiResponse,
+  AuthFailureError,
+  BadRequestError,
+  BadRequestResponse,
+  BadTokenError,
+  BadTokenResponse,
+  ENVIRONMENTS,
+  ErrorType,
+  ForbiddenError,
+  ForbiddenResponse,
+  InternalError,
+  InternalErrorResponse,
+  JwtService,
+  NoDataError,
+  NoEntryError,
+  NoFoundResponse,
+  NotFoundError,
+  Password,
+  ResponseStatusCode,
+  StatusCode,
+  SuccessResponse,
+  TokenExpiredError,
+  ValidationSource,
+  asyncHandler,
+  logger,
+  schemaValidator,
+  verifyToken
+});