handle errors from instance factory

Author: Feiyang1

packages/component/src/provider.test.ts

@@ -49,6 +49,40 @@ describe('Provider', () => {
     ).to.not.throw();
   });
 
+  it('does not throw if instance factory throws when calling getImmediate() with optional flag', () => {
+    provider.setComponent(getFakeComponent('test', () => { throw Error('something went wrong!'); }));
+    expect(() => provider.getImmediate({ optional: true })).to.not.throw();
+  });
+
+  it('throws if instance factory throws when calling getImmediate() without optional flag', () => {
+    provider.setComponent(getFakeComponent('test', () => { throw Error('something went wrong!'); }));
+    expect(() => provider.getImmediate()).to.throw();
+  });
+
+  it('does not throw if instance factory throws when calling get()', () => {
+    provider.setComponent(getFakeComponent('test', () => { throw Error('something went wrong!'); }));
+    expect(() => provider.get()).to.not.throw();
+  });
+
+  it('does not throw if instance factory throws when registering an eager component', () => {
+    const eagerComponent = getFakeComponent(
+      'test',
+      () => { throw Error('something went wrong!'); },
+      false,
+      InstantiationMode.EAGER
+    );
+
+    expect(() => provider.setComponent(eagerComponent)).to.not.throw();
+  });
+
+  it('does not throw if instance factory throws when registering a component with a pending promise', () => {
+    // create a pending promise
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    provider.get();
+    const component = getFakeComponent('test', () => { throw Error('something went wrong!'); });
+    expect(() => provider.setComponent(component)).to.not.throw();
+  });
+
   describe('Provider (multipleInstances = false)', () => {
     describe('getImmediate()', () => {
       it('throws if the service is not available', () => {

packages/component/src/provider.ts

@@ -36,7 +36,7 @@ export class Provider<T extends Name> {
   constructor(
     private readonly name: T,
     private readonly container: ComponentContainer
-  ) {}
+  ) { }
 
   /**
    * @param identifier A provider can provide mulitple instances of a service
@@ -50,9 +50,14 @@ export class Provider<T extends Name> {
       const deferred = new Deferred<NameServiceMapping[T]>();
       this.instancesDeferred.set(normalizedIdentifier, deferred);
       // If the service instance is available, resolve the promise with it immediately
-      const instance = this.getOrInitializeService(normalizedIdentifier);
-      if (instance) {
-        deferred.resolve(instance);
+      try {
+        const instance = this.getOrInitializeService(normalizedIdentifier);
+        if (instance) {
+          deferred.resolve(instance);
+        }
+      } catch (e) {
+        // when the instance factory throws an exception during get(), it should not cause
+        // an fatal error. We just return the unresolved promise in this case.
       }
     }
 
@@ -86,17 +91,24 @@ export class Provider<T extends Name> {
     };
     // if multipleInstances is not supported, use the default name
     const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);
+    try {
+      const instance = this.getOrInitializeService(normalizedIdentifier);
 
-    const instance = this.getOrInitializeService(normalizedIdentifier);
+      if (!instance) {
+        if (optional) {
+          return null;
+        }
+        throw Error(`Service ${this.name} is not available`);
+      }
 
-    if (!instance) {
+      return instance;
+    } catch (e) {
       if (optional) {
         return null;
+      } else {
+        throw e;
       }
-      throw Error(`Service ${this.name} is not available`);
     }
-
-    return instance;
   }
 
   setComponent(component: Component<T>): void {
@@ -113,7 +125,14 @@ export class Provider<T extends Name> {
     this.component = component;
     // if the service is eager, initialize the default instance
     if (isComponentEager(component)) {
-      this.getOrInitializeService(DEFAULT_ENTRY_NAME);
+      try {
+        this.getOrInitializeService(DEFAULT_ENTRY_NAME);
+      } catch (e) {
+        // when the instance factory for an eager Component throws an exception during the eager 
+        // initialization, it should not cause an fatal error.
+        // TODO: Investigate if we need to make it configurable, because some component may want to cause
+        // a fatal error in this case?
+      }
     }
 
     // Create service instances for the pending promises and resolve them
@@ -127,10 +146,14 @@ export class Provider<T extends Name> {
         instanceIdentifier
       );
 
-      // `getOrInitializeService()` should always return a valid instance since a component is guaranteed. use ! to make typescript happy.
-      const instance = this.getOrInitializeService(normalizedIdentifier)!;
-
-      instanceDeferred.resolve(instance);
+      try {
+        // `getOrInitializeService()` should always return a valid instance since a component is guaranteed. use ! to make typescript happy.
+        const instance = this.getOrInitializeService(normalizedIdentifier)!;
+        instanceDeferred.resolve(instance);
+      } catch (e) {
+        // when the instance factory throws an exception, it should not cause
+        // an fatal error. We just leave the promise unresolved.
+      }
     }
   }