#88 Default Life time for container.

Author: basedalexander

README.md

@@ -104,43 +104,63 @@ class Service {
 ```
 
 ### Life Time control.
-> By default, containers resolve singletons when using **useClass** and **useFactory**. Change it by setting **lifeTime** attribute to **LifeTime.PerRequest**.
+> By default, containers resolve singletons when using **useClass** and **useFactory**. You can specify life time individually for each item in a container by setting **lifeTime** attribute to **LifeTime.PerRequest**.
 
 ```typescript
 import { LifeTime } from 'container-ioc';
 
 container.register([
-    { token: TService, useClass: Service, lifeTime: LifeTime.PerRequest }
+    {
+        token: TService,
+        useClass: Service,
+        lifeTime: LifeTime.PerRequest
+    }
 ]);
 ```
 ```typescript
 container.register([
     {
         token: TService,
-        useFactory: () => { serve(): void {} },
+        useFactory: () => {
+            return {
+                serve(): void {}
+            }
+        },
         lifeTime: LifeTime.PerRequest }
 ]);
 ```
-
-### Hierarchical containers.
-> If container can't find value, it will look it up in ascendant containers.
+> Or you can set default life time for all items in a container by passing an option object.
 ```typescript
+const container = new Container({
+    defaultLifeTime: LifeTime.PerRequest
+});
+```
 
-let parentContainer = new Container();
-let childContainer = parentContainer.createChild();
-
-parentContainer.register({ token: TApplication, useClass: Application });
+### Hierarchical containers.
+> If container can't find a value within itself, it will look it up in ascendant containers. There a 3 ways to set a parent for a container.
 
-childContainer.resolve(TApplication);
+###### 1. Container.createChild() method.
+```typescript
+const parentContainer = new Container();
+const childContainer = parentContainer.createChild();
 ```
-> You can also assign parent container to any other container
+
+###### 2. Container.setParent() method.
 ```typescript
-let parent = new Container();
-let child = new Container();
+const parent = new Container();
+const child = new Container();
 
 child.setParent(parent);
 ```
 
+###### 3. Via Container's constructor with options.
+```typescript
+const parent = new Container();
+const child = new Container({
+    parent: parent
+});
+```
+
 ### Using Factories
 ```typescript
 /* Without injections */

src/lib/container.interface.ts

@@ -1,4 +1,9 @@
-import { IInjectionInstance, ProviderToken, RegistrationProvider } from './interfaces';
+import { IInjectionInstance, ProviderToken, RegistrationProvider, LifeTime } from './interfaces';
+
+export interface IContainerOptions {
+    parent?: IContainer;
+    defaultLifeTime?: LifeTime;
+}
 
 export interface IContainer {
     register(provider: RegistrationProvider|RegistrationProvider[]): void;

src/lib/container.ts

@@ -1,6 +1,6 @@
 import { IConstructor, IInjectionInstance, IInjectionMd, IProvider, LifeTime, ProviderToken, RegistrationProvider } from './interfaces';
 import { FactoryFunction, IFactory, IRegistryData, RegistryData } from './registry-data';
-import { IContainer } from './container.interface';
+import { IContainer, IContainerOptions } from './container.interface';
 import { InvalidProviderProvidedError, NoProviderError } from './exceptions';
 import { INJECTABLE_MD_KEY, INJECTIONS_MD_KEY } from './metadata/keys';
 import { IMetadataAnnotator } from './metadata/metadata-annotator.interface';
@@ -9,9 +9,17 @@ import { AnnotatorProvider } from './metadata/index';
 const MetadataAnnotator: IMetadataAnnotator = AnnotatorProvider.get();
 
 export class Container implements IContainer {
+    private static DEFAULT_LIFE_TIME = LifeTime.Persistent;
     private registry: Map<ProviderToken, IRegistryData> = new Map();
+    private parent: IContainer;
+    private defaultLifeTime: LifeTime = Container.DEFAULT_LIFE_TIME;
 
-    constructor(private parent?: IContainer) {}
+    constructor(options?: IContainerOptions) {
+        if (options) {
+            this.parent = <IContainer> options.parent;
+            this.defaultLifeTime = options.defaultLifeTime || this.defaultLifeTime;
+        }
+    }
 
     public register(provider: RegistrationProvider|RegistrationProvider[]): void {
         provider = this.nornalizeProvider(provider);
@@ -29,11 +37,11 @@ export class Container implements IContainer {
     }
 
     public createScope(): IContainer {
-        return new Container(this);
+        return new Container({ parent: this });
     }
 
     public createChild(): IContainer {
-        return new Container(this);
+        return this.createScope();
     }
 
     public setParent(parent: IContainer): void {
@@ -90,7 +98,7 @@ export class Container implements IContainer {
                 registryData.factory.inject = this.convertTokensToInjectionMd(<ProviderToken> provider.inject);
             }
 
-            registryData.lifeTime = provider.lifeTime || LifeTime.Persistent; // TODO issue #88
+            registryData.lifeTime = provider.lifeTime || this.defaultLifeTime;
         }
 
         this.registry.set(provider.token, registryData);

src/tests/container.spec.ts

@@ -221,6 +221,27 @@ describe('Container', () => {
                 expect(instance1).not.to.be.equal(instance2);
                 expect(instance1.b).to.be.equal(instance2.b);
             });
+
+            it('should set default lifeTime via options', () => {
+                const cont = new Container({
+                    defaultLifeTime: LifeTime.PerRequest
+                });
+
+                @Injectable()
+                class A {}
+
+                cont.register({ token: A, useClass: A });
+                let instance1 = cont.resolve(A);
+                let instance2 = cont.resolve(A);
+
+                expect(instance1).not.to.be.equal(instance2);
+
+                cont.register({ token: 'IB', useFactory: () => ({}) });
+                instance1 = cont.resolve('IB');
+                instance2 = cont.resolve('IB');
+
+                expect(instance1).not.to.be.equal(instance2);
+            });
         });
 
         describe('Errors', () => {
@@ -339,11 +360,38 @@ describe('Container', () => {
 
     });
 
-    describe('createScope()', () => {
-        it('should create child scope', () => {
+    describe('Constructor', () => {
+        it('should set defaultLife through option object', () => {
+            const cont = new Container({ defaultLifeTime: LifeTime.PerRequest });
+
+            cont.register({ token: 'A', useFactory: () => ({})});
+
+            const instance1 = cont.resolve('A');
+            const instance2 = cont.resolve('A');
+
+            expect(instance1).not.to.be.equal(instance2);
+        });
+    });
+
+    describe('createChild()', () => {
+        it('should create child container', () => {
             const childContainer: any = container.createChild();
             expect(childContainer).to.be.ok;
             expect(childContainer.parent).to.equal(container);
         });
     });
+
+    describe('setParent()', () => {
+        it('should set parent for a container', () => {
+            const parentContainer = new Container();
+            const childContainer = new Container();
+            childContainer.setParent(parentContainer);
+
+            parentContainer.register({ token: 'A', useValue: 'string' });
+
+            const value = childContainer.resolve('A');
+
+            expect(value).to.be.equal('string');
+        });
+    });
 });