Merge pull request #95 from dolittle/fix-tsyringe-di

Fix TSyringe bugs and add support for TypeDI

Author: jakhog

Source/dependencyInversion/Internal/Extensions/DelegatingResolver.ts

@@ -21,9 +21,8 @@ export class DelegatingResolver extends IDynamicResolver {
 
     /** @inheritdoc */
     bindUnknownService(serviceIdentifier: interfaces.ServiceIdentifier<unknown>, bindings: Bindings): void {
-        console.log('Delegating called with', serviceIdentifier);
+        // TODO: Implement binding multiple dependencies in special delegating resolvers
         if (this._services.has(serviceIdentifier)) {
-            // TODO: Deal with ResolveAll here (probably easy with the context)
             bindings.bind(serviceIdentifier).toDynamicValue(() => this._services.get(serviceIdentifier));
         }
     }

Source/dependencyInversion/Internal/Implementations/TypeDIServiceProvider.ts

@@ -0,0 +1,52 @@
+// Copyright (c) Dolittle. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { TypeDIContainer } from '../../Types/TypeDIContainer';
+import { IServiceProvider } from '../../IServiceProvider';
+import { ServiceIdentifier } from '../../ServiceIdentifier';
+
+/**
+ * Represents an implementation of {@link IServiceProvider} that uses TypeDI as it's underlying implementation.
+ */
+export class TypeDIServiceProvider extends IServiceProvider {
+    /**
+     * Initialises a new instance of the {@link TypeDIServiceProvider} class.
+     * @param {TypeDIContainer} _container - The TypeDI container.
+     */
+    constructor(private readonly _container: TypeDIContainer) {
+        super();
+    }
+
+    /** @inheritdoc */
+    has(service: ServiceIdentifier<any>): boolean {
+        return this._container.has(this.toAcceptableIdentifier(service));
+    }
+
+    /** @inheritdoc */
+    get<T>(service: ServiceIdentifier<T>): T {
+        return this._container.get<T>(this.toAcceptableIdentifier(service));
+    }
+
+    /** @inheritdoc */
+    getAsync<T>(service: ServiceIdentifier<T>): Promise<T> {
+        return Promise.resolve(this._container.get<T>(this.toAcceptableIdentifier(service)));
+    }
+
+    /** @inheritdoc */
+    getAll<T>(service: ServiceIdentifier<T>): T[] {
+        return this._container.getMany<T>(this.toAcceptableIdentifier(service));
+    }
+
+    /** @inheritdoc */
+    getAllAsync<T>(service: ServiceIdentifier<T>): Promise<T[]> {
+        return Promise.resolve(this._container.getMany<T>(this.toAcceptableIdentifier(service)));
+    }
+
+    private toAcceptableIdentifier<T>(service: ServiceIdentifier<T>): any {
+        if (typeof service === 'symbol') {
+            return service.toString();
+        } else {
+            return service;
+        }
+    }
+}

Source/dependencyInversion/Internal/Implementations/_exports.ts

@@ -4,3 +4,4 @@
 export { InversifyServiceBinder } from './InversifyServiceBinder';
 export { InversifyServiceProvider } from './InversifyServiceProvider';
 export { TSyringeServiceProvider } from './TSyringeServiceProvider';
+export { TypeDIServiceProvider } from './TypeDIServiceProvider';

Source/dependencyInversion/KnownServiceProviders.ts

@@ -3,10 +3,12 @@
 
 import { InversifyContainer } from './Types/InversifyContainer';
 import { TSyringeContainer } from './Types/TSyringeContainer';
+import { TypeDIContainer } from './Types/TypeDIContainer';
 
 /**
  * Defines the service provider types the Dolittle SDK is compatible with.
  */
 export type KnownServiceProviders =
     InversifyContainer |
-    TSyringeContainer;
+    TSyringeContainer |
+    TypeDIContainer;

Source/dependencyInversion/Types/TSyringeContainer.ts

@@ -14,9 +14,9 @@ export type TSyringeContainer = DependencyContainer;
  * @returns {boolean} True if the container is an {@link TSyringeContainer}, false if not.
  */
 export const isTSyringeContainer = (container: any): container is TSyringeContainer => {
-    if (typeof container.isRegistered !== 'function' || container.isRegistered.length !== 2) return false;
-    if (typeof container.resolve !== 'function' || container.resolve.length !== 2) return false;
-    if (typeof container.resolveAll !== 'function' || container.resolveAll.length !== 2) return false;
+    if (typeof container.isRegistered !== 'function' || container.isRegistered.length !== 1) return false;
+    if (typeof container.resolve !== 'function' || container.resolve.length !== 1) return false;
+    if (typeof container.resolveAll !== 'function' || container.resolveAll.length !== 1) return false;
 
     return true;
 };

Source/dependencyInversion/Types/TypeDIContainer.ts

@@ -0,0 +1,26 @@
+// Copyright (c) Dolittle. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { ContainerInstance } from 'typedi';
+
+type TypeDIContainerBase = {
+    [K in keyof ContainerInstance]: ContainerInstance[K];
+};
+
+/**
+ * Defines the interface of an TypeDI container.
+ */
+export interface TypeDIContainer extends TypeDIContainerBase {}
+
+/**
+ * Checks whether or not the provided container is an TypeDI container.
+ * @param {any} container - The container to check.
+ * @returns {boolean} True if the container is an {@link TypeDIContainer}, false if not.
+ */
+export const isTypeDIContainer = (container: any): container is TypeDIContainer => {
+    if (typeof container.has !== 'function' || container.has.length !== 1) return false;
+    if (typeof container.get !== 'function' || container.get.length !== 1) return false;
+    if (typeof container.getMany !== 'function' || container.getMany.length !== 1) return false;
+
+    return true;
+};

Source/dependencyInversion/Types/_exports.ts

@@ -3,3 +3,4 @@
 
 export { InversifyContainer, isInversifyContainer } from './InversifyContainer';
 export { TSyringeContainer, isTSyringeContainer } from './TSyringeContainer';
+export { TypeDIContainer, isTypeDIContainer } from './TypeDIContainer';

Source/dependencyInversion/createRootServiceProvider.ts

@@ -10,6 +10,8 @@ import { isTSyringeContainer } from './Types/TSyringeContainer';
 import { IServiceProvider } from './IServiceProvider';
 import { KnownServiceProviders } from './KnownServiceProviders';
 import { UnknownServiceProviderType } from './UnknownServiceProviderType';
+import { isTypeDIContainer } from './Types/TypeDIContainer';
+import { TypeDIServiceProvider } from './Internal/Implementations/TypeDIServiceProvider';
 
 /**
  * Creates a root {@link IServiceProvider} from the specified service provider.
@@ -26,6 +28,10 @@ export function createRootServiceProvider(serviceProvider: KnownServiceProviders
         return new TSyringeServiceProvider(serviceProvider);
     }
 
+    if (isTypeDIContainer(serviceProvider)) {
+        return new TypeDIServiceProvider(serviceProvider);
+    }
+
     const type = Object.getPrototypeOf(serviceProvider).constructor as Constructor<any>;
     throw new UnknownServiceProviderType(type);
 }

Source/dependencyInversion/package.json

@@ -51,6 +51,7 @@
         "winston": "3.3.2"
     },
     "devDependencies": {
-        "tsyringe": "4.6.0"
+        "tsyringe": "4.6.0",
+        "typedi": "0.10.0"
     }
-}
+}