#84_LifeTime for Factories

Author: basedalexander

README.md

@@ -104,7 +104,7 @@ class Service {
 ```
 
 ### Life Time control.
-> By default, containers resolve singletons when registering with **useClass**. Change it by setting **lifeTime** attribute to **LifeTime.PerRequest**.
+> By default, containers resolve singletons when **useClass** and **useFactory**. Change it by setting **lifeTime** attribute to **LifeTime.PerRequest**.
 
 ```typescript
 import { LifeTime } from 'container-ioc';
@@ -113,6 +113,14 @@ container.register([
     { token: TService, useClass: Service, lifeTime: LifeTime.PerRequest }
 ]);
 ```
+```typescript
+container.register([
+    {
+        token: TService,
+        useFactory: () => { serve(): void {} },
+        lifeTime: LifeTime.PerRequest }
+]);
+```
 
 ### Hierarchical containers.
 > If container can't find value, it will look it up in ascendant containers.

src/lib/container.ts

@@ -1,7 +1,7 @@
 import { IConstructor, IInjectionInstance, IInjectionMd, IProvider, LifeTime, ProviderToken, RegistrationProvider } from './interfaces';
-import { IRegistryData, RegistryData } from './registry-data';
+import { FactoryFunction, IFactory, IRegistryData, RegistryData } from './registry-data';
 import { IContainer } from './container.interface';
-import { ClassNotInjectableError, InvalidProviderProvidedError, NoProviderError } from './exceptions';
+import { InvalidProviderProvidedError, NoProviderError } from './exceptions';
 import { INJECTABLE_MD_KEY, INJECTIONS_MD_KEY } from './metadata/keys';
 import { IMetadataAnnotator } from './metadata/metadata-annotator.interface';
 import { AnnotatorProvider } from './metadata/index';
@@ -32,14 +32,14 @@ export class Container implements IContainer {
         return new Container(this);
     }
 
-    public setParent(parent: IContainer): void {
-        this.parent = parent;
-    }
-
     public createChild(): IContainer {
         return new Container(this);
     }
 
+    public setParent(parent: IContainer): void {
+        this.parent = parent;
+    }
+
     private resolveInternal(token: ProviderToken, traceMessage?: string): IInjectionInstance {
         traceMessage = this.buildTraceMessage(token, traceMessage);
 
@@ -56,24 +56,7 @@ export class Container implements IContainer {
             return registryData.instance;
         }
 
-        if (registryData.factory) {
-            let injections: ProviderToken[] = [];
-
-            if (registryData.injections) {
-                injections = registryData.injections.map(i => this.resolveInternal(i, traceMessage));
-            }
-
-            return registryData.factory(...injections);
-        }
-
-        const constructor: IConstructor = registryData.cls;
-
-        const isInjectable: boolean = this.isInjectable(constructor);
-        if (!isInjectable) {
-            throw new ClassNotInjectableError(constructor.name);
-        }
-
-        const instance: IInjectionInstance = this.createInstance(constructor, traceMessage);
+        const instance: IInjectionInstance = this.instantiateWithFactory(registryData.factory, traceMessage);
 
         if (registryData.lifeTime === LifeTime.Persistent) {
             registryData.instance = instance;
@@ -92,28 +75,57 @@ export class Container implements IContainer {
 
         if (provider.useValue) {
             registryData.instance = provider.useValue;
-        } else if (provider.useClass) {
-            registryData.cls = provider.useClass;
-        } else if (provider.useFactory) {
-            registryData.factory = provider.useFactory;
-            registryData.injections = <ProviderToken[]> provider.inject;
-        }
+        } else {
+            const factoryValue = provider.useFactory || provider.useClass;
+            const isClass: boolean = this.isInjectable(factoryValue);
+
+            registryData.factory = {
+                value: factoryValue,
+                isClass
+            };
+
+            if (isClass) {
+                registryData.factory.inject = this.retrieveInjectionsFromClass(<IConstructor> registryData.factory.value);
+            } else {
+                registryData.factory.inject = this.convertTokensToInjectionMd(<ProviderToken> provider.inject);
+            }
 
-        registryData.lifeTime = provider.lifeTime || LifeTime.Persistent;
+            registryData.lifeTime = provider.lifeTime || LifeTime.Persistent; // TODO issue #88
+        }
 
         this.registry.set(provider.token, registryData);
     }
 
-    private createInstance(cls: IConstructor, message: string): IInjectionInstance {
-        const injectionsMd: IInjectionMd[] = this.getInjections(cls);
-        const resolvedInjections: any[] = injectionsMd.map(injectionMd => this.resolveInternal(injectionMd.token, message));
+    private convertTokensToInjectionMd(tokens: ProviderToken[]): IInjectionMd[] {
+        let injections: IInjectionMd[] = [];
+
+        if (tokens) {
+            injections = tokens.map((token: ProviderToken, index: number) => {
+                return {
+                    token,
+                    parameterIndex: index
+                };
+            });
+        }
+
+        return injections;
+    }
+
+    private instantiateWithFactory(factory: IFactory, traceMessage: string): IInjectionInstance {
+        const injections = <IInjectionMd[]> factory.inject;
+
+        const resolvedInjections: any[] = injections.map(injection => this.resolveInternal(injection.token, traceMessage));
 
         const args: any[] = [];
-        injectionsMd.forEach((injection: IInjectionMd, index) => {
+        injections.forEach((injection: IInjectionMd, index: number) => {
             args[injection.parameterIndex] = resolvedInjections[index];
         });
 
-        return new cls(...args);
+        if (factory.isClass) {
+            return new (<IConstructor> factory.value)(...args);
+        } else {
+            return (<FactoryFunction> factory.value)(...args);
+        }
     }
 
     private nornalizeProvider(provider: RegistrationProvider|RegistrationProvider[]): IProvider {
@@ -167,7 +179,8 @@ export class Container implements IContainer {
         return !!(MetadataAnnotator.getMetadata(INJECTABLE_MD_KEY, cls));
     }
 
-    private getInjections(cls: any): IInjectionMd[] {
-        return MetadataAnnotator.getMetadata(INJECTIONS_MD_KEY, cls) || [];
+    private retrieveInjectionsFromClass(cls: IConstructor): IInjectionMd[] {
+        const injections: IInjectionMd[] = MetadataAnnotator.getMetadata(INJECTIONS_MD_KEY, cls) || [];
+        return this.convertTokensToInjectionMd(injections);
     }
 }

src/lib/decorators.ts

@@ -11,14 +11,7 @@ export function Injectable(injections?: ProviderToken[]) {
 
         if (injections && Array.isArray(injections)) {
             const injectionMd: IInjectionMd[] = MetadataAnnotator.getMetadata(INJECTIONS_MD_KEY, target) || [];
-
-            injections.forEach((injectionToken, injectionIndex) => {
-                injectionMd.push({
-                    token: injectionToken,
-                    parameterIndex: injectionIndex
-                });
-            });
-
+            injections.forEach(token => injectionMd.push(token));
             MetadataAnnotator.defineMetadata(INJECTIONS_MD_KEY, injectionMd, target);
         }
     };
@@ -27,12 +20,7 @@ export function Injectable(injections?: ProviderToken[]) {
 export function Inject(token: any) {
     return (target: object, propertyKey: string | symbol, parameterIndex: number) => {
         const injections: IInjectionMd[] = MetadataAnnotator.getMetadata(INJECTIONS_MD_KEY, target) || [];
-
-        injections.push({
-            token,
-            parameterIndex
-        });
-
+        injections.push(token);
         MetadataAnnotator.defineMetadata(INJECTIONS_MD_KEY, injections, target);
     };
 }

src/lib/registry-data.ts

@@ -1,17 +1,21 @@
-import { IConstructor, IInjectionInstance, LifeTime, ProviderToken } from './interfaces';
+import { IConstructor, IInjectionInstance, IInjectionMd, LifeTime } from './interfaces';
+
+export type FactoryFunction = (...args: any[]) => any;
+
+export interface IFactory {
+    value: IConstructor | FactoryFunction;
+    isClass: boolean;
+    inject?: IInjectionMd[];
+}
 
 export interface IRegistryData {
     instance: IInjectionInstance;
-    cls: IConstructor;
-    factory: (...args: any[]) => any;
-    injections: ProviderToken[];
+    factory: IFactory;
     lifeTime: LifeTime;
 }
 
 export class RegistryData {
     public instance: IInjectionInstance;
-    public cls: IConstructor;
-    public factory: (...args: any[]) => any;
-    public injections: ProviderToken[];
+    public factory: IFactory;
     public lifeTime: LifeTime;
 }

src/tests/container.spec.ts

@@ -91,7 +91,7 @@ describe('Container', () => {
             expect(instance instanceof TestClass).to.be.true;
         });
 
-        it('should resolve ф value when registered with "useFactory"', () => {
+        it('should resolve value when registered with "useFactory"', () => {
             container.register({
                 token: 'V',
                 useFactory: () => {
@@ -144,7 +144,7 @@ describe('Container', () => {
         });
 
         describe('LifeTime', () => {
-            it('should resolve a singleton instance if LifeTime was not specified', () => {
+            it('should resolve a singleton by default if LifeTime was not specified with useClass', () => {
                 @Injectable()
                 class A {}
 
@@ -156,7 +156,40 @@ describe('Container', () => {
                 expect(instance1).to.be.equal(instance2);
             });
 
-            it('should resolve a different instances if LifeTime was set to LifeTime.PerRequest', () => {
+            it('should resolve a singleton by default if LifeTime was not specified with useFactory', () => {
+                class A {}
+
+                container.register([
+                    {
+                        token: A,
+                        useFactory: () => new A()
+                    }
+                ]);
+
+                const instance1 = container.resolve(A);
+                const instance2 = container.resolve(A);
+
+                expect(instance1).to.be.equal(instance2);
+            });
+
+            it('should resolve an instance with useFactory if LifeTime was set to LifeTime.PerRequest', () => {
+                class A {}
+
+                container.register([
+                    {
+                        token: A,
+                        useFactory: () => new A(),
+                        lifeTime: LifeTime.PerRequest
+                    }
+                ]);
+
+                const instance1 = container.resolve(A);
+                const instance2 = container.resolve(A);
+
+                expect(instance1).not.to.be.equal(instance2);
+            });
+
+            it('should resolve an instances if LifeTime was set to LifeTime.PerRequest', () => {
                 @Injectable()
                 class A {}
 
@@ -168,7 +201,7 @@ describe('Container', () => {
                 expect(instance1).not.to.be.equal(instance2);
             });
 
-            it('should resolve a different instances if LifeTime was set to LifeTime.PerRequest in case of nested dependencies', () => {
+            it('should resolve different instances if LifeTime was set to LifeTime.PerRequest in case of nested dependencies', () => {
                 @Injectable()
                 class A {
                     constructor(@Inject('IB') private b: any) {}
@@ -308,7 +341,7 @@ describe('Container', () => {
 
     describe('createScope()', () => {
         it('should create child scope', () => {
-            const childContainer: any = container.createScope();
+            const childContainer: any = container.createChild();
             expect(childContainer).to.be.ok;
             expect(childContainer.parent).to.equal(container);
         });