feat(reactant-di): add got/gotAll api for DI container (#90)

Author: unadlib

packages/reactant-di/src/createContainer.ts

@@ -1,5 +1,6 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import {
-  Container,
+  Container as BaseContainer,
   MetadataReader,
   interfaces,
   ContainerModule,
@@ -93,6 +94,38 @@ function autoDecorateParams(target: object) {
   });
 }
 
+export class Container extends BaseContainer {
+  constructor(
+    options: interfaces.ContainerOptions,
+    private _serviceIdentifiers: Map<
+      interfaces.ServiceIdentifier<any>,
+      interfaces.ServiceIdentifier<any>[]
+    >
+  ) {
+    super(options);
+  }
+
+  /**
+   * get the loaded module
+   */
+  got<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): T | undefined {
+    return this._serviceIdentifiers.has(serviceIdentifier)
+      ? this.get(serviceIdentifier)
+      : undefined;
+  }
+
+  /**
+   * get loaded modules
+   */
+  gotAll<T>(
+    serviceIdentifier: interfaces.ServiceIdentifier<T>
+  ): T[] | undefined {
+    return this._serviceIdentifiers.has(serviceIdentifier)
+      ? this.getAll(serviceIdentifier)
+      : undefined;
+  }
+}
+
 export function bindModules(container: Container, modules: ModuleOptions[]) {
   const provideMeta = getMetadata(METADATA_KEY.provide);
   for (const module of modules) {
@@ -157,7 +190,7 @@ export function createContainer({
   options,
 }: ContainerConfig) {
   setModulesDeps(modules);
-  const container = new Container(options);
+  const container = new Container(options!, ServiceIdentifiers);
   container.applyCustomMetadataReader(new CustomMetadataReader());
   bindModules(container, modules);
   container.applyMiddleware(createCollector(ServiceIdentifiers));

packages/reactant-di/src/interfaces.ts

@@ -1,6 +1,8 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { interfaces, LazyServiceIdentifer } from 'inversify';
 import { METADATA_KEY } from './constants';
 import { Optional } from './optional';
+import type { Container as IContainer } from './createContainer';
 
 type PickByKey<T, P extends keyof T> = {
   [K in Exclude<keyof T, P>]: T[K];
@@ -10,7 +12,7 @@ export type ContainerOptions = PickByKey<
   interfaces.ContainerOptions,
   'skipBaseClassChecks'
 >;
-export type Container = interfaces.Container;
+export type Container = IContainer;
 export type ServiceIdentifier<T> = interfaces.ServiceIdentifier<T>;
 export type ServiceIdentifierOrFunc<T> =
   | ServiceIdentifier<T>
@@ -20,13 +22,12 @@ export type ServiceIdentifiersMap<T = any> = Map<
   ServiceIdentifier<T>,
   ServiceIdentifier<T>[]
 >;
-
-export type MetadataMap = Map<ServiceIdentifier<any>, Module<any>>;
-
 export interface Module<T> extends Function {
   new (...args: any[]): T;
 }
 
+export type MetadataMap = Map<ServiceIdentifier<any>, Module<any>>;
+
 export interface DependencyProviderOption {
   provide: ServiceIdentifier<any>;
   optional: boolean;

packages/reactant-di/test/index.test.ts

@@ -1,4 +1,4 @@
-import { injectable, createContainer, inject, optional } from '..';
+import { injectable, createContainer, inject, optional, multiInject } from '..';
 
 test('decoration for interface', () => {
   interface FooInterface {
@@ -162,3 +162,49 @@ test('mix @optional/@inject about inheritance', () => {
   expect(bar.foo instanceof Foo).toBeTruthy();
   expect(bar.foo1 instanceof Foo1).toBeTruthy();
 });
+
+test('Container APIs: got/gotAll', () => {
+  @injectable()
+  class Foo {
+    public get test() {
+      return 'test';
+    }
+  }
+
+  @injectable()
+  class FooBar {}
+
+  @injectable()
+  class FooBar1 {}
+
+  @injectable()
+  class Bar {
+    constructor(@multiInject(Foo) public foos: Foo[], public fooBar: FooBar) {}
+
+    public get length() {
+      return this.foos.length;
+    }
+  }
+
+  const ServiceIdentifiers = new Map();
+
+  const container = createContainer({
+    ServiceIdentifiers,
+    modules: [Foo, Foo, FooBar],
+    options: {
+      defaultScope: 'Singleton',
+    },
+  });
+
+  const bar = container.get(Bar);
+  const fooBar = container.get(FooBar);
+
+  expect(bar.length).toBe(2);
+  expect(bar.fooBar instanceof FooBar).toBeTruthy();
+  expect(bar.fooBar).toBe(fooBar);
+  expect(container.got(FooBar)).toBe(fooBar);
+  expect(container.gotAll(Foo)!.length).toBe(2);
+  expect(container.gotAll(Foo)).toEqual(bar.foos);
+  expect(container.got(FooBar1)).toBeUndefined();
+  expect(container.gotAll(FooBar1)).toBeUndefined();
+});