@modernlock/common 1.0.2

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

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

package/build/errors/auth-error.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthenticationError = void 0;
+const custom_error_1 = require("./custom-error");
+class AuthenticationError extends custom_error_1.CustomError {
+    constructor() {
+        super("Not Authenticated");
+        this.statusCode = 401;
+        Object.setPrototypeOf(this, AuthenticationError.prototype);
+    }
+    ;
+    serializeErrors() {
+        return [{ message: "Not Authenticated" }];
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+;

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

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

package/build/errors/authorization-error.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthorizationError = void 0;
+const custom_error_1 = require("./custom-error");
+class AuthorizationError extends custom_error_1.CustomError {
+    constructor() {
+        super("Not Authorized to perform this operation");
+        this.statusCode = 403;
+        Object.setPrototypeOf(this, AuthorizationError.prototype);
+    }
+    ;
+    serializeErrors() {
+        return [{ message: "Not Authorized to perform this operation" }];
+    }
+}
+exports.AuthorizationError = AuthorizationError;
+;

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

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

package/build/errors/custom-error.js

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

package/build/errors/email-exist-error.d.ts

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

package/build/errors/email-exist-error.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailExistsError = void 0;
+const custom_error_1 = require("./custom-error");
+class EmailExistsError extends custom_error_1.CustomError {
+    constructor() {
+        super("Email already exists");
+        this.statusCode = 400;
+        Object.setPrototypeOf(this, EmailExistsError.prototype);
+    }
+    ;
+    serializeErrors() {
+        return [{ message: 'Email already exists' }];
+    }
+}
+exports.EmailExistsError = EmailExistsError;
+;

package/build/errors/file-not-exist-error.d.ts

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

package/build/errors/file-not-exist-error.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileNotExistError = void 0;
+const custom_error_1 = require("./custom-error");
+class FileNotExistError extends custom_error_1.CustomError {
+    constructor() {
+        super('Please enter a file');
+        this.statusCode = 400;
+        Object.setPrototypeOf(this, FileNotExistError.prototype);
+    }
+    ;
+    serializeErrors() {
+        return [{ message: 'Please enter a file' }];
+    }
+}
+exports.FileNotExistError = FileNotExistError;
+;

package/build/errors/internal-server-error.d.ts

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

package/build/errors/internal-server-error.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalServerError = void 0;
+const custom_error_1 = require("./custom-error");
+class InternalServerError extends custom_error_1.CustomError {
+    constructor() {
+        super("Internal server error");
+        this.statusCode = 500;
+        Object.setPrototypeOf(this, InternalServerError.prototype);
+    }
+    ;
+    serializeErrors() {
+        return [{ message: this.message }];
+    }
+}
+exports.InternalServerError = InternalServerError;
+;

package/build/errors/no-key-assigned-error.d.ts

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

package/build/errors/no-key-assigned-error.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoKeyAssignedError = void 0;
+const custom_error_1 = require("./custom-error");
+class NoKeyAssignedError extends custom_error_1.CustomError {
+    constructor() {
+        super("No key assigned error");
+        this.statusCode = 400;
+        Object.setPrototypeOf(this, NoKeyAssignedError.prototype);
+    }
+    ;
+    serializeErrors() {
+        return [{ message: this.message }];
+    }
+}
+exports.NoKeyAssignedError = NoKeyAssignedError;
+;

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

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

package/build/errors/not-found-error.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundError = void 0;
+const custom_error_1 = require("./custom-error");
+class NotFoundError extends custom_error_1.CustomError {
+    constructor() {
+        super("Route not found");
+        this.statusCode = 404;
+        Object.setPrototypeOf(this, NotFoundError.prototype);
+    }
+    ;
+    serializeErrors() {
+        return [{ message: "Not found error" }];
+    }
+}
+exports.NotFoundError = NotFoundError;

package/build/errors/not-primary-email-error.d.ts

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

package/build/errors/not-primary-email-error.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotPrimaryEmailError = void 0;
+const custom_error_1 = require("./custom-error");
+class NotPrimaryEmailError extends custom_error_1.CustomError {
+    constructor() {
+        super("Please use the primary email to login!");
+        this.statusCode = 400;
+        Object.setPrototypeOf(this, NotPrimaryEmailError.prototype);
+    }
+    ;
+    serializeErrors() {
+        return [{ message: "Please use the primary email to login!" }];
+    }
+}
+exports.NotPrimaryEmailError = NotPrimaryEmailError;
+;

package/build/errors/password-incorrect-error.d.ts

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

package/build/errors/password-incorrect-error.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PasswordIncorrectError = void 0;
+const custom_error_1 = require("./custom-error");
+class PasswordIncorrectError extends custom_error_1.CustomError {
+    constructor() {
+        super("Password incorrect!");
+        this.statusCode = 400;
+        Object.setPrototypeOf(this, PasswordIncorrectError.prototype);
+    }
+    ;
+    serializeErrors() {
+        return [{ message: "Password incorrect!" }];
+    }
+}
+exports.PasswordIncorrectError = PasswordIncorrectError;
+;

package/build/errors/property-not-provided.d.ts

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

package/build/errors/property-not-provided.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyNotProvided = void 0;
+const custom_error_1 = require("./custom-error");
+class PropertyNotProvided extends custom_error_1.CustomError {
+    constructor() {
+        super("Property not provided");
+        this.statusCode = 400;
+        Object.setPrototypeOf(this, PropertyNotProvided.prototype);
+    }
+    ;
+    serializeErrors() {
+        return [{ message: 'Property not provided' }];
+    }
+}
+exports.PropertyNotProvided = PropertyNotProvided;
+;

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

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

package/build/errors/user-not-found-error.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserNotFoundError = void 0;
+const custom_error_1 = require("./custom-error");
+class UserNotFoundError extends custom_error_1.CustomError {
+    constructor() {
+        super("User not found, please signup and try again later!");
+        this.statusCode = 400;
+        Object.setPrototypeOf(this, UserNotFoundError.prototype);
+    }
+    ;
+    serializeErrors() {
+        return [{ message: "User not found, please signup and try again later!" }];
+    }
+}
+exports.UserNotFoundError = UserNotFoundError;
+;

package/build/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./errors/custom-error";
+export * from "./errors/internal-server-error";
+export * from "./errors/not-found-error";
+export * from "./errors/auth-error";
+export * from "./errors/email-exist-error";
+export * from "./errors/password-incorrect-error";
+export * from "./errors/user-not-found-error";
+export * from "./errors/not-primary-email-error";
+export * from "./errors/no-key-assigned-error";
+export * from "./errors/property-not-provided";
+export * from "./middlewares/checkAuth";
+export * from "./middlewares/error-handler";
+export * from "./middlewares/session";
+export * from "./utils/jwtEncryption";
+export * from "./utils/logger";

package/build/index.js

@@ -0,0 +1,31 @@
+"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("./errors/custom-error"), exports);
+__exportStar(require("./errors/internal-server-error"), exports);
+__exportStar(require("./errors/not-found-error"), exports);
+__exportStar(require("./errors/auth-error"), exports);
+__exportStar(require("./errors/email-exist-error"), exports);
+__exportStar(require("./errors/password-incorrect-error"), exports);
+__exportStar(require("./errors/user-not-found-error"), exports);
+__exportStar(require("./errors/not-primary-email-error"), exports);
+__exportStar(require("./errors/no-key-assigned-error"), exports);
+__exportStar(require("./errors/property-not-provided"), exports);
+__exportStar(require("./middlewares/checkAuth"), exports);
+__exportStar(require("./middlewares/error-handler"), exports);
+__exportStar(require("./middlewares/session"), exports);
+__exportStar(require("./utils/jwtEncryption"), exports);
+__exportStar(require("./utils/logger"), exports);

package/build/middlewares/checkAuth.d.ts

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

package/build/middlewares/checkAuth.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authenticateToken = void 0;
+const auth_error_1 = require("../errors/auth-error");
+const jwtEncryption_1 = require("../utils/jwtEncryption");
+const authenticateToken = (req, res, next) => {
+    const { token } = req.session || {};
+    if (!token)
+        throw new auth_error_1.AuthenticationError();
+    const user = (0, jwtEncryption_1.jwtDecrypt)(token);
+    if (!user)
+        throw new auth_error_1.AuthenticationError();
+    else {
+        req.user = user;
+        next();
+    }
+};
+exports.authenticateToken = authenticateToken;

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

@@ -0,0 +1,2 @@
+import { Request, Response, NextFunction } from 'express';
+export declare const errorHandler: (err: Error, req: Request, res: Response, next: NextFunction) => Response<any, Record<string, any>> | undefined;

package/build/middlewares/error-handler.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorHandler = void 0;
+const custom_error_1 = require("../errors/custom-error");
+const errorHandler = (err, req, res, next) => {
+    if (err instanceof custom_error_1.CustomError) {
+        return res.status(err.statusCode).send({ errors: err.serializeErrors() });
+    }
+    res.status(400).send({
+        errors: [{ message: err.message ? err.message : "Something went wrong" }]
+    });
+};
+exports.errorHandler = errorHandler;

package/build/middlewares/session.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="qs" />
+/// <reference types="express" />
+export declare const session: () => import("express").RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
+export default session;

package/build/middlewares/session.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.session = void 0;
+const cookie_session_1 = __importDefault(require("cookie-session"));
+const session = () => {
+    return (0, cookie_session_1.default)({
+        secret: process.env.SESSION_SECRET,
+        name: "session",
+        signed: false,
+        secure: false,
+        sameSite: "lax",
+        httpOnly: true,
+        path: "/",
+        maxAge: 60 * 60 * 24 * 100 * 365,
+    });
+};
+exports.session = session;
+exports.default = exports.session;

package/build/utils/jwtEncryption.d.ts

@@ -0,0 +1,2 @@
+export declare function jwtEncrypt(data: Record<string, any>, expiration?: string): string;
+export declare function jwtDecrypt(token: string): any;

package/build/utils/jwtEncryption.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jwtDecrypt = exports.jwtEncrypt = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+function jwtEncrypt(data, expiration = "5m") {
+    if (!process.env.ACCESS_TOKEN)
+        throw new Error("ACCESS_TOKEN must be defined");
+    let accessToken = jsonwebtoken_1.default.sign(data, process.env.ACCESS_TOKEN, {
+        expiresIn: expiration,
+    });
+    return accessToken;
+}
+exports.jwtEncrypt = jwtEncrypt;
+function jwtDecrypt(token) {
+    if (!process.env.ACCESS_TOKEN)
+        throw new Error("ACCESS_TOKEN must be defined");
+    let data = null;
+    jsonwebtoken_1.default.verify(token, process.env.ACCESS_TOKEN, (err, user) => {
+        if (err)
+            return;
+        else
+            data = user;
+    });
+    return data;
+}
+exports.jwtDecrypt = jwtDecrypt;

package/build/utils/logger.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from 'winston';
+export declare const winstonLogger: (elasticsearchNode: string, name: string, level: string) => Logger;

package/build/utils/logger.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.winstonLogger = void 0;
+const winston_1 = __importDefault(require("winston"));
+const winston_elasticsearch_1 = require("winston-elasticsearch");
+const esTransformer = (logData) => {
+    return (0, winston_elasticsearch_1.ElasticsearchTransformer)(logData);
+};
+const winstonLogger = (elasticsearchNode, name, level) => {
+    const options = {
+        console: {
+            level,
+            handleExceptions: true,
+            json: false,
+            colorize: true
+        },
+        elasticsearch: {
+            level,
+            transformer: esTransformer,
+            clientOpts: {
+                node: elasticsearchNode,
+                log: level,
+                maxRetries: 2,
+                requestTimeout: 10000,
+                sniffOnStart: false
+            }
+        }
+    };
+    const esTransport = new winston_elasticsearch_1.ElasticsearchTransport(options.elasticsearch);
+    const logger = winston_1.default.createLogger({
+        exitOnError: false,
+        defaultMeta: { service: name },
+        transports: [new winston_1.default.transports.Console(options.console), esTransport]
+    });
+    return logger;
+};
+exports.winstonLogger = winstonLogger;

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@modernlock/common",
+  "version": "1.0.2",
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "files": [
+    "./build/**/*"
+  ],
+  "scripts": {
+    "clean": "del ./build/*",
+    "build": "npm run clean && tsc"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/amqplib": "0.10.1",
+    "@types/jsonwebtoken": "9.0.2",
+    "del-cli": "^5.0.0",
+    "typescript": "5.0.4",
+    "@types/cookie-session": "2.0.44",
+    "@types/express": "4.17.17"
+  },
+  "dependencies": {
+    "@elastic/elasticsearch": "^8.12.2",
+    "amqplib": "0.10.3",
+    "cookie-session": "2.0.0",
+    "express": "4.18.2",
+    "jsonwebtoken": "9.0.0",
+    "winston": "^3.12.0",
+    "winston-elasticsearch": "^0.18.0"
+  },
+  "description": ""
+}