2.0.0 / 2022-03-23

==================

* Initial esm support - @craigparra

Author: craig

ApplicationContext.js

@@ -6,8 +6,6 @@ import {
   Context, Component, Property, Scopes,
 } from './context/index.js';
 
-const logger = { LoggerFactory }.getLogger('@alt-javascript/cdi/ApplicationContext');
-
 export default class ApplicationContext {
   // eslint-disable-next-line
   static DEFAULT_CONTEXT_NAME = 'default';
@@ -49,9 +47,9 @@ export default class ApplicationContext {
     this.profiles = options?.profiles;
     this.name = options?.name || ApplicationContext.DEFAULT_CONTEXT_NAME;
     this.configContextPath = options?.configContextPath
-        || process.env.NODE_CONFIG_CONTEXT_PATH
+        || (typeof (process) !== 'undefined' && process?.env?.NODE_CONFIG_CONTEXT_PATH)
         || ApplicationContext.DEFAULT_CONFIG_CONTEXT_PATH;
-    this.config = options?.config || { ConfigFactory }.getConfig({});
+    this.config = options?.config || ConfigFactory.getConfig({});
     if (options?.config) {
       // eslint-disable-next-line no-param-reassign
       delete options.config;
@@ -64,14 +62,15 @@ export default class ApplicationContext {
       // eslint-disable-next-line no-param-reassign
       delete options.configContextPath;
     }
+    this.logger = LoggerFactory.getLogger('@alt-javascript/cdi/ApplicationContext', this.config);
   }
 
   async start() {
     return this.lifeCycle();
   }
 
   async lifeCycle() {
-    logger.verbose(`ApplicationContext (${this.name}) lifecycle started.`);
+    this.logger.verbose(`ApplicationContext (${this.name}) lifecycle started.`);
     this.parseContexts();
     this.createSingletons();
     this.injectSingletonDependencies();
@@ -81,18 +80,18 @@ export default class ApplicationContext {
   }
 
   detectConfigContext() {
-    logger.verbose('Detecting config contexts started.');
+    this.logger.verbose('Detecting config contexts started.');
     if (this.config) {
       if (this.config.has(this.configContextPath)) {
-        logger.verbose(`Detected config context at ${this.configContextPath}, adding context.`);
+        this.logger.verbose(`Detected config context at ${this.configContextPath}, adding context.`);
         this.contexts.push(this.config.get(this.configContextPath));
       }
     }
-    logger.verbose('Detecting config contexts completed.');
+    this.logger.verbose('Detecting config contexts completed.');
   }
 
   detectGlobalContextComponents() {
-    logger.verbose('Detecting global context components started.');
+    this.logger.verbose('Detecting global context components started.');
 
     if (!this.components.config && ApplicationContext.getGlobalRoot('config')) {
       this.deriveContextComponent({
@@ -127,11 +126,11 @@ export default class ApplicationContext {
       });
     }
 
-    logger.verbose('Detecting global context components completed.');
+    this.logger.verbose('Detecting global context components completed.');
   }
 
   parseContexts() {
-    logger.verbose('Parsing configured contexts started.');
+    this.logger.verbose('Parsing configured contexts started.');
     this.detectConfigContext();
     for (let i = 0; i < this.contexts.length; i++) {
       if (this.contexts[i]) {
@@ -142,12 +141,12 @@ export default class ApplicationContext {
         }
       } else {
         const msg = `ApplicationContext (${this.name}) received a nullish context.`;
-        logger.error(msg);
+        this.logger.error(msg);
         throw new Error(msg);
       }
     }
     this.detectGlobalContextComponents();
-    logger.verbose('Parsing configured contexts completed.');
+    this.logger.verbose('Parsing configured contexts completed.');
   }
 
   deriveContextComponent(contextComponent) {
@@ -165,15 +164,15 @@ export default class ApplicationContext {
   }
 
   parseContextComponents(context) {
-    logger.verbose('Processing context components started');
+    this.logger.verbose('Processing context components started');
     if (context.components) {
       if (Array.isArray(context.components)) {
         for (let i = 0; i < context.components.length; i++) {
           this.deriveContextComponent(context.components[i]);
         }
       }
     }
-    logger.verbose('Processing context components completed');
+    this.logger.verbose('Processing context components completed');
   }
 
   parseContextComponent(componentArg) {
@@ -201,7 +200,7 @@ export default class ApplicationContext {
     $component.factoryFunction = component.factoryFunction;
     $component.factoryArgs = component.factoryArgs;
     $component.wireFactory = component.wireFactory;
-    //TODO - dynamic import (async)
+    // TODO - dynamic import (async)
     if (component.require) {
       // eslint-disable-next-line
       // import(component.require).then(
@@ -234,19 +233,19 @@ export default class ApplicationContext {
     if ($component.isActive) {
       if (!this.components[$component.name]) {
         this.components[$component.name] = $component;
-        logger.verbose(`Added application context component (${$component.name}) with ${$component.scope} scope`);
+        this.logger.verbose(`Added application context component (${$component.name}) with ${$component.scope} scope`);
       } else {
         const msg = `Duplicate definition of application context component (${$component.name})`;
-        logger.error(msg);
+        this.logger.error(msg);
         throw new Error(msg);
       }
     } else {
-      logger.verbose(`Skipped inactive application context component (${$component.name}), with scope ${$component.scope}`);
+      this.logger.verbose(`Skipped inactive application context component (${$component.name}), with scope ${$component.scope}`);
     }
   }
 
   createSingletons() {
-    logger.verbose('Creating singletons started');
+    this.logger.verbose('Creating singletons started');
     const keys = Object.keys(this.components);
     for (let i = 0; i < keys.length; i++) {
       const component = this.components[keys[i]];
@@ -263,10 +262,10 @@ export default class ApplicationContext {
         } else {
           component.instance = component.Reference;
         }
-        logger.verbose(`Created singleton (${component.name})`);
+        this.logger.verbose(`Created singleton (${component.name})`);
       }
     }
-    logger.verbose('Creating singletons completed');
+    this.logger.verbose('Creating singletons completed');
   }
 
   resolveConfigPlaceHolder(placeholderArg) {
@@ -279,7 +278,7 @@ export default class ApplicationContext {
       returnValue = this.config.get(path, defaultValue ? JSON.parse(defaultValue) : defaultValue);
     } catch (e) {
       const msg = `Failed to resolve placeholder component property value (${path}) from config.`;
-      logger.error(msg);
+      this.logger.error(msg);
       throw new Error(msg);
     }
     return returnValue;
@@ -294,23 +293,23 @@ export default class ApplicationContext {
       if (autowire) {
         // eslint-disable-next-line no-param-reassign
         instance[insKeys[j]] = this.get(insKeys[j], undefined, component);
-        logger.verbose(`Explicitly autowired component (${component.name}) property (${insKeys[j]}) from context.`);
+        this.logger.verbose(`Explicitly autowired component (${component.name}) property (${insKeys[j]}) from context.`);
       } else if (instance[insKeys[j]] == null) {
         // eslint-disable-next-line no-param-reassign
         instance[insKeys[j]] = this.get(insKeys[j], (instance[insKeys[j]] || null), component);
         if (instance[insKeys[j]] != null) {
-          logger.verbose(`Implicitly autowired null component (${component.name}) property (${insKeys[j]}) from context.`);
+          this.logger.verbose(`Implicitly autowired null component (${component.name}) property (${insKeys[j]}) from context.`);
         }
       } else if (typeof instance[insKeys[j]] === 'string' && instance[insKeys[j]].startsWith('${')) {
         try {
           // eslint-disable-next-line no-param-reassign
           instance[insKeys[j]] = this.resolveConfigPlaceHolder(instance[insKeys[j]]);
         } catch (e) {
           const msg = `Failed to explicitly autowired placeholder component (${component.name}) property value (${insKeys[j]}) from config.`;
-          logger.error(msg);
+          this.logger.error(msg);
           throw new Error(msg);
         }
-        logger.verbose(`Explicitly autowired placeholder component (${component.name}) property value (${insKeys[j]}) from config.`);
+        this.logger.verbose(`Explicitly autowired placeholder component (${component.name}) property value (${insKeys[j]}) from config.`);
       }
     }
   }
@@ -332,17 +331,17 @@ export default class ApplicationContext {
       if (property.reference) {
         // eslint-disable-next-line no-param-reassign
         component.instance[property.name] = this.get(property.reference, undefined, component);
-        logger.verbose(`Explicitly wired component (${component.name}) property (${property.name}) with context reference (${property.reference}).`);
+        this.logger.verbose(`Explicitly wired component (${component.name}) property (${property.name}) with context reference (${property.reference}).`);
       }
       if (property.value) {
         // eslint-disable-next-line no-param-reassign
         component.instance[property.name] = property.value;
-        logger.verbose(`Explicitly wired component (${component.name}) property (${property.name}) with value (${property.value}).`);
+        this.logger.verbose(`Explicitly wired component (${component.name}) property (${property.name}) with value (${property.value}).`);
       }
       if (property.path) {
         // eslint-disable-next-line no-param-reassign
         component.instance[property.name] = this.config.get(property.path, property.defaultValue);
-        logger.verbose(`Explicitly wired component (${component.name}) property (${property.name}) from config path (${property.path}).`);
+        this.logger.verbose(`Explicitly wired component (${component.name}) property (${property.name}) from config path (${property.path}).`);
       }
     }
   }
@@ -360,7 +359,7 @@ export default class ApplicationContext {
   }
 
   injectSingletonDependencies() {
-    logger.verbose('Injecting singletons dependencies started');
+    this.logger.verbose('Injecting singletons dependencies started');
     const keys = Object.keys(this.components);
     for (let i = 0; i < keys.length; i++) {
       const component = this.components[keys[i]];
@@ -369,11 +368,11 @@ export default class ApplicationContext {
         this.wireComponentDependencies(component);
       }
     }
-    logger.verbose('Injecting singleton dependencies completed');
+    this.logger.verbose('Injecting singleton dependencies completed');
   }
 
   initialiseSingletons() {
-    logger.verbose('Initialising singletons started');
+    this.logger.verbose('Initialising singletons started');
     const keys = Object.keys(this.components);
     for (let i = 0; i < keys.length; i++) {
       const component = this.components[keys[i]];
@@ -383,14 +382,14 @@ export default class ApplicationContext {
         } else if (typeof component.init === 'string') {
           component.instance[component.init]();
         }
-        logger.verbose(`Initialised singleton (${component.name})`);
+        this.logger.verbose(`Initialised singleton (${component.name})`);
       }
     }
-    logger.verbose('Initialising singletons completed');
+    this.logger.verbose('Initialising singletons completed');
   }
 
   static registerDestroyer(destroyer) {
-    if (destroyer) {
+    if (typeof (process) !== 'undefined' && destroyer) {
       // process.on('exit', destroyer?.bind());
       // catches ctrl+c event
       process.on('SIGINT', destroyer?.bind());
@@ -403,7 +402,7 @@ export default class ApplicationContext {
   }
 
   async registerSingletonDestroyers() {
-    logger.verbose('Registering singleton destroyers started');
+    this.logger.verbose('Registering singleton destroyers started');
     const keys = Object.keys(this.components);
     for (let i = 0; i < keys.length; i++) {
       const component = this.components[keys[i]];
@@ -415,13 +414,13 @@ export default class ApplicationContext {
           destroyer = () => component.instance[component.destroy](component.instance);
         }
         ApplicationContext.registerDestroyer(destroyer);
-        logger.verbose(`Registering singleton (${component.name}) destroyer`);
+        this.logger.verbose(`Registering singleton (${component.name}) destroyer`);
       }
     }
     ApplicationContext.registerDestroyer(() => {
-      logger.verbose(`ApplicationContext (${this.name}) lifecycle completed.`);
+      this.logger.verbose(`ApplicationContext (${this.name}) lifecycle completed.`);
     });
-    logger.verbose('Registering singleton destroyers completed');
+    this.logger.verbose('Registering singleton destroyers completed');
   }
 
   async run() {
@@ -436,19 +435,19 @@ export default class ApplicationContext {
         }
       }
     }
-    logger.verbose('Application context started');
+    this.logger.verbose('Application context started');
   }
 
   get(reference, defaultValue, targetArgs) {
     if (this.components[reference]) {
-      logger.verbose(`Found component (${reference})`);
+      this.logger.verbose(`Found component (${reference})`);
       if (this.components[reference].scope === Scopes.SINGLETON) {
-        logger.verbose(`Component (${reference}) is scoped as (${Scopes.SINGLETON}), returning existing instance.`);
+        this.logger.verbose(`Component (${reference}) is scoped as (${Scopes.SINGLETON}), returning existing instance.`);
         return this.components[reference].instance;
       }
       let prototype = null;
       if (this.components[reference].isClass) {
-        logger.verbose(`Component (${reference}) is scoped as (${Scopes.PROTOTYPE}), returning new instance.`);
+        this.logger.verbose(`Component (${reference}) is scoped as (${Scopes.PROTOTYPE}), returning new instance.`);
         prototype = new this.components[reference].Reference();
       } else if (typeof this.components[reference].Reference === 'function') {
         let args = targetArgs || this.components[reference].factoryArgs;
@@ -484,15 +483,15 @@ export default class ApplicationContext {
         const factory = this.get(this.components[reference].wireFactory);
         prototype = factory[this.components[reference].factoryFunction](...args);
       } else {
-        logger.verbose(`Component (${reference}) is scoped as (${Scopes.PROTOTYPE}), returning deep clone.`);
+        this.logger.verbose(`Component (${reference}) is scoped as (${Scopes.PROTOTYPE}), returning deep clone.`);
         prototype = _.cloneDeep(this.components[reference].Reference);
       }
       this.autowireComponentDependencies(prototype, this.components[reference]);
       return prototype;
     }
     if (typeof defaultValue === 'undefined') {
       const msg = `Failed component reference lookup for (${reference})`;
-      logger.error(msg);
+      this.logger.error(msg);
       throw new Error(msg);
     }
     return defaultValue;