@intlayer/backend 3.0.0

package/dist/cjs/utils/errors/ErrorHandler.cjs

@@ -0,0 +1,103 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ErrorHandler_exports = {};
+__export(ErrorHandler_exports, {
+  ErrorHandler: () => ErrorHandler
+});
+module.exports = __toCommonJS(ErrorHandler_exports);
+var import_logger = require('./../../logger/index.cjs');
+var import_responseData = require('./../../utils/responseData.cjs');
+var import_express_intlayer = require("express-intlayer");
+var import_errorCodes = require('./errorCodes.cjs');
+var import_export = require('./../../export.cjs');
+class ErrorHandler {
+  /**
+   * Handles generic error responses by formatting and sending a JSON response.
+   * @param res - The response object provided by Express.js.
+   * @param errorKey - A key representing the specific error.
+   * @param statusCode - (Optional) A specific HTTP status code to use for the response.
+   * @param isPaginatedResponse - Flag to determine if the response should be paginated.
+   */
+  static handleGenericErrorResponse(res, errorKey, errorDetails, statusCode, isPaginatedResponse = false) {
+    const error = import_errorCodes.errorData[errorKey];
+    const status = statusCode ?? error.statusCode;
+    this.handleCustomErrorResponse(
+      res,
+      errorKey,
+      error.message,
+      errorDetails,
+      status,
+      isPaginatedResponse
+    );
+  }
+  /**
+   * Handles application-specific error responses by formatting and sending a JSON response.
+   * @param res - The response object provided by Express.js.
+   * @param error - The error object.
+   * @param isPaginatedResponse - Flag to determine if the response should be paginated.
+   */
+  static handleAppErrorResponse(res, error, errorDetails, isPaginatedResponse = false) {
+    const isMultilingual = error.isMultilingual ?? false;
+    this.handleCustomErrorResponse(
+      res,
+      error.errorKey,
+      isMultilingual ? error.multilingualMessage : JSON.stringify(error.message),
+      errorDetails,
+      error.httpStatusCode,
+      isPaginatedResponse
+    );
+  }
+  /**
+   * Handles more customizable error responses with detailed error messages and codes.
+   * @param res - The response object.
+   * @param errorKey - Error code key used to fetch the corresponding message and default status.
+   * @param message - The localized error message object.
+   * @param statusCode - (Optional) HTTP status code, defaults to 500 if not specified.
+   * @param isPaginatedResponse - Determines if the error should be part of a paginated response.
+   */
+  static handleCustomErrorResponse(res, errorKey, message, errorDetails, statusCode, isPaginatedResponse = false) {
+    import_logger.logger.error(message?.en ?? message);
+    const status = statusCode ?? import_export.HttpStatusCodes.INTERNAL_SERVER_ERROR_500;
+    if (isPaginatedResponse) {
+      const responseData2 = (0, import_responseData.formatPaginatedResponse)({
+        error: {
+          code: errorKey,
+          message: typeof message === "string" ? message : (0, import_express_intlayer.t)(message)
+        },
+        status
+      });
+      res.status(status).json(responseData2);
+      return;
+    }
+    const responseData = (0, import_responseData.formatResponse)({
+      error: {
+        code: errorKey,
+        message: (0, import_express_intlayer.t)(message),
+        ...errorDetails
+      },
+      status
+    });
+    res.status(status).json(responseData);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ErrorHandler
+});
+//# sourceMappingURL=ErrorHandler.cjs.map

package/dist/cjs/utils/errors/ErrorHandler.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/utils/errors/ErrorHandler.ts"],"sourcesContent":["// Import required modules and types from their respective locations.\nimport { logger } from '@logger';\nimport { formatPaginatedResponse, formatResponse } from '@utils/responseData';\nimport type { Response } from 'express';\n// @ts-ignore express-intlayer not build yet\nimport { t, LanguageContent } from 'express-intlayer';\nimport { ErrorCodes, errorData } from './errorCodes';\nimport { AppError } from './ErrorsClass';\nimport { HttpStatusCodes, UserAPI } from '@/export';\n\n// Define a class named 'ErrorHandler' to encapsulate error handling logic.\nexport class ErrorHandler {\n  /**\n   * Handles generic error responses by formatting and sending a JSON response.\n   * @param res - The response object provided by Express.js.\n   * @param errorKey - A key representing the specific error.\n   * @param statusCode - (Optional) A specific HTTP status code to use for the response.\n   * @param isPaginatedResponse - Flag to determine if the response should be paginated.\n   */\n  static handleGenericErrorResponse(\n    res: Response,\n    errorKey: ErrorCodes,\n    errorDetails?: object,\n    statusCode?: HttpStatusCodes,\n    isPaginatedResponse: boolean = false\n  ) {\n    const error = errorData[errorKey];\n    const status = statusCode ?? error.statusCode; // Use the provided status code or default to the one in errorData.\n\n    // Delegate to a more customizable error response handler.\n    this.handleCustomErrorResponse(\n      res,\n      errorKey,\n      error.message,\n      errorDetails,\n      status,\n      isPaginatedResponse\n    );\n  }\n\n  /**\n   * Handles application-specific error responses by formatting and sending a JSON response.\n   * @param res - The response object provided by Express.js.\n   * @param error - The error object.\n   * @param isPaginatedResponse - Flag to determine if the response should be paginated.\n   */\n  static handleAppErrorResponse(\n    res: Response,\n    error: AppError,\n    errorDetails?: object,\n    isPaginatedResponse: boolean = false\n  ) {\n    const isMultilingual = error.isMultilingual ?? false;\n    // Delegate to a more customizable error response handler.\n    this.handleCustomErrorResponse(\n      res,\n      error.errorKey,\n      isMultilingual\n        ? error.multilingualMessage\n        : JSON.stringify(error.message),\n      errorDetails,\n      error.httpStatusCode,\n      isPaginatedResponse\n    );\n  }\n\n  /**\n   * Handles more customizable error responses with detailed error messages and codes.\n   * @param res - The response object.\n   * @param errorKey - Error code key used to fetch the corresponding message and default status.\n   * @param message - The localized error message object.\n   * @param statusCode - (Optional) HTTP status code, defaults to 500 if not specified.\n   * @param isPaginatedResponse - Determines if the error should be part of a paginated response.\n   */\n  static handleCustomErrorResponse<T>(\n    res: Response,\n    errorKey: ErrorCodes | string,\n    message: LanguageContent<string> | string,\n    errorDetails?: object,\n    statusCode?: HttpStatusCodes,\n    isPaginatedResponse: boolean = false\n  ) {\n    logger.error((message as { en: string })?.en ?? message); // Log the English version of the error message.\n    const status = statusCode ?? HttpStatusCodes.INTERNAL_SERVER_ERROR_500; // Default to 500 if no status code is provided.\n\n    if (isPaginatedResponse) {\n      // Format the response as a paginated error response if requested.\n      const responseData = formatPaginatedResponse<T>({\n        error: {\n          code: errorKey,\n          message: typeof message === 'string' ? message : t(message),\n        },\n        status,\n      });\n      res.status(status).json(responseData);\n      return;\n    }\n\n    // Format the response as a standard non-paginated error response.\n    const responseData = formatResponse<UserAPI>({\n      error: {\n        code: errorKey,\n        message: t(message),\n        ...errorDetails,\n      },\n      status,\n    });\n\n    res.status(status).json(responseData);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,oBAAuB;AACvB,0BAAwD;AAGxD,8BAAmC;AACnC,wBAAsC;AAEtC,oBAAyC;AAGlC,MAAM,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQxB,OAAO,2BACL,KACA,UACA,cACA,YACA,sBAA+B,OAC/B;AACA,UAAM,QAAQ,4BAAU,QAAQ;AAChC,UAAM,SAAS,cAAc,MAAM;AAGnC,SAAK;AAAA,MACH;AAAA,MACA;AAAA,MACA,MAAM;AAAA,MACN;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAO,uBACL,KACA,OACA,cACA,sBAA+B,OAC/B;AACA,UAAM,iBAAiB,MAAM,kBAAkB;AAE/C,SAAK;AAAA,MACH;AAAA,MACA,MAAM;AAAA,MACN,iBACI,MAAM,sBACN,KAAK,UAAU,MAAM,OAAO;AAAA,MAChC;AAAA,MACA,MAAM;AAAA,MACN;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,OAAO,0BACL,KACA,UACA,SACA,cACA,YACA,sBAA+B,OAC/B;AACA,yBAAO,MAAO,SAA4B,MAAM,OAAO;AACvD,UAAM,SAAS,cAAc,8BAAgB;AAE7C,QAAI,qBAAqB;AAEvB,YAAMA,oBAAe,6CAA2B;AAAA,QAC9C,OAAO;AAAA,UACL,MAAM;AAAA,UACN,SAAS,OAAO,YAAY,WAAW,cAAU,2BAAE,OAAO;AAAA,QAC5D;AAAA,QACA;AAAA,MACF,CAAC;AACD,UAAI,OAAO,MAAM,EAAE,KAAKA,aAAY;AACpC;AAAA,IACF;AAGA,UAAM,mBAAe,oCAAwB;AAAA,MAC3C,OAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAS,2BAAE,OAAO;AAAA,QAClB,GAAG;AAAA,MACL;AAAA,MACA;AAAA,IACF,CAAC;AAED,QAAI,OAAO,MAAM,EAAE,KAAK,YAAY;AAAA,EACtC;AACF;","names":["responseData"]}

package/dist/cjs/utils/errors/ErrorsClass.cjs

@@ -0,0 +1,65 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ErrorsClass_exports = {};
+__export(ErrorsClass_exports, {
+  AppError: () => AppError,
+  GenericError: () => GenericError
+});
+module.exports = __toCommonJS(ErrorsClass_exports);
+var import_httpStatusCodes = require('./../../utils/httpStatusCodes.cjs');
+var import_express_intlayer = require("express-intlayer");
+var import_errorCodes = require('./errorCodes.cjs');
+class AppError extends Error {
+  name;
+  isMultilingual = true;
+  errorKey;
+  message;
+  multilingualMessage;
+  httpStatusCode;
+  messageDetails;
+  /**
+   * Constructor for the custom error class.
+   * @param multilingualMessage - The error message which can be a simple string or a multilingual object.
+   * @param httpStatusCode - Optional HTTP status code, defaults to 500 Internal Server Error.
+   */
+  constructor(multilingualMessage, errorKey, httpStatusCode = import_httpStatusCodes.HttpStatusCodes.INTERNAL_SERVER_ERROR_500, messageDetails) {
+    const message = (0, import_express_intlayer.t)(multilingualMessage);
+    super(message);
+    this.message = message;
+    this.name = "AppError";
+    this.errorKey = errorKey;
+    this.multilingualMessage = multilingualMessage;
+    this.httpStatusCode = httpStatusCode;
+    this.messageDetails = messageDetails;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+class GenericError extends AppError {
+  constructor(errorKey, messageDetails) {
+    const multilingualMessage = import_errorCodes.errorData[errorKey].message;
+    const httpStatusCode = import_errorCodes.errorData[errorKey].statusCode;
+    super(multilingualMessage, errorKey, httpStatusCode, messageDetails);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AppError,
+  GenericError
+});
+//# sourceMappingURL=ErrorsClass.cjs.map

package/dist/cjs/utils/errors/ErrorsClass.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/utils/errors/ErrorsClass.ts"],"sourcesContent":["import { HttpStatusCodes } from '@utils/httpStatusCodes';\n// @ts-ignore express-intlayer not build yet\nimport { t, type LanguageContent } from 'express-intlayer';\nimport { ErrorCodes, errorData } from './errorCodes';\n\n/**\n * Custom error class that extends the native JavaScript Error class.\n * This class supports multilingual error messages and HTTP status codes.\n */\nexport class AppError extends Error {\n  public name: string;\n  public isMultilingual: boolean = true;\n  public errorKey: string;\n  public message: string;\n  public multilingualMessage: LanguageContent<string>;\n  public httpStatusCode: HttpStatusCodes;\n  public messageDetails?: object;\n\n  /**\n   * Constructor for the custom error class.\n   * @param multilingualMessage - The error message which can be a simple string or a multilingual object.\n   * @param httpStatusCode - Optional HTTP status code, defaults to 500 Internal Server Error.\n   */\n  constructor(\n    multilingualMessage: LanguageContent<string>,\n    errorKey: string,\n    httpStatusCode: HttpStatusCodes = HttpStatusCodes.INTERNAL_SERVER_ERROR_500,\n    messageDetails?: object\n  ) {\n    const message = t(multilingualMessage); // Translate message based on current locale.\n\n    super(message); // Use translated message for the superclass constructor.\n    this.message = message;\n    this.name = 'AppError';\n    this.errorKey = errorKey;\n    this.multilingualMessage = multilingualMessage; // Store original message format for potential use.\n    this.httpStatusCode = httpStatusCode; // Set the HTTP status code.\n    this.messageDetails = messageDetails; // Store any additional message details.\n\n    // Capture the stack trace to exclude the constructor call.\n    Error.captureStackTrace(this, this.constructor);\n  }\n}\n\nexport class GenericError extends AppError {\n  constructor(errorKey: ErrorCodes, messageDetails?: object) {\n    const multilingualMessage = errorData[errorKey].message;\n    const httpStatusCode = errorData[errorKey].statusCode;\n\n    super(multilingualMessage, errorKey, httpStatusCode, messageDetails);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,6BAAgC;AAEhC,8BAAwC;AACxC,wBAAsC;AAM/B,MAAM,iBAAiB,MAAM;AAAA,EAC3B;AAAA,EACA,iBAA0B;AAAA,EAC1B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOP,YACE,qBACA,UACA,iBAAkC,uCAAgB,2BAClD,gBACA;AACA,UAAM,cAAU,2BAAE,mBAAmB;AAErC,UAAM,OAAO;AACb,SAAK,UAAU;AACf,SAAK,OAAO;AACZ,SAAK,WAAW;AAChB,SAAK,sBAAsB;AAC3B,SAAK,iBAAiB;AACtB,SAAK,iBAAiB;AAGtB,UAAM,kBAAkB,MAAM,KAAK,WAAW;AAAA,EAChD;AACF;AAEO,MAAM,qBAAqB,SAAS;AAAA,EACzC,YAAY,UAAsB,gBAAyB;AACzD,UAAM,sBAAsB,4BAAU,QAAQ,EAAE;AAChD,UAAM,iBAAiB,4BAAU,QAAQ,EAAE;AAE3C,UAAM,qBAAqB,UAAU,gBAAgB,cAAc;AAAA,EACrE;AACF;","names":[]}