@konplit-services/common 1.2.0 → 1.2.1

package/build/services/Jwt.d.ts

@@ -0,0 +1,44 @@
+import { SignOptions } from "jsonwebtoken";
+import { Usage, USER_TYPES } from "../helper";
+export declare enum JWTType {
+    REFRESH = "REFRESH",
+    ACCESS = "ACCESS"
+}
+export interface JWT_Data {
+    id: string;
+    email: string;
+    role: string;
+    type: JWTType;
+    userType: USER_TYPES;
+    accountId?: string;
+    adminId?: string;
+    iat?: number;
+    exp?: number;
+}
+export interface TRANSACTION_JWT_DATA {
+    id: string;
+    transactionRef: string;
+    accountId: string;
+    merchantId: string;
+    amount: number;
+    payee: "merchant" | "customer";
+    usage: Usage;
+    businessName: string;
+    iat?: string;
+    exp?: number;
+}
+export interface SUBSCRIPTION_JWT_DATA {
+    subscriptionId: string;
+    merchantId: string;
+    usage: Usage;
+    iat?: string;
+    exp?: number;
+}
+export declare class JWT {
+    static getToken(data: JWT_Data, options?: SignOptions): Promise<string>;
+    static verifyToken(token: string): Promise<JWT_Data>;
+    static getTransactionToken(data: TRANSACTION_JWT_DATA, options?: SignOptions): Promise<string>;
+    static verifyTransactionToken(token: string): Promise<TRANSACTION_JWT_DATA>;
+    static getSubscriptionToken(data: SUBSCRIPTION_JWT_DATA, options?: SignOptions): Promise<string>;
+    static verifySubscriptionToken(token: string): Promise<SUBSCRIPTION_JWT_DATA>;
+}

package/build/services/Jwt.js

@@ -0,0 +1,77 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JWT = exports.JWTType = void 0;
+const util_1 = require("util");
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const signAsync = (0, util_1.promisify)(jsonwebtoken_1.default.sign);
+var JWTType;
+(function (JWTType) {
+    JWTType["REFRESH"] = "REFRESH";
+    JWTType["ACCESS"] = "ACCESS";
+})(JWTType = exports.JWTType || (exports.JWTType = {}));
+const secret = process.env.JWT_KEY;
+const transactionSecret = process.env.TRANSACTION_JWT_KEY;
+const subscriptionSecret = process.env.SUBSCRIPTION_JWT_KEY;
+class JWT {
+    static getToken(data, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return signAsync(data, secret, options);
+        });
+    }
+    static verifyToken(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                jsonwebtoken_1.default.verify(token, secret, function (err, decoded) {
+                    if (err)
+                        reject(err);
+                    resolve(decoded);
+                });
+            });
+        });
+    }
+    static getTransactionToken(data, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return signAsync(data, transactionSecret, options);
+        });
+    }
+    static verifyTransactionToken(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                jsonwebtoken_1.default.verify(token, transactionSecret, function (err, decoded) {
+                    if (err)
+                        reject(err);
+                    resolve(decoded);
+                });
+            });
+        });
+    }
+    static getSubscriptionToken(data, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return signAsync(data, subscriptionSecret, options);
+        });
+    }
+    static verifySubscriptionToken(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                jsonwebtoken_1.default.verify(token, subscriptionSecret, function (err, decoded) {
+                    if (err)
+                        reject(err);
+                    resolve(decoded);
+                });
+            });
+        });
+    }
+}
+exports.JWT = JWT;

package/build/services/base.service.d.ts

@@ -0,0 +1,34 @@
+import { NotFoundError } from "../errors/not-found";
+import { ServiceNotAvailableError } from "../errors/service-not-available";
+import { BadRequestError } from "../errors/bad-request-error";
+import { ForbiddenError } from "../errors/forbidden-error";
+import { NotAuthorizedError } from "../errors/notAuthorized";
+import { AxiosRequestError } from "../errors/axios-request-error";
+import { JetStreamClient } from "nats";
+import { LOGACTIONS } from "../log-activities/actions";
+import { JWT_Data } from "./Jwt";
+import { EmailValidationTypes, SMSTYPE } from "../notification";
+import { GatewayError } from "../errors";
+interface User {
+    id?: string;
+    email?: string;
+    role?: string;
+    accountId: string;
+    [key: string]: any;
+}
+export declare class Service {
+    protected NotFoundError: typeof NotFoundError;
+    protected BadRequestError: typeof BadRequestError;
+    protected ForbiddenError: typeof ForbiddenError;
+    protected NotAuthorizedError: typeof NotAuthorizedError;
+    protected ServiceNotAvailableError: typeof ServiceNotAvailableError;
+    protected AxiosRequestError: typeof AxiosRequestError;
+    protected GatewayError: typeof GatewayError;
+    activityLog(client: JetStreamClient, user: Partial<User> | Partial<JWT_Data>, action: LOGACTIONS, data: any): void;
+    merchantOnlyLogs(client: JetStreamClient, user: Partial<User> | Partial<JWT_Data>, action: LOGACTIONS, data: any): void;
+    sendSMS(token: string, type: SMSTYPE, data: any, client: JetStreamClient): void;
+    sendEmail(emailtype: EmailValidationTypes, data: any, to: string, subject: string, client: JetStreamClient): void;
+    private sysType;
+    private emailType;
+}
+export {};

package/build/services/base.service.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Service = void 0;
+const not_found_1 = require("../errors/not-found");
+const service_not_available_1 = require("../errors/service-not-available");
+const bad_request_error_1 = require("../errors/bad-request-error");
+const forbidden_error_1 = require("../errors/forbidden-error");
+const notAuthorized_1 = require("../errors/notAuthorized");
+const axios_request_error_1 = require("../errors/axios-request-error");
+const merchant_log_publisher_1 = require("../events/publisher/merchant-log.publisher");
+const admin_log_publisher_1 = require("../events/publisher/admin-log.publisher");
+const helper_1 = require("../helper");
+const notification_1 = require("../notification");
+const app_configs_1 = require("../app.configs");
+const util_1 = require("../util");
+const email_publisher_1 = require("../events/publisher/email.publisher");
+const sms_publisher_1 = require("../events/publisher/sms.publisher");
+const errors_1 = require("../errors");
+class Service {
+    constructor() {
+        this.NotFoundError = not_found_1.NotFoundError;
+        this.BadRequestError = bad_request_error_1.BadRequestError;
+        this.ForbiddenError = forbidden_error_1.ForbiddenError;
+        this.NotAuthorizedError = notAuthorized_1.NotAuthorizedError;
+        this.ServiceNotAvailableError = service_not_available_1.ServiceNotAvailableError;
+        this.AxiosRequestError = axios_request_error_1.AxiosRequestError;
+        this.GatewayError = errors_1.GatewayError;
+    }
+    activityLog(client, user, action, data) {
+        if (Object.values(helper_1.AdminRoles).includes(user.role)) {
+            new admin_log_publisher_1.AdminLogActivityPublisher(client).publish({
+                id: user.id,
+                role: user.role,
+                email: user.email,
+                action,
+                data,
+            });
+        }
+        new merchant_log_publisher_1.MerchantLogActivityPublisher(client).publish({
+            id: user.id,
+            email: user.email,
+            role: user.role,
+            accountId: user.accountId,
+            action,
+            data,
+        });
+    }
+    merchantOnlyLogs(client, user, action, data) {
+        new merchant_log_publisher_1.MerchantLogActivityPublisher(client).publish({
+            id: user.id,
+            email: user.email,
+            role: user.role,
+            accountId: user.accountId,
+            action,
+            data,
+        });
+    }
+    sendSMS(token, type, data, client) {
+        const sms = this.sysType(type, token);
+        new sms_publisher_1.SMSCreatedPublisher(client).publish({
+            to: (0, util_1.formatPhoneNumber)(data.phone),
+            sms,
+            channel: "unknown",
+            type: "unknown",
+            from: "unknown",
+        });
+    }
+    sendEmail(emailtype, data, to, subject, client) {
+        const templateId = this.emailType(emailtype);
+        new email_publisher_1.EmailCreatedPublisher(client).publish({
+            to: to,
+            subject: subject,
+            templateId: templateId,
+            data: data,
+        });
+    }
+    sysType(type, token) {
+        let message;
+        switch (type) {
+            case notification_1.SMSTYPE.PHONE_VALIDATION:
+                message = (0, notification_1.phoneValidation)(token);
+                break;
+            case notification_1.SMSTYPE.TWO_FACTOR_VALIDATION:
+                message = (0, notification_1.twoFactor)(token);
+                break;
+            default:
+                throw new Error("Invalid sms type");
+        }
+        return message;
+    }
+    emailType(type) {
+        let templateId;
+        switch (type) {
+            case notification_1.EmailValidationTypes.EMAILVALIDATION:
+                templateId = app_configs_1.appConfigs.getEmailTemplates().verify_account;
+                break;
+            case notification_1.EmailValidationTypes.TWO_FACTOR_VALIDATION:
+                templateId = app_configs_1.appConfigs.getEmailTemplates().token;
+                break;
+            case notification_1.EmailValidationTypes.ACCOUNTVERIFIED:
+                templateId = app_configs_1.appConfigs.getEmailTemplates().account_verified;
+                break;
+            case notification_1.EmailValidationTypes.FORGETPASSWORD:
+                templateId = app_configs_1.appConfigs.getEmailTemplates().forgot_password;
+                break;
+            case notification_1.EmailValidationTypes.RESETPASSORD:
+                templateId = app_configs_1.appConfigs.getEmailTemplates().reset_password;
+                break;
+            case notification_1.EmailValidationTypes.TWO_FACTOR_AUTHS_CHANGE:
+                templateId = app_configs_1.appConfigs.getEmailTemplates().two_factor_auth_change;
+                break;
+            case notification_1.EmailValidationTypes.USER_ACCOUNT_CREATED:
+                templateId = app_configs_1.appConfigs.getEmailTemplates().user_account_created;
+                break;
+            case notification_1.EmailValidationTypes.USER_INVITED:
+                templateId = app_configs_1.appConfigs.getEmailTemplates().user_invited;
+                break;
+            default:
+                throw new Error("Invalid email type");
+        }
+        return templateId;
+    }
+}
+exports.Service = Service;

package/build/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Jwt";
+export * from "./base.service";

package/build/services/index.js

@@ -0,0 +1,18 @@
+"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("./Jwt"), exports);
+__exportStar(require("./base.service"), exports);

package/build/swagger/config.d.ts

@@ -0,0 +1,2 @@
+import { Application } from "express";
+export declare const configureSwagger: (app: Application, paths: string) => void;

package/build/swagger/config.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureSwagger = void 0;
+const swagger_jsdoc_1 = __importDefault(require("swagger-jsdoc"));
+const swagger_ui_express_1 = __importDefault(require("swagger-ui-express"));
+const configureSwagger = (app, paths) => {
+    const options = {
+        definition: {
+            openapi: "3.1.0",
+            info: {
+                title: "Valuepay Payment System Documentation",
+                version: "1.0.0",
+                description: "This is a complete API definition for the Valuepay payment system documented with Swagger UI",
+                license: {
+                    name: "IEC Code Components End-user licence agreement",
+                    url: "https://spdx.org/licenses/IEC-Code-Components-EULA.html",
+                },
+                contact: {
+                    name: "Valuepay",
+                    url: "https://valuepayng.com",
+                    email: "info@valuepay.ng",
+                },
+            },
+            servers: [
+                {
+                    url: "https://konplit.com",
+                },
+                {
+                    url: " https://valuepay.konplit.com",
+                },
+            ],
+            components: {
+                securitySchemes: {
+                    bearerAuth: {
+                        type: "http",
+                        scheme: "bearer",
+                        bearerFormat: "JWT",
+                    },
+                },
+            },
+            security: [
+                {
+                    bearerAuth: [],
+                },
+            ],
+        },
+        apis: [paths],
+    };
+    const swaggerSpec = (0, swagger_jsdoc_1.default)(options);
+    app.use("/api-docs", swagger_ui_express_1.default.serve, swagger_ui_express_1.default.setup(swaggerSpec, {
+        explorer: true,
+        // customCssUrl:
+        //   "https://cdn.jsdelivr.net/npm/swagger-ui-themes@3.0.0/themes/3.x/theme-newspaper.css",
+    }));
+    // ➕ Serve raw Swagger JSON
+    app.get("/api-json", (_, res) => {
+        res.setHeader("Content-Type", "application/json");
+        res.send(swaggerSpec);
+    });
+};
+exports.configureSwagger = configureSwagger;

package/build/swagger/routes/logs.d.ts

@@ -0,0 +1,130 @@
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     ActivityLog:
+ *       type: object
+ *       required:
+ *         - action
+ *         - data
+ *       properties:
+ *         id:
+ *           type: string
+ *           description: The auto-generated id of the role
+ *         accountId:
+ *           type: string
+ *           description: the account id optional
+ *         role:
+ *           type: string
+ *           description: The name of the role
+ *         email:
+ *           type: string
+ *           description: email of the person that carried out the action
+ *         data:
+ *           type: object
+ *           description: email of the person that carried out the action
+ *       example:
+ *         id: 36356-376363-33663
+ *         role: ADMIN
+ *         email: ibraheemyousouf@gmail.com
+ *         accountId: 123
+ *         data: {name: John, email: example@gmail.com}
+ *     ErrorResponse:
+ *       type: object
+ *       properties:
+ *         status:
+ *           type: string
+ *           enum: [FAILED]
+ *         errors:
+ *           type: array
+ *           items:
+ *             type: object
+ *             properties:
+ *               message:
+ *                 type: string
+ *               field:
+ *                 type: string
+ *               error_code:
+ *                 type: string
+ *               code:
+ *                 type: integer
+ *     SuccessResponse:
+ *       type: object
+ *       properties:
+ *         status:
+ *           type: string
+ *           enum: [Success]
+ *         data:
+ *           type: object
+ *         message:
+ *           type: string
+ *         code:
+ *           type: string
+ * securitySchemes:
+ *     type: http
+ *     scheme: bearer
+ *     bearerFormat: JWT
+ * tags:
+ *   name: Activity Logs
+ *   description: The Logs Activity managing API
+ * /v1/activityLogs/admins:
+ *   get:
+ *     summary: Get Admin Activity Logs
+ *     tags:  [Activity Logs]
+ *     security:
+ *       - bearerAuth: []
+ *     parameters:
+ *       - in: query
+ *         name: action
+ *         schema:
+ *           type: string
+ *         description: Filter logs by action
+ *       - in: query
+ *         name: email
+ *         schema:
+ *           type: string
+ *         description: Filter logs by email
+ *     responses:
+ *       '200':
+ *         description: Successful operation
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/SuccessResponse'
+ *       '400':
+ *         description: Invalid input
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ * /v1/activityLogs/merchants:
+ *   get:
+ *     summary: Get Merchant Activity Logs
+ *     tags: [Activity Logs]
+ *     security:
+ *       - bearerAuth: []
+ *     parameters:
+ *       - in: query
+ *         name: action
+ *         schema:
+ *           type: string
+ *         description: Filter logs by action
+ *       - in: query
+ *         name: email
+ *         schema:
+ *           type: string
+ *         description: Filter logs by email
+ *     responses:
+ *       '200':
+ *         description: Successful operation
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/SuccessResponse'
+ *       '400':
+ *         description: Invalid input
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ */

package/build/swagger/routes/logs.js

@@ -0,0 +1,131 @@
+"use strict";
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     ActivityLog:
+ *       type: object
+ *       required:
+ *         - action
+ *         - data
+ *       properties:
+ *         id:
+ *           type: string
+ *           description: The auto-generated id of the role
+ *         accountId:
+ *           type: string
+ *           description: the account id optional
+ *         role:
+ *           type: string
+ *           description: The name of the role
+ *         email:
+ *           type: string
+ *           description: email of the person that carried out the action
+ *         data:
+ *           type: object
+ *           description: email of the person that carried out the action
+ *       example:
+ *         id: 36356-376363-33663
+ *         role: ADMIN
+ *         email: ibraheemyousouf@gmail.com
+ *         accountId: 123
+ *         data: {name: John, email: example@gmail.com}
+ *     ErrorResponse:
+ *       type: object
+ *       properties:
+ *         status:
+ *           type: string
+ *           enum: [FAILED]
+ *         errors:
+ *           type: array
+ *           items:
+ *             type: object
+ *             properties:
+ *               message:
+ *                 type: string
+ *               field:
+ *                 type: string
+ *               error_code:
+ *                 type: string
+ *               code:
+ *                 type: integer
+ *     SuccessResponse:
+ *       type: object
+ *       properties:
+ *         status:
+ *           type: string
+ *           enum: [Success]
+ *         data:
+ *           type: object
+ *         message:
+ *           type: string
+ *         code:
+ *           type: string
+ * securitySchemes:
+ *     type: http
+ *     scheme: bearer
+ *     bearerFormat: JWT
+ * tags:
+ *   name: Activity Logs
+ *   description: The Logs Activity managing API
+ * /v1/activityLogs/admins:
+ *   get:
+ *     summary: Get Admin Activity Logs
+ *     tags:  [Activity Logs]
+ *     security:
+ *       - bearerAuth: []
+ *     parameters:
+ *       - in: query
+ *         name: action
+ *         schema:
+ *           type: string
+ *         description: Filter logs by action
+ *       - in: query
+ *         name: email
+ *         schema:
+ *           type: string
+ *         description: Filter logs by email
+ *     responses:
+ *       '200':
+ *         description: Successful operation
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/SuccessResponse'
+ *       '400':
+ *         description: Invalid input
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ * /v1/activityLogs/merchants:
+ *   get:
+ *     summary: Get Merchant Activity Logs
+ *     tags: [Activity Logs]
+ *     security:
+ *       - bearerAuth: []
+ *     parameters:
+ *       - in: query
+ *         name: action
+ *         schema:
+ *           type: string
+ *         description: Filter logs by action
+ *       - in: query
+ *         name: email
+ *         schema:
+ *           type: string
+ *         description: Filter logs by email
+ *     responses:
+ *       '200':
+ *         description: Successful operation
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/SuccessResponse'
+ *       '400':
+ *         description: Invalid input
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ */

package/build/util/format-phoneNumber.d.ts

@@ -0,0 +1 @@
+export declare const formatPhoneNumber: (value: string) => string;

package/build/util/format-phoneNumber.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPhoneNumber = void 0;
+//TODO: this endpoint does not format to only Nigerian phone numbers
+const formatPhoneNumber = (value) => {
+    let phone = "";
+    if (value.length === 13) {
+        phone = value;
+    }
+    else if (value.length === 14) {
+        phone = value.substring(1);
+    }
+    if (value.startsWith("0")) {
+        return `234${value.substring(1)}`;
+    }
+    return phone;
+};
+exports.formatPhoneNumber = formatPhoneNumber;

package/build/util/generate-id.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param alphabet Set of random strings to be used to generate IDs
+ * @param numberOfCharacters The number of characters to be returned
+ *
+ * This function takes in the number of characters to be returned.
+ * If the numberOfCharacters input is not provided, the default of 15 is returned.
+ */
+export declare const uniqueId: (alphabet?: string, numberOfCharacters?: number) => string;

package/build/util/generate-id.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniqueId = void 0;
+const nanoid_1 = require("nanoid");
+/**
+ * @param alphabet Set of random strings to be used to generate IDs
+ * @param numberOfCharacters The number of characters to be returned
+ *
+ * This function takes in the number of characters to be returned.
+ * If the numberOfCharacters input is not provided, the default of 15 is returned.
+ */
+const uniqueId = (alphabet = "0123456789", numberOfCharacters = 13) => {
+    const nanoid = (0, nanoid_1.customAlphabet)(alphabet, numberOfCharacters);
+    return `vp${nanoid()}`;
+};
+exports.uniqueId = uniqueId;