drapcode-utility 1.0.0

package/build/encryption/index.d.ts

@@ -0,0 +1,15 @@
+declare type AwsConfig = {
+    accessKeyId: string;
+    secretAccessKey: string;
+    region: string;
+};
+declare type Encryption = {
+    encryptionType: string;
+    algorithm: string;
+    key: string;
+    awsConfig: AwsConfig;
+};
+export declare const crypt: (data: any, fields: Array<object>, encryption: Encryption, decrypt: boolean) => Promise<any>;
+export declare const createKMSDataKey: (awsConfig: object, KeyId: string) => Promise<any>;
+export declare const decryptDataKey: (dataKey: string, awsConfig: object) => Promise<any>;
+export {};

package/build/encryption/index.js

@@ -0,0 +1,255 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decryptDataKey = exports.createKMSDataKey = exports.crypt = void 0;
+var aws_sdk_1 = require("aws-sdk");
+var crypto_1 = __importDefault(require("crypto"));
+var prefix = "rec";
+var randomCharLen = 8;
+var crypt = function (data, fields, encryption, decrypt) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, accessKeyId, secretAccessKey, region, config, key, promises;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                if (!(encryption.encryptionType === "KMS")) return [3 /*break*/, 2];
+                _a = encryption.awsConfig, accessKeyId = _a.accessKeyId, secretAccessKey = _a.secretAccessKey, region = _a.region;
+                config = {
+                    region: region,
+                    credentials: {
+                        accessKeyId: accessKeyId,
+                        secretAccessKey: secretAccessKey,
+                    },
+                };
+                return [4 /*yield*/, exports.decryptDataKey(encryption.key, config)];
+            case 1:
+                key = _b.sent();
+                encryption.key = key.toString("base64");
+                _b.label = 2;
+            case 2:
+                if (!Array.isArray(data)) return [3 /*break*/, 4];
+                promises = data.map(function (item) {
+                    return cryptItem(item, fields, encryption, decrypt);
+                });
+                return [4 /*yield*/, Promise.all(promises)];
+            case 3:
+                data = _b.sent();
+                return [3 /*break*/, 6];
+            case 4: return [4 /*yield*/, cryptItem(data, fields, encryption, decrypt)];
+            case 5:
+                data = _b.sent();
+                _b.label = 6;
+            case 6: return [2 /*return*/, data];
+        }
+    });
+}); };
+exports.crypt = crypt;
+var cryptItem = function (item, fields, encryption, decrypt) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        Object.keys(item).forEach(function (fieldName) { return __awaiter(void 0, void 0, void 0, function () {
+            var field, _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        field = fields.find(function (field) { return field.fieldName === fieldName; });
+                        if (!(field && field.encrypted)) return [3 /*break*/, 2];
+                        _a = item;
+                        _b = fieldName;
+                        return [4 /*yield*/, cryptData(item[fieldName], encryption, decrypt)];
+                    case 1:
+                        _a[_b] = _c.sent();
+                        _c.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        }); });
+        return [2 /*return*/, item];
+    });
+}); };
+var cryptData = function (data, encryption, decrypt) { return __awaiter(void 0, void 0, void 0, function () {
+    var encryptionType, algorithm, key, _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                encryptionType = encryption.encryptionType, algorithm = encryption.algorithm, key = encryption.key;
+                if (!data)
+                    return [2 /*return*/, data];
+                _a = encryptionType;
+                switch (_a) {
+                    case "BASE64": return [3 /*break*/, 1];
+                    case "CUSTOM": return [3 /*break*/, 2];
+                    case "KMS": return [3 /*break*/, 3];
+                }
+                return [3 /*break*/, 8];
+            case 1: return [2 /*return*/, decrypt ? decryptBase64(data) : encryptBase64(data)];
+            case 2: return [2 /*return*/, decrypt
+                    ? decryptCustom(data, algorithm, key)
+                    : encryptCustom(data, algorithm, key)];
+            case 3:
+                if (!decrypt) return [3 /*break*/, 5];
+                return [4 /*yield*/, decryptWithKMS(data, algorithm, key)];
+            case 4:
+                _b = _c.sent();
+                return [3 /*break*/, 7];
+            case 5: return [4 /*yield*/, encryptWithKMS(data, algorithm, key)];
+            case 6:
+                _b = _c.sent();
+                _c.label = 7;
+            case 7: return [2 /*return*/, _b];
+            case 8: return [2 /*return*/, data];
+        }
+    });
+}); };
+var encryptBase64 = function (data) {
+    if (data.startsWith(prefix))
+        return data;
+    var randomFront = getRandomAlphaNumeric(randomCharLen);
+    var randomback = getRandomAlphaNumeric(randomCharLen);
+    var base64Data = btoa(data);
+    return prefix + randomFront + base64Data + randomback;
+};
+var decryptBase64 = function (encryptedData) {
+    if (encryptedData.startsWith(prefix)) {
+        encryptedData = encryptedData.replace(prefix, "");
+        encryptedData = encryptedData.substring(randomCharLen, encryptedData.length - randomCharLen);
+        encryptedData = atob(encryptedData);
+    }
+    return encryptedData;
+};
+var encryptCustom = function (data, alogrithm, key) {
+    return data;
+};
+var decryptCustom = function (encryptedData, alogrithm, key) {
+    return encryptedData;
+};
+var getRandomAlphaNumeric = function (length) {
+    return Math.random().toString(36).substr(2, length);
+};
+var createKMSDataKey = function (awsConfig, KeyId) { return __awaiter(void 0, void 0, void 0, function () {
+    var kms_1;
+    return __generator(this, function (_a) {
+        try {
+            kms_1 = new aws_sdk_1.KMS(awsConfig);
+            return [2 /*return*/, new Promise(function (resolve, reject) {
+                    var params = {
+                        KeyId: KeyId,
+                        KeySpec: "AES_256",
+                    };
+                    kms_1.generateDataKey(params, function (err, data) {
+                        if (err) {
+                            console.log("\n Error", err);
+                            reject(err);
+                        }
+                        else {
+                            resolve(data);
+                        }
+                    });
+                })];
+        }
+        catch (error) {
+            console.log("\n Error: ", error);
+        }
+        return [2 /*return*/];
+    });
+}); };
+exports.createKMSDataKey = createKMSDataKey;
+var decryptDataKey = function (dataKey, awsConfig) { return __awaiter(void 0, void 0, void 0, function () {
+    var kms_2, CiphertextBlob_1;
+    return __generator(this, function (_a) {
+        try {
+            kms_2 = new aws_sdk_1.KMS(awsConfig);
+            CiphertextBlob_1 = Buffer.from(dataKey, "base64");
+            return [2 /*return*/, new Promise(function (resolve, reject) {
+                    var params = { CiphertextBlob: CiphertextBlob_1 };
+                    kms_2.decrypt(params, function (err, data) {
+                        if (err) {
+                            console.log("\n Error", err);
+                            reject(err);
+                        }
+                        else {
+                            resolve(data.Plaintext);
+                        }
+                    });
+                })];
+        }
+        catch (error) {
+            console.log("\n Error: ", error);
+        }
+        return [2 /*return*/];
+    });
+}); };
+exports.decryptDataKey = decryptDataKey;
+var encryptWithKMS = function (data, algorithm, key) { return __awaiter(void 0, void 0, void 0, function () {
+    var iv, keyBuffer, cipher, encryptedDataBuffer;
+    return __generator(this, function (_a) {
+        try {
+            iv = Buffer.from("i4mboZDwaNEC38YCzi77lw==", "base64");
+            keyBuffer = Buffer.from(key, "base64");
+            cipher = crypto_1.default.createCipheriv(algorithm, keyBuffer, iv);
+            encryptedDataBuffer = cipher.update(data);
+            encryptedDataBuffer = Buffer.concat([encryptedDataBuffer, cipher.final()]);
+            return [2 /*return*/, encryptedDataBuffer.toString("base64")];
+        }
+        catch (error) {
+            console.log("\n Error: ", error);
+            return [2 /*return*/, data];
+        }
+        return [2 /*return*/];
+    });
+}); };
+var decryptWithKMS = function (data, algorithm, key) { return __awaiter(void 0, void 0, void 0, function () {
+    var iv, encryptedData, keyBuffer, decipher, decryptedBuffer;
+    return __generator(this, function (_a) {
+        try {
+            iv = Buffer.from("i4mboZDwaNEC38YCzi77lw==", "base64");
+            encryptedData = Buffer.from(data, "base64");
+            keyBuffer = Buffer.from(key, "base64");
+            decipher = crypto_1.default.createDecipheriv(algorithm, keyBuffer, iv);
+            decryptedBuffer = decipher.update(encryptedData);
+            decryptedBuffer = Buffer.concat([decryptedBuffer, decipher.final()]);
+            return [2 /*return*/, decryptedBuffer.toString()];
+        }
+        catch (error) {
+            console.log("\n Error: ", error);
+            return [2 /*return*/, data];
+        }
+        return [2 /*return*/];
+    });
+}); };

package/build/errors/app-error.d.ts

@@ -0,0 +1,6 @@
+export declare class AppError extends Error {
+    message: string;
+    statusCode: number;
+    isOperational: boolean;
+    constructor(message: string, statusCode: number);
+}

package/build/errors/app-error.js

@@ -0,0 +1,30 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppError = void 0;
+var AppError = /** @class */ (function (_super) {
+    __extends(AppError, _super);
+    function AppError(message, statusCode) {
+        var _this = _super.call(this, message) || this;
+        _this.message = message;
+        _this.statusCode = statusCode;
+        _this.statusCode = statusCode;
+        _this.isOperational = true;
+        Object.setPrototypeOf(_this, AppError.prototype);
+        return _this;
+    }
+    return AppError;
+}(Error));
+exports.AppError = AppError;

package/build/errors/axios-error.d.ts

@@ -0,0 +1,13 @@
+import { AxiosError } from "axios";
+export declare const parseAxiosError: (error: AxiosError) => {
+    success?: undefined;
+    error?: undefined;
+    status?: undefined;
+} | {
+    success: boolean;
+    error: any;
+    status: number;
+};
+export declare const parseXanoConfigError: (error: any) => string;
+export declare const parseAirtableConfigError: (error: any) => string;
+export declare const parseSupabaseConfigError: (error: any) => string;

package/build/errors/axios-error.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSupabaseConfigError = exports.parseAirtableConfigError = exports.parseXanoConfigError = exports.parseAxiosError = void 0;
+var parseAxiosError = function (error) {
+    if (!error) {
+        return {};
+    }
+    var response = error.response, request = error.request, message = error.message;
+    var errData = "", errStatus = 400;
+    if (response) {
+        console.log("err.response.data: ", response.data);
+        console.log("err.response.status: ", response.status);
+        console.log("err.response.headers", response.headers);
+        errData = response.data;
+        errStatus = response.status;
+    }
+    else if (request) {
+        errData = "No Response Received from the API";
+        console.log("err.request: ", request);
+    }
+    else {
+        if (message.includes("ECONNABORTED")) {
+            errData = "No response received from the REST API";
+        }
+        else {
+            errData = message;
+        }
+    }
+    return { success: false, error: errData, status: errStatus };
+};
+exports.parseAxiosError = parseAxiosError;
+var parseXanoConfigError = function (error) {
+    if (!error || !error.code) {
+        return "Failed from Xano";
+    }
+    var errorMessage = "";
+    switch (error.code) {
+        case "ERROR_CODE_UNAUTHORIZED":
+            errorMessage = "Developer API Key is wrong";
+            break;
+        default:
+            errorMessage = "Failed from Xano";
+            break;
+    }
+    return errorMessage;
+};
+exports.parseXanoConfigError = parseXanoConfigError;
+var parseAirtableConfigError = function (error) {
+    if (!error || !error.error || !error.error.type) {
+        return "Failed from Airtable";
+    }
+    var errorMessage = "";
+    switch (error.error.type) {
+        case "AUTHENTICATION_REQUIRED":
+            errorMessage = "Authorization is missing/wrong.";
+            break;
+        default:
+            errorMessage = "Failed from Airtable";
+            break;
+    }
+    return errorMessage;
+};
+exports.parseAirtableConfigError = parseAirtableConfigError;
+var parseSupabaseConfigError = function (error) {
+    if (!error) {
+        return "Failed from Supabase";
+    }
+    var errorMessage = "";
+    switch (error) {
+        case "ENOTFOUND":
+            errorMessage = "Given Supabase URL does not exists/API Key is wrong";
+            break;
+        default:
+            break;
+    }
+    return errorMessage;
+};
+exports.parseSupabaseConfigError = parseSupabaseConfigError;

package/build/errors/bad-request-error.d.ts

@@ -0,0 +1,9 @@
+import { CustomError } from "./custom-error";
+export declare class BadRequestError extends CustomError {
+    message: string;
+    statusCode: number;
+    constructor(message: string);
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/bad-request-error.js

@@ -0,0 +1,32 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BadRequestError = void 0;
+var custom_error_1 = require("./custom-error");
+var BadRequestError = /** @class */ (function (_super) {
+    __extends(BadRequestError, _super);
+    function BadRequestError(message) {
+        var _this = _super.call(this, message) || this;
+        _this.message = message;
+        _this.statusCode = 400;
+        Object.setPrototypeOf(_this, BadRequestError.prototype);
+        return _this;
+    }
+    BadRequestError.prototype.serializeErrors = function () {
+        return [{ message: this.message }];
+    };
+    return BadRequestError;
+}(custom_error_1.CustomError));
+exports.BadRequestError = BadRequestError;

package/build/errors/custom-error.d.ts

@@ -0,0 +1,8 @@
+export declare abstract class CustomError extends Error {
+    abstract statusCode: number;
+    constructor(message: string);
+    abstract serializeErrors(): {
+        message: string;
+        field?: string;
+    }[];
+}

package/build/errors/custom-error.js

@@ -0,0 +1,26 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomError = void 0;
+var CustomError = /** @class */ (function (_super) {
+    __extends(CustomError, _super);
+    function CustomError(message) {
+        var _this = _super.call(this) || this;
+        Object.setPrototypeOf(_this, CustomError.prototype);
+        return _this;
+    }
+    return CustomError;
+}(Error));
+exports.CustomError = CustomError;

package/build/errors/not-found.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class NotFoundError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/not-found.js

@@ -0,0 +1,31 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundError = void 0;
+var custom_error_1 = require("./custom-error");
+var NotFoundError = /** @class */ (function (_super) {
+    __extends(NotFoundError, _super);
+    function NotFoundError() {
+        var _this = _super.call(this, "Route Not Found") || this;
+        _this.statusCode = 404;
+        Object.setPrototypeOf(_this, NotFoundError.prototype);
+        return _this;
+    }
+    NotFoundError.prototype.serializeErrors = function () {
+        return [{ message: "Not Found" }];
+    };
+    return NotFoundError;
+}(custom_error_1.CustomError));
+exports.NotFoundError = NotFoundError;

package/build/index.d.ts

@@ -0,0 +1,17 @@
+export * from "./errors/bad-request-error";
+export * from "./errors/custom-error";
+export * from "./errors/not-found";
+export * from "./errors/app-error";
+export * from "./errors/axios-error";
+export * from "./middlewares/error-logger";
+export * from "./middlewares/interceptor-logger";
+export * from "./middlewares/interceptor-logger-new";
+export * from "./middlewares/api-limiter";
+export * from "./utils/date-util";
+export * from "./utils/query-parser";
+export * from "./utils/query-paser-new";
+export * from "./utils/util";
+export * from "./utils/uuid-generator";
+export * from "./utils/check-error";
+export * from "./utils/prepare-query";
+export * from "./encryption/index";

package/build/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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("./errors/bad-request-error"), exports);
+__exportStar(require("./errors/custom-error"), exports);
+__exportStar(require("./errors/not-found"), exports);
+__exportStar(require("./errors/app-error"), exports);
+__exportStar(require("./errors/axios-error"), exports);
+__exportStar(require("./middlewares/error-logger"), exports);
+__exportStar(require("./middlewares/interceptor-logger"), exports);
+__exportStar(require("./middlewares/interceptor-logger-new"), exports);
+__exportStar(require("./middlewares/api-limiter"), exports);
+__exportStar(require("./utils/date-util"), exports);
+__exportStar(require("./utils/query-parser"), exports);
+__exportStar(require("./utils/query-paser-new"), exports);
+__exportStar(require("./utils/util"), exports);
+__exportStar(require("./utils/uuid-generator"), exports);
+__exportStar(require("./utils/check-error"), exports);
+__exportStar(require("./utils/prepare-query"), exports);
+__exportStar(require("./encryption/index"), exports);

package/build/middlewares/api-limiter.d.ts

@@ -0,0 +1 @@
+export declare const apiLimiter: any;

package/build/middlewares/api-limiter.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiLimiter = void 0;
+var rateLimit = require("express-rate-limit");
+exports.apiLimiter = rateLimit({
+    windowMs: 1 * 60 * 1000,
+    max: 5,
+    message: "You have crossed your limit. please try after some time",
+    headers: true,
+    keyGenerator: function (req, res) {
+        var subdomains = req.subdomains;
+        var ip = req.headers["x-forwarded-for"] ||
+            req.connection.remoteAddress ||
+            req.socket.remoteAddress ||
+            (req.connection.socket ? req.connection.socket.remoteAddress : null);
+        var key = Array.isArray(subdomains) && subdomains.length
+            ? ip + "-" + subdomains[1]
+            : ip;
+        return key;
+    },
+});

package/build/middlewares/error-logger.d.ts

@@ -0,0 +1,3 @@
+import { Response, NextFunction } from "express";
+import { CustomError } from "../errors/custom-error";
+export declare const errorLogger: (err: CustomError, req: any, res: Response, next: NextFunction) => Response<any, Record<string, any>> | undefined;