@konplit-services/common 1.2.0 → 1.2.1

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

@@ -0,0 +1,17 @@
+import { Status } from "../helper/status";
+import { CustomError } from "./custom-error";
+import { ErrorReturn } from "./error.interface";
+export declare class AxiosRequestError extends CustomError {
+    message: string;
+    private error_data;
+    readonly statusCode: number;
+    constructor(message: string, error_data: ErrorReturn);
+    sequalizeErrors(): {
+        status: Status;
+        errors: {
+            message: string;
+            error_code: string;
+            code: number;
+        }[];
+    };
+}

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AxiosRequestError = void 0;
+const status_1 = require("../helper/status");
+const custom_error_1 = require("./custom-error");
+class AxiosRequestError extends custom_error_1.CustomError {
+    constructor(message, error_data) {
+        super(message);
+        this.message = message;
+        this.error_data = error_data;
+        this.statusCode = 500;
+        this.error_data = error_data;
+        Object.setPrototypeOf(this, AxiosRequestError.prototype);
+    }
+    sequalizeErrors() {
+        return {
+            status: status_1.Status.Failed,
+            errors: [
+                {
+                    message: this.message
+                        ? this.message
+                        : "Sorry! We are aware of this issue...but you can also reach us form our contact page",
+                    error_code: this.error_data.error_code
+                        ? this.error_data.error_code
+                        : "Server error",
+                    code: this.error_data.code,
+                },
+            ],
+        };
+    }
+}
+exports.AxiosRequestError = AxiosRequestError;

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

@@ -0,0 +1,17 @@
+import { Status } from "../helper/status";
+import { CustomError } from "./custom-error";
+import { ErrorReturn } from "./error.interface";
+export declare class BadRequestError extends CustomError {
+    message: string;
+    private error_data;
+    readonly statusCode: number;
+    constructor(message: string, error_data: ErrorReturn);
+    sequalizeErrors(): {
+        status: Status;
+        errors: {
+            message: string;
+            error_code: string;
+            code: number;
+        }[];
+    };
+}

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BadRequestError = void 0;
+const status_1 = require("../helper/status");
+const custom_error_1 = require("./custom-error");
+class BadRequestError extends custom_error_1.CustomError {
+    constructor(message, error_data) {
+        super(message);
+        this.message = message;
+        this.error_data = error_data;
+        this.statusCode = 400;
+        this.error_data = error_data;
+        Object.setPrototypeOf(this, BadRequestError.prototype);
+    }
+    sequalizeErrors() {
+        return {
+            status: status_1.Status.Failed,
+            errors: [
+                {
+                    message: this.message,
+                    error_code: this.error_data.error_code,
+                    code: this.error_data.code,
+                },
+            ],
+        };
+    }
+}
+exports.BadRequestError = BadRequestError;

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

@@ -0,0 +1,15 @@
+import { Status } from "../helper/status";
+export declare abstract class CustomError extends Error {
+    message: string;
+    abstract statusCode: number;
+    constructor(message: string);
+    abstract sequalizeErrors(): {
+        status: Status;
+        errors: {
+            message: string;
+            field?: string;
+            error_code: string;
+            code: number;
+        }[];
+    };
+}

package/build/errors/custom-error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomError = void 0;
+class CustomError extends Error {
+    constructor(message) {
+        super(message);
+        this.message = message;
+        Object.setPrototypeOf(this, CustomError.prototype);
+    }
+}
+exports.CustomError = CustomError;

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

@@ -0,0 +1,17 @@
+import { Status } from "../helper/status";
+import { CustomError } from "./custom-error";
+import { ErrorReturn } from "./error.interface";
+export declare class DatabaseConnectionError extends CustomError {
+    message: string;
+    private error_data;
+    readonly statusCode = 500;
+    constructor(message: string, error_data: ErrorReturn);
+    sequalizeErrors(): {
+        status: Status;
+        errors: {
+            message: string;
+            error_code: string;
+            code: number;
+        }[];
+    };
+}

package/build/errors/database-error.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseConnectionError = void 0;
+const status_1 = require("../helper/status");
+const custom_error_1 = require("./custom-error");
+class DatabaseConnectionError extends custom_error_1.CustomError {
+    constructor(message, error_data) {
+        super(message);
+        this.message = message;
+        this.error_data = error_data;
+        this.statusCode = 500;
+        this.error_data = error_data;
+        Object.setPrototypeOf(this, DatabaseConnectionError.prototype);
+    }
+    sequalizeErrors() {
+        return {
+            status: status_1.Status.Failed,
+            errors: [
+                {
+                    message: this.message,
+                    error_code: this.error_data.error_code,
+                    code: this.error_data.code,
+                },
+            ],
+        };
+    }
+}
+exports.DatabaseConnectionError = DatabaseConnectionError;

package/build/errors/error.interface.d.ts

@@ -0,0 +1,4 @@
+export interface ErrorReturn {
+    code: number;
+    error_code: string;
+}

package/build/errors/error.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,17 @@
+import { Status } from "../helper/status";
+import { CustomError } from "./custom-error";
+import { ErrorReturn } from "./error.interface";
+export declare class ForbiddenError extends CustomError {
+    message: string;
+    private error_data;
+    readonly statusCode: number;
+    constructor(message: string, error_data: ErrorReturn);
+    sequalizeErrors(): {
+        status: Status;
+        errors: {
+            message: string;
+            error_code: string;
+            code: number;
+        }[];
+    };
+}

package/build/errors/forbidden-error.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForbiddenError = void 0;
+const status_1 = require("../helper/status");
+const custom_error_1 = require("./custom-error");
+class ForbiddenError extends custom_error_1.CustomError {
+    constructor(message, error_data) {
+        super(message);
+        this.message = message;
+        this.error_data = error_data;
+        this.statusCode = 403;
+        this.error_data = error_data;
+        Object.setPrototypeOf(this, ForbiddenError.prototype);
+    }
+    sequalizeErrors() {
+        return {
+            status: status_1.Status.Failed,
+            errors: [
+                {
+                    message: this.message,
+                    error_code: this.error_data.error_code,
+                    code: this.error_data.code,
+                },
+            ],
+        };
+    }
+}
+exports.ForbiddenError = ForbiddenError;

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

@@ -0,0 +1,19 @@
+import { Status } from "../helper/status";
+import { CustomError } from "./custom-error";
+import { ErrorReturn } from "./error.interface";
+export declare class GatewayError extends CustomError {
+    message: string;
+    private error_data;
+    private gatewayaResponse?;
+    readonly statusCode = 502;
+    constructor(message: string, error_data: ErrorReturn, gatewayaResponse?: string | undefined);
+    sequalizeErrors(): {
+        status: Status;
+        errors: {
+            message: string;
+            code: number;
+            error_code: string;
+            gatewayaResponse: string | undefined;
+        }[];
+    };
+}

package/build/errors/gateway-error.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayError = void 0;
+const status_1 = require("../helper/status");
+const custom_error_1 = require("./custom-error");
+class GatewayError extends custom_error_1.CustomError {
+    constructor(message, error_data, gatewayaResponse) {
+        super(message);
+        this.message = message;
+        this.error_data = error_data;
+        this.gatewayaResponse = gatewayaResponse;
+        this.statusCode = 502;
+        this.error_data = error_data;
+        Object.setPrototypeOf(this, GatewayError.prototype);
+    }
+    sequalizeErrors() {
+        return {
+            status: status_1.Status.Failed,
+            errors: [
+                {
+                    message: this.message,
+                    code: this.error_data.code,
+                    error_code: this.error_data.error_code,
+                    gatewayaResponse: this.gatewayaResponse,
+                },
+            ],
+        };
+    }
+}
+exports.GatewayError = GatewayError;

package/build/errors/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./bad-request-error";
+export * from "./custom-error";
+export * from "./database-error";
+export * from "./not-found";
+export * from "./notAuthorized";
+export * from "./request-validation-error";
+export * from "./forbidden-error";
+export * from "./mongoose-validation-error";
+export * from "./invalid-input-error";
+export * from "./service-not-available";
+export * from "./axios-request-error";
+export * from "./gateway-error";
+export * from "./toomany-request.errors";

package/build/errors/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;
+    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("./bad-request-error"), exports);
+__exportStar(require("./custom-error"), exports);
+__exportStar(require("./database-error"), exports);
+__exportStar(require("./not-found"), exports);
+__exportStar(require("./notAuthorized"), exports);
+__exportStar(require("./request-validation-error"), exports);
+__exportStar(require("./forbidden-error"), exports);
+__exportStar(require("./mongoose-validation-error"), exports);
+__exportStar(require("./invalid-input-error"), exports);
+__exportStar(require("./service-not-available"), exports);
+__exportStar(require("./axios-request-error"), exports);
+__exportStar(require("./gateway-error"), exports);
+__exportStar(require("./toomany-request.errors"), exports);

package/build/errors/invalid-input-error.d.ts

@@ -0,0 +1,19 @@
+import { Status } from "../helper/status";
+import { CustomError } from "./custom-error";
+import { ErrorReturn } from "./error.interface";
+export declare class InvalidInputError extends CustomError {
+    message: string;
+    private field;
+    private error_data;
+    readonly statusCode: number;
+    constructor(message: string, field: string, error_data: ErrorReturn);
+    sequalizeErrors(): {
+        status: Status;
+        errors: {
+            message: string;
+            error_code: string;
+            field: string;
+            code: number;
+        }[];
+    };
+}

package/build/errors/invalid-input-error.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidInputError = void 0;
+const status_1 = require("../helper/status");
+const custom_error_1 = require("./custom-error");
+class InvalidInputError extends custom_error_1.CustomError {
+    constructor(message, field, error_data) {
+        super(message);
+        this.message = message;
+        this.field = field;
+        this.error_data = error_data;
+        this.statusCode = 400;
+        this.error_data = error_data;
+        this.field = field;
+        Object.setPrototypeOf(this, InvalidInputError.prototype);
+    }
+    sequalizeErrors() {
+        return {
+            status: status_1.Status.Failed,
+            errors: [
+                {
+                    message: this.message,
+                    error_code: this.error_data.error_code,
+                    field: this.field,
+                    code: this.error_data.code,
+                },
+            ],
+        };
+    }
+}
+exports.InvalidInputError = InvalidInputError;

package/build/errors/mongoose-validation-error.d.ts

@@ -0,0 +1,17 @@
+import { Status } from "../helper/status";
+import { CustomError } from "./custom-error";
+import { ErrorReturn } from "./error.interface";
+export declare class MongooseBadRequestError extends CustomError {
+    message: string;
+    private error_data;
+    readonly statusCode: number;
+    constructor(message: string, error_data: ErrorReturn);
+    sequalizeErrors(): {
+        status: Status;
+        errors: {
+            message: string;
+            error_code: string;
+            code: number;
+        }[];
+    };
+}

package/build/errors/mongoose-validation-error.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongooseBadRequestError = void 0;
+const status_1 = require("../helper/status");
+const custom_error_1 = require("./custom-error");
+class MongooseBadRequestError extends custom_error_1.CustomError {
+    constructor(message, error_data) {
+        super(message);
+        this.message = message;
+        this.error_data = error_data;
+        this.statusCode = 400;
+        this.error_data = error_data;
+        Object.setPrototypeOf(this, MongooseBadRequestError.prototype);
+    }
+    sequalizeErrors() {
+        return {
+            status: status_1.Status.Failed,
+            errors: [
+                {
+                    message: this.message,
+                    error_code: this.error_data.error_code,
+                    code: this.error_data.code,
+                },
+            ],
+        };
+    }
+}
+exports.MongooseBadRequestError = MongooseBadRequestError;

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

@@ -0,0 +1,17 @@
+import { Status } from "../helper/status";
+import { CustomError } from "./custom-error";
+import { ErrorReturn } from "./error.interface";
+export declare class NotFoundError extends CustomError {
+    message: string;
+    private error_data;
+    readonly statusCode = 404;
+    constructor(message: string, error_data: ErrorReturn);
+    sequalizeErrors(): {
+        status: Status;
+        errors: {
+            message: string;
+            error_code: string;
+            code: number;
+        }[];
+    };
+}

package/build/errors/not-found.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundError = void 0;
+const status_1 = require("../helper/status");
+const custom_error_1 = require("./custom-error");
+class NotFoundError extends custom_error_1.CustomError {
+    constructor(message, error_data) {
+        super(message);
+        this.message = message;
+        this.error_data = error_data;
+        this.statusCode = 404;
+        this.error_data = error_data;
+        Object.setPrototypeOf(this, NotFoundError.prototype);
+    }
+    sequalizeErrors() {
+        return {
+            status: status_1.Status.Failed,
+            errors: [
+                {
+                    message: this.message,
+                    error_code: this.error_data.error_code,
+                    code: this.error_data.code,
+                },
+            ],
+        };
+    }
+}
+exports.NotFoundError = NotFoundError;

package/build/errors/notAuthorized.d.ts

@@ -0,0 +1,17 @@
+import { Status } from "../helper/status";
+import { CustomError } from "./custom-error";
+import { ErrorReturn } from "./error.interface";
+export declare class NotAuthorizedError extends CustomError {
+    message: string;
+    private error_data;
+    readonly statusCode: number;
+    constructor(message: string, error_data: ErrorReturn);
+    sequalizeErrors(): {
+        status: Status;
+        errors: {
+            message: string;
+            error_code: string;
+            code: number;
+        }[];
+    };
+}

package/build/errors/notAuthorized.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAuthorizedError = void 0;
+const status_1 = require("../helper/status");
+const custom_error_1 = require("./custom-error");
+class NotAuthorizedError extends custom_error_1.CustomError {
+    constructor(message, error_data) {
+        super(message);
+        this.message = message;
+        this.error_data = error_data;
+        this.statusCode = 401;
+        this.error_data = error_data;
+        Object.setPrototypeOf(this, NotAuthorizedError.prototype);
+    }
+    sequalizeErrors() {
+        return {
+            status: status_1.Status.Failed,
+            errors: [
+                {
+                    message: this.message,
+                    error_code: this.error_data.error_code,
+                    code: this.error_data.code,
+                },
+            ],
+        };
+    }
+}
+exports.NotAuthorizedError = NotAuthorizedError;

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

@@ -0,0 +1,17 @@
+import { ValidationError } from "express-validator";
+import { Status } from "../helper/status";
+import { CustomError } from "./custom-error";
+export declare class RequestValidationError extends CustomError {
+    private errors;
+    readonly statusCode = 400;
+    constructor(errors: ValidationError[]);
+    sequalizeErrors(): {
+        status: Status;
+        errors: {
+            message: any;
+            error_code: any;
+            field: string;
+            code: any;
+        }[];
+    };
+}

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestValidationError = void 0;
+const status_1 = require("../helper/status");
+const custom_error_1 = require("./custom-error");
+class RequestValidationError extends custom_error_1.CustomError {
+    constructor(errors) {
+        super("validation error");
+        this.errors = errors;
+        this.statusCode = 400;
+        Object.setPrototypeOf(this, RequestValidationError.prototype);
+    }
+    sequalizeErrors() {
+        const errors = this.errors.map((error) => {
+            return {
+                message: error.msg.message,
+                error_code: error.msg.error_code,
+                field: error.param,
+                code: error.msg.error_code,
+            };
+        });
+        return {
+            status: status_1.Status.Failed,
+            errors,
+        };
+    }
+}
+exports.RequestValidationError = RequestValidationError;

package/build/errors/service-not-available.d.ts

@@ -0,0 +1,17 @@
+import { Status } from "../helper/status";
+import { CustomError } from "./custom-error";
+import { ErrorReturn } from "./error.interface";
+export declare class ServiceNotAvailableError extends CustomError {
+    message: string;
+    private error_data;
+    readonly statusCode = 503;
+    constructor(message: string, error_data: ErrorReturn);
+    sequalizeErrors(): {
+        status: Status;
+        errors: {
+            message: string;
+            code: number;
+            error_code: string;
+        }[];
+    };
+}

package/build/errors/service-not-available.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceNotAvailableError = void 0;
+const status_1 = require("../helper/status");
+const custom_error_1 = require("./custom-error");
+class ServiceNotAvailableError extends custom_error_1.CustomError {
+    constructor(message, error_data) {
+        super(message);
+        this.message = message;
+        this.error_data = error_data;
+        this.statusCode = 503;
+        this.error_data = error_data;
+        Object.setPrototypeOf(this, ServiceNotAvailableError.prototype);
+    }
+    sequalizeErrors() {
+        return {
+            status: status_1.Status.Failed,
+            errors: [
+                {
+                    message: this.message,
+                    code: this.error_data.code,
+                    error_code: this.error_data.error_code,
+                },
+            ],
+        };
+    }
+}
+exports.ServiceNotAvailableError = ServiceNotAvailableError;

package/build/errors/toomany-request.errors.d.ts

@@ -0,0 +1,17 @@
+import { Status } from "../helper/status";
+import { CustomError } from "./custom-error";
+import { ErrorReturn } from "./error.interface";
+export declare class TooManyRequestError extends CustomError {
+    message: string;
+    private error_data;
+    readonly statusCode: number;
+    constructor(message: string, error_data: ErrorReturn);
+    sequalizeErrors(): {
+        status: Status;
+        errors: {
+            message: string;
+            error_code: string;
+            code: number;
+        }[];
+    };
+}

package/build/errors/toomany-request.errors.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TooManyRequestError = void 0;
+const status_1 = require("../helper/status");
+const custom_error_1 = require("./custom-error");
+class TooManyRequestError extends custom_error_1.CustomError {
+    constructor(message, error_data) {
+        super(message);
+        this.message = message;
+        this.error_data = error_data;
+        this.statusCode = 429;
+        this.error_data = error_data;
+        Object.setPrototypeOf(this, TooManyRequestError.prototype);
+    }
+    sequalizeErrors() {
+        return {
+            status: status_1.Status.Failed,
+            errors: [
+                {
+                    message: this.message,
+                    error_code: this.error_data.error_code,
+                    code: this.error_data.code,
+                },
+            ],
+        };
+    }
+}
+exports.TooManyRequestError = TooManyRequestError;