parsony 2.0.1 → 2.0.2

package/lib/api/api.js

@@ -14,7 +14,7 @@ const {
   endpointValidationGateAsync,
   apiKeyGateAsync,
   sessionAuthenticationGateAsync,
-  signedRequestGate
+  signedRequestGate,
 } = require("./gates");
 
 const {
@@ -26,27 +26,27 @@ const {
     PARAMS,
     AUTHENTICATION,
     SESSION_TOKEN,
-    API_KEY
+    API_KEY,
   },
   REQUEST: { METHOD: REQUEST_METHOD, ARGS, HINT },
-  RESPONSE: { API_EXPECTS }
+  RESPONSE: { API_EXPECTS },
 } = require("../enums");
 
 const HTTP = {
   GET: "get",
   POST: "post",
   PUT: "put",
-  DELETE: "delete"
+  DELETE: "delete",
 };
 
 const ABORT = {
   METHOD: {
     NOT_FOUND: "noMethodFound",
-    NOT_SUPPLIED: "noMethodSupplied"
+    NOT_SUPPLIED: "noMethodSupplied",
   },
   ARGS: {
-    MISSING: "noArgsSupplied"
-  }
+    MISSING: "noArgsSupplied",
+  },
 };
 
 let parsony;
@@ -60,7 +60,7 @@ let parsony;
 const combineInterfaceContracts = (master, service) => {
   const contracts = service.interface || [];
   const combined = Object.assign({}, master);
-  contracts.forEach(endpoint => {
+  contracts.forEach((endpoint) => {
     combined.contracts[endpoint[JSON_API]] = endpoint;
     combined.mappings[endpoint[JSON_API]] = endpoint[JSON_API];
   });
@@ -79,7 +79,7 @@ const combineInterfaceContracts = (master, service) => {
 const bindRESTEndpointsToRoutes = (app, service) => {
   const contracts = service.interface || [];
 
-  contracts.forEach(contract => {
+  contracts.forEach((contract) => {
     const method = contract[INTERFACE_METHOD];
     const url = contract[REST_URL];
 
@@ -124,7 +124,7 @@ const bindRESTEndpointsToRoutes = (app, service) => {
  */
 function _restfulReq(req, res, contract) {
   const method = req.route.path;
-  const args = {...req.body, ...req.query};
+  const args = { ...req.body, ...req.query };
   _validateThenHandle(req, res, args, method, contract);
 }
 
@@ -147,7 +147,7 @@ const bindJsonRpcToPostEndpoint = (app, master, apiEndpoint, debugMode) => {
   const api = `/${apiEndpoint}`;
   const {
     METHOD: { NOT_SUPPLIED, NOT_FOUND },
-    ARGS: { MISSING }
+    ARGS: { MISSING },
   } = ABORT;
 
   app.post(api, (req, res) => {
@@ -178,7 +178,7 @@ const bindJsonRpcToPostEndpoint = (app, master, apiEndpoint, debugMode) => {
 function _abortWithError(res, req, type, detail) {
   const {
     METHOD: { NOT_FOUND, NOT_SUPPLIED },
-    ARGS: { MISSING }
+    ARGS: { MISSING },
   } = ABORT;
 
   switch (type) {
@@ -187,9 +187,9 @@ function _abortWithError(res, req, type, detail) {
         res,
         makeStandardError(
           errors.REQUEST.NO_METHOD_FOUND,
-          `The requested method: ${detail} was not found.`
+          `The requested method: ${detail} was not found.`,
         ),
-        req.body
+        req.body,
       );
       break;
 
@@ -197,7 +197,7 @@ function _abortWithError(res, req, type, detail) {
       sendFailure(
         res,
         makeStandardError(errors.REQUEST.NO_METHOD_SUPPLIED),
-        req.body
+        req.body,
       );
       break;
 
@@ -240,8 +240,8 @@ function _validateThenHandle(req, res, args, method, contract) {
     .then(({ data, sessionObj }) => {
       _handleRequest(contract[HANDLER], sessionObj, data, res, method);
     })
-    .catch(err => {
-      sendFailure(res, err, req.body,method,parsony.debugMode);
+    .catch((err) => {
+      sendFailure(res, err, req.body, method, parsony.debugMode);
     });
 }
 
@@ -262,9 +262,10 @@ function _validateThenHandle(req, res, args, method, contract) {
  */
 async function _validateRequest(req, data, contract) {
   let sessionObj;
+
   if (isApiKeyRequired(contract)) {
     await apiKeyGateAsync(req);
-    await signedRequestGate(req, data);
+    await signedRequestGate(req);
   }
   if (isSessionTokenRequired(contract)) {
     sessionObj = await sessionAuthenticationGateAsync(req);
@@ -272,7 +273,7 @@ async function _validateRequest(req, data, contract) {
   await endpointValidationGateAsync(data, contract[PARAMS]);
   return {
     data,
-    sessionObj
+    sessionObj,
   };
 }
 
@@ -291,10 +292,10 @@ async function _validateRequest(req, data, contract) {
  */
 function _handleRequest(handler, sessionObj, data, res, reqMethod) {
   handler({ ...data, sessionObj })
-    .then(results => {
+    .then((results) => {
       sendSuccess(res, results, reqMethod);
     })
-    .catch(err => {
+    .catch((err) => {
       err = err.code
         ? err
         : makeStandardError(errors.SERVER_ERROR, err.message);
@@ -312,8 +313,6 @@ function _sendDebugHint(res, contract) {
   sendSuccess(res, { [API_EXPECTS]: contract });
 }
 
-
-
 /**
  * Does the contract require an API Key
  * @param contract
@@ -336,8 +335,7 @@ function isSessionTokenRequired(contract) {
  * Configs setter.
  * @param {object} parsony - Parsony singleton
  */
-const setParsony = withParsony => (parsony = withParsony);
-
+const setParsony = (withParsony) => (parsony = withParsony);
 
 module.exports = {
   setParsony,
@@ -346,5 +344,5 @@ module.exports = {
   JSONGate,
   combineInterfaceContracts,
   bindRESTEndpointsToRoutes,
-  bindJsonRpcToPostEndpoint
+  bindJsonRpcToPostEndpoint,
 };

package/lib/api/gates/endpointValidation.js

@@ -3,24 +3,26 @@
  * @module /api/gates/endpointValidation
  */
 
-
 const { isURL, isJSON, validateEmail } = require("../../utils");
-const { makeStandardError } = require('../../http');
-const { REQUEST:{ MALFORMED_VALIDATION:MALFORMED } } = require('../../errors/errors.json');
-const { INTERFACE: { VALIDATION } } = require('../../enums');
-
+const { makeStandardError } = require("../../http");
+const {
+  REQUEST: { MALFORMED_VALIDATION: MALFORMED },
+} = require("../../errors/errors.json");
+const {
+  INTERFACE: { VALIDATION },
+} = require("../../enums");
 
 const ERROR = {
-  MISSING_ARG   : 'missing_arg',
-  MAX_LENGTH    : 'max_length_exceeded',
-  MIN_LENGTH    : 'min_length_not_met',
-  INVALID_EMAIL : 'invalid_email',
-  ARG_MISMATCH  : 'argument_type_mismatch',
-  OUT_OF_RANGE  : 'argument_out_of_range',
-  NOT_URL       : 'argument_not_url',
-  NOT_JSON      : 'argument_not_json',
-  NOT_ARRAY     : 'argument_not_an_array',
-  REGEX         : 'argument_invalid_pattern'
+  MISSING_ARG: "missing_arg",
+  MAX_LENGTH: "max_length_exceeded",
+  MIN_LENGTH: "min_length_not_met",
+  INVALID_EMAIL: "invalid_email",
+  ARG_MISMATCH: "argument_type_mismatch",
+  OUT_OF_RANGE: "argument_out_of_range",
+  NOT_URL: "argument_not_url",
+  NOT_JSON: "argument_not_json",
+  NOT_ARRAY: "argument_not_an_array",
+  REGEX: "argument_invalid_pattern",
 };
 
 /**
@@ -60,20 +62,19 @@ const ERROR = {
  */
 const endpointValidationGateAsync = async (data, params) => {
   const errors = [];
-
-  params.forEach( def => {
+  params.forEach((def) => {
     const rules = Object.keys(def[VALIDATION]);
     const param = def.param;
 
     if (data.hasOwnProperty(param)) {
-      rules.forEach( rule => {
-          const arg = data[param];
-          const error = _validate(arg, def, rule);
-          if(error){
-            errors.push(error)
-          }
-        })
-    } else if(def.required) {
+      rules.forEach((rule) => {
+        const arg = data[param];
+        const error = _validate(arg, def, rule);
+        if (error) {
+          errors.push(error);
+        }
+      });
+    } else if (def.required) {
       errors.push(_missingArgError(param));
     }
   });
@@ -81,13 +82,10 @@ const endpointValidationGateAsync = async (data, params) => {
   if (errors.length === 0) {
     return data;
   } else {
-    throw makeStandardError(
-      MALFORMED,
-      errors);
+    throw makeStandardError(MALFORMED, errors);
   }
 };
 
-
 /**
  * Compares passed arg for param to validation rule
  *
@@ -107,7 +105,7 @@ function _validate(arg, def, type) {
   const error = validator.error;
 
   if (!test(arg, comp)) {
-    return error(arg, param, comp)
+    return error(arg, param, comp);
   } else {
     return null;
   }
@@ -116,48 +114,48 @@ function _validate(arg, def, type) {
 const VALIDATIONS_MAP = {
   max_length: {
     test: _maxLength,
-    error: _maxLengthError
+    error: _maxLengthError,
   },
   min_length: {
     test: _minLength,
-    error: _minLengthError
+    error: _minLengthError,
   },
   valid_email: {
     test: _isEmail,
-    error: _emailError
+    error: _emailError,
   },
   is_type: {
     test: _isType,
-    error: _typeError
+    error: _typeError,
   },
   in_set: {
     test: _inSet,
-    error: _inSetError
+    error: _inSetError,
   },
   is_url: {
     test: _isUrl,
-    error: _isUrlError
+    error: _isUrlError,
   },
   is_json: {
     test: _isJSON,
-    error: _isJsonError
+    error: _isJsonError,
   },
   is_array: {
     test: _isArray,
-    error: _isArrayError
+    error: _isArrayError,
   },
   regex: {
-    test : _regexTest,
-    error: _isRegexError
-  }
+    test: _regexTest,
+    error: _isRegexError,
+  },
 };
 
 function _maxLength(arg, comp) {
-  return arg.split('').length <= comp;
+  return arg.split("").length <= comp;
 }
 
 function _minLength(arg, comp) {
-  return arg.split('').length >= comp;
+  return arg.split("").length >= comp;
 }
 
 function _isEmail(arg) {
@@ -165,16 +163,15 @@ function _isEmail(arg) {
 }
 
 function _isType(arg, comp) {
-  if (comp === 'date') {
+  if (comp === "date") {
     return Date.parse(arg);
-  }
-  else {
+  } else {
     return typeof arg === comp;
   }
 }
 
 function _inSet(arg, comp) {
-  return comp.indexOf(arg) > -1
+  return comp.indexOf(arg) > -1;
 }
 
 function _isUrl(arg) {
@@ -182,121 +179,81 @@ function _isUrl(arg) {
 }
 
 function _isJSON(arg) {
-  return isJSON(arg)
+  return isJSON(arg);
 }
 
 function _isArray(arg) {
-  return Array.isArray(arg)
+  return Array.isArray(arg);
 }
 
-function _regexTest(arg, comp){
+function _regexTest(arg, comp) {
   const regex = new RegExp(comp);
   return regex.test(arg);
 }
 
 function _missingArgError(param) {
-  return _validationError(
-    ERROR.MISSING_ARG,
-    param,
-    null
-  );
+  return _validationError(ERROR.MISSING_ARG, param, null);
 }
 
 function _maxLengthError(arg, def, required) {
-  return _validationError(
-    ERROR.MAX_LENGTH,
-    def,
-    {
-      max: required,
-      sent: arg.split('').length
-    }
-  )
+  return _validationError(ERROR.MAX_LENGTH, def, {
+    max: required,
+    sent: arg.split("").length,
+  });
 }
 
 function _minLengthError(arg, def, required) {
-  return _validationError(
-    ERROR.MIN_LENGTH,
-    def,
-    {
-      min: required,
-      sent: arg.split('').length
-    }
-  )
+  return _validationError(ERROR.MIN_LENGTH, def, {
+    min: required,
+    sent: arg.split("").length,
+  });
 }
 
 function _emailError(arg, def) {
-  return _validationError(
-    ERROR.INVALID_EMAIL,
-    def,
-    arg
-  )
+  return _validationError(ERROR.INVALID_EMAIL, def, arg);
 }
 
 function _typeError(arg, def, required) {
-  return _validationError(
-    ERROR.ARG_MISMATCH,
-    def,
-    {
-      expected_type: required,
-      provided_type: typeof arg
-    }
-  )
+  return _validationError(ERROR.ARG_MISMATCH, def, {
+    expected_type: required,
+    provided_type: typeof arg,
+  });
 }
 
 function _inSetError(arg, def, required) {
-  return _validationError(
-    ERROR.OUT_OF_RANGE,
-    def,
-    {
-      acceptable_set: required,
-      sent: arg
-    }
-  )
+  return _validationError(ERROR.OUT_OF_RANGE, def, {
+    acceptable_set: required,
+    sent: arg,
+  });
 }
 
 function _isUrlError(arg, def) {
-  return _validationError(
-    ERROR.NOT_URL,
-    def,
-    arg
-  )
+  return _validationError(ERROR.NOT_URL, def, arg);
 }
 
 function _isJsonError(arg, def) {
-  return _validationError(
-    ERROR.NOT_JSON,
-    def,
-    arg
-  )
+  return _validationError(ERROR.NOT_JSON, def, arg);
 }
 
 function _isArrayError(arg, def) {
-  return _validationError(
-    ERROR.NOT_ARRAY,
-    def,
-    arg
-  )
+  return _validationError(ERROR.NOT_ARRAY, def, arg);
 }
 
 function _isRegexError(arg, def, required) {
-  return _validationError(
-    ERROR.REGEX,
-    def,
-    {
-      expected_pattern: required,
-      provided: arg
-    }
-  )
+  return _validationError(ERROR.REGEX, def, {
+    expected_pattern: required,
+    provided: arg,
+  });
 }
 
 function _validationError(code, param, opt) {
   return {
     code,
     param,
-    opt_desc: opt
-  }
+    opt_desc: opt,
+  };
 }
 
 module.exports = {
-  endpointValidationGateAsync
-};
+  endpointValidationGateAsync,
+};

package/lib/auth/persistence.js

@@ -3,9 +3,8 @@
  * @module auth/persistence
  */
 
-
 const cache = require("../cache").getCache();
-const models  = require("../models").getModels();
+const models = require("../models").getModels();
 const cachedAPIKeyPrefix = "APIKey:";
 
 /**
@@ -14,7 +13,7 @@ const cachedAPIKeyPrefix = "APIKey:";
  * @param secret
  * @return {Promise.<void>}
  */
-const cacheApiKeyPair  = async (apiKey, secret) =>{
+const cacheApiKeyPair = async (apiKey, secret) => {
   const cacheAPIKey = cachedAPIKeyPrefix + apiKey;
   await cache.set(cacheAPIKey, secret);
 };
@@ -24,7 +23,7 @@ const cacheApiKeyPair  = async (apiKey, secret) =>{
  * @param apiKey
  * @return {Promise.<string>}
  */
-const  cachedApiKeyPair = async (apiKey) => {
+const cachedApiKeyPair = async (apiKey) => {
   const cacheAPIKey = cachedAPIKeyPrefix + apiKey;
   return await cache.get(cacheAPIKey);
 };
@@ -36,19 +35,19 @@ const  cachedApiKeyPair = async (apiKey) => {
  */
 const dbApiKeyPair = async (apiKey) => {
   const { ApiKey } = models;
-  const keyPass = await ApiKey.find({
+  const keyPass = await ApiKey.findOne({
     where: {
       key: apiKey,
-      enabled:true,
-    }
+      enabled: true,
+    },
   });
-  if(keyPass){
+  if (keyPass) {
     return {
       key: keyPass.key,
-      secret: keyPass.secret
+      secret: keyPass.secret,
     };
-  } else{
-    return false
+  } else {
+    return false;
   }
 };
 
@@ -57,11 +56,11 @@ const dbApiKeyPair = async (apiKey) => {
  * @param apiKey
  * @return {Promise.<void>}
  */
-const dbDeleteKey = async apiKey => {
+const dbDeleteKey = async (apiKey) => {
   await models.ApiKey.destroy({
     where: {
-      key: apiKey
-    }
+      key: apiKey,
+    },
   });
 };
 
@@ -70,9 +69,9 @@ const dbDeleteKey = async apiKey => {
  * @param apiKey
  * @return {Promise.<void>}
  */
-const unsetCachedApiKey = async apiKey => {
+const unsetCachedApiKey = async (apiKey) => {
   const cached = cachedAPIKeyPrefix + apiKey;
-  await cache.del(cached)
+  await cache.del(cached);
 };
 
 /**
@@ -82,21 +81,23 @@ const unsetCachedApiKey = async apiKey => {
  * @return {Promise.<void>}
  */
 const dbToggleKeyEnabled = async (apiKey, enabled) => {
-  await models.ApiKey.update({
-      enabled: enabled
+  await models.ApiKey.update(
+    {
+      enabled: enabled,
     },
     {
       where: {
-        key: apiKey
-      }
-    });
+        key: apiKey,
+      },
+    },
+  );
 };
 
-module.exports ={
+module.exports = {
   cacheApiKeyPair,
   cachedApiKeyPair,
   dbApiKeyPair,
   dbDeleteKey,
   unsetCachedApiKey,
-  dbToggleKeyEnabled
-};
+  dbToggleKeyEnabled,
+};

package/lib/auth/session.js

@@ -2,21 +2,19 @@
  * Auth Module
  * @module /auth/session
  */
-const crypto = require('crypto');
+const crypto = require("crypto");
 const cache = require("../cache").getCache();
 const { randomString } = require("../utils");
 const { makeStandardError } = require("../http");
 const {
   INVALID_CREDENTIALS,
   SERVER_ERROR,
-  SESSION
+  SESSION,
 } = require("../errors/errors.json");
 const models = require("../models").getModels();
 
 const cachePrefix = "sessionToken:";
 
-
-
 /**
  * Checks provided credentials. Throws HTTP Error Obj if not, otherwise
  * returns null;
@@ -26,14 +24,18 @@ const cachePrefix = "sessionToken:";
  */
 const checkCredentials = async (username, password) => {
   const { User } = models;
-  const user = await User.find({
+  const user = await User.findOne({
     where: { username },
-    include: [models.UserAuth]
+    include: [models.UserAuth],
   });
   if (user) {
     let equality = null;
     try {
-      equality = _hashEquality(password,user.UserAuth.passwordHash, user.UserAuth.salt)
+      equality = _hashEquality(
+        password,
+        user.UserAuth.passwordHash,
+        user.UserAuth.salt,
+      );
     } catch (err) {
       throw makeStandardError(SERVER_ERROR, err.message);
     }
@@ -47,14 +49,14 @@ const checkCredentials = async (username, password) => {
   }
 };
 
-function _hashEquality(value, hash, salt){
-  return _saltedHash(value,salt) === hash;
+function _hashEquality(value, hash, salt) {
+  return _saltedHash(value, salt) === hash;
 }
 
-function _saltedHash(string, salt){
-  const hash = crypto.createHmac('sha256',salt);
+function _saltedHash(string, salt) {
+  const hash = crypto.createHmac("sha256", salt);
   hash.update(string);
-  return hash.digest('hex');
+  return hash.digest("hex");
 }
 
 /**
@@ -63,7 +65,7 @@ function _saltedHash(string, salt){
  * @param sessionToken
  * @return {Promise.<object>}
  */
-const getSession = async sessionToken => {
+const getSession = async (sessionToken) => {
   const cachedSession = await _cacheHasSession(sessionToken);
   if (cachedSession) {
     return cachedSession;
@@ -73,7 +75,7 @@ const getSession = async sessionToken => {
     await _cacheSession(
       dbSession.UserId,
       dbSession.sessionToken,
-      dbSession.sessionStart
+      dbSession.sessionStart,
     );
     await _extendSessionInCache(dbSession.sessionToken, dbSession);
     return dbSession;
@@ -87,14 +89,14 @@ const getSession = async sessionToken => {
  * @param userId
  * @return {Promise.<*>}
  */
-const createSession = async userId => {
+const createSession = async (userId) => {
   const sessionToken = randomString(40);
   const dbSession = await _storeSessionInDB(userId, sessionToken);
   if (dbSession) {
     const cachedSession = await _cacheSession(
       userId,
       dbSession.sessionToken,
-      dbSession.sessionStart
+      dbSession.sessionStart,
     );
     return cachedSession || dbSession;
   } else {
@@ -108,9 +110,9 @@ const createSession = async userId => {
  * @param options
  * @return {Promise.<void>}
  */
-const extendSession = async (sessionToken, options) =>{
+const extendSession = async (sessionToken, options) => {
   await _extendSessionInCache(sessionToken, options);
-  await _extendSessionInDB(sessionToken,options);
+  await _extendSessionInDB(sessionToken, options);
 };
 
 /**
@@ -118,29 +120,32 @@ const extendSession = async (sessionToken, options) =>{
  * @param sessionToken
  * @return {Promise.<null>}
  */
-const destroySession = async sessionToken => {
+const destroySession = async (sessionToken) => {
   await Promise.all([
     _deleteSessionFromDB(sessionToken),
-    _flushSessionFromCache(sessionToken)
+    _flushSessionFromCache(sessionToken),
   ]);
   return null;
 };
 
-
 async function _dbHasSession(sessionToken) {
   const { User, UserSessions } = models;
-  const session = await UserSessions.find({
+  const session = await UserSessions.findOne({
     where: {
-      sessionToken
+      sessionToken,
     },
-    include: [User]
+    include: [User],
   });
   return session
-    ? Object.assign({},{
-      userId: session.UserId,
-      sessionToken: session.sessionToken,
-      sessionStart: session.sessionStart
-    },JSON.parse(session.options))
+    ? Object.assign(
+        {},
+        {
+          userId: session.UserId,
+          sessionToken: session.sessionToken,
+          sessionStart: session.sessionStart,
+        },
+        JSON.parse(session.options),
+      )
     : false;
 }
 
@@ -155,7 +160,7 @@ async function _cacheSession(userId, sessionToken, sessionStart) {
   const sessionObj = {
     userId,
     sessionStart,
-    sessionToken
+    sessionToken,
   };
   await cache.set(cacheToken, JSON.stringify(sessionObj));
 }
@@ -163,25 +168,26 @@ async function _cacheSession(userId, sessionToken, sessionStart) {
 async function _extendSessionInCache(sessionToken, options) {
   const cacheToken = cachePrefix + sessionToken;
   const session = await cache.get(cacheToken);
-  if(session){
+  if (session) {
     const sessionObj = JSON.parse(session);
     const extendedSessionObj = Object.assign({}, sessionObj, options);
     await cache.set(cacheToken, JSON.stringify(extendedSessionObj));
   }
 }
 
-async function _extendSessionInDB( sessionToken, options){
+async function _extendSessionInDB(sessionToken, options) {
   const { UserSessions } = models;
   try {
     await UserSessions.update(
       {
-        options:JSON.stringify(options)
+        options: JSON.stringify(options),
       },
       {
         where: {
-          sessionToken
-        }
-      });
+          sessionToken,
+        },
+      },
+    );
   } catch (err) {
     throw makeStandardError(SESSION.DB_WRITE_ERROR);
   }
@@ -193,12 +199,12 @@ async function _storeSessionInDB(userId, sessionToken) {
     const session = await UserSessions.create({
       UserId: userId,
       sessionToken,
-      sessionStart: new Date()
+      sessionStart: new Date(),
     });
     return {
       userId,
       sessionToken,
-      sessionStart: session.sessionStart
+      sessionStart: session.sessionStart,
     };
   } catch (err) {
     throw makeStandardError(SESSION.DB_WRITE_ERROR);
@@ -216,10 +222,10 @@ async function _flushSessionFromCache(sessionToken) {
 
 async function _deleteSessionFromDB(sessionToken) {
   const { UserSessions } = models;
-  const session = await UserSessions.find({
+  const session = await UserSessions.findOne({
     where: {
-      sessionToken
-    }
+      sessionToken,
+    },
   });
   if (session) await session.destroy();
 }
@@ -228,5 +234,5 @@ module.exports = {
   getSession,
   createSession,
   destroySession,
-  extendSession
+  extendSession,
 };

package/lib/http/errors.js

@@ -27,12 +27,12 @@ const makeError = (errCode, type, errMsg, detail) => {
  * @param {Error} err
  * @return {Error}
  */
-const modelError = err => {
+const modelError = (err) => {
   return makeError(
     MODEL_ERROR.code,
     MODEL_ERROR.type,
     MODEL_ERROR.msg,
-    err.message
+    err.message,
   );
 };
 
@@ -49,19 +49,19 @@ const modelError = err => {
  *     "msg": "An error has occurred."
  *   }
  */
-const makeStandardError = (errorObj, optionalDesc) => {
+const makeStandardError = (errorObj, optionalDesc = "") => {
   const newErrorObj = Object.assign({}, SERVER_ERROR, errorObj);
   newErrorObj.detail = optionalDesc || newErrorObj.detail;
   return makeError(
     newErrorObj.code,
     newErrorObj.type,
     newErrorObj.msg,
-    newErrorObj.detail
+    newErrorObj.detail,
   );
 };
 
 module.exports = {
   makeError,
   modelError,
-  makeStandardError
+  makeStandardError,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parsony",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "API Engine for Parsony Framework.",
   "keywords": [
     "JSON-RPC, API, Rapid Development"
@@ -29,7 +29,8 @@
     "mysql2": "^3.12.0",
     "node-cron": "^3.0.3",
     "nodemailer": "^6.10.0",
-    "redis": "^4.7.0",
+    "prettier": "^3.5.2",
+    "redis": "^3.1.2",
     "sequelize": "^6.37.5",
     "superagent": "^10.1.1",
     "twilio": "^5.4.5",