@konplit-services/common 1.0.1

package/build/Schema/CFLESCHEMA.d.ts

@@ -0,0 +1,138 @@
+declare const schemaDefinition: (_key: string) => {
+    "konplit.merchantbusinesses": {
+        bsonType: string;
+        properties: {
+            keys: {
+                bsonType: string;
+                properties: {
+                    kpLivePrivate: {
+                        encrypt: {
+                            bsonType: string;
+                            algorithm: string;
+                            keyId: string[];
+                        };
+                    };
+                    kpTestPrivate: {
+                        encrypt: {
+                            bsonType: string;
+                            algorithm: string;
+                            keyId: string[];
+                        };
+                    };
+                    kpLiveEncryption: {
+                        encrypt: {
+                            bsonType: string;
+                            algorithm: string;
+                            keyId: string[];
+                        };
+                    };
+                };
+            };
+        };
+    };
+    "konplit.merchantcustomers": {
+        bsonType: string;
+        properties: {
+            email: {
+                encrypt: {
+                    bsonType: string;
+                    algorithm: string;
+                    keyId: string[];
+                };
+            };
+            phone: {
+                encrypt: {
+                    bsonType: string;
+                    algorithm: string;
+                    keyId: string[];
+                };
+            };
+            publicKey: {
+                encrypt: {
+                    bsonType: string;
+                    algorithm: string;
+                    keyId: string[];
+                };
+            };
+        };
+    };
+    "konplit.blacklistedcards": {
+        bsonType: string;
+        properties: {
+            card_pan: {
+                encrypt: {
+                    bsonType: string;
+                    algorithm: string;
+                    keyId: string[];
+                };
+            };
+            card_expiry_date: {
+                encrypt: {
+                    bsonType: string;
+                    algorithm: string;
+                    keyId: string[];
+                };
+            };
+            card_holder_name: {
+                encrypt: {
+                    bsonType: string;
+                    algorithm: string;
+                    keyId: string[];
+                };
+            };
+        };
+    };
+    "konplit.subaccounts": {
+        bsonType: string;
+        properties: {
+            account_number: {
+                encrypt: {
+                    bsonType: string;
+                    algorithm: string;
+                    keyId: string[];
+                };
+            };
+        };
+    };
+    "konplit.cards": {
+        bsonType: string;
+        properties: {
+            expiry_year: {
+                encrypt: {
+                    bsonType: string;
+                    algorithm: string;
+                    keyId: string[];
+                };
+            };
+            expiry_month: {
+                encrypt: {
+                    bsonType: string;
+                    algorithm: string;
+                    keyId: string[];
+                };
+            };
+            card_pan: {
+                encrypt: {
+                    bsonType: string;
+                    algorithm: string;
+                    keyId: string[];
+                };
+            };
+            card_holder: {
+                encrypt: {
+                    bsonType: string;
+                    algorithm: string;
+                    keyId: string[];
+                };
+            };
+            token_expir_date: {
+                encrypt: {
+                    bsonType: string;
+                    algorithm: string;
+                    keyId: string[];
+                };
+            };
+        };
+    };
+};
+export { schemaDefinition };

package/build/Schema/CFLESCHEMA.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaDefinition = void 0;
+const schemaDefinition = (_key) => {
+    const schema = {
+        "konplit.merchantbusinesses": {
+            bsonType: 'object',
+            properties: {
+                keys: {
+                    bsonType: 'object',
+                    properties: {
+                        kpLivePrivate: {
+                            encrypt: {
+                                bsonType: 'string',
+                                algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic',
+                                keyId: [_key]
+                            }
+                        },
+                        kpTestPrivate: {
+                            encrypt: {
+                                bsonType: 'string',
+                                algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic',
+                                keyId: [_key]
+                            }
+                        },
+                        kpLiveEncryption: {
+                            encrypt: {
+                                bsonType: 'string',
+                                algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic',
+                                keyId: [_key]
+                            }
+                        },
+                    },
+                },
+            }
+        },
+        "konplit.merchantcustomers": {
+            bsonType: 'object',
+            properties: {
+                email: {
+                    encrypt: {
+                        bsonType: 'string',
+                        algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic',
+                        keyId: [_key]
+                    }
+                },
+                phone: {
+                    encrypt: {
+                        bsonType: 'string',
+                        algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic',
+                        keyId: [_key]
+                    }
+                },
+                publicKey: {
+                    encrypt: {
+                        bsonType: 'string',
+                        algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic',
+                        keyId: [_key]
+                    }
+                },
+            }
+        },
+        "konplit.blacklistedcards": {
+            bsonType: 'object',
+            properties: {
+                card_pan: {
+                    encrypt: {
+                        bsonType: 'string',
+                        algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic',
+                        keyId: [_key]
+                    }
+                },
+                card_expiry_date: {
+                    encrypt: {
+                        bsonType: 'string',
+                        algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic',
+                        keyId: [_key]
+                    }
+                },
+                card_holder_name: {
+                    encrypt: {
+                        bsonType: 'string',
+                        algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic',
+                        keyId: [_key]
+                    }
+                },
+            }
+        },
+        "konplit.subaccounts": {
+            bsonType: 'object',
+            properties: {
+                account_number: {
+                    encrypt: {
+                        bsonType: 'string',
+                        algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic',
+                        keyId: [_key]
+                    }
+                },
+            }
+        },
+        "konplit.cards": {
+            bsonType: 'object',
+            properties: {
+                expiry_year: {
+                    encrypt: {
+                        bsonType: 'string',
+                        algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic',
+                        keyId: [_key]
+                    }
+                },
+                expiry_month: {
+                    encrypt: {
+                        bsonType: 'string',
+                        algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic',
+                        keyId: [_key]
+                    }
+                },
+                card_pan: {
+                    encrypt: {
+                        bsonType: 'string',
+                        algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic',
+                        keyId: [_key]
+                    }
+                },
+                card_holder: {
+                    encrypt: {
+                        bsonType: 'string',
+                        algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic',
+                        keyId: [_key]
+                    }
+                },
+                token_expir_date: {
+                    encrypt: {
+                        bsonType: 'string',
+                        algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic',
+                        keyId: [_key]
+                    }
+                }
+            }
+        },
+    };
+    return schema;
+};
+exports.schemaDefinition = schemaDefinition;

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/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;
+        }[];
+    };
+}