@konplit-services/common 1.0.1

package/build/middlewares/permission.js

@@ -0,0 +1,46 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasPermission = void 0;
+const forbidden_error_1 = require("../errors/forbidden-error");
+const notAuthorized_1 = require("../errors/notAuthorized");
+const error_codes_1 = require("../helper/errorCodes/error-codes");
+const language_1 = require("../helper/lang/language");
+const base_1 = require("../redis/base");
+const constants_1 = require("../redis/constants");
+const hasPermission = (permissionCode) => {
+    return (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+        //comment
+        if (!req.currentUser) {
+            throw new notAuthorized_1.NotAuthorizedError(language_1.lang.not_authorized, error_codes_1.error_codes.INVALID_AUTHORIZATION);
+        }
+        const user = req.currentUser;
+        try {
+            let permissions = [];
+            const perm = yield base_1.redisWrapper.get((0, constants_1.getPermissions)(user.id));
+            if (!perm) {
+                throw new notAuthorized_1.NotAuthorizedError(language_1.lang.not_authorized, error_codes_1.error_codes.INVALID_AUTHORIZATION);
+            }
+            permissions = JSON.parse(perm);
+            if (!permissions.includes(permissionCode)) {
+                throw new forbidden_error_1.ForbiddenError(language_1.lang.forbidden, error_codes_1.error_codes.INVALID_FORBIDDEN);
+            }
+            return next();
+        }
+        catch (error) {
+            console.log("====================================");
+            console.log("From Permission Authorization", error);
+            console.log("====================================");
+            throw new notAuthorized_1.NotAuthorizedError(language_1.lang.not_authorized, error_codes_1.error_codes.INVALID_AUTHORIZATION);
+        }
+    });
+};
+exports.hasPermission = hasPermission;

package/build/middlewares/require-auth.d.ts

@@ -0,0 +1,2 @@
+import { NextFunction, Request, Response } from "express";
+export declare const requireAuth: (req: Request, res: Response, next: NextFunction) => void;

package/build/middlewares/require-auth.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireAuth = void 0;
+const notAuthorized_1 = require("../errors/notAuthorized");
+const language_1 = require("../helper/lang/language");
+const error_codes_1 = require("../helper/errorCodes/error-codes");
+const requireAuth = (req, res, next) => {
+    if (!req.currentUser) {
+        throw new notAuthorized_1.NotAuthorizedError(language_1.lang.not_authorized, error_codes_1.error_codes.INVALID_AUTHORIZATION);
+    }
+    next();
+};
+exports.requireAuth = requireAuth;

package/build/middlewares/validate-request.d.ts

@@ -0,0 +1,2 @@
+import { NextFunction, Request, Response } from "express";
+export declare const validateRequest: (req: Request, res: Response, next: NextFunction) => void;

package/build/middlewares/validate-request.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRequest = void 0;
+const express_validator_1 = require("express-validator");
+const request_validation_error_1 = require("../errors/request-validation-error");
+const validateRequest = (req, res, next) => {
+    const errros = (0, express_validator_1.validationResult)(req);
+    if (!errros.isEmpty()) {
+        throw new request_validation_error_1.RequestValidationError(errros.array());
+    }
+    next();
+};
+exports.validateRequest = validateRequest;

package/build/redis/base/index.d.ts

@@ -0,0 +1,13 @@
+import Redis from "ioredis";
+declare class RedisWrapper {
+    private _client?;
+    get client(): Redis;
+    connect(host: string, port: number, username?: string, password?: string): Promise<void>;
+    set(key: string, value: string, expiryInSeconds?: number): Promise<void>;
+    get(key: string): Promise<string | null>;
+    revokeToken(token: string, expiryTime: number): Promise<void>;
+    isTokenRevoked(token: string): Promise<boolean>;
+    del(key: string): Promise<void>;
+}
+declare const redisWrapper: RedisWrapper;
+export { redisWrapper };

package/build/redis/base/index.js

@@ -0,0 +1,104 @@
+"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.redisWrapper = void 0;
+const ioredis_1 = __importDefault(require("ioredis"));
+class RedisWrapper {
+    get client() {
+        if (!this._client) {
+            throw new Error("You have to initialize Redis first");
+        }
+        return this._client;
+    }
+    connect(host, port, username, password) {
+        const options = {
+            host,
+            port,
+            username,
+            password,
+        };
+        this._client = new ioredis_1.default(options);
+        return new Promise((resolve, reject) => {
+            this._client.on("connect", () => {
+                console.log("Successfully connected to Redis");
+                resolve();
+            });
+            this._client.on("error", (err) => {
+                console.error("Error connecting to Redis", err);
+                reject(err);
+            });
+        });
+    }
+    set(key, value, expiryInSeconds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                this.client.set(key, value, (err) => {
+                    if (err) {
+                        return reject(err);
+                    }
+                    if (expiryInSeconds) {
+                        this.client.expire(key, expiryInSeconds, (expireErr) => {
+                            if (expireErr) {
+                                return reject(expireErr);
+                            }
+                            resolve();
+                        });
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        });
+    }
+    get(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                this.client.get(key, (err, data) => {
+                    if (err) {
+                        return reject(err);
+                    }
+                    resolve(data !== null && data !== void 0 ? data : null); // Ensure resolve gets string or null
+                });
+            });
+        });
+    }
+    revokeToken(token, expiryTime) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.set(token, "revoked", expiryTime);
+        });
+    }
+    isTokenRevoked(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const value = yield this.get(token);
+            return value === "revoked";
+        });
+    }
+    del(key) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            (_a = this._client) === null || _a === void 0 ? void 0 : _a.sendCommand;
+            return new Promise((resolve, reject) => {
+                this.client.del(key, (err) => {
+                    if (err) {
+                        return reject(err);
+                    }
+                    resolve();
+                });
+            });
+        });
+    }
+}
+const redisWrapper = new RedisWrapper();
+exports.redisWrapper = redisWrapper;

package/build/redis/constants/index.d.ts

@@ -0,0 +1,5 @@
+export declare const REDIS_REPOSITORY = "RedisRepository";
+export declare const getPermissions: (id: string) => string;
+export declare const setPermissions: (id: string) => string;
+export declare const checkRevokedToken: (id: string, token: string) => string;
+export declare const setsetRevokedToken: (id: string, token: string) => string;

package/build/redis/constants/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setsetRevokedToken = exports.checkRevokedToken = exports.setPermissions = exports.getPermissions = exports.REDIS_REPOSITORY = void 0;
+exports.REDIS_REPOSITORY = "RedisRepository";
+const getPermissions = (id) => `${id}-permission`;
+exports.getPermissions = getPermissions;
+const setPermissions = (id) => `${id}-permission`;
+exports.setPermissions = setPermissions;
+const checkRevokedToken = (id, token) => `${id}-{token}`;
+exports.checkRevokedToken = checkRevokedToken;
+const setsetRevokedToken = (id, token) => `${id}-{token}`;
+exports.setsetRevokedToken = setsetRevokedToken;

package/build/repository/interface/baseRepository.d.ts

@@ -0,0 +1,9 @@
+/**
+ * IRepository interface extends the IWrite and IRead interfaces, providing a combined set of methods for CRUD operations on a data source.
+ * This interface serves as a unified contract for interacting with repositories.
+ *
+ * @template T The type of data managed by repositories implementing this interface.
+ */
+import { IWrite, IRead } from "./based";
+export interface IRepository<T> extends IWrite<T>, IRead<T> {
+}

package/build/repository/interface/baseRepository.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * IRepository interface extends the IWrite and IRead interfaces, providing a combined set of methods for CRUD operations on a data source.
+ * This interface serves as a unified contract for interacting with repositories.
+ *
+ * @template T The type of data managed by repositories implementing this interface.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/repository/interface/based.d.ts

@@ -0,0 +1,9 @@
+export interface IWrite<T> {
+    create(item: T, session?: any): Promise<T>;
+    update(id: string, item: T, filter?: any, session?: any): Promise<T | null>;
+    delete(id: string, filter?: any, session?: any): Promise<T | boolean | null>;
+}
+export interface IRead<T> {
+    find(item: T, filter?: any, session?: any): Promise<T[]>;
+    findOne(id: string, filter?: any, session?: any): Promise<T | null>;
+}

package/build/repository/interface/based.js

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

package/build/services/Jwt.d.ts

@@ -0,0 +1,17 @@
+export declare enum JWTType {
+    REFRESH = "REFRESH",
+    ACCESS = "ACCESS"
+}
+export interface JWT_Data {
+    id: string;
+    email: string;
+    role: string;
+    type: JWTType;
+    accountId?: string;
+    iat?: string;
+    exp?: number;
+}
+export declare class JWT {
+    static getToken(data: JWT_Data): Promise<string>;
+    static verifyToken(token: string): Promise<JWT_Data>;
+}

package/build/services/Jwt.js

@@ -0,0 +1,44 @@
+"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;
+class JWT {
+    static getToken(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token = (yield signAsync(data, secret));
+            return token;
+        });
+    }
+    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);
+                });
+            });
+        });
+    }
+}
+exports.JWT = JWT;

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

@@ -0,0 +1,14 @@
+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";
+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;
+}

package/build/services/base.service.js

@@ -0,0 +1,20 @@
+"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");
+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;
+    }
+}
+exports.Service = Service;

package/build/services/mailersend.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+export interface PersonalizationEntry {
+    email: string;
+    data: Record<string, any>;
+}
+export interface EmailData {
+    to: string;
+    subject: string;
+    templateId?: string;
+    personalization?: PersonalizationEntry[];
+    pdf?: {
+        file: Buffer;
+        fileName: string;
+    };
+    sendAt?: number;
+}
+export declare class EmailService {
+    private mailerSend;
+    constructor(apiKey: string);
+    /**
+     *
+     * @param data the send mail data
+     */
+    sendEmail(data: EmailData, send_email: string, sender_name: string, recipient_name?: string): Promise<void>;
+}

package/build/services/mailersend.js

@@ -0,0 +1,56 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailService = void 0;
+const mailersend_1 = require("mailersend");
+class EmailService {
+    constructor(apiKey) {
+        this.mailerSend = new mailersend_1.MailerSend({
+            apiKey,
+        });
+    }
+    /**
+     *
+     * @param data the send mail data
+     */
+    sendEmail(data, send_email, sender_name, recipient_name = "") {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sentFrom = new mailersend_1.Sender(send_email, sender_name);
+            const recipients = [new mailersend_1.Recipient(data.to, recipient_name)];
+            const emailParams = new mailersend_1.EmailParams()
+                .setFrom(sentFrom)
+                .setTo(recipients)
+                .setReplyTo(sentFrom)
+                .setSubject(data.subject);
+            if (data.templateId) {
+                emailParams.setTemplateId(data.templateId);
+                if (data.personalization) {
+                    const personalizationArray = data.personalization.map(entry => ({
+                        email: entry.email,
+                        data: entry.data,
+                    }));
+                    emailParams.setPersonalization(personalizationArray);
+                }
+            }
+            if (data.pdf) {
+                const pdfAttachment = [
+                    new mailersend_1.Attachment(data.pdf.file.toString('base64'), data.pdf.fileName, "attachment")
+                ];
+                emailParams.setAttachments(pdfAttachment);
+            }
+            if (data.sendAt) {
+                emailParams.setSendAt(new Date(data.sendAt * 1000).getTime());
+            }
+            yield this.mailerSend.email.send(emailParams);
+        });
+    }
+}
+exports.EmailService = EmailService;

package/build/util/jwt.validation.d.ts

@@ -0,0 +1 @@
+export declare const isJwt: (token: string) => boolean;

package/build/util/jwt.validation.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isJwt = void 0;
+function isBase64Url(str) {
+    const base64urlRegex = /^[A-Za-z0-9_-]+$/;
+    return base64urlRegex.test(str);
+}
+const isJwt = (token) => {
+    const parts = token.split(".");
+    if (parts.length !== 3) {
+        return false;
+    }
+    const [header, payload, signature] = parts;
+    if (!isBase64Url(header) ||
+        !isBase64Url(payload) ||
+        !isBase64Url(signature)) {
+        return false;
+    }
+    try {
+        const decodedHeader = JSON.parse(Buffer.from(header, "base64url").toString("utf8"));
+        return decodedHeader.typ === "JWT";
+    }
+    catch (error) {
+        return false;
+    }
+};
+exports.isJwt = isJwt;

package/build/util/lib/nats/nat-error-codes.d.ts

@@ -0,0 +1,4 @@
+export declare const NATS_ERROR: {
+    STREAM_NOT_FOUND: number;
+    CONSUMER_NOT_FOUND: number;
+};

package/build/util/lib/nats/nat-error-codes.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NATS_ERROR = void 0;
+exports.NATS_ERROR = {
+    STREAM_NOT_FOUND: 10059,
+    CONSUMER_NOT_FOUND: 10014,
+};

package/build/util/parse-query-string.d.ts

@@ -0,0 +1,4 @@
+declare const parseQueryToStrings: (query: any) => {
+    [key: string]: string | undefined;
+};
+export { parseQueryToStrings };

package/build/util/parse-query-string.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseQueryToStrings = void 0;
+const parseQueryToStrings = (query) => {
+    const parsedQuery = {};
+    for (const key in query) {
+        if (query.hasOwnProperty(key)) {
+            const value = query[key];
+            if (typeof value === "string") {
+                parsedQuery[key] = value;
+            }
+            else if (Array.isArray(value)) {
+                parsedQuery[key] = value.join(",");
+            }
+            else if (value !== undefined) {
+                parsedQuery[key] = String(value);
+            }
+        }
+    }
+    return parsedQuery;
+};
+exports.parseQueryToStrings = parseQueryToStrings;

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@konplit-services/common",
+  "version": "1.0.1",
+  "description": "",
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "private": false,
+  "files": [
+    "build/**/*"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "pub": "git add . && git commit -m \"updates\" && npm version patch && npm run build && npm publish --access public"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "trash-cli": "^5.0.0",
+    "typescript": "^4.7.4"
+  },
+  "dependencies": {
+    "@types/cookie-session": "^2.0.45",
+    "@types/express": "^4.17.13",
+    "@types/jsonwebtoken": "^8.5.8",
+    "@types/node": "^18.6.1",
+    "@types/pug": "^2.0.7",
+    "cookie-session": "^2.0.0",
+    "express": "^4.18.1",
+    "express-validator": "^6.14.2",
+    "ioredis": "^5.4.1",
+    "jsonwebtoken": "^8.5.1",
+    "mailersend": "^2.0.5",
+    "mongoose": "^6.9.2",
+    "nats": "^2.25.0",
+    "node-ipinfo": "^3.5.0",
+    "pug": "^3.0.2",
+    "puppeteer": "^21.3.6",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^4.8.4"
+  },
+  "engines": {
+    "node": "v18.20.1",
+    "npm": "8.1.0"
+  }
+}