test: complete edge cases

src/containers/Container.ts

@@ -210,7 +210,7 @@ export class Container implements IContainer {
       }
 
       // if this token itself is a constructor, use itself as class provider
-      if (isConstructor(token)) {
+      if (isConstructor(token) && context.rootToken === token) {
         return this.resolveFromRegistrations(
           token,
           [
@@ -260,7 +260,9 @@ export class Container implements IContainer {
     const cachedInstance = this.instanceMap.get(registration);
     const shouldUseCache =
       cachedInstance &&
-      (context.useCache ||
+      context.useCache &&
+      (getProviderType(registration.provider) !==
+        ProviderTypeEnum.ClassProvider ||
         isGlobalSingleton(registration) ||
         (isScopedSingleton(registration) && context.container === this));
 

src/decorators/injectable.ts

@@ -21,10 +21,6 @@ export function injectable(
         Reflect.getMetadata('design:paramtypes', target) || [];
 
       constructorParams.forEach((paramType: unknown, index: number) => {
-        if (typeof paramType !== 'function') {
-          return;
-        }
-
         defineConstructorDependencyDescriptor(target, {
           token: paramType as Constructor<unknown>,
           index,

src/decorators/lazy.ts

@@ -1,24 +1,22 @@
 import { defineOptionInDescriptor } from '@/utils';
 
-export function lazy() {
-  return function (
-    target: any,
-    propertyKey?: string | symbol,
-    parameterIndex?: number,
-  ) {
-    // constructor params decorator
-    if (parameterIndex !== undefined) {
-      defineOptionInDescriptor(target, parameterIndex, {
-        lazy: true,
-      });
-      return;
-    }
+export function lazy(
+  target: any,
+  propertyKey?: string | symbol,
+  parameterIndex?: number,
+) {
+  // constructor params decorator
+  if (parameterIndex !== undefined) {
+    defineOptionInDescriptor(target, parameterIndex, {
+      lazy: true,
+    });
+    return;
+  }
 
-    // property decorator
-    if (propertyKey !== undefined) {
-      defineOptionInDescriptor(target.constructor, propertyKey, {
-        lazy: true,
-      });
-    }
-  };
+  // property decorator
+  if (propertyKey !== undefined) {
+    defineOptionInDescriptor(target.constructor, propertyKey, {
+      lazy: true,
+    });
+  }
 }

src/decorators/multiple.ts

@@ -1,24 +1,22 @@
 import { defineOptionInDescriptor } from '@/utils';
 
-export function multiple() {
-  return function (
-    target: any,
-    propertyKey?: string | symbol,
-    parameterIndex?: number,
-  ) {
-    // constructor params decorator
-    if (parameterIndex !== undefined) {
-      defineOptionInDescriptor(target, parameterIndex, {
-        multiple: true,
-      });
-      return;
-    }
+export function multiple(
+  target: any,
+  propertyKey?: string | symbol,
+  parameterIndex?: number,
+) {
+  // constructor params decorator
+  if (parameterIndex !== undefined) {
+    defineOptionInDescriptor(target, parameterIndex, {
+      multiple: true,
+    });
+    return;
+  }
 
-    // property decorator
-    if (propertyKey !== undefined) {
-      defineOptionInDescriptor(target.constructor, propertyKey, {
-        multiple: true,
-      });
-    }
-  };
+  // property decorator
+  if (propertyKey !== undefined) {
+    defineOptionInDescriptor(target.constructor, propertyKey, {
+      multiple: true,
+    });
+  }
 }

src/decorators/optional.ts

@@ -1,24 +1,22 @@
 import { defineOptionInDescriptor } from '@/utils';
 
-export function optional() {
-  return function (
-    target: any,
-    propertyKey?: string | symbol,
-    parameterIndex?: number,
-  ) {
-    // constructor params decorator
-    if (parameterIndex !== undefined) {
-      defineOptionInDescriptor(target, parameterIndex, {
-        optional: true,
-      });
-      return;
-    }
+export function optional(
+  target: any,
+  propertyKey?: string | symbol,
+  parameterIndex?: number,
+) {
+  // constructor params decorator
+  if (parameterIndex !== undefined) {
+    defineOptionInDescriptor(target, parameterIndex, {
+      optional: true,
+    });
+    return;
+  }
 
-    // property decorator
-    if (propertyKey !== undefined) {
-      defineOptionInDescriptor(target.constructor, propertyKey, {
-        optional: true,
-      });
-    }
-  };
+  // property decorator
+  if (propertyKey !== undefined) {
+    defineOptionInDescriptor(target.constructor, propertyKey, {
+      optional: true,
+    });
+  }
 }

src/modules/loader.ts

@@ -65,10 +65,5 @@ export function createAsyncModuleLoader<T>(
     get(_, key: string | symbol, receiver) {
       return loadModule().then(module => Reflect.get(module, key, receiver));
     },
-
-    set(_, key: string | symbol, value: any, receiver) {
-      loadModule().then(module => Reflect.set(module, key, value, receiver));
-      return true;
-    },
   });
 }

src/utils/is.ts

@@ -9,6 +9,7 @@ export function isDisposable(
 
 export function isGlobalSingleton(registration: ProviderRegistration<unknown>) {
   return (
+    registration.options?.singleton === undefined ||
     registration.options?.singleton === true ||
     registration.options?.singleton === SingletonScope.Global
   );

tests/child-container.test.ts

@@ -0,0 +1,50 @@
+import { NoProviderFoundError } from '@/common';
+import { SingletonScope, inject, injectable, rootContainer } from '@/index';
+import { beforeEach, describe, expect, it } from 'vitest';
+
+describe('[Child Container] test hierarchical containers', () => {
+  beforeEach(() => rootContainer.dispose(true));
+
+  it('should resolve dependencies from parent by default', () => {
+    class A {}
+    class B {
+      constructor(@inject('A') public a: A) {}
+    }
+
+    rootContainer.register('A').toClass(A);
+    const childContainer = rootContainer.fork('CHILDREN');
+
+    const b = childContainer.resolve(B);
+    expect(b).toBeInstanceOf(B);
+    expect(b.a).toBeInstanceOf(A);
+  });
+
+  it('should throw NoProviderFoundError when resolveParent is disabled', () => {
+    class A {}
+    class B {
+      constructor(@inject('A') public a: A) {}
+    }
+
+    rootContainer.register('A').toClass(A);
+    const childContainer = rootContainer.fork('CHILDREN');
+
+    expect(() =>
+      childContainer.resolve(B, { resolveParent: false }),
+    ).toThrowError(NoProviderFoundError);
+  });
+
+  it('should not use scoped singleton instance from parent container even resolveParent is enabled', () => {
+    @injectable({ token: 'A', singleton: SingletonScope.Scoped }) class A {}
+
+    class B {
+      constructor(@inject('A') public a: A) {}
+    }
+
+    const childContainer = rootContainer.fork('CHILDREN');
+
+    const a = rootContainer.resolve('A');
+    const b = childContainer.resolve(B);
+
+    expect(a === b.a).toBeFalsy();
+  })
+});

tests/decorators.test.ts

@@ -44,12 +44,12 @@ describe('[Decorator] test util decorators', () => {
 
     class B {
       constructor(
-        @inject('C') @optional() public c: unknown,
-        @optional() @inject('D') public d: unknown,
+        @inject('C') @optional public c: unknown,
+        @optional @inject('D') public d: unknown,
       ) {}
 
-      @inject('C') @optional() public c2: unknown;
-      @optional() @inject('D') public d2: unknown;
+      @inject('C') @optional public c2: unknown;
+      @optional @inject('D') public d2: unknown;
     }
 
     const b = rootContainer.resolve(B);
@@ -65,12 +65,12 @@ describe('[Decorator] test util decorators', () => {
 
     class C {
       constructor(
-        @inject('Foo') @multiple() public foo1: unknown[],
-        @multiple() @inject('Foo') public foo2: unknown[],
+        @inject('Foo') @multiple public foo1: unknown[],
+        @multiple @inject('Foo') public foo2: unknown[],
       ) {}
 
-      @multiple() @inject('Foo') public foo3!: unknown[];
-      @inject('Foo') @multiple() public foo4!: unknown[];
+      @multiple @inject('Foo') public foo3!: unknown[];
+      @inject('Foo') @multiple public foo4!: unknown[];
     }
 
     const c = rootContainer.resolve(C);

tests/errors.test.ts

@@ -75,7 +75,7 @@ describe('[Errors] test scenes that should throw error', () => {
 
     @injectable({ token: 'B' })
     class B {
-      constructor(@lazy() @inject('A') public a: A) {}
+      constructor(@lazy @inject('A') public a: A) {}
     }
 
     const b = rootContainer.resolve(B);
@@ -90,12 +90,12 @@ describe('[Errors] test scenes that should throw error', () => {
       echo() {
         console.log('A');
       }
-      @inject('B') @lazy() public b2: unknown;
+      @inject('B') @lazy public b2: unknown;
     }
 
     @injectable({ token: 'B' })
     class B {
-      constructor(@inject('A') @lazy() public a: A) {
+      constructor(@inject('A') @lazy public a: A) {
         a.echo();
       }
     }

tests/metadata.test.ts

@@ -1,8 +1,9 @@
 import { beforeEach, describe, expect, it } from 'vitest';
 
 import 'reflect-metadata';
-import { inject, injectable } from '@/decorators';
+import { inject, injectable, optional } from '@/decorators';
 import { rootContainer } from '@/containers';
+import { InjectionTokenInvalidError } from '@/common';
 
 describe('[Metadata] test scenes that requires reflect-metadata polyfill', () => {
   beforeEach(() => {
@@ -17,7 +18,7 @@ describe('[Metadata] test scenes that requires reflect-metadata polyfill', () =>
 
     @injectable()
     class C {
-      constructor(public a: A, public b: B) {}
+      constructor(public a: A, public b: B, @optional public c?: Number) {}
     }
 
     const c = rootContainer.resolve(C);
@@ -28,7 +29,9 @@ describe('[Metadata] test scenes that requires reflect-metadata polyfill', () =>
 
   it('@inject(): should automatically infer dependency constructor when used in consturctor parameters', () => {
     @injectable()
-    class A {}
+    class A {
+      constructor() {}
+    }
 
     @injectable()
     class B {}
@@ -59,4 +62,24 @@ describe('[Metadata] test scenes that requires reflect-metadata polyfill', () =>
     expect(c.a).toBeInstanceOf(A);
     expect(c.b).toBeInstanceOf(B);
   });
+
+  it('@inject(): should throw error if inferred dependency is invalid', () => {
+    @injectable()
+    class A {}
+
+    @injectable()
+    class B {}
+
+    expect(() => {
+      class C {
+        constructor(@inject() public a: undefined) {}
+      }
+    }).toThrowError(InjectionTokenInvalidError);
+
+    expect(() => {
+      class D {
+        @inject() public a: undefined;
+      }
+    }).toThrowError(InjectionTokenInvalidError);
+  });
 });