feat: add onReady lifecycle

This notifies listeners on ready to be used components

Closes #1121

lib/__tests__/on-ready-lifecycle-test.ts

@@ -0,0 +1,115 @@
+// tslint:disable: no-implicit-dependencies
+import { assert } from 'chai';
+import { TSDI, component, initialize, inject } from '..';
+
+describe('TSDI', () => {
+  let tsdi: TSDI;
+
+  beforeEach(() => {
+    tsdi = new TSDI();
+  });
+
+  afterEach(() => {
+    tsdi.close();
+  });
+
+  describe('with initializers', () => {
+    it('should notify when a component without initializer is ready to be used', (done) => {
+      @component
+      class Component {}
+      tsdi.register(Component);
+
+      tsdi.addLifecycleListener({
+        onReady(component: any): void {
+          assert.instanceOf(component, Component);
+          done();
+        },
+      });
+
+      tsdi.get(Component);
+    });
+
+    it('should notify when a component is ready to be used', (done) => {
+      @component
+      class Component {
+        @initialize
+        protected init(): void {
+          //
+        }
+      }
+      tsdi.register(Component);
+
+      tsdi.addLifecycleListener({
+        onReady(component: any): void {
+          assert.instanceOf(component, Component);
+          done();
+        },
+      });
+
+      tsdi.get(Component);
+    });
+
+    it('should notify when a component with async dependency is ready to be used', (done) => {
+      @component
+      class Dependency {
+        @initialize
+        protected async init(): Promise<void> {
+          return Promise.resolve();
+        }
+      }
+      tsdi.register(Dependency);
+
+      @component
+      class Component {
+        @inject
+        public readonly dependency!: Dependency;
+
+        @initialize
+        protected async init(): Promise<void> {
+          return Promise.resolve();
+        }
+      }
+      tsdi.register(Component);
+
+      tsdi.addLifecycleListener({
+        onReady(component: any): void {
+          if (component instanceof Component) {
+            assert.instanceOf(component, Component);
+            done();
+          }
+        },
+      });
+
+      tsdi.get(Component);
+    });
+
+    it('should notify when a component without initializer but with async dependency is ready to be used', (done) => {
+      @component
+      class Dependency {
+        @initialize
+        protected async init(): Promise<void> {
+          return Promise.resolve();
+        }
+      }
+      tsdi.register(Dependency);
+
+      @component
+      class Component {
+        @inject
+        public readonly dependency!: Dependency;
+      }
+      tsdi.register(Component);
+
+      tsdi.addLifecycleListener({
+        onReady(component: any): void {
+          if (component instanceof Component) {
+            assert.instanceOf(component, Component);
+            done();
+          }
+        },
+      });
+
+      tsdi.get(Component);
+    });
+  });
+});

lib/tsdi.ts

@@ -65,6 +65,7 @@ export type Mock<T> = { -readonly [P in keyof T]: T[P] };
 
 export interface LifecycleListener {
   onCreate?(component: any): void;
+  onReady?(component: any): void;
   onDestroy?(component: any): void;
 }
 
@@ -151,25 +152,21 @@ export class TSDI {
 
   public addLifecycleListener(lifecycleListener: LifecycleListener): void {
     this.lifecycleListeners.push(lifecycleListener);
-    Object.keys(this.instances).forEach((idx) => {
-      this.notifyOnCreate(this.instances[parseInt(idx, 10)]);
-    });
+    Object.keys(this.instances).forEach((idx) =>
+      this.notifyOnCreate(this.instances[parseInt(idx, 10)])
+    );
   }
 
   private notifyOnCreate(component: any): void {
-    this.lifecycleListeners.forEach((l) => {
-      if (l.onCreate) {
-        l.onCreate(component);
-      }
-    });
+    this.lifecycleListeners.forEach((l) => l.onCreate?.(component));
+  }
+
+  private notifyOnReady(component: any): void {
+    this.lifecycleListeners.forEach((l) => l.onReady?.(component));
   }
 
   private notifyOnDestroy(component: any): void {
-    this.lifecycleListeners.forEach((l) => {
-      if (l.onDestroy) {
-        l.onDestroy(component);
-      }
-    });
+    this.lifecycleListeners.forEach((l) => l.onDestroy?.(component));
   }
 
   public addProperty(key: string, value: any): void {
@@ -537,13 +534,24 @@ export class TSDI {
       if (awaiter) {
         this.addInitializerPromise(
           instance,
-          awaiter.then(() => instance[init].call(instance) || Promise.resolve())
+          awaiter
+            .then(() => instance[init].call(instance) || Promise.resolve())
+            .then(() => this.notifyOnReady(instance))
         );
       } else {
-        this.addInitializerPromise(instance, instance[init].call(instance));
+        this.addInitializerPromise(
+          instance,
+          (instance[init].call(instance) || Promise.resolve()).then(() =>
+            this.notifyOnReady(instance)
+          )
+        );
       }
     } else if (awaiter) {
+      // tslint:disable-next-line: no-floating-promises
+      awaiter.then(() => this.notifyOnReady(instance));
       this.addInitializerPromise(instance, awaiter);
+    } else {
+      this.notifyOnReady(instance);
     }
   }