@go-mailer/jarvis 1.0.0 → 2.1.0

package/README.md

@@ -1,2 +1,256 @@
 # jarvis-node
-A multipurpose helper package for our node apps.
+A multipurpose helper package for our node apps. This package contains helpers for the following:
+
+* Authentication
+* Feature flag control
+* Logging & Monitoring
+* Environment variable management
+* Request Query processing
+
+## **Installation**
+
+    yarn install @go-mailer/jarvis
+## **Authentication**
+In Go-Mailer, there are two major types of authentication: 
+
+
+  1. **JWT authentication**:
+      is employed in simple username/password log-ins and is the primary method of user authentication in the system. 
+      We use the `jsonwetoken` package for [JWT](https://jwt.io/) authentication.
+      
+          const { Authenticator } = require('@go-mailer/jarvis');
+          const { JWTAuth } = Authenticator;
+          
+          app.use('/route', JWTAuth, route_handler);
+  2. **API authentication**:
+      is done via in-house authentication methods. The [IAM](https://github.com/go-mailer-ltd/iam) app is responsible
+      for managing user identities, authorizations and API keys. This package makes simple API calls to the IAM app to 
+      verify the provided API keys. There are two ways API keys can be authenticated:
+      
+      * **As a Query Parameter**: Here the API key is passed as a request query parameter - typically for applications 
+      which intend to authenticate via `GET` HTTP method.
+      * **As an Authentication Header**: This is default way to pass API keys and security tokens in HTTP requests.
+      
+      
+            const { Authenticator } = require('@go-mailer/jarvis');
+            const { APIAuth } = Authenticator;
+            const { defaultAuth, paramAuth } = APIAuth();
+            
+            app.use('/api-route', defaultAuth, handler); //API auth
+            app.use('/api-param-route', paramAuth, handler); //Query param auth
+
+## **Feature Flag Control**
+Go-Mailer uses [Go-Flags](https://go-flags.com) to control application feature visibility. This gives us the ability to 
+build our application's feature continuosly without worry about the customers seeing or using them before release.
+
+`async FeatureFlag.verify(<flage_name>, <criteria>)`: used to verify whether or not a feature is turned ON or OFF. 
+Returns `true` if feature is enabled and `false` otherwise. 
+
+* **flag_name** `string`: **required**
+
+  This is the name of the feature to be checked as defined on the [Go-Flags app](https://go-flags.com).
+
+* **criteria** `Object`: **required**
+  This is a key -> value pair of criteria with which the status of the flag should be checked. 
+  These criteria are matched against those configure on the [Go-Flags app](https://go-flags.com).
+
+      const { FeatureFlag } = require('@go-mailer/jarvis');
+      FeatureFlag.verify(<flag_name>: String, <criteria>: Object ).then((result) => {
+        // do anything with result.
+      });
+    
+## **Logging**
+Logging is essential to the success of any application. The ability to collect information about the application's processes is crucial
+to making engineering and business decisions as well as resolving any issues that may arise in the system. Jarvis provides logging capabilities. Currently, the logging application we utilize is [Logtail](https://logtail.com/).
+
+There are two kinds of Loggers provided by Jarvis:
+
+1. Request Logger
+2. Process Logger
+
+### **Request Logger**
+
+This middleware generates logs each time a request passes through the system. It should be placed before any routes are defined.
+
+    const { RequestLogger } = require('@go-mailer/jarvis'); 
+    app.use('/', RequestLogger);
+    
+### **Process Logger**
+
+This logger is used to keep various kinds of logs from different parts of the system. There are two kinds of process logs recorded: `error` & `info`.
+
+1. **error** logs are recorded whenever an exception is thrown or some anormally is detected or encountered.
+2. **info** logs are strictly informational. They are typically used to provide visibility through the system for things
+like system health, process paths, etc.
+
+``` 
+  const { ProcessLogger } = require('@go-mailer/jarvis');
+  const logger = new ProcessLogger(<service_name>: String);
+  
+  // error logging
+  logger.error(<error_object>: Error, <method_name>: String);
+  
+  // info logging
+  logger.error(<message_to_be_logged>: String, <method_name>: String);
+```
+
+1. **`<service_name>`**: This is the name of the service or part of the system where the log is generated. For example, if the log was generated in the Mailing controller, this would have the value `MailingController`.
+2. **`<error_object>`**: This is the instance of the Error that was thrown and caught.
+3. **`<message_to_be_logged>`**: For informational logs, this is the information to be logged.
+4. **`<method_name>`**: This is the method/function within which the log was generated.
+
+.
+## **Environment variable management**
+Jarvis also provides environment variable management. This enables applications to set and retrieve environment variables more seamlessly.
+1. **`set(config: Object)`**: allows for the configuration of new variables. This does not override environment variables.
+
+    * `config: Object`: a key-value set that specifies application or instance specific criteria to the environment namespace.
+    
+    .
+2. **`fetch(variable_name: String, is_required: Boolean)`**: retrieves the specified variable.
+    
+    * `variable_name: String`: The name of the variable to retrieve.
+    * `is_required: Boolean`: Specifies whether or not the variable to be retrieved is required. If set to `true`, an Exception would be thrown if no value exists. default: `false`  
+
+```
+const { EnvVar } = require('@go-mailer/jarvis');
+
+// set environment variable(s)
+EnvVar.set({
+  APP_NAME: 'Mailing'
+});
+
+// retrieve environment variable
+EnvVar.fetch('APP_NAME', true); // required
+EnvVar.fetch('APP_NAME'); // not required
+```
+## **Request Query processing**
+Jarvis provides a query processor that converts request queries into MongoDB compatible queries. Request Queries are processed based on keywords and the use of special characters. A request query is the part of the request path that comes after the question mark (?). The `QueryBuilder.buildQuery()` is used for request processing.
+
+    GET http://go-mailer.com?<query_part>
+
+```
+QueryBuilder.buildQuery(options: Object) : {
+  count: boolean
+  fields_to_return: string
+  limit: number
+  seek_conditions: MongooseQueryObject
+  skip: number
+  sort_condition: string  
+}
+```  
+
+### **Keywords**:
+Keywords in request queries are used to prepare the following queries. Given the sample records in the database:
+```
+[{
+  name: "Nathan",
+  age: 21,
+  sex: 'M'
+}, {
+  name: "Anita",
+  age: 15,
+  sex: 'F'
+}, {
+  name: "Manchang",
+  age: 25,
+  sex: 'M'
+}]
+```
+1. **Field inclusion** queries: when the keyword `return_only` is used the query, ONLY the properties that are contained in the  value that is assigned to this keyword WILL be returned. For example:
+  
+    ```
+    // given the request
+    GET https://go-mailer.com?return_only=name,age
+    
+    // sample response will return only the `age` and `name` properties on the records
+    [{
+      name: "Nathan",
+      age: 21,
+    }, {
+      name: "Anita",
+      age: 15,
+    }, {
+      name: "Manchang",
+      age: 25,
+    }]
+    ```
+2. **Field exclusion** queries: when the keyword `exclude_only` is used the query, ONLY the properties that are NOT contained in the  value that is assigned to this keyword WILL be returned. For example:
+  
+    ```
+    // given the request
+    GET https://go-mailer.com?exclude_only=name,age
+    
+    // sample response will return only the `sex` property on the records.
+    [{
+      sex: 'M'
+    }, {
+      sex: 'F'
+    }, {
+      sex: 'M'
+    }]
+    ```
+3. **Pagination** queries: when the keywords `page` & `population` are specified in the query, the result set would be paginated. NOTE that the first page number is `0`. For example:
+    ```
+    // given the request
+    GET https://go-mailer.com?page=0&population=2
+  
+    // sample response. First two matching objects 
+    [{
+      name: "Nathan",
+      age: 21,
+      sex: 'M'
+    }, {
+      name: "Anita",
+      age: 15,
+      sex: 'F'
+    }]
+    ```
+4. **Sort** queries: we can specify sort conditions by using the `sort_by` keyword in the query. The value would contain the property with which we would like to sort. Default sort mode is `ASC`. If you want `DESC`, specify the value with a minus sign (`-`):
+    ```
+    // ASCending (age)
+    GET https://go-mailer.com?sort_by=age
+    
+    // DESCending (-age)
+    GET https://go-mailer.com?sort_by=-age
+    ```
+5. **count**: To return a count of items that match the query, the `count` keyword is used.
+
+    ```
+    GET https://go-mailer.com?count=1
+    ```
+
+### **Special Characters**
+The use of special characters in query values indicate the need to prepare the following queries:
+1. **OR** queries: Whenever a comma separated list is used as a keyword value. This is hand
+
+    ```
+    // return records where 'name' is 'Nathan' OR 'Michael' 
+    GET https://go-mailer.com?name=Nathan,Michael
+    ```
+3. **NOR** queries: Whenever the values of a query field are separated by an exclamation mark (!), a NOR query is built.
+
+    ```
+    // return records where 'name' is neither 'Nathan' NOR 'Michael' 
+    GET https://go-mailer.com?name=Nathan!Michael
+    ```
+4. **Range selection** queries: To support range queries, the tilde character (~) is used in between values. currently, ranges only work with integer values
+    ```
+    // get all records where age is between 12 and 34 (inclusive)
+    GET https://go-mailer.com?age=12~34
+    
+    // get all records less than 34
+    GET https://go-mailer.com?age=~34
+    
+    // get all records greater than 34
+    GET https://go-mailer.com?age=34~
+    ```
+
+### **Wildcard** 
+The `QueryBuilder` closure also provides a `buildWildcardOptions()` function that prepares a mongoose regular expression query object for text matching.
+```
+QueryBuilder.buildWildcardOptions(key_list: string, value) : MongooseQueryObject
+```  
+
+* `key_list: string`: is a comma-separated list of properties against which value is sought
+* `value: any`: is the value being sought for.

package/index.js

@@ -0,0 +1,7 @@
+const EnvVar = require('./lib/env')
+const FeatureFlag = require('./lib/flag')
+const QueryBuilder = require('./lib/query')
+const HTTP = require('./lib/middlewares/http')
+const Authenticator = require('./lib/middlewares/auth')
+const { RequestLogger, ProcessLogger } = require('./lib/middlewares/logger')
+module.exports = { RequestLogger, ProcessLogger, Authenticator, EnvVar, FeatureFlag, HTTP, QueryBuilder }

package/lib/clients/go-flags.js

@@ -0,0 +1,27 @@
+const axios = require("axios");
+const Env = require("../env");
+const BASE_URI = Env.fetch("GO_FLAGS_URI", true);
+const API_KEY = Env.fetch("GO_FLAGS_KEY", true);
+
+const verifyFeatureFlag = async (flag_name, criteria = {}) => {
+  const { error, payload } = (
+    await axios.post(
+      `${BASE_URI}/api/v1/flags/${flag_name}`,
+      {
+        payload: criteria,
+        environment: Env.fetch("NODE_ENV", true)
+      },
+      {
+        headers: {
+          authorization: `Bearer ${API_KEY}`,
+        },
+      }
+    )
+  ).data;
+
+  if (error) throw new Error(error);
+
+  return payload.is_permitted;
+};
+
+module.exports = { verifyFeatureFlag };

package/lib/clients/iam.js

@@ -0,0 +1,42 @@
+const axios = require("axios");
+const Env = require("../env");
+const IAM_URI = Env.fetch("IAM_SERVICE_URI", true);
+const DEFAULT_TOKEN = Env.fetch("DEFAULT_TOKEN", true);
+
+const verifyAPIKey = async (key) => {
+  const { error, payload } = (
+    await axios.get(`${IAM_URI}/keys/verify/${key}`, {
+      headers: {
+        authorization: `Bearer ${DEFAULT_TOKEN}`,
+      },
+    })
+  ).data;
+
+  if (error) throw new Error("Unauthorized");
+
+  return payload.org_id;
+};
+
+const verifyFeatureFlag = async (flag_name, criteria = {}) => {
+  const { error, payload } = (
+    await axios.post(
+      `${IAM_URI}/flags`,
+      {
+        criteria,
+        environment: Env.fetch("NODE_ENV"),
+        name: flag_name,
+      },
+      {
+        headers: {
+          authorization: `Bearer ${DEFAULT_TOKEN}`,
+        },
+      }
+    )
+  ).data;
+
+  if (error) throw new Error(error);
+
+  return payload.is_permitted;
+};
+
+module.exports = { verifyAPIKey, verifyFeatureFlag };

package/lib/env.js

@@ -1,12 +1,24 @@
-require('dotenv').config()
+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
+  constructor() {
+    this.config = {};
+  }
+
+  set(config = {}) {
+    this.config = {
+      ...this.config,
+      ...config,
+    };
+  }
+
+  fetch(var_name = "", is_required = false) {
+    if (!var_name) throw new Error(`Variable name is required.`);
+    const value = process.env[var_name] || this.config[var_name];
+    if (is_required && !value) throw new Error(`Required EnvVar ${var_name} not found`);
+    return value;
   }
 }
 
-module.exports = new EnvVar()
+module.exports = new EnvVar();

package/lib/flag.js

@@ -0,0 +1,18 @@
+const { verifyFeatureFlag } = require('./clients/go-flags')
+const { ProcessLogger } = require('./middlewares/logger')
+const flagLogger = new ProcessLogger('FeatureFlag')
+
+const verify = async (flag_name = '', criteria = {}) => {
+  try {
+    if (!flag_name) throw new Error('Unspecified flag name');
+    if (!Object.keys(criteria)) throw new Error('Unspecified criteria');
+    
+    const result = await verifyFeatureFlag(flag_name, criteria);
+    return result
+  } catch (e) {
+    flagLogger.error(e, 'verify')
+    return false
+  }
+}
+
+module.exports = { verify }

package/lib/middlewares/auth.js

@@ -1,116 +1,73 @@
 /**
  * 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));
-      }
 
-      if (token === GM_TOKEN) {
-        request.tenant_id = { $exists: true };
-        return next();
-      }
+const jwt = require("jsonwebtoken");
+const Env = require("../env");
+const Errors = require("./errors");
+const { ProcessLogger } = require("./logger");
+const { verifyAPIKey } = require("../clients/iam");
+const authLogger = new ProcessLogger("Authenticator");
 
-      const verified_data = await jwt.verify(token, JWT_SECRET, {
-        issuer: JWT_ISSUER,
-      });
+// helpers
+const extract_token = (headers) => {
+  const { authorization } = headers;
+  if (!authorization) throw new Error("Unauthorized");
 
-      const { tenant_id, is_admin } = verified_data;
-      request.tenant_id = tenant_id;
-      if (is_admin) process_request(request);
+  const [, token] = authorization.split(" ");
+  if (!token) throw new Error("Unauthorized");
 
-      next();
-    } catch (e) {
-      logger.error(`[Auth Error] ${e.message}`);
-      next(rootService.process_failed_response("Unauthorized", 403));
-    }
-  }
-}
+  return token;
+};
 
-const authenticate_api_key = async (request, response, next) => {
+// main
+const JWTAuth = async (request, response, next) => {
   try {
-    const { authorization } = request.headers;
-    if (!authorization) {
-      return next(rootService.process_failed_response("Unauthorized", 403));
-    }
-
-    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;
+    // env vars
+    const DEFAULT_TOKEN = Env.fetch("DEFAULT_TOKEN", true);
+    const ISSUER = Env.fetch("JWT_ISSUER", true);
+    const SECRET = Env.fetch("JWT_SECRET", true);
+    
+    const token = extract_token(request.headers);
+    if (token === DEFAULT_TOKEN) {
+      // inter-service requests
+      request.is_service_request = true;
+      // typically scope requests by tenant_id
+      request.tenant_id = request.body.tenant_id || request.query.tenant_id || { $exists: true };
       return next();
     }
 
-    const payload = await verify_api_key(api_key);
-    request.tenant_id = payload.org_id;
+    const { tenant_id, is_admin } = await jwt.verify(token, SECRET, { issuer: ISSUER });
+    request.is_admin = !!is_admin;
+    request.tenant_id = is_admin ? { $exists: true } : tenant_id;
+
     next();
   } catch (e) {
-    logger.error(`${e.message}`, "authenticate_api_key");
-    next(rootService.process_failed_response("Unauthorized", 403));
+    authLogger.error(e, "JWTAuth");
+    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 authenticateParamKey = async (request, response, next) => {
+  try {
+    const { api_key: token } = request.params;
+    request.tenant_id = await verifyAPIKey(token);
+    next();
+  } catch (e) {
+    authLogger.error(e, "authenticateParamKey");
+    return response.status(403).json(Errors.UNAUTHORIZED);
+  }
 };
 
-const authenticate_user = async (request, __, next) => {
+const authenticateBearerKey = async (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));
-    }
-
-    if (token === GM_TOKEN) {
-      request.tenant_id = { $exists: true };
-      return next();
-    }
-
-    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);
-
+    const token = extract_token(request.headers);
+    request.tenant_id = await verifyAPIKey(token);
     next();
   } catch (e) {
-    logger.error(`[Auth Error] ${e.message}`);
-    next(rootService.process_failed_response("Unauthorized", 403));
+    authLogger.error(e, "authenticateBearerKey");
+    return response.status(403).json(Errors.UNAUTHORIZED);
   }
 };
 
-module.exports = { authenticate_api_key, authenticate_user };
+module.exports = { authenticateBearerKey, authenticateParamKey, JWTAuth };

package/lib/middlewares/errors.js

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

package/lib/middlewares/http.js

@@ -0,0 +1,52 @@
+/** **/
+const { ProcessLogger } = require("./logger");
+const HTTPLogger = new ProcessLogger("HTTPSetup");
+
+module.exports = {
+  handle404(_, __, next) {
+    const return_data = {
+      status_code: 404,
+      success: false,
+      error: "Resource not found",
+      payload: null,
+    };
+
+    next(return_data);
+  },
+
+  handleError(error, __, response, ____) {
+    // Log errors
+    if (error.error) {
+      HTTPLogger.info(error.error, "handleError");
+    } else {
+      HTTPLogger.error(error, "handleError");
+    }
+
+    // return error
+    return response.status(error.status_code || 500).json({
+      success: false,
+      status_code: error.status_code || 500,
+      error: error.error || "Internal Server Error",
+      payload: null,
+    });
+  },
+
+  processResponse(request, response, next) {
+    if (!request.payload) return next();
+
+    const { status_code } = request.payload;
+    return response.status(status_code).json(request.payload);
+  },
+
+  setupRequest(request, response, next) {
+    request.headers["access-control-allow-origin"] = "*";
+    request.headers["access-control-allow-headers"] = "*";
+
+    if (request.method === "OPTIONS") {
+      request.headers["access-control-allow-methods"] = "GET, POST, PUT, PATCH, DELETE";
+      response.status(200).json();
+    }
+
+    next();
+  },
+};

package/lib/middlewares/logger.js

@@ -0,0 +1,95 @@
+/**
+ * @author Oguntuberu Nathan O. <nateoguns.work@gmail.com>
+ **/
+
+ const Env = require("../env");
+ const { randomUUID } = require("crypto");
+ const { Logtail } = require("@logtail/node");
+ const LOGTAIL_SECRET = Env.fetch("LOGTAIL_SECRET", true);
+ const logtail = new Logtail(LOGTAIL_SECRET);
+ 
+ function RequestLogger() {
+   const app_name = Env.fetch("APP_NAME", true);
+   return (request, response, next) => {
+     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.service = service;
+   }
+ 
+   error(error, method = "unspecified_method") {
+     logtail.error(`${this.service}:${method}:${error.message}`, {
+       app_name: Env.fetch("APP_NAME", true),
+       type: "process",
+       message: error.message,
+       trace: error.stack,
+     });
+     logtail.flush();
+   }
+ 
+   info(info, method = "unspecified_method") {
+     logtail.info(`${this.service}:${method}:${info}`, {
+       app_name: Env.fetch("APP_NAME", true),
+       type: "process",
+       message: info,
+     });
+     logtail.flush();
+   }
+ }
+ 
+ module.exports = { RequestLogger, ProcessLogger };
+ 

package/lib/query.js

@@ -1,29 +1,10 @@
-/** */
-const check_if_value_is_integer = (value) => {
-  return !isNaN(Number(value))
-}
-
-exports.build_query = (options) => {
+const buildQuery = (options) => {
   const seek_conditions = {}
-  const sort_condition = options.sort_by
-    ? this.build_sort_order_string(options.sort_by)
-    : ''
-  const fields_to_return = options.return_only
-    ? this.build_return_fields_string(options.return_only)
-    : ''
+  const sort_condition = options.sort_by ? buildSortOrderString(options.sort_by) : ''
+  const fields_to_return = options.return_only ? buildReturnFieldsString(options.return_only) : ''
   const count = options.count || false
 
-  let skip = 0
-  let limit = Number.MAX_SAFE_INTEGER
-
-  if (options.page && options.population) {
-    const pagination = this.determine_pagination(
-      options.page,
-      options.population
-    )
-    limit = pagination.limit
-    skip = pagination.skip
-  }
+  const { skip, limit } = determinePagination(options.page, options.population)
 
   /** Delete sort and return fields */
   delete options.count
@@ -33,24 +14,17 @@ exports.build_query = (options) => {
   delete options.sort_by
 
   Object.keys(options).forEach((field) => {
-    const field_value =
-      typeof options[field] === 'number'
-        ? options[field].toString()
-        : options[field]
+    const field_value = options[field].toLowerCase()
     let condition
 
-    if (typeof field_value === 'string') {
-      if (field_value.includes(':')) {
-        condition = this.build_in_query(field_value)
-      } else if (field_value.includes('!')) {
-        condition = this.build_nor_query(field_value)
-      } else if (field_value.includes('~')) {
-        condition = this.build_range_query(field_value)
-      } else {
-        condition = this.build_or_query(field_value)
-      }
+    if (field_value.includes(':')) {
+      condition = buildInQuery(field_value)
+    } else if (field_value.includes('!')) {
+      condition = buildNorQuery(field_value)
+    } else if (field_value.includes('~')) {
+      condition = buildRangeQuery(field_value)
     } else {
-      condition = field_value
+      condition = buildOrQuery(field_value)
     }
 
     seek_conditions[field] = { ...condition }
@@ -66,74 +40,71 @@ exports.build_query = (options) => {
   }
 }
 
-exports.build_in_query = (value) => {
+const buildInQuery = (value) => {
   const values = value.split(':')
   return {
-    $in: [
-      ...values.map((value) =>
-        check_if_value_is_integer(value) ? Number(value) : value
-      )
-    ]
+    $in: [...values]
   }
 }
 
-exports.build_nor_query = (value) => {
+const buildNorQuery = (value) => {
   const values = value.split('!')
   return {
-    $nin: [
-      ...values
-        .slice(1)
-        .map((value) =>
-          check_if_value_is_integer(value) ? Number(value) : value
-        )
-    ]
+    $nin: [...values.slice(1)]
   }
 }
 
-exports.build_or_query = (value) => {
+const buildOrQuery = (value) => {
   const values = value.split(',')
   return {
-    $in: [
-      ...values.map((value) =>
-        check_if_value_is_integer(value) ? Number(value) : value
-      )
-    ]
+    $in: [...values]
   }
 }
 
-exports.build_range_query = (value) => {
-  const values = value.split('-')
+const buildRangeQuery = (value) => {
+  const [min, max] = value.split('~')
   return {
-    $gte: values[0] ? Number(values[0]) : Number.MIN_SAFE_INTEGER,
-    $lte: values[1] ? Number(values[1]) : Number.MAX_SAFE_INTEGER
+    $gte: min ? Number(min) : Number.MIN_SAFE_INTEGER,
+    $lte: max ? Number(max) : Number.MAX_SAFE_INTEGER
   }
 }
 
-exports.build_return_fields_string = (value) => {
-  const fields = value.split(',')
-  return fields.join(' ')
+const buildReturnFieldsString = (value) => {
+  return value.replace(/,/gi, ' ')
 }
 
-exports.build_sort_order_string = (value) => {
-  const values = value.split(',')
-  return values.join(' ')
+const buildSortOrderString = (value) => {
+  return value.replace(/,/gi, ' ')
 }
 
-exports.build_wildcard_options = (key_list, value) => {
+const buildWildcardOptions = (key_list, value) => {
   const keys = key_list.split(',')
+
   return {
     $or: keys.map((key) => ({
       [key]: {
-        $regex: `${value}`,
+        $regex: value || '',
         $options: 'i'
       }
     }))
   }
 }
 
-exports.determine_pagination = (page, population) => {
+const determinePagination = (page = 0, population = Number.MAX_SAFE_INTEGER) => {
   return {
     limit: Number(population),
     skip: page * population
   }
 }
+
+module.exports = {
+  buildInQuery,
+  buildNorQuery,
+  buildOrQuery,
+  buildQuery,
+  buildRangeQuery,
+  buildReturnFieldsString,
+  buildSortOrderString,
+  buildWildcardOptions,
+  determinePagination
+}

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "@go-mailer/jarvis",
-  "version": "1.0.0",
+  "version": "2.1.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"
+  },
+  "devDependencies": {
+    "chai": "^4.3.7",
+    "mocha": "^10.2.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 }

package/lib/middlewares/request.js

@@ -1,50 +0,0 @@
-/**
- * @author Oguntuberu Nathan O. <nateoguns.work@gmail.com>
-**/
-const { app_logger } = require('../utilities/logger')
-const logger = app_logger('HTTP Middleware')
-
-module.exports = {
-  handle_404 (request, response, next) {
-    const return_data = {
-      status_code: 404,
-      success: false,
-      error: 'Resource not found',
-      payload: null
-    }
-
-    next(return_data)
-  },
-
-  handle_error (error, request, response, next) {
-    // Log errors
-    logger.error(error.error || error.message, 'handle_error')
-
-    // return error
-    return response.status(error.status_code || 500).json({
-      success: false,
-      status_code: error.status_code || 500,
-      error: error.error || 'Internal Server Error',
-      payload: null
-    })
-  },
-
-  process_response (request, response, next) {
-    if (!request.payload) return next()
-
-    const { status_code } = request.payload
-    return response.status(status_code).json(request.payload)
-  },
-
-  setup_request (request, response, next) {
-    request.headers['access-control-allow-origin'] = '*'
-    request.headers['access-control-allow-headers'] = '*'
-
-    if (request.method === 'OPTIONS') {
-      request.headers['access-control-allow-methods'] = 'GET, POST, PUT, PATCH, DELETE'
-      response.status(200).json()
-    }
-
-    next()
-  }
-}