Fix OnlyInstantiableByContainer

Author: Thiago Bustamante

package-lock.json

@@ -1,6 +1,6 @@
 {
  "name": "typescript-ioc",
- "version": "3.0.1",
+ "version": "3.0.2",
  "description": "A Lightweight annotation-based dependency injection container for typescript.",
  "author": "Thiago da Rosa de Bustamante <trbustamante@gmail.com>",
  "scripts": {

package.json

@@ -82,17 +82,9 @@ export class IoCBindConfig implements Config {
  if (!this.iocScope) {
  this.scope(Scope.Local);
  }
- if (this.decoratedConstructor) {
- return this.getContainerManagedInstance(context);
- } else {
- return this.iocScope.resolve(this.iocFactory, this.source, context);
- }
- }
-
- private getContainerManagedInstance(context: BuildContext) {
- InjectorHandler.unblockInstantiation(this.source);
+ InjectorHandler.unblockInstantiation();
  const instance = this.iocScope.resolve(this.iocFactory, this.source, context);
- InjectorHandler.blockInstantiation(this.source);
+ InjectorHandler.blockInstantiation();
  return instance;
  }
 

src/container/container-binding-config.ts

@@ -2,35 +2,35 @@ import { InstanceFactory } from './container-types';
 import { BuildContext } from '../model';
 
 const BUILD_CONTEXT_KEY = '__BuildContext';
-const BLOCK_INSTANTIATION_KEY = '__block_Instantiation';
 const IOC_WRAPPER_CLASS = 'ioc_wrapper';
 
 /**
  * Utility class to handle injection behavior on class decorations.
  */
 export class InjectorHandler {
  public static constructorNameRegEx = /function (\w*)/;
+ private static instantiationsBlocked = true;
+
 
  public static instrumentConstructor(source: Function) {
  let newConstructor: any;
  // tslint:disable-next-line:class-name
  newConstructor = class ioc_wrapper extends (source as FunctionConstructor) {
  constructor(...args: Array<any>) {
  super(...args);
- InjectorHandler.assertInstantiable(source);
+ InjectorHandler.assertInstantiable();
  }
  };
  newConstructor['__parent'] = source;
- InjectorHandler.blockInstantiation(source);
  return newConstructor;
  }
 
- public static blockInstantiation(source: Function) {
- source[BLOCK_INSTANTIATION_KEY] = true;
+ public static blockInstantiation() {
+ InjectorHandler.instantiationsBlocked = true;
  }
 
- public static unblockInstantiation(source: Function) {
- source[BLOCK_INSTANTIATION_KEY] = false;
+ public static unblockInstantiation() {
+ InjectorHandler.instantiationsBlocked = false;
  }
 
  public static getConstructorFromType(target: Function): FunctionConstructor {
@@ -92,8 +92,8 @@ export class InjectorHandler {
  }
  }
 
- private static assertInstantiable(target: any) {
- if (target[BLOCK_INSTANTIATION_KEY]) {
+ private static assertInstantiable() {
+ if (InjectorHandler.instantiationsBlocked) {
  throw new TypeError('Can not instantiate it. The instantiation is blocked for this class. ' +
  'Ask Container for it, using Container.get');
  }

src/container/injection-handler.ts

@@ -443,6 +443,17 @@ describe('@OnlyInstantiableByContainer decorator', () => {
  expect(instance).toBeDefined();
  });
 
+ it('should allow Container instantiation of Singleton classes with instrumented parent.', () => {
+ @OnlyInstantiableByContainer
+ class First { }
+
+ @OnlyInstantiableByContainer
+ class Second extends First { }
+
+ const instance: First = Container.get(Second);
+ expect(instance).toBeDefined();
+ });
+
  it('should allow scope change to Local from Singleton.', () => {
  Container.bind(SingletonInstantiation).scope(Scope.Local);
  const instance: SingletonInstantiation = Container.get(SingletonInstantiation);

test/integration/ioc-container-tests.spec.ts

@@ -18,7 +18,7 @@
  "removeComments": true,
  "sourceMap": true,
  "strictNullChecks": false,
- "target": "es5"
+ "target": "es6"
  },
  "include": [
  "**/*.spec.ts"

test/tsconfig.json

@@ -141,9 +141,9 @@ describe('IoCBindConfig', () => {
  bindConfig.instrumentConstructor();
 
  expect(bindConfig.getInstance(buildContext)).toEqual(instance);
- expect(mockInjectorBlockInstantiation).toBeCalledWith(MyBaseType);
+ expect(mockInjectorBlockInstantiation).toBeCalled();
  expect(bindConfig.iocScope.resolve).toBeCalledWith(bindConfig.iocFactory, MyBaseType, buildContext);
- expect(mockInjectorUnBlockInstantiation).toBeCalledWith(MyBaseType);
+ expect(mockInjectorUnBlockInstantiation).toBeCalledWith();
  });
  });
 

test/unit/container/container-binding-config.spec.ts

@@ -9,42 +9,27 @@ describe('InjectorHandler', () => {
  const newConstructor = InjectorHandler.instrumentConstructor(MyBaseType);
  expect(newConstructor.name).toEqual('ioc_wrapper');
  expect(newConstructor['__parent']).toEqual(MyBaseType);
- expect((MyBaseType as any)['__block_Instantiation']).toBeTruthy();
  });
 
  it('should keep creating valid instances for the baseType', () => {
  class MyBaseType { }
  const newConstructor = InjectorHandler.instrumentConstructor(MyBaseType);
- InjectorHandler.unblockInstantiation(MyBaseType);
+ InjectorHandler.unblockInstantiation();
  expect(new newConstructor()).toBeInstanceOf(MyBaseType);
+ InjectorHandler.blockInstantiation();
  });
  });
 
  describe('blockInstantiation()', () => {
- it('should configure the constructor as non instantiable', () => {
- class MyBaseType { }
- InjectorHandler.blockInstantiation(MyBaseType);
- expect((MyBaseType as any)['__block_Instantiation']).toBeTruthy();
- });
-
  it('should avoid that instrumented constructor create instances', () => {
  class MyBaseType { }
  const newConstructor = InjectorHandler.instrumentConstructor(MyBaseType);
- InjectorHandler.blockInstantiation(MyBaseType);
+ InjectorHandler.blockInstantiation();
  expect(() => new newConstructor())
  .toThrow(new TypeError('Can not instantiate it. The instantiation is blocked for this class. Ask Container for it, using Container.get'));
  });
  });
 
- describe('unblockInstantiation()', () => {
- it('should configure the constructor as instantiable', () => {
- class MyBaseType { }
- InjectorHandler.blockInstantiation(MyBaseType);
- InjectorHandler.unblockInstantiation(MyBaseType);
- expect((MyBaseType as any)['__block_Instantiation']).toBeFalsy();
- });
- });
-
  describe('injectContext()', () => {
  it('should inject the context as a hidden property into the target', () => {
  class MyBaseType { }