@mimik/configuration 5.0.12 → 6.0.0

package/README.md

@@ -3,7 +3,7 @@
 ## configuration
 **Example**  
 ```js
-const config = require('@mimik/configuration');
+import config from '@mimik/configuration';
 ```
 
 * [configuration](#module_configuration)
@@ -98,6 +98,7 @@ The following environement variables are being used for the configuration:
 | 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_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`
 | `$_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
 

package/eslint.config.js

@@ -0,0 +1,63 @@
+import importPlugin from 'eslint-plugin-import';
+import js from '@eslint/js';
+import processDoc from '@mimik/eslint-plugin-document-env';
+import stylistic from '@stylistic/eslint-plugin';
+
+const MAX_LENGTH_LINE = 180;
+const MAX_FUNCTION_PARAMETERS = 6;
+const MAX_LINES_IN_FILES = 600;
+const MAX_LINES_IN_FUNCTION = 150;
+const MAX_STATEMENTS_IN_FUNCTION = 45;
+const MIN_KEYS_IN_OBJECT = 10;
+const MAX_COMPLEXITY = 30;
+
+export default [
+  {
+    ignores: ['mochawesome-report/**', 'node_modules/**', 'dist/**'],
+  },
+  importPlugin.flatConfigs.recommended,
+  stylistic.configs['recommended-flat'],
+  js.configs.all,
+  {
+    plugins: {
+      processDoc,
+    },
+    languageOptions: {
+      ecmaVersion: 2022,
+      globals: {
+        console: 'readonly',
+        describe: 'readonly',
+        it: 'readonly',
+        require: 'readonly',
+      },
+      sourceType: 'module',
+    },
+    rules: {
+      '@stylistic/brace-style': ['warn', 'stroustrup', { allowSingleLine: true }],
+      '@stylistic/line-comment-position': ['off'],
+      '@stylistic/semi': ['error', 'always'],
+      'capitalized-comments': ['off'],
+      'complexity': ['error', MAX_COMPLEXITY],
+      'curly': ['off'],
+      'id-length': ['error', { exceptions: ['x', 'y', 'z', 'i', 'j', 'k'] }],
+      'import/no-extraneous-dependencies': ['error', { devDependencies: true }],
+      'import/no-unresolved': ['error', { amd: true, caseSensitiveStrict: true, commonjs: true }],
+      'init-declarations': ['off'],
+      'linebreak-style': ['off'],
+      'max-len': ['warn', MAX_LENGTH_LINE, { ignoreComments: true }],
+      'max-lines': ['warn', { max: MAX_LINES_IN_FILES, skipComments: true }],
+      'max-lines-per-function': ['warn', { max: MAX_LINES_IN_FUNCTION, skipComments: true }],
+      'max-params': ['error', MAX_FUNCTION_PARAMETERS],
+      'max-statements': ['warn', MAX_STATEMENTS_IN_FUNCTION],
+      'no-confusing-arrow': ['off'], // arrow isnt confusing
+      'no-inline-comments': ['off'],
+      'no-process-env': ['error'],
+      'no-ternary': ['off'],
+      'no-undefined': ['off'],
+      'one-var': ['error', 'never'],
+      'processDoc/validate-document-env': ['error'],
+      'quotes': ['warn', 'single'],
+      'sort-keys': ['error', 'asc', { caseSensitive: true, minKeys: MIN_KEYS_IN_OBJECT, natural: false }],
+    },
+  },
+];

package/index.js

@@ -1,106 +1,113 @@
 /* eslint no-process-env: "off" */
-const includes = require('lodash.includes');
-const isNaN = require('lodash.isnan');
-const isNil = require('lodash.isnil');
-const isString = require('lodash.isstring');
-const isUndefined = require('lodash.isundefined');
-const split = require('lodash.split');
-const trim = require('lodash.trim');
-const fs = require('fs');
-const ip = require('ip');
-const uuid = require('uuid');
-const querystring = require('querystring');
-
-const logger = require('@mimik/sumologic-winston-logger');
-const { getCorrelationId } = require('@mimik/request-helper');
-const { userDefinitions } = require('@mimik/user-filters');
-/**
- * @module configuration
- * @example
- * const config = require('@mimik/configuration');
- */
-
-const {
-  SUMOLOGIC,
-  AWS_S3,
+import {
   ALL,
-  SET_ON,
-  SET_OFF,
-  NO_PUBLIC_PROVIDER,
-  NO_GENERIC,
-  ENV_VARIABLE,
-  REDIS_BASE_URL,
-  MONGO_BASE_URL,
-  MONGO_BASE_URL_SRV,
-  SWAGGER_EXT,
-  SWAGGER_SEP,
+  AWS_S3,
   CUSTOMER_CODE_SEP,
-  DEFAULT_ENV,
-  PRODUCTIONS,
-  DEFAULT_LOCATION_PROVIDER,
-  DEFAULT_CLOUD_PROVIDER,
-  DEFAULT_CUSTOMER_CODE,
-  DEFAULT_CACHE_IP,
+  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_VALIDATION_CHECK,
   DEFAULT_CACHE_REQUEST_TTL,
-  DEFAULT_CACHE_API_ID_TTL,
-  DEFAULT_CACHE_API_OPTION_TTL,
-  DEFAULT_REDIS_RECONNECT_TRIES,
-  DEFAULT_REDIS_RECONNECT_INTERVAL,
-  DEFAULT_REDIS_REQUEST_MAX_MEMORY,
-  DEFAULT_REDIS_REQUEST_MAX_MEMORY_POLICY,
-  DEFAULT_REDIS_SOCKET_KEEPALIVE,
-  DEFAULT_REDIS_DISABLE_OFFLINE_QUEUE,
-  DEFAULT_AWS_REGION,
-  DEFAULT_AWS_LOCAL_PROPERTIES,
-  DEFAULT_DYNAMODB_LOCAL_URL,
-  DEFAULT_DYNAMO_THROUGHPUT_READ,
-  DEFAULT_DYNAMO_THROUGHPUT_WRITE,
-  DEFAULT_DYNAMO_THROUGHPUT,
-  DEFAULT_MONGO_MAX_POOL_SIZE,
-  DEFAULT_MONGO_MIN_POOL_SIZE,
-  DEFAULT_MONGO_MAX_IDLE_TIME,
-  DEFAULT_MONGO_SOCKET_TIMEOUT,
-  DEFAULT_MONGO_FAMILY,
-  DEFAULT_MONGO_SERVER_SELECTION_TIMEOUT,
-  DEFAULT_MONGO_HEARTBEAT_FREQUENCY,
+  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_USER,
   DEFAULT_DATABASE_PASSWORD,
-  DEFAULT_DATABASE_CONNECTION_TIMEOUT,
   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_FILTER_FILE,
-  DEFAULT_EXIT_DELAY,
+  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_USER_DEFINITIONS_FILE,
-  DEFAULT_S3_AWS_TIMEOUT,
-  DEFAULT_S3_AWS_MAX_SIZE,
-  DEFAULT_S3_AWS_MAX_EVENTS,
-  DEFAULT_SERVER_SECURITY_SET,
-  DEFAULT_CLUSTER_MANAGEMENT,
-  DEFAULT_CACHE_SET,
-  DEFAULT_TOPIC_SET,
-  DEFAULT_REGISTRATION_SET,
+  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_SERVER_PUBLIC_PROTOCOL,
+  DEFAULT_S3_AWS_MAX_EVENTS,
+  DEFAULT_S3_AWS_MAX_SIZE,
+  DEFAULT_S3_AWS_TIMEOUT,
   DEFAULT_SERVER_PUBLIC_DOMAIN_NAME,
-  DEFAULT_ADMIN_EXTERNAL_ID,
+  DEFAULT_SERVER_PUBLIC_PROTOCOL,
+  DEFAULT_SERVER_SECURITY_SET,
   DEFAULT_SWAGGER_DIR,
   DEFAULT_SWAGGER_FILE_PROVIDER,
+  DEFAULT_TOPIC_SET,
+  DEFAULT_USER_DEFINITIONS_FILE,
+  ENV_VARIABLE,
+  MONGO_BASE_URL,
+  MONGO_BASE_URL_SRV,
+  NO,
+  NO_GENERIC,
+  NO_PUBLIC_PROVIDER,
+  PRODUCTIONS,
+  REDIS_BASE_URL,
+  SET_OFF,
+  SET_ON,
+  SUMOLOGIC,
   SUPPORTED_SWAGGER_FILE_PROVIDERS,
-  DEFAULT_INTERCEPT_ERROR,
-  DEFAULT_BITBUCKET_USERNAME,
-  DEFAULT_BITBUCKET_PASSWORD,
+  SWAGGER_EXT,
+  SWAGGER_SEP,
   YES,
-  NO,
-} = require('./lib/common');
+} from './lib/common.js';
+import fs from '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 trim from 'lodash.trim';
+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;
+const NO_KEY = 0;
+const ISSUE_EXIT = 1;
+/**
+ * @module configuration
+ * @example
+ * import config from '@mimik/configuration';
+ */
 
 let display = true;
 const locParams = [NO_PUBLIC_PROVIDER, ENV_VARIABLE];
@@ -111,8 +118,8 @@ const setupRedis = () => {
   const domain = process.env.CACHE_IP || DEFAULT_CACHE_IP;
   const username = process.env.CACHE_USER;
   const password = process.env.CACHE_PASSWORD;
-  const reconnectTries = parseInt(process.env.REDIS_RECONNECT_TRIES, 10) || DEFAULT_REDIS_RECONNECT_TRIES;
-  const reconnectInterval = parseInt(process.env.REDIS_RECONNECT_INTERVAL, 10) || DEFAULT_REDIS_RECONNECT_INTERVAL;
+  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;
   let url = REDIS_BASE_URL;
   let noAuthUrl = url;
   if (username && password) url += `${username}:${password}@`;
@@ -126,26 +133,25 @@ 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,
+    },
+    cluster: clusterConfig,
+    connectTimeout: parseInt(process.env.CACHE_CONNECTION_TIMEOUT, DECIMAL) || DEFAULT_CACHE_CONNECTION_TIMEOUT,
     domain,
-    username,
-    password,
-    connectTimeout: parseInt(process.env.CACHE_CONNECTION_TIMEOUT, 10) || DEFAULT_CACHE_CONNECTION_TIMEOUT,
-    validationCheck: parseInt(process.env.CACHE_VALIDATION_CHECK, 10) || DEFAULT_CACHE_VALIDATION_CHECK,
-    reconnectOffset: parseInt(process.env.CACHE_RECONNECTION_OFFSET, 10) || DEFAULT_CACHE_RECONNECTION_OFFSET,
-    url,
     noAuthUrl,
-    cluster: clusterConfig,
     options: {
       socket: {
         keepAlive: process.env.REDIS_SOCKET_KEEPALIVE || DEFAULT_REDIS_SOCKET_KEEPALIVE,
-        reconnectStrategy: function retryStrategy(opts) {
-          if (opts.timesConnected > 0 && opts.attempt < reconnectTries) {
+        reconnectStrategy: function reconnectStrategy(opts) {
+          if (opts.timesConnected > AT_LEAST_ONE && opts.attempt < reconnectTries) {
             return reconnectInterval;
           }
           if (opts.error && opts.error.code === 'ECONNREFUSED') {
             if (display) {
               logger.error('Fatal error: Could not connect to cache', { type: 'redis', error: opts.error.code }, `redis-cache-start@0/${new Date().toISOString()}`);
-              logger.flushAndExit(1);
+              logger.flushAndExit(ISSUE_EXIT);
             }
             display = false;
           }
@@ -156,34 +162,35 @@ const setupRedis = () => {
       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,
     },
+    password,
+    reconnectOffset: parseInt(process.env.CACHE_RECONNECTION_OFFSET, DECIMAL) || DEFAULT_CACHE_RECONNECTION_OFFSET,
+    request: {
+      TTL: parseInt(process.env.CACHE_REQUEST_TTL, DECIMAL) || DEFAULT_CACHE_REQUEST_TTL,
+    },
     retryStrategyOptions: {
       reconnectTries,
       reconnectInterval,
     },
-    request: {
-      TTL: parseInt(process.env.CACHE_REQUEST_TTL, 10) || DEFAULT_CACHE_REQUEST_TTL,
-    },
-    api: {
-      idTTL: parseInt(process.env.CACHE_API_ID_TTL, 10) || DEFAULT_CACHE_API_ID_TTL,
-      optionTTL: parseInt(process.env.CACHE_API_OPTION_TTL, 10) || DEFAULT_CACHE_API_OPTION_TTL,
-    },
+    url,
+    username,
+    validationCheck: parseInt(process.env.CACHE_VALIDATION_CHECK, DECIMAL) || DEFAULT_CACHE_VALIDATION_CHECK,
   };
 };
 
 const setupDynamo = (dbOpts) => {
   const dbConfig = {
-    connectTimeout: parseInt(process.env.DATABASE_CONNECTION_TIMEOUT, 10) || DEFAULT_DATABASE_CONNECTION_TIMEOUT,
-    validationCheck: parseInt(process.env.DATABASE_VALIDATION_CHECK, 10) || DEFAULT_DATABASE_VALIDATION_CHECK,
-    reconnectOffset: parseInt(process.env.DATABASE_RECONNECTION_OFFSET, 10) || DEFAULT_DATABASE_RECONNECTION_OFFSET,
+    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,
     throughput: {
-      read: parseInt(process.env.DYNAMO_THROUGHPUT_READ, 10) || DEFAULT_DYNAMO_THROUGHPUT_READ,
-      write: parseInt(process.env.DYNAMO_THROUGHPUT_WRITE, 10) || DEFAULT_DYNAMO_THROUGHPUT_WRITE,
+      read: parseInt(process.env.DYNAMO_THROUGHPUT_READ, DECIMAL) || DEFAULT_DYNAMO_THROUGHPUT_READ,
+      write: parseInt(process.env.DYNAMO_THROUGHPUT_WRITE, DECIMAL) || DEFAULT_DYNAMO_THROUGHPUT_WRITE,
     },
     schemaThroughput: {
-      read: parseInt(process.env.DYNAMO_SCHEMA_THROUGHPUT_READ, 10) || DEFAULT_DYNAMO_THROUGHPUT_READ,
-      write: parseInt(process.env.DYNAMO_SCHEMA_THROUGHPUT_WRITE, 10) || DEFAULT_DYNAMO_THROUGHPUT_WRITE,
+      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,
     },
     tableName: dbOpts.table,
   };
@@ -195,7 +202,7 @@ const setupDynamo = (dbOpts) => {
     delete dbConfig.throughput;
   }
   else if (!isNil(process.env.DYNAMO_SCHEMA_THROUGHPUT)) {
-    const throughput = parseInt(process.env.DYNAMO_SCHEMA_THROUGHPUT, 10);
+    const throughput = parseInt(process.env.DYNAMO_SCHEMA_THROUGHPUT, DECIMAL);
 
     if (isNil(throughput) || isNaN(throughput)) dbConfig.schemaThroughput = DEFAULT_DYNAMO_THROUGHPUT;
     else dbConfig.schemaThroughput = throughput;
@@ -207,9 +214,9 @@ const setupMongo = (dbOpts) => {
   const processStringOptions = () => {
     // default string variables
     const stringOptions = {
-      maxPoolSize: parseInt(process.env.MONGO_MAX_POOL_SIZE, 10) || DEFAULT_MONGO_MAX_POOL_SIZE,
-      minPoolSize: parseInt(process.env.MONGO_MIN_POOL_SIZE, 10) || DEFAULT_MONGO_MIN_POOL_SIZE,
-      maxIdleTimeMS: parseInt(process.env.MONGO_MAX_IDLE_TIME, 10) || DEFAULT_MONGO_MAX_IDLE_TIME,
+      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,
     };
     // string variables without default
     if (process.env.MONGO_SSL === YES) stringOptions.ssl = true; // default value of mongo driver is false
@@ -218,10 +225,11 @@ const setupMongo = (dbOpts) => {
     // if (process.env.MONGO_SSL_CA) stringOptions.sslCA = process.env.MONGO_SSL_CA; // commented out for now as we're not using a pem file at the moment
     if (process.env.MONGO_REPLICAT_SET) stringOptions.replicaSet = process.env.MONGO_REPLICAT_SET;
     if (process.env.MONGO_AUTH_DATABASE) stringOptions.authSource = process.env.MONGO_AUTH_DATABASE;
+    // 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, 10);
-    if (process.env.MONGO_WAIT_QUEUE_TIMEOUT) stringOptions.waitQueueTimeoutMS = parseInt(process.env.MONGO_WAIT_QUEUE_TIMEOUT, 10); // in ms
+    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;
   };
   const database = process.env.DATABASE_NAME;
@@ -243,24 +251,24 @@ const setupMongo = (dbOpts) => {
     noAuthUrl = `${noAuthUrl}?${qs}`;
   }
   return {
-    domain,
+    connectTimeout: parseInt(process.env.DATABASE_CONNECTION_TIMEOUT, DECIMAL) || DEFAULT_DATABASE_CONNECTION_TIMEOUT,
     database,
-    user,
+    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,
+    },
     password,
-    connectTimeout: parseInt(process.env.DATABASE_CONNECTION_TIMEOUT, 10) || DEFAULT_DATABASE_CONNECTION_TIMEOUT,
-    validationCheck: parseInt(process.env.DATABASE_VALIDATION_CHECK, 10) || DEFAULT_DATABASE_VALIDATION_CHECK,
-    reconnectOffset: parseInt(process.env.DATABASE_RECONNECTION_OFFSET, 10) || DEFAULT_DATABASE_RECONNECTION_OFFSET,
-    replicat: !!process.env.MONGO_REPLICAT_SET,
+    reconnectOffset: parseInt(process.env.DATABASE_RECONNECTION_OFFSET, DECIMAL) || DEFAULT_DATABASE_RECONNECTION_OFFSET,
+    replicat: Boolean(process.env.MONGO_REPLICAT_SET),
     stringOptions: qs,
     table: dbOpts.table,
     url,
-    noAuthUrl,
-    options: {
-      family: parseInt(process.env.MONGO_FAMILY, 10) || DEFAULT_MONGO_FAMILY,
-      socketTimeoutMS: parseInt(process.env.MONGO_SOCKET_TIMEOUT, 10) || DEFAULT_MONGO_SOCKET_TIMEOUT,
-      serverSelectionTimeoutMS: parseInt(process.env.MONGO_SERVER_SELECTION_TIMEOUT, 10) || DEFAULT_MONGO_SERVER_SELECTION_TIMEOUT,
-      heartbeatFrequencyMS: parseInt(process.env.MONGO_HEARTBEAT_FREQUENCY, 10) || DEFAULT_MONGO_HEARTBEAT_FREQUENCY,
-    },
+    user,
+    validationCheck: parseInt(process.env.DATABASE_VALIDATION_CHECK, DECIMAL) || DEFAULT_DATABASE_VALIDATION_CHECK,
   };
 };
 
@@ -283,7 +291,7 @@ const setupLog = () => {
       log: process.env.LOG_LEVEL || DEFAULT_LOG_LEVEL,
     },
     filterFile: process.env.FILTER_FILE || DEFAULT_FILTER_FILE,
-    exitDelay: parseInt(process.env.EXIT_DELAY, 10) || DEFAULT_EXIT_DELAY,
+    exitDelay: parseInt(process.env.EXIT_DELAY, DECIMAL) || DEFAULT_EXIT_DELAY,
     noStack: process.env.NO_STACK || DEFAULT_NO_STACK,
   };
 
@@ -297,9 +305,9 @@ const setupLog = () => {
     logInfo[AWS_S3] = {
       region: process.env.S3_AWS_REGION,
       bucketname: process.env.S3_AWS_BUCKET_NAME,
-      timeout: parseInt(process.env.S3_AWS_TIMEOUT, 10) || DEFAULT_S3_AWS_TIMEOUT,
-      maxSize: parseInt(process.env.S3_AWS_MAX_SIZE, 10) || DEFAULT_S3_AWS_MAX_SIZE,
-      maxEvents: parseInt(process.env.S3_AWS_MAX_EVENTS, 10) || DEFAULT_S3_AWS_MAX_EVENTS,
+      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,
     };
     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;
@@ -340,7 +348,7 @@ const setupEncryption = (encryptionOpts) => {
   }
   else encryptionConfig.localMasterKey = process.env.LOCAL_MASTER_KEY;
 
-  if (Object.keys(encryptionOpts.keys).length > 0) encryptionConfig.keys = encryptionOpts.keys;
+  if (Object.keys(encryptionOpts.keys).length > SOME_KEYS) encryptionConfig.keys = encryptionOpts.keys;
 
   return encryptionConfig;
 };
@@ -349,7 +357,9 @@ const setupUserDefinitions = (definitions) => {
   const userDefinitionsFile = definitions.file;
   let customDefinitions = {};
   if (userDefinitionsFile && userDefinitionsFile !== DEFAULT_USER_DEFINITIONS_FILE) {
-    try { customDefinitions = JSON.parse(fs.readFileSync(userDefinitionsFile).toString()); }
+    try {
+      customDefinitions = JSON.parse(fs.readFileSync(userDefinitionsFile).toString());
+    }
     catch (err) {
       throw new Error(`Invalid file for user definitions: ${userDefinitionsFile}, error: ${err.message}`);
     }
@@ -364,20 +374,20 @@ const setupUserDefinitions = (definitions) => {
 const checkConfig = (config) => {
   const errors = [];
 
-  function traverseNodeSync(node, path) {
+  const traverseNodeSync = (node, path) => {
     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}` });
     });
-  }
+  };
 
   traverseNodeSync(config, 'configuration');
   // dependency errors
-  if (!isMSTSet && config.security.apiKeys.length === 0) errors.push({ reason: 'invalid', value: 'config.security.apiKeys', cause: 'isMSTSet' });
+  if (!isMSTSet && config.security.apiKeys.length === NO_KEY) errors.push({ reason: 'invalid', value: 'config.security.apiKeys', cause: 'isMSTSet' });
 
-  if (errors.length > 0) {
+  if (errors.length > SOME_ERRORS) {
     const error = new Error('Errors in configuration');
 
     logger.error(error, { errors }, correlationIdStart);
@@ -405,30 +415,35 @@ const isProd = () => {
 
 process.env.SERVER_LOCAL_IPV4 = ip.address();
 process.env.AWS_LOCAL_PROPERTIES = DEFAULT_AWS_LOCAL_PROPERTIES;
-process.env.CONSOLE_LEVEL = process.env.CONSOLE_LEVEL || DEFAULT_LOG_LEVEL;
-process.env.LOG_LEVEL = process.env.LOG_LEVEL || DEFAULT_LOG_LEVEL;
-process.env.SERVER_ID = process.env.SERVER_ID || uuid.v4();
+process.env.CONSOLE_LEVEL ||= DEFAULT_LOG_LEVEL;
+process.env.LOG_LEVEL ||= DEFAULT_LOG_LEVEL;
+process.env.SERVER_ID ||= uuidv4();
 
 const configuration = {
-  nodeEnvironment: process.env.NODE_ENV || DEFAULT_ENV,
-  locationProvider: process.env.LOCATION_PROVIDER || DEFAULT_LOCATION_PROVIDER,
+  cache: {
+    set: process.env.CACHE_SET || DEFAULT_CACHE_SET,
+  },
   cloudProvider: process.env.CLOUD_PROVIDER || DEFAULT_CLOUD_PROVIDER,
-  serverSettings: {
-    id: process.env.SERVER_ID,
-    customerCode: process.env.CUSTOMER_CODE || DEFAULT_CUSTOMER_CODE,
-    customerCodeSep: process.env.CUSTOMER_CODE ? CUSTOMER_CODE_SEP : '',
-    securitySet: process.env.SERVER_SECURITY_SET || DEFAULT_SERVER_SECURITY_SET,
-    isMSTSet,
-    port: parseInt(process.env.SERVER_PORT, 10),
-    interceptError: process.env.INTERCEPT_ERROR || DEFAULT_INTERCEPT_ERROR,
-    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,
+  cluster: {
+    management: process.env.CLUSTER_MANAGEMENT || DEFAULT_CLUSTER_MANAGEMENT,
+    timeout: parseInt(process.env.REQUEST_TIMEOUT, DECIMAL) || DEFAULT_REQUEST_TIMEOUT,
+  },
+  dependencies: {
+    mIT: {
+      url: process.env.MIT_URL,
+      audience: process.env.MIT_AUDIENCE,
     },
   },
+  encryption: {
+    set: process.env.ENCRYPTION_SET || DEFAULT_ENCRYPTION_SET,
+  },
+  locationProvider: process.env.LOCATION_PROVIDER || DEFAULT_LOCATION_PROVIDER,
+  nodeEnvironment: process.env.NODE_ENV || DEFAULT_ENV,
+  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,
+  },
   security: {
     admin: {
       externalId: process.env.ADMIN_EXTERNAL_ID || DEFAULT_ADMIN_EXTERNAL_ID,
@@ -444,33 +459,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(trim(process.env.API_KEYS), /\s*,\s*/) : [],
-  },
-  cluster: {
-    management: process.env.CLUSTER_MANAGEMENT || DEFAULT_CLUSTER_MANAGEMENT,
-    timeout: parseInt(process.env.REQUEST_TIMEOUT, 10) || DEFAULT_REQUEST_TIMEOUT,
-  },
-  cache: {
-    set: process.env.CACHE_SET || DEFAULT_CACHE_SET,
+    apiKeys: process.env.API_KEYS ? split(trim(process.env.API_KEYS), /\s*,\s*/u) : [],
   },
-  encryption: {
-    set: process.env.ENCRYPTION_SET || DEFAULT_ENCRYPTION_SET,
-  },
-  userDefinitions: {
-    file: process.env.USER_DEFINITIONS_FILE || DEFAULT_USER_DEFINITIONS_FILE,
+  serverSettings: {
+    id: process.env.SERVER_ID,
+    customerCode: process.env.CUSTOMER_CODE || DEFAULT_CUSTOMER_CODE,
+    customerCodeSep: process.env.CUSTOMER_CODE ? CUSTOMER_CODE_SEP : '',
+    securitySet: process.env.SERVER_SECURITY_SET || DEFAULT_SERVER_SECURITY_SET,
+    isMSTSet,
+    port: parseInt(process.env.SERVER_PORT, DECIMAL),
+    interceptError: process.env.INTERCEPT_ERROR || DEFAULT_INTERCEPT_ERROR,
+    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,
+    },
   },
   topic: {
     set: process.env.TOPIC_SET || DEFAULT_TOPIC_SET,
   },
-  dependencies: {
-    mIT: {
-      url: process.env.MIT_URL,
-      audience: process.env.MIT_AUDIENCE,
-    },
-  },
-  registration: {
-    set: process.env.REGISTRATION_SET || DEFAULT_REGISTRATION_SET,
-    retry: parseInt(process.env.REGISTRATION_RETRY, 10) || DEFAULT_REGISTRATION_RETRY,
+  userDefinitions: {
+    file: process.env.USER_DEFINITIONS_FILE || DEFAULT_USER_DEFINITIONS_FILE,
   },
 };
 
@@ -568,6 +579,7 @@ configuration.locationProvider = setupLocationProvider();
  * | 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_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`
  * | `${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
  *
@@ -778,21 +790,21 @@ const setConfig = (pack, options) => {
   }
   if (options.security) {
     Object.keys(options.security).forEach((securityItem) => {
-      if (!configuration.security[securityItem]) {
-        configuration.security[securityItem] = options.security[securityItem];
-      }
-      else {
+      if (configuration.security[securityItem]) {
         Object.keys(options.security[securityItem]).forEach((subSecurityItem) => {
           configuration.security[securityItem][subSecurityItem] = options.security[securityItem][subSecurityItem];
         });
       }
+      else {
+        configuration.security[securityItem] = options.security[securityItem];
+      }
     });
   }
   checkConfig(configuration);
   return configuration;
 };
 
-module.exports = {
+export {
   setConfig,
   isProd,
 };

package/lib/common.js

@@ -81,6 +81,7 @@ const DEFAULT_CLUSTER_MANAGEMENT = SET_OFF;
 const DEFAULT_CACHE_SET = SET_OFF;
 const DEFAULT_TOPIC_SET = SET_OFF;
 const DEFAULT_REGISTRATION_SET = SET_ON;
+const DEFAULT_REGISTRATION_AFTER_POSTOPS_SET = SET_OFF;
 const DEFAULT_INTERCEPT_ERROR = SET_ON;
 
 const DEFAULT_REGISTRATION_RETRY = 3000; // in ms
@@ -98,84 +99,85 @@ const SUPPORTED_SWAGGER_FILE_PROVIDERS = [DEFAULT_SWAGGER_FILE_PROVIDER, 'swagge
 const DEFAULT_BITBUCKET_USERNAME = ' ';
 const DEFAULT_BITBUCKET_PASSWORD = ' ';
 
-module.exports = {
-  SUMOLOGIC,
-  AWS_S3,
+export {
   ALL,
-  SET_ON,
-  SET_OFF,
-  YES,
-  NO,
+  AWS_S3,
   CUSTOMER_CODE_SEP,
-  NO_PUBLIC_PROVIDER,
-  NO_GENERIC,
-  ENV_VARIABLE,
-  DEFAULT_CUSTOMER_CODE,
-  REDIS_BASE_URL,
-  MONGO_BASE_URL,
-  MONGO_BASE_URL_SRV,
-  SWAGGER_EXT,
-  SWAGGER_SEP,
-  PRODUCTIONS,
-  DEFAULT_ENV,
-  DEFAULT_LOCATION_PROVIDER,
-  DEFAULT_CLOUD_PROVIDER,
-  DEFAULT_CACHE_IP,
+  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_VALIDATION_CHECK,
   DEFAULT_CACHE_REQUEST_TTL,
-  DEFAULT_CACHE_API_ID_TTL,
-  DEFAULT_CACHE_API_OPTION_TTL,
-  DEFAULT_REDIS_RECONNECT_TRIES,
-  DEFAULT_REDIS_RECONNECT_INTERVAL,
-  DEFAULT_REDIS_REQUEST_MAX_MEMORY,
-  DEFAULT_REDIS_REQUEST_MAX_MEMORY_POLICY,
-  DEFAULT_REDIS_SOCKET_KEEPALIVE,
-  DEFAULT_REDIS_DISABLE_OFFLINE_QUEUE,
-  DEFAULT_AWS_REGION,
-  DEFAULT_AWS_LOCAL_PROPERTIES,
-  DEFAULT_DYNAMODB_LOCAL_URL,
-  DEFAULT_DYNAMO_THROUGHPUT_READ,
-  DEFAULT_DYNAMO_THROUGHPUT_WRITE,
-  DEFAULT_DYNAMO_THROUGHPUT,
-  DEFAULT_MONGO_MAX_POOL_SIZE,
-  DEFAULT_MONGO_MIN_POOL_SIZE,
-  DEFAULT_MONGO_MAX_IDLE_TIME,
-  DEFAULT_MONGO_SOCKET_TIMEOUT,
-  DEFAULT_MONGO_FAMILY,
-  DEFAULT_MONGO_SERVER_SELECTION_TIMEOUT,
-  DEFAULT_MONGO_HEARTBEAT_FREQUENCY,
+  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_USER,
   DEFAULT_DATABASE_PASSWORD,
-  DEFAULT_DATABASE_CONNECTION_TIMEOUT,
   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_FILTER_FILE,
-  DEFAULT_EXIT_DELAY,
+  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_USER_DEFINITIONS_FILE,
-  DEFAULT_S3_AWS_TIMEOUT,
-  DEFAULT_S3_AWS_MAX_SIZE,
-  DEFAULT_S3_AWS_MAX_EVENTS,
-  DEFAULT_SERVER_SECURITY_SET,
-  DEFAULT_CLUSTER_MANAGEMENT,
-  DEFAULT_CACHE_SET,
-  DEFAULT_TOPIC_SET,
-  DEFAULT_REGISTRATION_SET,
+  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_SERVER_PUBLIC_PROTOCOL,
+  DEFAULT_S3_AWS_MAX_EVENTS,
+  DEFAULT_S3_AWS_MAX_SIZE,
+  DEFAULT_S3_AWS_TIMEOUT,
   DEFAULT_SERVER_PUBLIC_DOMAIN_NAME,
-  DEFAULT_ADMIN_EXTERNAL_ID,
+  DEFAULT_SERVER_PUBLIC_PROTOCOL,
+  DEFAULT_SERVER_SECURITY_SET,
   DEFAULT_SWAGGER_DIR,
   DEFAULT_SWAGGER_FILE_PROVIDER,
+  DEFAULT_TOPIC_SET,
+  DEFAULT_USER_DEFINITIONS_FILE,
+  ENV_VARIABLE,
+  MONGO_BASE_URL,
+  MONGO_BASE_URL_SRV,
+  NO,
+  NO_GENERIC,
+  NO_PUBLIC_PROVIDER,
+  PRODUCTIONS,
+  REDIS_BASE_URL,
+  SET_OFF,
+  SET_ON,
+  SUMOLOGIC,
   SUPPORTED_SWAGGER_FILE_PROVIDERS,
-  DEFAULT_INTERCEPT_ERROR,
-  DEFAULT_BITBUCKET_USERNAME,
-  DEFAULT_BITBUCKET_PASSWORD,
+  SWAGGER_EXT,
+  SWAGGER_SEP,
+  YES,
 };

package/manual-test/test-config.js

@@ -0,0 +1,47 @@
+/* eslint-disable no-console */
+import './testEnv.js';
+import { setConfig } from '../index.js';
+
+const pack = {
+  swaggerFile: {
+    version: '2.0.6',
+    account: 'mimiktech',
+    name: 'swagger-mds',
+  },
+  mimik: {
+    type: 'test-pack-type',
+  },
+};
+const config = {
+  database: {
+    type: 'mongodb',
+    table: {
+      itResource: 'itResource',
+      lease: 'lease',
+    },
+  },
+  dependencies: {
+    'mIT': {
+      audience: 'test-audience',
+      url: 'test-url',
+    },
+    'test-pack-type': {
+      audience: 'test=pack-type-audience',
+    },
+  },
+  security: {
+    server: {
+      id: 'test-id',
+      secret: 'test-secret',
+      accessKey: 'test-access-key',
+      audience: 'test-scurity-audience',
+      issuer: 'test-issuer',
+    },
+  },
+  serverSettings: {
+    type: 'test-type',
+  },
+};
+
+const configuration = setConfig(pack, config);
+console.log(configuration);

package/manual-test/testEnv.js

@@ -0,0 +1,21 @@
+/* eslint no-process-env: "off" */
+import process from 'process';
+
+/**
+ *
+ * Test configuration Configuration.
+ *
+ * @description The following environment variables are needed to configure configuration:
+ *
+ * | Env variable name | Description | Default | Comments |
+ * | ----------------- | ----------- | ------- | -------- |
+ * | DATABASE_NAME | name of the database to use for mongodb
+ * | MONGO_REPLICAT_SET | test for Boolean()
+ * | SUMO_LOGIC_ENDPOINT | dummy endpoint for sumologic
+ * | SUMO_LOGIC_COLLECTOR_CODE | dummy collector code for sumologic
+ */
+
+process.env.DATABASE_NAME = 'test-database-name';
+process.env.MONGO_REPLICAT_SET = 'test-mongo-replicat-set';
+process.env.SUMO_LOGIC_ENDPOINT = 'test-logIngo-sumologic-endpoint';
+process.env.SUMO_LOGIC_COLLECTOR_CODE = 'test-logInfo-sumologic-code';

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@mimik/configuration",
-  "version": "5.0.12",
+  "version": "6.0.0",
   "description": "Common configuration for mimik services",
-  "main": "index.js",
+  "main": "./index.js",
+  "type": "module",
   "scripts": {
-    "lint": "eslint --ignore-path .gitignore .",
+    "lint": "eslint . --no-error-on-unmatched-pattern",
     "docs": "jsdoc2md index.js > README.md",
     "test": "echo \"Error: no test specified\" && exit 0",
     "test-ci": "echo \"Error: no test specified\" && exit 0",
@@ -29,9 +30,9 @@
     "url": "https://bitbucket.org/mimiktech/configuration"
   },
   "dependencies": {
-    "@mimik/request-helper": "^1.7.10",
-    "@mimik/sumologic-winston-logger": "^1.6.20",
-    "@mimik/user-filters": "^1.3.7",
+    "@mimik/request-helper": "^2.0.0",
+    "@mimik/sumologic-winston-logger": "^2.0.1",
+    "@mimik/user-filters": "^2.0.0",
     "ip": "2.0.1",
     "lodash.includes": "4.3.0",
     "lodash.isnan": "3.0.2",
@@ -40,18 +41,15 @@
     "lodash.isundefined": "3.0.1",
     "lodash.split": "4.4.2",
     "lodash.trim": "4.5.1",
-    "uuid": "9.0.1"
+    "uuid": "11.1.0"
   },
   "devDependencies": {
-    "@mimik/eslint-plugin-dependencies": "^2.4.6",
-    "@mimik/eslint-plugin-document-env": "^1.0.6",
-    "eslint": "8.57.0",
-    "eslint-config-airbnb": "19.0.4",
-    "eslint-plugin-import": "2.29.1",
-    "eslint-plugin-jsx-a11y": "6.8.0",
-    "eslint-plugin-react": "7.34.0",
-    "eslint-plugin-react-hooks": "4.6.0",
-    "husky": "9.0.11",
-    "jsdoc-to-markdown": "8.0.1"
+    "@eslint/js": "9.22.0",
+    "@mimik/eslint-plugin-document-env": "^2.0.2",
+    "@stylistic/eslint-plugin": "4.2.0",
+    "eslint": "9.22.0",
+    "eslint-plugin-import": "2.31.0",
+    "husky": "9.1.7",
+    "jsdoc-to-markdown": "9.1.1"
   }
 }

package/.eslintrc

@@ -1,43 +0,0 @@
-{
-  "plugins": [
-    "@mimik/document-env",
-    "@mimik/dependencies"
-  ],
-  "env": {
-    "node": true
-  },
-  "parserOptions": {
-    "ecmaVersion": 2020
-  },
-  "extends": "airbnb",
-  "rules": {
-    "import/no-extraneous-dependencies": ["error", {"devDependencies": true}],
-    "import/no-unresolved": ["error", { "amd": true, "commonjs": true, "caseSensitiveStrict": true }],
-    "brace-style": [1, "stroustrup", {"allowSingleLine": true}],
-    "no-confusing-arrow": [0], // arrow isnt confusing
-    "max-len": [1, 180, { "ignoreComments": true }],
-    "linebreak-style": 0,
-    "quotes": [1, "single"],
-    "semi": [1, "always"],
-    "no-process-env": ["error"],
-    "@mimik/document-env/validate-document-env": 2,
-    "@mimik/dependencies/case-sensitive": 2,
-    "@mimik/dependencies/no-cycles": 2,
-    "@mimik/dependencies/require-json-ext": 2
-  },
-  "settings":{
-    "react": {
-      "version": "detect"
-    }
-  },
-  "globals": {
-    "module": true,
-    "require": true,
-    "const": false,
-    "it": false,
-    "describe": false,
-    "before": true,
-    "after": true,
-    "JSON": true
-  }
-}