@go-mailer/jarvis 1.0.0 → 2.0.0

package/index.js

@@ -0,0 +1,5 @@
+const Authenticator = require('./lib/middlewares/auth')
+const HTTP = require('@go-mailer/jarvis/lib/middlewares/http')
+const { RequestLogger, ProcessLogger } = require('./lib/logger')
+const QueryBuilder = require('./lib/query')
+module.exports = { RequestLogger, ProcessLogger, Authenticator, HTTP, QueryBuilder }

package/lib/env.js

@@ -1,12 +1,10 @@
 require('dotenv').config()
 
 /** */
-class EnvVar {
-  fetch (var_name = '', is_required = false) {
-    const value = process.env[var_name]
-    if (is_required && !var_name) throw new Error(`Required EnvVar ${var_name} not found`)
-    return value
-  }
+const fetch = (var_name = '', is_required = false) => {
+  const value = process.env[var_name]
+  if (is_required && !value) throw new Error(`Required EnvVar ${var_name} not found`)
+  return value
 }
 
-module.exports = new EnvVar()
+module.exports = { fetch }

package/lib/middlewares/auth.js

@@ -1,116 +1,88 @@
 /**
  * User Authentication Middleware
  */
-const jwt = require("jsonwebtoken");
-const { verify_api_key } = require("../clients/iam");
-const RootService = require("../services/_root");
-const rootService = new RootService();
-const { JWT_ISSUER, JWT_SECRET, DEFAULT_TOKEN: GM_TOKEN } = require("../../.config");
-
-const { app_logger } = require("../utilities/logger");
-const logger = app_logger("Authentication Middleware");
-
-class Authentication {
-  async authenticate_user(request, response, next) {
-    try {
-      const { authorization } = request.headers;
-      if (!authorization) {
-        return next(rootService.process_failed_response("Unauthorized", 403));
-      }
 
-      const [, token] = authorization.split(" ");
-      if (!token) {
-        return next(rootService.process_failed_response("Unauthorized", 403));
-      }
+const jwt = require("jsonwebtoken");
+const Env = require('../env');
+const Errors = require('./errors');
+const { ProcessLogger } = require('../logger/index')
+const authLogger = new ProcessLogger('Authenticator')
+
+// env vars
+const ISSUER = Env.fetch('JWT_ISSUER', true)
+const SECRET = Env.fetch('JWT_SECRET', true)
+const IAM_URI = Env.fetch('IAM_SERVICE_URI', true)
+const DEFAULT_TOKEN = Env.fetch('DEFAULT_TOKEN', true)
+
+// helpers
+const extract_token = (headers) => {
+  const { authorization } = headers
+  if (!authorization) throw new Error('Unauthorized')
+
+  const [, token] = authorization.split(' ')
+  if (!token) throw new Error('Unauthorized')
+
+  return token
+}
 
-      if (token === GM_TOKEN) {
-        request.tenant_id = { $exists: true };
-        return next();
+const verify_key = async (key) => {
+  const { error, payload } = (
+    await axios.get(`${IAM_URI}/keys/verify/${key}`, {
+      headers: {
+        authorization: `Bearer ${DEFAULT_TOKEN}`
       }
+    })
+  ).data
 
-      const verified_data = await jwt.verify(token, JWT_SECRET, {
-        issuer: JWT_ISSUER,
-      });
+  if (error) throw new Error('Unauthorized')
 
-      const { tenant_id, is_admin } = verified_data;
-      request.tenant_id = tenant_id;
-      if (is_admin) process_request(request);
-
-      next();
-    } catch (e) {
-      logger.error(`[Auth Error] ${e.message}`);
-      next(rootService.process_failed_response("Unauthorized", 403));
-    }
-  }
+  return payload.org_id
 }
 
-const authenticate_api_key = async (request, response, next) => {
+// main
+const authenticate_user = async (request, response, next) => {
   try {
-    const { authorization } = request.headers;
-    if (!authorization) {
-      return next(rootService.process_failed_response("Unauthorized", 403));
+    const token = extract_token(request.headers)
+    if (token === DEFAULT_TOKEN) { // service level requests
+      request.is_service_request = true
+      return next()
     }
 
-    const [, api_key] = authorization.split(" ");
-    if (!api_key) {
-      return next(rootService.process_failed_response("Unauthorized", 403));
-    }
-
-    if (api_key === GM_TOKEN) {
-      request.tenant_id = request.body.tenant_id;
-      return next();
-    }
+    const { tenant_id, is_admin } = await jwt.verify(token, SECRET, { issuer: ISSUER })
+    request.is_admin = !!is_admin
+    request.tenant_id = tenant_id
 
-    const payload = await verify_api_key(api_key);
-    request.tenant_id = payload.org_id;
-    next();
+    next()
   } catch (e) {
-    logger.error(`${e.message}`, "authenticate_api_key");
-    next(rootService.process_failed_response("Unauthorized", 403));
+    authLogger.error(e, 'authenticate_user')
+    return response.status(403).json(Errors.UNAUTHORIZED)
   }
-};
-
-/** All requests not made from the 'admin console' must be scoped by tenant */
-const process_request = (request) => {
-  const { query, params, body } = request;
-  let tenant_id = { $exists: true };
-  if (query.tenant_id) tenant_id = query.tenant_id;
-  if (params.tenant_id) tenant_id = params.tenant_id;
-  if (body.tenant_id) tenant_id = body.tenant_id;
-
-  request.tenant_id = tenant_id;
-};
-
-const authenticate_user = async (request, __, next) => {
-  try {
-    const { authorization } = request.headers;
-    if (!authorization) {
-      return next(rootService.process_failed_response("Unauthorized", 403));
-    }
+}
 
-    const [, token] = authorization.split(" ");
-    if (!token) {
-      return next(rootService.process_failed_response("Unauthorized", 403));
+const api = () => {
+  const param_key = async (request, response, next) => {
+    try {
+      const { api_key: token} = request.params
+      request.tenant_id = await verify_key(token)
+      next()
+    } catch (e) {
+      authLogger.error(e, 'param_key')
+      return response.status(403).json(Errors.UNAUTHORIZED)
     }
+  }
 
-    if (token === GM_TOKEN) {
-      request.tenant_id = { $exists: true };
-      return next();
+  const default_key = async (request, response, next) => {
+    try {
+      const token = extract_token(request.headers)
+      request.tenant_id = await verify_key(token)
+      next()
+    } catch (e) {
+      authLogger.error(e, 'default_key')
+      return response.status(403).json(Errors.UNAUTHORIZED)
     }
-
-    const verified_data = await jwt.verify(token, JWT_SECRET, {
-      issuer: JWT_ISSUER,
-    });
-
-    const { tenant_id, is_admin } = verified_data;
-    request.tenant_id = tenant_id;
-    if (is_admin) process_request(request);
-
-    next();
-  } catch (e) {
-    logger.error(`[Auth Error] ${e.message}`);
-    next(rootService.process_failed_response("Unauthorized", 403));
   }
-};
 
-module.exports = { authenticate_api_key, authenticate_user };
+  return { default_key, param_key }
+}
+
+module.exports = { api, authenticate_user }

package/lib/middlewares/errors.js

@@ -0,0 +1,7 @@
+module.exports = {
+  UNAUTHORIZED: {
+    payload: null,
+    error: 'Unauthorized',
+    status_code: 403
+  }
+}

package/lib/middlewares/{request.js → http.js}

@@ -1,11 +1,9 @@
-/**
- * @author Oguntuberu Nathan O. <nateoguns.work@gmail.com>
-**/
-const { app_logger } = require('../utilities/logger')
-const logger = app_logger('HTTP Middleware')
+/** **/
+const { ProcessLogger } = require('@go-mailer/jarvis/lib/logger')
+const HTTPLogger = new ProcessLogger('HTTPSetup')
 
 module.exports = {
-  handle_404 (request, response, next) {
+  handle_404 (_, __, next) {
     const return_data = {
       status_code: 404,
       success: false,
@@ -16,9 +14,13 @@ module.exports = {
     next(return_data)
   },
 
-  handle_error (error, request, response, next) {
+  handle_error (error, __, response, ____) {
     // Log errors
-    logger.error(error.error || error.message, 'handle_error')
+    if (error.error) {
+      HTTPLogger.info(error.error, 'handle_error')
+    } else {
+      HTTPLogger.error(error, 'handle_error')
+    }
 
     // return error
     return response.status(error.status_code || 500).json({

package/lib/middlewares/logger.js

@@ -0,0 +1,93 @@
+/**
+ * @author Oguntuberu Nathan O. <nateoguns.work@gmail.com>
+ **/
+
+const Env = require("../env");
+const { randomUUID } = require("crypto");
+const LOGTAIL_SECRET = Env.fetch("LOGTAIL_SECRET", true);
+const { Logtail } = require("@logtail/node");
+const logtail = new Logtail(LOGTAIL_SECRET);
+
+function RequestLogger(request, response, next) {
+  const app_name = Env.fetch("APP_NAME", true);
+  if (!request.request_id) request.request_id = randomUUID();
+
+  //
+  const {
+    query,
+    params,
+    headers: { host, origin, "user-agent": user_agent, "sec-ch-ua-platform": os, referer },
+    request_id,
+    tenant_id,
+  } = request;
+
+  response.on("finish", () => {
+    const {
+      _parsedUrl: { pathname },
+      httpVersion,
+      _startTime,
+      _remoteAddress,
+      payload,
+    } = response.req;
+    const { statusCode, statusMessage } = response.req.res;
+    const duration = Date.now() - Date.parse(_startTime);
+    const log = {
+      app_name,
+      request_id,
+      tenant_id,
+      query,
+      params,
+      host,
+      origin,
+      user_agent,
+      os,
+      referer,
+      httpVersion,
+      _remoteAddress,
+      pathname,
+      duration,
+      type: "request",
+      status_code: payload ? payload.status_code : statusCode,
+    };
+
+    let error = payload ? payload.error : statusMessage;
+    if (error) {
+      log.error = error;
+      logtail.error(pathname, log);
+    } else {
+      logtail.info(pathname, log);
+    }
+
+    logtail.flush();
+  });
+
+  next();
+}
+
+class ProcessLogger {
+  constructor(service = "System") {
+    this.app_name = Env.fetch("APP_NAME", true);
+    this.service = service;
+  }
+
+  error(error, method = "unspecified_method") {
+    logtail.error(`${this.service}:${method}:${error.message}`, {
+      app_name: this.app_name,
+      type: "process",
+      message: error.message,
+      trace: error.stack,
+    });
+    logtail.flush();
+  }
+
+  info(info, method = "unspecified_method") {
+    logtail.info(`${this.service}:${method}:${info}`, {
+      app_name: this.app_name,
+      type: "process",
+      message: info,
+    });
+    logtail.flush();
+  }
+}
+
+module.exports = { RequestLogger, ProcessLogger };

package/package.json

@@ -1,16 +1,14 @@
 {
   "name": "@go-mailer/jarvis",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "main": "index.js",
-  "repository": "git@noguntuberu:go-mailer-ltd/jarvis-node.git",
+  "repository": "git@github.com:go-mailer-ltd/jarvis-node.git",
   "author": "Nathan Oguntuberu <nateoguns.work@gmail.com>",
   "license": "MIT",
   "dependencies": {
     "@logtail/node": "^0.3.3",
     "axios": "^1.3.4",
     "dotenv": "^16.0.3",
-    "jsonwebtoken": "^9.0.0",
-    "morgan": "^1.10.0",
-    "winston": "^3.8.2"
+    "jsonwebtoken": "^9.0.0"
   }
 }

package/lib/logger.js

@@ -1,126 +0,0 @@
-/**
- * @author Oguntuberu Nathan O. <nateoguns.work@gmail.com>
-**/
-
-const envVar = require('./env')
-const { Logtail } = require("@logtail/node");
-const logtail = new Logtail("oTNABUxtJb6erTRpZ2jhJhEs");
-
-const request_logger = (request, __, next) => {
-  
-}
-
-/** MORGAN */
-const { createWriteStream } = require('fs')
-const { resolve } = require('path')
-
-/** REQUEST LOG */
-const morgan = require('morgan')
-const request_log_format  = '[:date[web] :remote-addr :remote-user ] :method :url HTTP/:http-version :referrer - :user-agent | :status :response-time ms'
-
-const request_log_stream = createWriteStream(resolve(__dirname, '../../logs/request.log'), { flags: 'a' })
-const morgan_logger = morgan(request_log_format, { stream: request_log_stream })
-
-/** WINSTON */
-const {
-  createLogger,
-  format,
-  transports
-} = require('winston')
-
-const {
-  colorize,
-  combine,
-  printf,
-  timestamp
-} = format
-
-const log_transports = {
-  client_log: new transports.File({ level: 'error', filename: 'logs/client.log' }),
-  console: new transports.Console({ level: 'warn' }),
-  combined_log: new transports.File({ level: 'info', filename: 'logs/combined.log' }),
-  error_log: new transports.File({ level: 'error', filename: 'logs/error.log' }),
-  exception_log: new transports.File({ filename: 'logs/exception.log' }),
-  mailer_log: new transports.File({ level: 'error', filename: 'logs/mailer.log' }),
-  stream_log: new transports.File({ level: 'error', filename: 'logs/stream.log' })
-}
-
-const log_format = printf(({ level, message, timestamp }) => `[${timestamp} : ${level}] - ${message}`)
-
-const logger = createLogger({
-  transports: [
-    log_transports.console,
-    log_transports.combined_log,
-    log_transports.error_log
-  ],
-  exceptionHandlers: [
-    log_transports.exception_log
-  ],
-  exitOnError: false,
-  format: combine(
-    colorize(),
-    timestamp(),
-    log_format
-  )
-})
-
-const client_logger = createLogger({
-  transports: [
-    log_transports.console,
-    log_transports.client_log
-  ],
-  exitOnError: false,
-  format: combine(
-    colorize(),
-    timestamp(),
-    log_format
-  )
-})
-
-const mail_logger = createLogger({
-  transports: [
-    log_transports.console,
-    log_transports.mailer_log
-  ],
-  exitOnError: false,
-  format: combine(
-    colorize(),
-    timestamp(),
-    log_format
-  )
-})
-
-const stream_logger = createLogger({
-  transports: [
-    log_transports.console,
-    log_transports.stream_log
-  ],
-  exitOnError: false,
-  format: combine(
-    colorize(),
-    timestamp(),
-    log_format
-  )
-})
-
-const log = console.log
-const app_logger = (service = 'System') => {
-  const console = (message, method = 'unspecified_method') => {
-    const formatted_message = `[${service} ${method}()]: ${message}`
-    log(formatted_message)
-  }
-
-  const error = (message, method = 'unspecified_method') => {
-    const formatted_message = `[${service} ${method}()]: ${message}`
-    logger.error(`${formatted_message}`)
-  }
-
-  const info = (message, method = 'unspecified_method') => {
-    const formatted_message = `[${service} ${method}()]: ${message}`
-    logger.info(`${formatted_message} ${message}`)
-  }
-
-  return { console, error, info }
-}
-
-module.exports = { app_logger, client_logger, logger, mail_logger, morgan: morgan_logger, stream_logger }