@mimik/configuration 6.0.6 → 6.0.8

package/index.js

@@ -1,74 +1,15 @@
-/* eslint no-process-env: "off" */
+/* eslint no-process-env: "off", no-magic-numbers: "off" */
 import {
   ALL,
   AWS_S3,
   CUSTOMER_CODE_SEP,
-  DEFAULT_ADMIN_EXTERNAL_ID,
-  DEFAULT_AWS_LOCAL_PROPERTIES,
-  DEFAULT_AWS_REGION,
-  DEFAULT_BITBUCKET_PASSWORD,
-  DEFAULT_BITBUCKET_USERNAME,
-  DEFAULT_CACHE_API_ID_TTL,
-  DEFAULT_CACHE_API_OPTION_TTL,
-  DEFAULT_CACHE_CONNECTION_TIMEOUT,
-  DEFAULT_CACHE_IP,
-  DEFAULT_CACHE_RECONNECTION_OFFSET,
-  DEFAULT_CACHE_REQUEST_TTL,
-  DEFAULT_CACHE_SET,
-  DEFAULT_CACHE_VALIDATION_CHECK,
-  DEFAULT_CLOUD_PROVIDER,
-  DEFAULT_CLUSTER_MANAGEMENT,
-  DEFAULT_CUSTOMER_CODE,
-  DEFAULT_DATABASE_CONNECTION_TIMEOUT,
-  DEFAULT_DATABASE_IP,
-  DEFAULT_DATABASE_PASSWORD,
-  DEFAULT_DATABASE_RECONNECTION_OFFSET,
-  DEFAULT_DATABASE_USER,
-  DEFAULT_DATABASE_VALIDATION_CHECK,
-  DEFAULT_DYNAMODB_LOCAL_URL,
-  DEFAULT_DYNAMO_THROUGHPUT,
-  DEFAULT_DYNAMO_THROUGHPUT_READ,
-  DEFAULT_DYNAMO_THROUGHPUT_WRITE,
-  DEFAULT_ENCRYPTION_SET,
-  DEFAULT_ENV,
-  DEFAULT_EXIT_DELAY,
-  DEFAULT_FILTER_FILE,
-  DEFAULT_INTERCEPT_ERROR,
-  DEFAULT_KMS_PROVIDER,
-  DEFAULT_LOCATION_PROVIDER,
-  DEFAULT_LOG_LEVEL,
-  DEFAULT_MONGO_FAMILY,
-  DEFAULT_MONGO_HEARTBEAT_FREQUENCY,
-  DEFAULT_MONGO_MAX_IDLE_TIME,
-  DEFAULT_MONGO_MAX_POOL_SIZE,
-  DEFAULT_MONGO_MIN_POOL_SIZE,
-  DEFAULT_MONGO_SERVER_SELECTION_TIMEOUT,
-  DEFAULT_MONGO_SOCKET_TIMEOUT,
-  DEFAULT_NO_STACK,
-  DEFAULT_REDIS_DISABLE_OFFLINE_QUEUE,
-  DEFAULT_REDIS_RECONNECT_INTERVAL,
-  DEFAULT_REDIS_RECONNECT_TRIES,
-  DEFAULT_REDIS_REQUEST_MAX_MEMORY,
-  DEFAULT_REDIS_REQUEST_MAX_MEMORY_POLICY,
-  DEFAULT_REDIS_SOCKET_KEEPALIVE,
-  DEFAULT_REGISTRATION_AFTER_POSTOPS_SET,
-  DEFAULT_REGISTRATION_RETRY,
-  DEFAULT_REGISTRATION_SET,
-  DEFAULT_REQUEST_TIMEOUT,
-  DEFAULT_S3_AWS_MAX_EVENTS,
-  DEFAULT_S3_AWS_MAX_SIZE,
-  DEFAULT_S3_AWS_TIMEOUT,
-  DEFAULT_SERVER_PUBLIC_DOMAIN_NAME,
-  DEFAULT_SERVER_PUBLIC_PROTOCOL,
-  DEFAULT_SERVER_SECURITY_SET,
-  DEFAULT_SWAGGER_DIR,
-  DEFAULT_SWAGGER_FILE_PROVIDER,
-  DEFAULT_TOPIC_SET,
-  DEFAULT_USER_DEFINITIONS_FILE,
+  DEBUG,
   ENV_VARIABLE,
+  LOCAL,
   MONGO_BASE_URL,
   MONGO_BASE_URL_SRV,
   NO,
+  NOT_SET,
   NO_GENERIC,
   NO_PUBLIC_PROVIDER,
   PRODUCTIONS,
@@ -80,23 +21,16 @@ import {
   SWAGGER_EXT,
   SWAGGER_SEP,
   YES,
+  toInt,
 } from './lib/common.js';
-import fs from 'fs';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
 import { getCorrelationId } from '@mimik/request-helper';
-import includes from 'lodash.includes';
 import ip from 'ip';
-import isNaN from 'lodash.isnan';
-import isNil from 'lodash.isnil';
-import isString from 'lodash.isstring';
-import isUndefined from 'lodash.isundefined';
 import logger from '@mimik/sumologic-winston-logger';
-import process from 'process';
-import querystring from 'querystring';
-import split from 'lodash.split';
+import process from 'node:process';
 import { userDefinitions } from '@mimik/user-filters';
-import { v4 as uuidv4 } from 'uuid';
 
-const DECIMAL = 10;
 const AT_LEAST_ONE = 0;
 const SOME_KEYS = 0;
 const SOME_ERRORS = 0;
@@ -116,11 +50,11 @@ const correlationIdStart = getCorrelationId('config-start');
 const isMSTSet = process.env.MST_SET !== SET_OFF;
 
 const setupRedis = () => {
-  const domain = process.env.CACHE_IP || DEFAULT_CACHE_IP;
+  const domain = process.env.CACHE_IP || 'localhost:6379';
   const username = process.env.CACHE_USER;
   const password = process.env.CACHE_PASSWORD;
-  const reconnectTries = parseInt(process.env.REDIS_RECONNECT_TRIES, DECIMAL) || DEFAULT_REDIS_RECONNECT_TRIES;
-  const reconnectInterval = parseInt(process.env.REDIS_RECONNECT_INTERVAL, DECIMAL) || DEFAULT_REDIS_RECONNECT_INTERVAL;
+  const reconnectTries = toInt(process.env.REDIS_RECONNECT_TRIES, 100);
+  const reconnectInterval = toInt(process.env.REDIS_RECONNECT_INTERVAL, 500);
   let url = REDIS_BASE_URL;
   let noAuthUrl = url;
   if (username && password) url += `${username}:${password}@`;
@@ -135,16 +69,16 @@ const setupRedis = () => {
 
   return {
     api: {
-      idTTL: parseInt(process.env.CACHE_API_ID_TTL, DECIMAL) || DEFAULT_CACHE_API_ID_TTL,
-      optionTTL: parseInt(process.env.CACHE_API_OPTION_TTL, DECIMAL) || DEFAULT_CACHE_API_OPTION_TTL,
+      idTTL: toInt(process.env.CACHE_API_ID_TTL, 20),
+      optionTTL: toInt(process.env.CACHE_API_OPTION_TTL, 5),
     },
     cluster: clusterConfig,
-    connectTimeout: parseInt(process.env.CACHE_CONNECTION_TIMEOUT, DECIMAL) || DEFAULT_CACHE_CONNECTION_TIMEOUT,
+    connectTimeout: toInt(process.env.CACHE_CONNECTION_TIMEOUT, 30),
     domain,
     noAuthUrl,
     options: {
       socket: {
-        keepAlive: process.env.REDIS_SOCKET_KEEPALIVE || DEFAULT_REDIS_SOCKET_KEEPALIVE,
+        keepAlive: toInt(process.env.REDIS_SOCKET_KEEPALIVE, 5000),
         reconnectStrategy: function reconnectStrategy(opts) {
           if (opts.timesConnected > AT_LEAST_ONE && opts.attempt < reconnectTries) {
             return reconnectInterval;
@@ -158,15 +92,15 @@ const setupRedis = () => {
           }
           return undefined;
         },
-        disableOfflineQueue: (process.env.REDIS_DISABLE_OFFLINE_QUEUE === YES) || DEFAULT_REDIS_DISABLE_OFFLINE_QUEUE,
+        disableOfflineQueue: (process.env.REDIS_DISABLE_OFFLINE_QUEUE === YES),
       },
-      maxMemory: process.env.REDIS_REQUEST_MAX_MEMORY || DEFAULT_REDIS_REQUEST_MAX_MEMORY,
-      maxMemoryPolicy: process.env.REDIS_REQUEST_MAX_MEMORY_POLICY || DEFAULT_REDIS_REQUEST_MAX_MEMORY_POLICY,
+      maxMemory: process.env.REDIS_REQUEST_MAX_MEMORY || '10mb',
+      maxMemoryPolicy: process.env.REDIS_REQUEST_MAX_MEMORY_POLICY || 'allkeys-lru',
     },
     password,
-    reconnectOffset: parseInt(process.env.CACHE_RECONNECTION_OFFSET, DECIMAL) || DEFAULT_CACHE_RECONNECTION_OFFSET,
+    reconnectOffset: toInt(process.env.CACHE_RECONNECTION_OFFSET, 5),
     request: {
-      TTL: parseInt(process.env.CACHE_REQUEST_TTL, DECIMAL) || DEFAULT_CACHE_REQUEST_TTL,
+      TTL: toInt(process.env.CACHE_REQUEST_TTL, 10),
     },
     retryStrategyOptions: {
       reconnectTries,
@@ -174,39 +108,36 @@ const setupRedis = () => {
     },
     url,
     username,
-    validationCheck: parseInt(process.env.CACHE_VALIDATION_CHECK, DECIMAL) || DEFAULT_CACHE_VALIDATION_CHECK,
+    validationCheck: toInt(process.env.CACHE_VALIDATION_CHECK, 1000),
   };
 };
 
 const setupDynamo = (dbOpts) => {
   const dbConfig = {
-    connectTimeout: parseInt(process.env.DATABASE_CONNECTION_TIMEOUT, DECIMAL) || DEFAULT_DATABASE_CONNECTION_TIMEOUT,
-    validationCheck: parseInt(process.env.DATABASE_VALIDATION_CHECK, DECIMAL) || DEFAULT_DATABASE_VALIDATION_CHECK,
-    reconnectOffset: parseInt(process.env.DATABASE_RECONNECTION_OFFSET, DECIMAL) || DEFAULT_DATABASE_RECONNECTION_OFFSET,
-    region: process.env.DYNAMODB_AWS_REGION || DEFAULT_AWS_REGION,
-    url: process.env.DYNAMODB_LOCAL_URL || DEFAULT_DYNAMODB_LOCAL_URL,
+    connectTimeout: toInt(process.env.DATABASE_CONNECTION_TIMEOUT, 30),
+    validationCheck: toInt(process.env.DATABASE_VALIDATION_CHECK, 1000),
+    reconnectOffset: toInt(process.env.DATABASE_RECONNECTION_OFFSET, 5),
+    region: process.env.DYNAMODB_AWS_REGION || '----noRegion----',
+    url: process.env.DYNAMODB_LOCAL_URL || 'http://localhost:8000',
     throughput: {
-      read: parseInt(process.env.DYNAMO_THROUGHPUT_READ, DECIMAL) || DEFAULT_DYNAMO_THROUGHPUT_READ,
-      write: parseInt(process.env.DYNAMO_THROUGHPUT_WRITE, DECIMAL) || DEFAULT_DYNAMO_THROUGHPUT_WRITE,
+      read: toInt(process.env.DYNAMO_THROUGHPUT_READ, 1),
+      write: toInt(process.env.DYNAMO_THROUGHPUT_WRITE, 1),
     },
     schemaThroughput: {
-      read: parseInt(process.env.DYNAMO_SCHEMA_THROUGHPUT_READ, DECIMAL) || DEFAULT_DYNAMO_THROUGHPUT_READ,
-      write: parseInt(process.env.DYNAMO_SCHEMA_THROUGHPUT_WRITE, DECIMAL) || DEFAULT_DYNAMO_THROUGHPUT_WRITE,
+      read: toInt(process.env.DYNAMO_SCHEMA_THROUGHPUT_READ, 1),
+      write: toInt(process.env.DYNAMO_SCHEMA_THROUGHPUT_WRITE, 1),
     },
     tableName: dbOpts.table,
   };
-  if (!isNil(process.env.DYNAMODB_AWS_ACCESS_KEY_ID)) dbConfig.accessKeyId = process.env.DYNAMODB_AWS_ACCESS_KEY_ID;
-  if (!isNil(process.env.DYNAMODB_AWS_SECRET_ACCESS_KEY)) dbConfig.secretAccessKey = process.env.DYNAMODB_AWS_SECRET_ACCESS_KEY;
+  if (process.env.DYNAMODB_AWS_ACCESS_KEY_ID !== undefined) dbConfig.accessKeyId = process.env.DYNAMODB_AWS_ACCESS_KEY_ID;
+  if (process.env.DYNAMODB_AWS_SECRET_ACCESS_KEY !== undefined) dbConfig.secretAccessKey = process.env.DYNAMODB_AWS_SECRET_ACCESS_KEY;
 
   if (process.env.DYNAMO_SCHEMA_THROUGHPUT === 'ON_DEMAND') {
     dbConfig.schemaThroughput = process.env.DYNAMO_SCHEMA_THROUGHPUT;
     delete dbConfig.throughput;
   }
-  else if (!isNil(process.env.DYNAMO_SCHEMA_THROUGHPUT)) {
-    const throughput = parseInt(process.env.DYNAMO_SCHEMA_THROUGHPUT, DECIMAL);
-
-    if (isNil(throughput) || isNaN(throughput)) dbConfig.schemaThroughput = DEFAULT_DYNAMO_THROUGHPUT;
-    else dbConfig.schemaThroughput = throughput;
+  else if (process.env.DYNAMO_SCHEMA_THROUGHPUT !== undefined) {
+    dbConfig.schemaThroughput = toInt(process.env.DYNAMO_SCHEMA_THROUGHPUT, 1);
   }
   return dbConfig;
 };
@@ -215,9 +146,9 @@ const setupMongo = (dbOpts) => {
   const processStringOptions = () => {
     // default string variables
     const stringOptions = {
-      maxPoolSize: parseInt(process.env.MONGO_MAX_POOL_SIZE, DECIMAL) || DEFAULT_MONGO_MAX_POOL_SIZE,
-      minPoolSize: parseInt(process.env.MONGO_MIN_POOL_SIZE, DECIMAL) || DEFAULT_MONGO_MIN_POOL_SIZE,
-      maxIdleTimeMS: parseInt(process.env.MONGO_MAX_IDLE_TIME, DECIMAL) || DEFAULT_MONGO_MAX_IDLE_TIME,
+      maxPoolSize: toInt(process.env.MONGO_MAX_POOL_SIZE, 10),
+      minPoolSize: toInt(process.env.MONGO_MIN_POOL_SIZE, 0),
+      maxIdleTimeMS: toInt(process.env.MONGO_MAX_IDLE_TIME, 30000),
     };
     // string variables without default
     if (process.env.MONGO_SSL === YES) stringOptions.ssl = true; // default value of mongo driver is false
@@ -229,17 +160,17 @@ const setupMongo = (dbOpts) => {
     // eslint-disable-next-line id-length
     if (process.env.MONGO_WRITE_CONCERN) stringOptions.w = process.env.MONGO_WRITE_CONCERN;
     if (process.env.MONGO_RETRY_WRITES) stringOptions.retryWrites = process.env.MONGO_RETRY_WRITES;
-    if (process.env.MONGO_WAIT_QUEUE_MULTIPLE) stringOptions.waitQueueMultiple = parseInt(process.env.MONGO_WAIT_QUEUE_MULTIPLE, DECIMAL);
-    if (process.env.MONGO_WAIT_QUEUE_TIMEOUT) stringOptions.waitQueueTimeoutMS = parseInt(process.env.MONGO_WAIT_QUEUE_TIMEOUT, DECIMAL); // in ms
-    return stringOptions ? querystring.stringify(stringOptions) : null;
+    if (process.env.MONGO_WAIT_QUEUE_MULTIPLE) stringOptions.waitQueueMultiple = toInt(process.env.MONGO_WAIT_QUEUE_MULTIPLE, 0);
+    if (process.env.MONGO_WAIT_QUEUE_TIMEOUT) stringOptions.waitQueueTimeoutMS = toInt(process.env.MONGO_WAIT_QUEUE_TIMEOUT, 0); // in ms
+    return new URLSearchParams(stringOptions).toString();
   };
   const database = process.env.DATABASE_NAME;
   if (!database) {
     return undefined;
   }
-  const domain = process.env.DATABASE_IP || DEFAULT_DATABASE_IP;
-  const user = process.env.DATABASE_USER || DEFAULT_DATABASE_USER;
-  const password = process.env.DATABASE_PASSWORD || DEFAULT_DATABASE_PASSWORD;
+  const domain = process.env.DATABASE_IP || 'localhost';
+  const user = process.env.DATABASE_USER || null;
+  const password = process.env.DATABASE_PASSWORD || null;
   const qs = processStringOptions();
   let url = (process.env.MONGO_USE_SRV === YES) ? MONGO_BASE_URL_SRV : MONGO_BASE_URL;
   let noAuthUrl = url;
@@ -252,24 +183,24 @@ const setupMongo = (dbOpts) => {
     noAuthUrl = `${noAuthUrl}?${qs}`;
   }
   return {
-    connectTimeout: parseInt(process.env.DATABASE_CONNECTION_TIMEOUT, DECIMAL) || DEFAULT_DATABASE_CONNECTION_TIMEOUT,
+    connectTimeout: toInt(process.env.DATABASE_CONNECTION_TIMEOUT, 30),
     database,
     domain,
     noAuthUrl,
     options: {
-      family: parseInt(process.env.MONGO_FAMILY, DECIMAL) || DEFAULT_MONGO_FAMILY,
-      socketTimeoutMS: parseInt(process.env.MONGO_SOCKET_TIMEOUT, DECIMAL) || DEFAULT_MONGO_SOCKET_TIMEOUT,
-      serverSelectionTimeoutMS: parseInt(process.env.MONGO_SERVER_SELECTION_TIMEOUT, DECIMAL) || DEFAULT_MONGO_SERVER_SELECTION_TIMEOUT,
-      heartbeatFrequencyMS: parseInt(process.env.MONGO_HEARTBEAT_FREQUENCY, DECIMAL) || DEFAULT_MONGO_HEARTBEAT_FREQUENCY,
+      family: toInt(process.env.MONGO_FAMILY, 4),
+      socketTimeoutMS: toInt(process.env.MONGO_SOCKET_TIMEOUT, 20000),
+      serverSelectionTimeoutMS: toInt(process.env.MONGO_SERVER_SELECTION_TIMEOUT, 30000),
+      heartbeatFrequencyMS: toInt(process.env.MONGO_HEARTBEAT_FREQUENCY, 10000),
     },
     password,
-    reconnectOffset: parseInt(process.env.DATABASE_RECONNECTION_OFFSET, DECIMAL) || DEFAULT_DATABASE_RECONNECTION_OFFSET,
+    reconnectOffset: toInt(process.env.DATABASE_RECONNECTION_OFFSET, 5),
     replicat: Boolean(process.env.MONGO_REPLICAT_SET),
     stringOptions: qs,
     table: dbOpts.table,
     url,
     user,
-    validationCheck: parseInt(process.env.DATABASE_VALIDATION_CHECK, DECIMAL) || DEFAULT_DATABASE_VALIDATION_CHECK,
+    validationCheck: toInt(process.env.DATABASE_VALIDATION_CHECK, 1000),
   };
 };
 
@@ -277,7 +208,7 @@ const setupLocationProvider = () => {
   const url = process.env.LOCATION_PROVIDER;
 
   if (!url) return NO_PUBLIC_PROVIDER;
-  if (includes(locParams, url)) return url;
+  if (locParams.includes(url)) return url;
   const locationProvider = { url };
 
   if (process.env.LOCATION_PROVIDER_KEY) locationProvider.key = process.env.LOCATION_PROVIDER_KEY;
@@ -288,12 +219,12 @@ const setupLog = () => {
   const logInfo = {
     mode: process.env.LOG_MODE || SUMOLOGIC,
     level: {
-      console: process.env.CONSOLE_LEVEL || DEFAULT_LOG_LEVEL,
-      log: process.env.LOG_LEVEL || DEFAULT_LOG_LEVEL,
+      console: process.env.CONSOLE_LEVEL || DEBUG,
+      log: process.env.LOG_LEVEL || DEBUG,
     },
-    filterFile: process.env.FILTER_FILE || DEFAULT_FILTER_FILE,
-    exitDelay: parseInt(process.env.EXIT_DELAY, DECIMAL) || DEFAULT_EXIT_DELAY,
-    noStack: process.env.NO_STACK || DEFAULT_NO_STACK,
+    filterFile: process.env.FILTER_FILE || NOT_SET,
+    exitDelay: toInt(process.env.EXIT_DELAY, 2000),
+    noStack: process.env.NO_STACK || YES,
   };
 
   if (logInfo.mode === SUMOLOGIC || logInfo.mode === ALL) {
@@ -305,28 +236,28 @@ const setupLog = () => {
   if (logInfo.mode === AWS_S3 || logInfo.mode === ALL) {
     logInfo[AWS_S3] = {
       region: process.env.S3_AWS_REGION,
-      bucketname: process.env.S3_AWS_BUCKET_NAME,
-      timeout: parseInt(process.env.S3_AWS_TIMEOUT, DECIMAL) || DEFAULT_S3_AWS_TIMEOUT,
-      maxSize: parseInt(process.env.S3_AWS_MAX_SIZE, DECIMAL) || DEFAULT_S3_AWS_MAX_SIZE,
-      maxEvents: parseInt(process.env.S3_AWS_MAX_EVENTS, DECIMAL) || DEFAULT_S3_AWS_MAX_EVENTS,
+      bucketName: process.env.S3_AWS_BUCKET_NAME,
+      timeout: toInt(process.env.S3_AWS_TIMEOUT, 5),
+      maxSize: toInt(process.env.S3_AWS_MAX_SIZE, 5),
+      maxEvents: toInt(process.env.S3_AWS_MAX_EVENTS, 1000),
     };
-    if (!isNil(process.env.S3_AWS_ACCESS_KEY_ID)) logInfo[AWS_S3].accessKeyId = process.env.S3_AWS_ACCESS_KEY_ID;
-    if (!isNil(process.env.S3_AWS_SECRET_ACCESS_KEY)) logInfo[AWS_S3].secretAccessKey = process.env.S3_AWS_SECRET_ACCESS_KEY;
+    if (process.env.S3_AWS_ACCESS_KEY_ID !== undefined) logInfo[AWS_S3].accessKeyId = process.env.S3_AWS_ACCESS_KEY_ID;
+    if (process.env.S3_AWS_SECRET_ACCESS_KEY !== undefined) logInfo[AWS_S3].secretAccessKey = process.env.S3_AWS_SECRET_ACCESS_KEY;
   }
   return logInfo;
 };
 
 const setupTopic = (topicOpts) => {
   const topicConfig = {
-    region: process.env.SNS_AWS_REGION || DEFAULT_AWS_REGION,
+    region: process.env.SNS_AWS_REGION || '----noRegion----',
     name: topicOpts.name,
     isFifoTopic: process.env.SET_SNS_TOPIC_FIFO === YES,
     contentBasedDeduplication: false,
   };
 
   if (topicConfig.isFifoTopic) topicConfig.contentBasedDeduplication = process.env.SET_SNS_CONTENT_DEDUPLICATION === YES;
-  if (!isNil(process.env.SNS_AWS_ACCESS_KEY_ID)) topicConfig.accessKeyId = process.env.SNS_AWS_ACCESS_KEY_ID;
-  if (!isNil(process.env.SNS_AWS_SECRET_ACCESS_KEY)) topicConfig.secretAccessKey = process.env.SNS_AWS_SECRET_ACCESS_KEY;
+  if (process.env.SNS_AWS_ACCESS_KEY_ID !== undefined) topicConfig.accessKeyId = process.env.SNS_AWS_ACCESS_KEY_ID;
+  if (process.env.SNS_AWS_SECRET_ACCESS_KEY !== undefined) topicConfig.secretAccessKey = process.env.SNS_AWS_SECRET_ACCESS_KEY;
 
   return topicConfig;
 };
@@ -336,16 +267,16 @@ const setupEncryption = (encryptionOpts) => {
     set: encryptionOpts.set,
     database: process.env.ENCRYPTION_DATABASE,
     keyVaultTable: process.env.KEY_VAULT_TABLE,
-    kmsProvider: process.env.KMS_PROVIDER || DEFAULT_KMS_PROVIDER,
+    kmsProvider: process.env.KMS_PROVIDER || LOCAL,
   };
 
   if (encryptionConfig.kmsProvider.toLowerCase() === 'aws') {
     encryptionConfig.aws = {};
-    encryptionConfig.region = process.env.MASTER_KEY_AWS_REGION || DEFAULT_AWS_REGION;
+    encryptionConfig.region = process.env.MASTER_KEY_AWS_REGION || '----noRegion----';
     encryptionConfig.masterKeyARN = process.env.MASTER_KEY_ARN;
 
-    if (!isNil(process.env.ENCRYPTION_ACCESS_KEY_ID)) encryptionConfig.aws.accessKeyId = process.env.ENCRYPTION_ACCESS_KEY_ID;
-    if (!isNil(process.env.ENCRYPTION_SECRET_ACCESS_KEY)) encryptionConfig.aws.secretAccessKey = process.env.ENCRYPTION_SECRET_ACCESS_KEY;
+    if (process.env.ENCRYPTION_ACCESS_KEY_ID !== undefined) encryptionConfig.aws.accessKeyId = process.env.ENCRYPTION_ACCESS_KEY_ID;
+    if (process.env.ENCRYPTION_SECRET_ACCESS_KEY !== undefined) encryptionConfig.aws.secretAccessKey = process.env.ENCRYPTION_SECRET_ACCESS_KEY;
   }
   else encryptionConfig.localMasterKey = process.env.LOCAL_MASTER_KEY;
 
@@ -357,12 +288,12 @@ const setupEncryption = (encryptionOpts) => {
 const setupUserDefinitions = (definitions) => {
   const userDefinitionsFile = definitions.file;
   let customDefinitions = {};
-  if (userDefinitionsFile && userDefinitionsFile !== DEFAULT_USER_DEFINITIONS_FILE) {
+  if (userDefinitionsFile && userDefinitionsFile !== NOT_SET) {
     try {
       customDefinitions = JSON.parse(fs.readFileSync(userDefinitionsFile).toString());
     }
     catch (err) {
-      throw new Error(`Invalid file for user definitions: ${userDefinitionsFile}, error: ${err.message}`);
+      throw new Error(`Invalid file for user definitions: ${userDefinitionsFile}, error: ${err.message}`, { cause: err });
     }
   }
   return {
@@ -376,11 +307,12 @@ const checkConfig = (config) => {
   const errors = [];
 
   const traverseNodeSync = (node, path) => {
+    if (Array.isArray(node)) return;
     Object.keys(node).forEach((prop) => {
       if (typeof node[prop] === 'object' && node[prop]) {
         traverseNodeSync(node[prop], `${path}.${prop}`);
       }
-      else if (isUndefined(node[prop])) errors.push({ reason: 'missing', value: `${path}.${prop}` });
+      else if (node[prop] === undefined) errors.push({ reason: 'missing', value: `${path}.${prop}` });
     });
   };
 
@@ -407,27 +339,27 @@ const checkConfig = (config) => {
  *
  * | Env variable name | Description | Value | Comments |
  * | ----------------- | ----------- | ----- | -------- |
- * | NODE_ENV | environnment of the microservice |
+ * | NODE_ENV | environment of the microservice |
  */
 export const isProd = () => {
-  if (isString(process.env.NODE_ENV)) return includes(PRODUCTIONS, process.env.NODE_ENV.toLowerCase());
+  if (typeof process.env.NODE_ENV === 'string') return PRODUCTIONS.includes(process.env.NODE_ENV.toLowerCase());
   return false;
 };
 
 process.env.SERVER_LOCAL_IPV4 = ip.address();
-process.env.AWS_LOCAL_PROPERTIES = DEFAULT_AWS_LOCAL_PROPERTIES;
-process.env.CONSOLE_LEVEL ||= DEFAULT_LOG_LEVEL;
-process.env.LOG_LEVEL ||= DEFAULT_LOG_LEVEL;
-process.env.SERVER_ID ||= uuidv4();
+process.env.AWS_LOCAL_PROPERTIES = '169.254.169.254';
+process.env.CONSOLE_LEVEL ||= DEBUG;
+process.env.LOG_LEVEL ||= DEBUG;
+process.env.SERVER_ID ||= crypto.randomUUID();
 
 const configuration = {
   cache: {
-    set: process.env.CACHE_SET || DEFAULT_CACHE_SET,
+    set: process.env.CACHE_SET || SET_OFF,
   },
-  cloudProvider: process.env.CLOUD_PROVIDER || DEFAULT_CLOUD_PROVIDER,
+  cloudProvider: process.env.CLOUD_PROVIDER || 'noCloud',
   cluster: {
-    management: process.env.CLUSTER_MANAGEMENT || DEFAULT_CLUSTER_MANAGEMENT,
-    timeout: parseInt(process.env.REQUEST_TIMEOUT, DECIMAL) || DEFAULT_REQUEST_TIMEOUT,
+    management: process.env.CLUSTER_MANAGEMENT || SET_OFF,
+    timeout: toInt(process.env.REQUEST_TIMEOUT, 10000),
   },
   dependencies: {
     mIT: {
@@ -436,18 +368,18 @@ const configuration = {
     },
   },
   encryption: {
-    set: process.env.ENCRYPTION_SET || DEFAULT_ENCRYPTION_SET,
+    set: process.env.ENCRYPTION_SET || SET_OFF,
   },
-  locationProvider: process.env.LOCATION_PROVIDER || DEFAULT_LOCATION_PROVIDER,
-  nodeEnvironment: process.env.NODE_ENV || DEFAULT_ENV,
+  locationProvider: process.env.LOCATION_PROVIDER || NO_PUBLIC_PROVIDER,
+  nodeEnvironment: process.env.NODE_ENV || LOCAL,
   registration: {
-    set: process.env.REGISTRATION_SET || DEFAULT_REGISTRATION_SET,
-    retry: parseInt(process.env.REGISTRATION_RETRY, DECIMAL) || DEFAULT_REGISTRATION_RETRY,
-    afterPostOpsSet: process.env.REGISTRATION_AFTER_POSTOPS_SET || DEFAULT_REGISTRATION_AFTER_POSTOPS_SET,
+    set: process.env.REGISTRATION_SET || SET_ON,
+    retry: toInt(process.env.REGISTRATION_RETRY, 3000),
+    afterPostOpsSet: process.env.REGISTRATION_AFTER_POSTOPS_SET || SET_OFF,
   },
   security: {
     admin: {
-      externalId: process.env.ADMIN_EXTERNAL_ID || DEFAULT_ADMIN_EXTERNAL_ID,
+      externalId: process.env.ADMIN_EXTERNAL_ID || 'admin',
     },
     server: {
       id: process.env.OAUTH_CLIENT_ID,
@@ -460,29 +392,29 @@ const configuration = {
       key: process.env.OAUTH_GENERIC_KEY || NO_GENERIC,
       audience: process.env.OAUTH_GENERIC_AUDIENCE || NO_GENERIC,
     },
-    apiKeys: process.env.API_KEYS ? split(process.env.API_KEYS.trim(), /\s*,\s*/u) : [],
+    apiKeys: process.env.API_KEYS ? process.env.API_KEYS.trim().split(/\s*,\s*/u) : [],
   },
   serverSettings: {
     id: process.env.SERVER_ID,
-    customerCode: process.env.CUSTOMER_CODE || DEFAULT_CUSTOMER_CODE,
+    customerCode: process.env.CUSTOMER_CODE || '',
     customerCodeSep: process.env.CUSTOMER_CODE ? CUSTOMER_CODE_SEP : '',
-    securitySet: process.env.SERVER_SECURITY_SET || DEFAULT_SERVER_SECURITY_SET,
+    securitySet: process.env.SERVER_SECURITY_SET || SET_ON,
     isMSTSet,
-    port: parseInt(process.env.SERVER_PORT, DECIMAL),
-    interceptError: process.env.INTERCEPT_ERROR || DEFAULT_INTERCEPT_ERROR,
+    port: toInt(process.env.SERVER_PORT, undefined),
+    interceptError: process.env.INTERCEPT_ERROR || SET_ON,
     ip: {
       local: process.env.SERVER_LOCAL_IPV4,
     },
     public: {
-      protocol: process.env.SERVER_PUBLIC_PROTOCOL || DEFAULT_SERVER_PUBLIC_PROTOCOL,
-      domainName: process.env.SERVER_PUBLIC_DOMAIN_NAME || DEFAULT_SERVER_PUBLIC_DOMAIN_NAME,
+      protocol: process.env.SERVER_PUBLIC_PROTOCOL || 'http:',
+      domainName: process.env.SERVER_PUBLIC_DOMAIN_NAME || null,
     },
   },
   topic: {
-    set: process.env.TOPIC_SET || DEFAULT_TOPIC_SET,
+    set: process.env.TOPIC_SET || SET_OFF,
   },
   userDefinitions: {
-    file: process.env.USER_DEFINITIONS_FILE || DEFAULT_USER_DEFINITIONS_FILE,
+    file: process.env.USER_DEFINITIONS_FILE || NOT_SET,
   },
 };
 
@@ -496,8 +428,8 @@ if (!isMSTSet) {
 if (process.env.OAUTH_GENERIC_PREVIOUS_KEY) configuration.security.generic.previousKey = process.env.OAUTH_GENERIC_PREVIOUS_KEY;
 if (process.env.BITBUCKET_USERNAME || process.env.BITBUCKET_PASSWORD) {
   configuration.serverSettings.apiBasicAuth = {
-    username: process.env.BITBUCKET_USERNAME || DEFAULT_BITBUCKET_USERNAME,
-    password: process.env.BITBUCKET_PASSWORD || DEFAULT_BITBUCKET_PASSWORD,
+    username: process.env.BITBUCKET_USERNAME || ' ',
+    password: process.env.BITBUCKET_PASSWORD || ' ',
   };
 }
 if (process.env.SWAGGERHUB_API_KEY) {
@@ -513,10 +445,10 @@ configuration.locationProvider = setupLocationProvider();
  *
  * @function setConfig
  * @category sync
- * @param {string} pack - `Package.json` object to use for the configuration.
+ * @param {object} pack - `Package.json` object to use for the configuration.
  * @param {object} options - Options to add to the config.
  * @return {object} The configuration.
- * @exception Will trow an error if a mandatory value is missing.
+ * @exception Will throw an error if a mandatory value is missing.
  *
  * The following environment variables are being setup:
  *
@@ -535,7 +467,7 @@ configuration.locationProvider = setupLocationProvider();
  * | AWS_LOCAL_PROPERTIES | internal ip address to access aws instance properties | 169.254.169.254
  * | MST_SET | to setup configuration without mST and oauth token setup | on | on/off
  *
- * The following environement variables are being used for the configuration:
+ * The following environment variables are being used for the configuration:
  *
  * | Env variable name | Description | Default | Config property | Comments |
  * | ----------------- | ----------- | ------- | ----------------| -------- |
@@ -543,18 +475,18 @@ configuration.locationProvider = setupLocationProvider();
  * | LOCATION_PROVIDER | location provider URL to use for ip location or `noPublic` or `environment` | noPublic | locationProvider.url or locationProvider | `see public-helper`
  * | LOCATION_PROVIDER_KEY | location provider key to use to access the location provider | null | locationProvider.key | see `public-helper`
  * | CLOUD_PROVIDER | cloud provider running the service | noCloud | cloudProvider | see `public-helper`
- * | SERVER_ID | service id | uuid.v4() | serverSettings.id |
+ * | SERVER_ID | service id | crypto.randomUUID() | serverSettings.id |
  * | CUSTOMER_CODE | customer code associated with the service instance | '' | serverSettings.customerCode | empty string
- * | SWAGGER_FILE_DIRECTORY | directory where the api definition is located | ./api | serverSettings.api | [1]
+ * | SWAGGER_FILE_DIRECTORY | directory where the api definition is located | ../api | serverSettings.api | [1]
  * | BITBUCKET_USERNAME | username to access bitbucket read access on the swagger repos | ' ' | serverSettings.apiBasicAuth.username
  * | BITBUCKET_PASSWORD | password to access bitbucket read access on the swagger repos | ' ' | serverSettings.apiBasicAuth.password
  * | SWAGGERHUB_API_KEY | apiKey to access swaggerhub | | serverSettings.apiApiKey
  * | SERVER_SECURITY_SET | switch to enable or disable the token interpretation | on | serverSettings.securitySet | only active if environment is `local`
  * | INTERCEPT_ERROR | switch to use or not the errorIntercept option | on | serverSettings.interceptError | must be set to off for mID
  * | SERVER_PORT | port of the server |  | serverSettings.port |
- * | SERVER_PUBLIC_PROTOCOL | protocol used to defined the domain address of the sevice | http: | serverSettings.public.protocol |
+ * | SERVER_PUBLIC_PROTOCOL | protocol used to define the domain address of the service | http: | serverSettings.public.protocol |
  * | SERVER_PUBLIC_DOMAIN_NAME | domain name used to define the domain address of the service | null | serverSettings.public.domainName |
- * | ADMIN_EXTERNAL_ID | external id of the admin role to be chacked in the token | admin | security.admin.externalId |
+ * | ADMIN_EXTERNAL_ID | external id of the admin role to be checked in the token | admin | security.admin.externalId |
  * | OAUTH_CLIENT_ID | security id of the service |  | security.server.id | [2]
  * | OAUTH_CLIENT_SECRET | secret of the service |  | security.server.secret | [2]
  * | OAUTH_CLIENT_ACCESS_KEY | key for token signature |  | security.server.accessKey | [2]
@@ -563,9 +495,9 @@ configuration.locationProvider = setupLocationProvider();
  * | OAUTH_GENERIC_KEY | key for token signature provided when a generic for this service type is defined | noGeneric | security.generic.key | [2]
  * | OAUTH_GENERIC_PREVIOUS_KEY | key for the token signature before change the public key | | security.generic.previousKey | [2]
  * | OAUTH_GENERIC_AUDIENCE | url representing the generic of the service type to mST | noGeneric | security.generic.audience | [2]
- * | API_KEYS | list of API Keys which a test against in case of APIKey security | [] |
- * | LOG_MODE | collector the be used to log events | sumologic | logInfo.mode | can be `sumologic`, `awsS3`, `all`, 'awsKinesis'
- * | NO_STACK | disable the inclusion of a the stack in all logs | yes | logInfo.noStack
+ * | API_KEYS | list of API Keys which are tested against in case of APIKey security | [] |
+ * | LOG_MODE | collector to be used to log events | sumologic | logInfo.mode | can be `sumologic`, `awsS3`, `all`, 'awsKinesis'
+ * | NO_STACK | disable the inclusion of the stack in all logs | yes | logInfo.noStack
  * | FILTER_FILE | path for the filter file definition | null | logInfo.filterFile |
  * | USER_DEFINITIONS_FILE | path for the custom user definitions | null | userDefinitions.file |
  * | EXIT_DELAY | delay to allow the log transports to flush | 2000 | logInfo.exitDelay | in milliseconds
@@ -578,23 +510,23 @@ configuration.locationProvider = setupLocationProvider();
  * | ENCRYPTION_SET | switch to enable use of mongodb encryption | off | encryption.set | can be `on`, or `off`
  * | MIT_URL | url for reaching mIT |  | dependencies.mIT.url |
  * | MIT_AUDIENCE | audience of mIT |  | dependencies.mIT.audience | [2]
- * | REGISTRATION_SET | swicht to enable user of registration | on | registration.set | can be `on` or `off`
+ * | REGISTRATION_SET | switch to enable use of registration | on | registration.set | can be `on` or `off`
  * | REGISTRATION_RETRY | retry time for registering to mIT | 3000 | registration.retry | in milliseconds
- * | REGISTRATION_AFTER_POSTOPS_SET | switch to set the registration of execution the postOps | off | registratiom.afterPostOpsSet | can be `on` or `off`
+ * | REGISTRATION_AFTER_POSTOPS_SET | switch to set the registration of execution the postOps | off | registration.afterPostOpsSet | can be `on` or `off`
  * | `${configuration.serverSettings.type}_URL`.toUpperCase() | cluster information | self | dependencies.`(SERVER_TYPE)`.url | should not be used
  * | `${configuration.serverSettings.type}_AUDIENCE`.toUpperCase() | cluster information |  | dependencies.`(SERVER_TYPE)`.audience | [2], but should not be used
  *
- * [1]: `/(SWAGGER_FILE_ACCOUNT)_(SERVER_TYPE)_(SWAGGER_FILE_VERSION)_swagger.json` is added to the `serverSettings.api` property
+ * [1]: `/(SWAGGER_FILE_ACCOUNT)_(SWAGGER_FILE_NAME)_(SWAGGER_FILE_VERSION)_swagger.json` is added to the `serverSettings.api` property
  *
  * [2]: defined when registering to mST
  *
- * When MST_SET is `off`, registration and cluster should not be enabled, so configuration.cluster.management and configuration.registration.set will be set to `off``
+ * When MST_SET is `off`, registration and cluster should not be enabled, so configuration.cluster.management and configuration.registration.set will be set to `off`
  *
  * When `sumologic` or `all` is used for `LOG_MODE` the following environment variables are used for the configuration:
  *
  * | Env variable name | Description | Default | Comments |
  * | ----------------- | ----------- | ------- | -------- |
- * | SUMO_LOGIC_ENDPOINT | endpoint of the sumologic collector to used for logs |
+ * | SUMO_LOGIC_ENDPOINT | endpoint of the sumologic collector used for logs |
  * | SUMO_LOGIC_COLLECTOR_CODE | id of the collector in sumologic |
  *
  * When `awsS3` or `all` is used for `LOG_MODE` the following environment variables are used for the configuration:
@@ -618,7 +550,9 @@ configuration.locationProvider = setupLocationProvider();
  * | SNS_AWS_REGION | region where the topic is | ----noRegion---- |
  *
  * When a database is involved
+ *
  * | Env variable name | Description | Default | Comments |
+ * | ----------------- | ----------- | ------- | -------- |
  * | DATABASE_CONNECTION_TIMEOUT | the time to connect to the database before error is generated | 30 | in seconds
  * | DATABASE_VALIDATION_CHECK | the delay before checking for connection | 1000 | in ms
  * | DATABASE_RECONNECTION_OFFSET | offset for the time to reconnect to the database before error is generated | 5 | in seconds
@@ -632,17 +566,17 @@ configuration.locationProvider = setupLocationProvider();
  * | DATABASE_USER | user to access the database | null | if missing no user/password will be used
  * | DATABASE_PASSWORD | password to access the database | null | if missing no user/password will be used
  * | MONGO_USE_SRV | to use srv connection url set to `yes` | `no` |
- * | MONGO_AUTH_DATABASE | the auth database where users exists | |
- * | MONGO_MAX_POOL_SIZE | the minimum number of connections in the connection pool | 5 |
- * | MONGO_MIN_POOL_SIZE | the maximum number of connections in the connection pool | 10 |
- * | MONGO_MAX_IDLE_TIME | the maximum number of milliseconds that a connection can remain idle in the pool before being removed and closed | 3000 | in milliseconds
+ * | MONGO_AUTH_DATABASE | the auth database where users exist | |
+ * | MONGO_MIN_POOL_SIZE | the minimum number of connections in the connection pool | 0 |
+ * | MONGO_MAX_POOL_SIZE | the maximum number of connections in the connection pool | 10 |
+ * | MONGO_MAX_IDLE_TIME | the maximum number of milliseconds that a connection can remain idle in the pool before being removed and closed | 30000 | in milliseconds
  * | MONGO_RETRY_WRITES | defines if the transaction should be tried again to write set to true or false | |
  * | MONGO_WRITE_CONCERN | accepts a number or `majority` | |
  * | MONGO_SSL | uses ssl connection if `yes` | `no` |
  * | MONGO_SSL_VALIDATE | validates mongod server certificate against ca if set to `yes` | `yes` | `yes` if MONGO_SSL is also `yes`
- * | MONGO_SSL_ALLOW_INVALID_HOSTNAMES | set to yes to allows invalid hostnames | |
+ * | MONGO_SSL_ALLOW_INVALID_HOSTNAMES | set to yes to allow invalid hostnames | |
  * | MONGO_REPLICAT_SET | specifies the name of the replica set, if the mongod is a member of a replica set |  | not mandatory
- * | MONGO_WAIT_QUEUE_MULTIPLE | a number that the driver multiples the maxPoolSize value to, to provide the maximum number of threads allowed to wait for a connection to become available from the pool |  | no mandatory
+ * | MONGO_WAIT_QUEUE_MULTIPLE | a number that the driver multiplies the maxPoolSize value to, to provide the maximum number of threads allowed to wait for a connection to become available from the pool |  | not mandatory
  * | MONGO_WAIT_QUEUE_TIMEOUT | the maximum time in milliseconds that a thread can wait for a connection to become available |  | not mandatory
  * | MONGO_SOCKET_TIMEOUT | The time in milliseconds to attempt a send or receive on a socket before the attempt times out | 20000 | in milliseconds
  * | MONGO_FAMILY | IP address family | 4 | 4 -> IPV4, 6 -> IPV6
@@ -662,7 +596,7 @@ configuration.locationProvider = setupLocationProvider();
  * | ENCRYPTION_SECRET_ACCESS_KEY | if KMS is aws, secretAccessKey to connect KMS | |
  * | LOCAL_MASTER_KEY |  if KMS is local, masterkey to encrypt data keys | |
  *
- * When `dynamodb` is used the following environement variables are used for the configuration:
+ * When `dynamodb` is used the following environment variables are used for the configuration:
  *
  * | Env variable name | Description | Default | Comments |
  * | ----------------- | ----------- | ------- | -------- |
@@ -676,13 +610,13 @@ configuration.locationProvider = setupLocationProvider();
  * | DYNAMO_SCHEMA_THROUGHPUT_WRITE | throughput write for dynamodb schema | 1 |
  * | DYNAMO_SCHEMA_THROUGHPUT | throughput for dynamodb schema |
  *
- * `DYNAMO_SCHEMA_THROUGHPUT` takes precedence over `DYNAMO_SCHEMA_THROUGHPUT_READ` and `DYNAMO_SCHEMA_THROUGHPUT_WRITE`. If DYNAMO_SCHEMA_THROUGHPUT is set to `ON_DEMAND` then index throughput wont apply, and if DYNAMO_SCHEMA_THROUGHPUT is not set to a number the value will be 1.
+ * `DYNAMO_SCHEMA_THROUGHPUT` takes precedence over `DYNAMO_SCHEMA_THROUGHPUT_READ` and `DYNAMO_SCHEMA_THROUGHPUT_WRITE`. If DYNAMO_SCHEMA_THROUGHPUT is set to `ON_DEMAND` then index throughput won't apply, and if DYNAMO_SCHEMA_THROUGHPUT is not set to a number the value will be 1.
  *
- * When `redis` is used the following environement variables are used for the configuration:
+ * When `redis` is used the following environment variables are used for the configuration:
  *
  * | Env variable name | Description | Default | Comments |
  * | ----------------- | ----------- | ------- | -------- |
- * | CACHE_IP | domain of the redis server to use with port, a comma seperated list if using cluster | localhost:6379 |
+ * | CACHE_IP | domain of the redis server to use with port, a comma separated list if using cluster | localhost:6379 |
  * | CACHE_USER | redis user if the redis service is auth protected | null |
  * | CACHE_PASSWORD | redis password for the user if the redis service is auth protected | null |
  * | CACHE_CLUSTER_SET | set on, when using redis in a cluster. | off |
@@ -694,11 +628,11 @@ configuration.locationProvider = setupLocationProvider();
  * | CACHE_REQUEST_TTL | request time to live in cache | 10 | in seconds
  * | CACHE_API_ID_TTL | API request time to live for main resource | 20 | in seconds
  * | CACHE_API_OPTION_TTL | API request time to live for option | 5 | in seconds
- * | REDIS_RECONNECT_TRIES | number of tries to restablish a connection | 100 |
+ * | REDIS_RECONNECT_TRIES | number of tries to reestablish a connection | 100 |
  * | REDIS_RECONNECT_INTERVAL | time to wait before retry | 500 | in milliseconds
- * | REDIS_REQUEST_MAX_MEMORY | maximum memory size of the request cache | 10 | in megabytes
+ * | REDIS_REQUEST_MAX_MEMORY | maximum memory size of the request cache | 10mb | in megabytes
  * | REDIS_REQUEST_MAX_MEMORY_POLICY | eviction policy of the request cache | allkeys-lru |
- * | REDIS_SOCKET_KEEPALIVE | keep long running connections alive for x seconds | 5000 | in seconds
+ * | REDIS_SOCKET_KEEPALIVE | keep long-running connections alive | 5000 | in milliseconds
  * | REDIS_DISABLE_OFFLINE_QUEUE | queuing event when not connected | no |
  */
 export const setConfig = (pack, options) => {
@@ -710,16 +644,15 @@ export const setConfig = (pack, options) => {
     process.env.SWAGGER_FILE_ACCOUNT = pack.swaggerFile.account;
     process.env.SWAGGER_FILE_NAME = pack.swaggerFile.name;
     if (pack.swaggerFile.provider) process.env.SWAGGER_FILE_PROVIDER = pack.swaggerFile.provider;
-    else process.env.SWAGGER_FILE_PROVIDER = DEFAULT_SWAGGER_FILE_PROVIDER;
+    else process.env.SWAGGER_FILE_PROVIDER = 'bitbucket';
   }
 
-  // eslint-disable-next-line max-len
   const apiFilename = `${process.env.SWAGGER_FILE_ACCOUNT}${SWAGGER_SEP}${process.env.SWAGGER_FILE_NAME}${SWAGGER_SEP}${process.env.SWAGGER_FILE_VERSION}${SWAGGER_SEP}${SWAGGER_EXT}`;
 
   configuration.serverSettings.name = process.env.SERVER_NAME;
   configuration.serverSettings.type = process.env.SERVER_TYPE;
   configuration.serverSettings.version = process.env.SERVER_VERSION;
-  configuration.serverSettings.api = `${process.env.SWAGGER_FILE_DIRECTORY || DEFAULT_SWAGGER_DIR}/${apiFilename}`;
+  configuration.serverSettings.api = `${process.env.SWAGGER_FILE_DIRECTORY || '../api'}/${apiFilename}`;
   configuration.serverSettings.swaggerFile = {
     version: process.env.SWAGGER_FILE_VERSION,
     name: process.env.SWAGGER_FILE_NAME,
@@ -751,15 +684,15 @@ export const setConfig = (pack, options) => {
       configuration.dynamoose = setupDynamo(options.database);
     }
     else {
-      throw new Error(`database type no supported: ${options.database.type}`);
+      throw new Error(`database type not supported: ${options.database.type}`);
     }
   }
   if (options.cache && configuration.cache.set === SET_ON) {
     if (options.cache.type === 'redis') {
-      configuration.redisSettings = setupRedis(options.cache);
+      configuration.redisSettings = setupRedis();
     }
     else {
-      throw new Error(`cache type no supported: ${options.cache.type}`);
+      throw new Error(`cache type not supported: ${options.cache.type}`);
     }
   }
   if (options.topic && configuration.topic.set === SET_ON) {
@@ -791,7 +724,7 @@ export const setConfig = (pack, options) => {
   }
   if (options.security) {
     Object.keys(options.security).forEach((securityItem) => {
-      if (configuration.security[securityItem]) {
+      if (securityItem in configuration.security) {
         Object.keys(options.security[securityItem]).forEach((subSecurityItem) => {
           configuration.security[securityItem][subSecurityItem] = options.security[securityItem][subSecurityItem];
         });