feat: Introduce access to already injected instances

This is interesting mostly with keyedSingletons, where inject can happen multiple times with
different keys. Without this feature, accessing said instances again is needlessly problematic.

Disclaimer: getInstances is to be considered experimental, as it could promote suboptimal coding
patterns with eg. more than one responsibility.

packages/injectable/core/index.d.ts

@@ -111,6 +111,12 @@ export type InjectWithParameter = <InjectionInstance, InstantiationParam>(
 
 export type Inject = InjectWithoutParameter & InjectWithParameter;
 
+export type GetInstances = <InjectionInstance>(
+  alias:
+    | Injectable<InjectionInstance, unknown>
+    | InjectionToken<InjectionInstance, void>,
+) => InjectionInstance[];
+
 export type SpecificInjectWithoutParameter<InjectionInstance> = (
   key:
     | Injectable<InjectionInstance, unknown>
@@ -180,6 +186,7 @@ export interface DiContainerForInjection {
   register(...injectables: Injectable<any, any, any>[]): void;
   deregister(...injectables: Injectable<any, any, any>[]): void;
   context: ContextItem[];
+  getInstances: GetInstances;
 }
 
 export interface ILifecycle<InstantiationParam> {

packages/injectable/core/index.test-d.ts

@@ -359,3 +359,22 @@ expectError(
     someProperty: 'not a number',
   })),
 );
+
+// given injectable, when getting instances using injectable, typing is OK
+expectType<string[]>(
+  di.getInstances(
+    getInjectable({
+      id: 'some-injectable',
+      instantiate: () => 'irrelevant',
+    }),
+  ),
+);
+
+// given token, when getting instances using token, typing is OK
+expectType<number[]>(
+  di.getInstances(
+    getInjectionToken<number>({
+      id: 'some-token',
+    }),
+  ),
+);

packages/injectable/core/src/dependency-injection-container/createContainer.js

@@ -229,6 +229,11 @@ export default (containerId, { detectCycles = true } = {}) => {
           : [containerRootContextItem],
         containerRootContextItem.injectable,
       ),
+
+    getInstances: alias =>
+      getRelatedInjectables(alias).flatMap(injectable => [
+        ...instancesByInjectableMap.get(injectable).values(),
+      ]),
   };
 
   return publicDi;

packages/injectable/core/src/scenarios/access-to-already-injected-instances.test.js

@@ -0,0 +1,177 @@
+import getInjectable from '../getInjectable/getInjectable';
+import createContainer from '../dependency-injection-container/createContainer';
+import getInjectionToken from '../getInjectionToken/getInjectionToken';
+import lifecycleEnum from '../dependency-injection-container/lifecycleEnum';
+
+describe('access-to-already-injected-instances', () => {
+  it('given an injectable but not registered, when accessing instances of said injectable, returns empty list', () => {
+    const di = createContainer('irrelevant');
+
+    const someInjectable = getInjectable({
+      id: 'some-injectable',
+      instantiate: () => 'some-instance',
+    });
+
+    const instances = di.getInstances(someInjectable);
+
+    expect(instances).toEqual([]);
+  });
+
+  it('given a injectable and registered, but not injected, when accessing instances of said injectable, returns empty list', () => {
+    const di = createContainer('irrelevant');
+
+    const someInjectable = getInjectable({
+      id: 'some-injectable',
+      instantiate: () => 'some-instance',
+    });
+
+    di.register(someInjectable);
+
+    const instances = di.getInstances(someInjectable);
+
+    expect(instances).toEqual([]);
+  });
+
+  it('given a singleton injectable and registered and injected, when accessing instances of said injectable, returns list containing the instance', () => {
+    const di = createContainer('irrelevant');
+
+    const someInjectable = getInjectable({
+      id: 'some-injectable',
+      instantiate: () => 'some-instance',
+    });
+
+    di.register(someInjectable);
+
+    di.inject(someInjectable);
+
+    const instances = di.getInstances(someInjectable);
+
+    expect(instances).toEqual(['some-instance']);
+  });
+
+  it('given a singleton injectable implementing a token and registered and injected, when accessing instances of said token, returns list containing the instance', () => {
+    const di = createContainer('irrelevant');
+
+    const someInjectionToken = getInjectionToken({
+      id: 'some-injection-token',
+    });
+
+    const someInjectable = getInjectable({
+      id: 'some-injectable',
+      instantiate: () => 'some-instance',
+      injectionToken: someInjectionToken,
+    });
+
+    di.register(someInjectable);
+
+    di.inject(someInjectable);
+
+    const instances = di.getInstances(someInjectionToken);
+
+    expect(instances).toEqual(['some-instance']);
+  });
+
+  it('given a transient injectable and registered and injected, when accessing instances of said injectable, returns empty list of instance, because transient instances are not stored', () => {
+    const di = createContainer('irrelevant');
+
+    const someInjectable = getInjectable({
+      id: 'some-injectable',
+      instantiate: () => 'some-instance',
+      lifecycle: lifecycleEnum.transient,
+    });
+
+    di.register(someInjectable);
+
+    di.inject(someInjectable);
+
+    const instances = di.getInstances(someInjectable);
+
+    expect(instances).toEqual([]);
+  });
+
+  it('given a keyed singleton injectable and registered and injected with different keys, when accessing instances of said injectable, returns list containing the instances', () => {
+    const di = createContainer('irrelevant');
+
+    const someInjectable = getInjectable({
+      id: 'some-injectable',
+      instantiate: (di, key) => `some-instance-for-${key}`,
+      lifecycle: lifecycleEnum.keyedSingleton({
+        getInstanceKey: (di, key) => key,
+      }),
+    });
+
+    di.register(someInjectable);
+
+    di.inject(someInjectable, 'some-key-1');
+    di.inject(someInjectable, 'some-key-2');
+
+    const instances = di.getInstances(someInjectable);
+
+    expect(instances).toEqual([
+      'some-instance-for-some-key-1',
+      'some-instance-for-some-key-2',
+    ]);
+  });
+
+  it('given a keyed singleton injectable implementing a token and registered and injected with different keys, when accessing instances of said token, returns list containing the instances', () => {
+    const di = createContainer('irrelevant');
+
+    const someInjectionToken = getInjectionToken({
+      id: 'some-injection-token',
+    });
+
+    const someInjectable = getInjectable({
+      id: 'some-injectable',
+      instantiate: (di, key) => `some-instance-for-${key}`,
+
+      lifecycle: lifecycleEnum.keyedSingleton({
+        getInstanceKey: (di, key) => key,
+      }),
+
+      injectionToken: someInjectionToken,
+    });
+
+    di.register(someInjectable);
+
+    di.inject(someInjectionToken, 'some-key-1');
+    di.inject(someInjectionToken, 'some-key-2');
+
+    const instances = di.getInstances(someInjectable);
+
+    expect(instances).toEqual([
+      'some-instance-for-some-key-1',
+      'some-instance-for-some-key-2',
+    ]);
+  });
+
+  it('given a keyed singleton injectable implementing a token and registered and "injected many" with different keys, when accessing instances of said token, returns list containing the instances', () => {
+    const di = createContainer('irrelevant');
+
+    const someInjectionToken = getInjectionToken({
+      id: 'some-injection-token',
+    });
+
+    const someInjectable = getInjectable({
+      id: 'some-injectable',
+      instantiate: (di, key) => `some-instance-for-${key}`,
+
+      lifecycle: lifecycleEnum.keyedSingleton({
+        getInstanceKey: (di, key) => key,
+      }),
+
+      injectionToken: someInjectionToken,
+    });
+
+    di.register(someInjectable);
+
+    di.injectMany(someInjectionToken, 'some-key-1');
+    di.injectMany(someInjectionToken, 'some-key-2');
+
+    const instances = di.getInstances(someInjectable);
+
+    expect(instances).toEqual([
+      'some-instance-for-some-key-1',
+      'some-instance-for-some-key-2',
+    ]);
+  });
+});