chg: refactor all api for async behaviour workflow for protocol layer

Author: wemakshaychavan

.gitignore

@@ -56,6 +56,7 @@ typings/
 
 # dotenv environment variables file
 .env
+*local.env
 
 # next.js build output
 .next

notifications/.babelrc

@@ -0,0 +1,5 @@
+{
+  "presets": [
+    "@babel/preset-env"
+  ]
+}

notifications/.eslintrc.js

@@ -0,0 +1,20 @@
+module.exports = {
+    env: {
+        es2021: true,
+        node: true,
+        mocha:true,
+    },
+    extends: 'eslint:recommended',
+    parserOptions: {
+        ecmaVersion: 13,
+        sourceType: 'module',
+    },
+    rules: {
+        indent: ['error', 4],
+        'linebreak-style': ['error', 'unix'],
+        quotes: ['error', 'single'],
+        semi: ['error', 'always'],
+        'no-unused-vars': ['error', { argsIgnorePattern: '^((req|res|next)$|_)' }],
+        'eol-last': ['error', 'always'],
+    },
+};

notifications/app/config/constant/httpStatusConstants.js

@@ -0,0 +1,12 @@
+module.exports = Object.freeze({
+    // Status Code
+    STATUS_CODE_GENERALIZED_SUCCESS: '200',
+    STATUS_CODE_GENERALIZED_ALREADY_EXISTS: '202',
+    STATUS_CODE_GENERALIZED_INVALID_REQUEST: '400',
+    STATUS_CODE_GENERALIZED_UNAUTHORIZED: '401',
+    STATUS_CODE_GENERALIZED_NOT_FOUND: '404',
+    STATUS_CODE_GENERALIZED_FAILED: '412',
+    STATUS_CODE_GENERALIZED_CONFIG_MISMATCH: '422',
+    STATUS_CODE_GENERALIZED_UPGRADE_REQUIRED: '426',
+    STATUS_CODE_GENERALIZED_SEQUELIZE_ERROR: '500'
+}); // freeze prevents changes by users

notifications/app/config/constant/notificationConstants.js

@@ -0,0 +1,10 @@
+module.exports = Object.freeze({
+    MOM_MENTION: 'MOM_MENTION',
+    TASK_ASSIGN: 'TASK_ASSIGN',
+    PROJECT_ASSIGN: 'PROJECT_ASSIGN',
+    COMMENT_MENTION: 'COMMENT_MENTION',
+    NEW_COMMENT: 'NEW_COMMENT',
+    TEAM_ASSIGN: 'TEAM_ASSIGN',
+    TASK_APPROVE_SUCCESS: 'TASK_APPROVE_SUCCESS',
+    TASK_APPROVE_FAIL: 'TASK_APPROVE_FAIL',
+}); 

notifications/app/config/emailTemplates/index.js

@@ -0,0 +1,6 @@
+module.exports = Object.freeze({
+    EXCEPTION_EMAIL: {
+        SUBJECT: '{{subject}}',
+        BODY: '{{{text}}}',
+    },
+}); // freeze prevents changes by users

notifications/app/config/env.config.js

@@ -0,0 +1,20 @@
+
+const nodeEnvironment = process.env.NODE_ENV || 'development';
+const projectBaseDirectory = global.__basedir;
+const appEnvironment = process.env.APP_ENV ?? 'local';
+
+if(appEnvironment === 'local') {
+    require('dotenv').config({
+        path: `${__dirname}/local.env`,
+    });
+}
+
+const environmentConfig = require('./environments/base');
+const mergedEnvironmentConfig = {
+    ...environmentConfig,
+    nodeEnvironment,
+    appEnvironment,
+    projectBaseDirectory,
+};
+Object.freeze(mergedEnvironmentConfig);
+exports.mergedEnvironmentConfig =  mergedEnvironmentConfig;

notifications/app/config/environments/base/env.base.js

@@ -0,0 +1,20 @@
+module.exports = {
+    appNamespace: process.env.BASE_APP_NAMESPACE ?? 'artifex-auth',
+    servicePort: process.env.BASE_APP_PORT ?? '3008',
+    mobileApplicationAllowedVersions: {
+        ios: {
+            minimumVersion: process.env.MOBILE_APP_IOS_MIN_ALLOWED_VERSION ?? '2.7.0',  // App needs to be forcefully upgraded to this version
+            optionalVersion: process.env.MOBILE_APP_IOS_MAX_ALLOWED_VERSION ?? '2.7.0', // App can be optionally upgraded to this version
+        },
+        android: {
+            minimumVersion: process.env.MOBILE_APP_ANDROID_MIN_ALLOWED_VERSION ?? '2.7.0',  // App needs to be forcefully upgraded to this version
+            optionalVersion: process.env.MOBILE_APP_ANDROID_MAX_ALLOWED_VERSION ?? '2.7.0', // App can be optionally upgraded to this version
+        }
+    },
+    intraServiceApiEndpoints: {
+        authService: process.env.INTRA_SERVICE_AUTH_SERVICE_URL,
+        pmService: process.env.INTRA_SERVICE_PROJECT_MANAGEMENT_URL,
+    },
+    jwtSecret:process.env.AUTH_ACCESS_JWT_SECRET,
+    appUrl:process.env.APP_URL
+};

notifications/app/config/environments/base/env.cors.js

@@ -0,0 +1,20 @@
+module.exports = {
+    'cors': {
+        'whitelistUrls': [
+            '*',
+            'http://localhost:3000',
+            'https://localhost:3000',
+            'https://artifex.com',
+            'http://artifex.com',
+            'https://staging.artifex.com',
+            'http://staging.artifex.com',
+            'http://dev.artifex.com',
+            'https://dev.artifex.com',
+            'https://artifex-auth-dev.wemotive.in',
+            'https://artifex-pm-dev.wemotive.in',
+            'https://artifex.artifex-dev.com:3000',
+            'https://auth.artifex-dev.com:3005'
+
+        ]
+    }
+};

notifications/app/config/environments/base/env.db.js

@@ -0,0 +1,8 @@
+module.exports = {
+    mongodb: {
+        username: process.env.MONGODB_DATABASE_USERNAME,
+        password: process.env.MONGODB_DATABASE_PASSWORD,
+        name: process.env.MONGODB_DATABASE_NAME,
+        host: process.env.MONGODB_DATABASE_HOST,
+    }
+};

notifications/app/config/environments/base/env.email.js

@@ -0,0 +1,19 @@
+module.exports = {
+    email: {
+        transport: {
+            host: process.env.SMTP_HOST,
+            port: process.env.SMTP_PORT,
+            auth: {
+                user: process.env.SMTP_AUTH_USERNAME,
+                pass: process.env.SMTP_AUTH_PASSWORD,
+            },
+        },
+        sender: process.env.SMTP_EMAIL_SENDER,
+        exceptionEmailRecipients: process.env.SMTP_EXCEPTION_EMAIL_RECIPIENTS,
+        templateDefaults: {
+            header: {
+                logoUrl: process.env.SMTP_EMAIL_TEMPLATE_HEADER_IMAGE_PATH,
+            },
+        },
+    },
+};

notifications/app/config/environments/base/index.js

@@ -0,0 +1,15 @@
+import baseConfig from './env.base';
+import corsConfig from './env.cors';
+import dbConfig from './env.db';
+const mailConfig = require('./env.email');
+
+
+const mergedEnvironmentConfig = {
+    ...baseConfig,
+    ...corsConfig,
+    ...dbConfig,
+    ...mailConfig
+};
+
+Object.freeze(mergedEnvironmentConfig);
+module.exports = mergedEnvironmentConfig;

notifications/app/init/database.init.js

@@ -0,0 +1,11 @@
+import mongoose from 'mongoose';
+import { mergedEnvironmentConfig } from '../config/env.config.js';
+
+const config = mergedEnvironmentConfig.mongodb;
+mongoose.connect(`${config.host}/${config.name}`,{
+    useNewUrlParser:true
+});
+
+mongoose.set('debug', (collectionName, method, query, doc) => {
+    console.log(`[MONGOOS]:${collectionName}.${method}`, JSON.stringify(query), doc);
+});

notifications/app/init/router.init.js

@@ -0,0 +1,31 @@
+import { Router } from 'express';
+import glob from 'glob';
+import cors from 'cors';
+import { mergedEnvironmentConfig as config } from '../config/env.config';
+
+const whitelist = config.cors.whitelistUrls;
+const corsOptionsDelegate = function (req, callback) {
+    let corsOptions = {credentials: true};
+    corsOptions['origin'] = (whitelist.indexOf(req.header('Origin')) !== -1);
+    corsOptions['exposedHeaders'] = 'set-cookie';
+    callback(null, corsOptions); // callback expects two parameters: error and optionsns
+};
+
+module.exports = () => glob
+    .sync('**/*.route.js', {
+        cwd: `${global.__basedir}/modules/`,
+    })
+    .map((filename) => {
+        // console.log(`Attempting to register router at: path ../modules/${filename} from relative path ${__dirname}`);
+        return require(`../modules/${filename}`);
+    })
+    .filter((currentRouter) => {
+        const isCurrentRouterValid = Object.getPrototypeOf(currentRouter) === Router;
+        return isCurrentRouterValid;
+    })
+    .reduce(
+        (rootRouter, router) => rootRouter.use(router, cors(corsOptionsDelegate)),
+        Router({
+            mergeParams: true,
+        })
+    );

notifications/app/lib/authentication/index.js

@@ -0,0 +1,5 @@
+export { default as JsonWebToken } from './json-web-token';
+export { default as Token } from './token';
+// export { default as passportMobileLocalStrategy } from './strategies/passport-mobile-local';
+// export { default as passportOTPLocalStrategy } from './strategies/passport-OTP-local';
+export { default as passportJwtStrategy } from './strategies/passport-jwt';

notifications/app/lib/authentication/json-web-token.js

@@ -0,0 +1,50 @@
+import jwt from 'jsonwebtoken';
+
+class JsonWebToken {
+    /**
+   *
+   * @param {*} options JWT options
+   */
+    constructor(options) {
+        this.options = options;
+    }
+
+    /**
+   * Sign JWT token
+   * @param {*} token Instance of Token class
+   */
+    sign(token) {
+        return new Promise((resolve, reject) => {
+            jwt.sign(
+                token.payload,
+                this.options.secret,
+                { expiresIn: token.exp },
+                function (err, token) {
+                    if (err) {
+                        reject(err);
+                    } else {
+                        resolve(token);
+                    }
+                }
+            );
+        });
+    }
+
+    /**
+   * Verify JWT token
+   * @param {} jwtToken JWT token in String format
+   */
+    verify(jwtToken) {
+        return new Promise((resolve, reject) => {
+            jwt.verify(jwtToken, this.options.secret, function (err, decoded) {
+                if (err) {
+                    reject(err);
+                } else {
+                    resolve(decoded);
+                }
+            });
+        });
+    }
+}
+
+export default JsonWebToken;

notifications/app/lib/authentication/strategies/passport-jwt.js

@@ -0,0 +1,76 @@
+import passportJWT from 'passport-jwt';
+import { UnauthenticatedError } from '../../errors';
+import MESSAGES from '../../utils/messages';
+import {mergedEnvironmentConfig} from '../../../config/env.config';
+const JwtStrategy = passportJWT.Strategy;
+import { HEADERS } from '../../utils/constants';
+var httpContext = require('express-http-context');
+let currentUserToken = '';
+const tokenExtractor = function (req) {
+    let token = null;
+    let tokenArray = [];
+
+    if (req) {
+        token = req.get(HEADERS.ACCESS_TOKEN);
+
+        if (!token) {
+            throw new UnauthenticatedError(
+                MESSAGES.LOGIN_ERROR_USER_ACCESS_TOKEN_INVALID
+            );
+        }
+
+        tokenArray = token.split(' ');
+    }
+    currentUserToken =tokenArray[1];
+    return tokenArray[1];
+};
+
+const opts = {
+    jwtFromRequest: tokenExtractor, //ExtractJwt.fromAuthHeaderAsBearerToken(),
+    secretOrKey: mergedEnvironmentConfig.jwtSecret,
+    passReqToCallback: true,
+};
+
+const passportJwtStrategy = new JwtStrategy(
+    opts,
+    async (req, jwtPayload, done) => {
+        try {
+            let user = {};
+
+            // if jwt payload contains user obj then its an inter service communication call
+            if (jwtPayload.user) {
+                user = jwtPayload.user;
+            } else if (jwtPayload.userId) {
+                //TODO: add db level auth check
+
+                // user = await User.findOne({
+                //   where: {
+                //     id: jwtPayload.userId
+                //   },
+                //   include: [{ model: UserOrganization, include: [{ model: Role }] }]
+                // });
+
+                if (!user) {
+                    throw new UnauthenticatedError(
+                        MESSAGES.LOGIN_ERROR_USER_ACCESS_TOKEN_INVALID
+                    );
+                } else if (user.enabled === false) {
+                    throw new UnauthenticatedError(
+                        MESSAGES.LOGIN_ERROR_USER_ACCOUNT_DEACTIVATED
+                    );
+                }
+
+
+                user = user.toJSON();
+            }
+            // httpContext.set('request.req.user.token',currentUserToken);
+            // httpContext.set('request.req.user.id',user.id);
+            user.currentUserToken = currentUserToken;
+            return done(null, user);
+        } catch (err) {
+            return done(err, null);
+        }
+    }
+);
+
+export default passportJwtStrategy;

notifications/app/lib/authentication/token.js

@@ -0,0 +1,29 @@
+class Token {
+    /**
+   *
+   * @param {*} payload token payload
+   * @param {*} exp     token expiry
+   */
+    constructor(payload, exp) {
+        this.payload = payload;
+        this.exp = exp;
+    }
+
+    setPayload(payload) {
+        this.payload = payload;
+    }
+
+    getPayload() {
+        return this.payload;
+    }
+
+    setExp(exp) {
+        this.exp = exp;
+    }
+
+    getExp() {
+        return this.exp;
+    }
+}
+
+export default Token;

notifications/app/lib/errors/bad-request-parameter.error.js

@@ -0,0 +1,11 @@
+import ERRORS from './errors';
+
+class BadRequestParameterError extends Error {
+    constructor(message = ERRORS.BAD_REQUEST_PARAMETER_ERROR.message) {
+        super(message);
+        this.name = ERRORS.BAD_REQUEST_PARAMETER_ERROR.name;
+        this.status = ERRORS.BAD_REQUEST_PARAMETER_ERROR.status;
+    }
+}
+
+export default BadRequestParameterError;