feat(scope): create SameScope decorator

Author: runjuu

src/core/scope/__test__/scope.spec.ts

@@ -1,4 +1,7 @@
-import { getInstanceWithScope, TransientScope } from '../'
+import 'reflect-metadata'
+import { Injectable } from '@asuka/di'
+
+import { getInstanceWithScope, TransientScope, SameScope } from '../'
 import { createNewInstance, createOrGetInstanceInScope } from '../utils'
 
 describe('Scope spec:', () => {
@@ -51,5 +54,75 @@ describe('Scope spec:', () => {
           getInstanceWithScope(Test, { scope: TransientScope }),
       ).toBeFalsy()
     })
+
+    describe('Injection scope', () => {
+      describe('default behavior', () => {
+        @Injectable()
+        class A {}
+
+        @Injectable()
+        class B {
+          constructor(public a: A) {}
+        }
+
+        @Injectable()
+        class C {
+          constructor(public a: A) {}
+        }
+
+        @Injectable()
+        class D {
+          constructor(public a: A) {}
+        }
+
+        it('should return same instance whether scope is same or not', () => {
+          const b = getInstanceWithScope(B, { scope: 'b' })
+          const c1 = getInstanceWithScope(C, { scope: 'c1' })
+          const c2 = getInstanceWithScope(C, { scope: 'c2' })
+          const d = getInstanceWithScope(D, { scope: 'c2' })
+
+          expect(b.a).toBeInstanceOf(A)
+          expect(b.a).toBe(c1.a)
+          expect(c1.a).toBe(c2.a)
+          expect(c2.a).toBe(d.a)
+        })
+      })
+
+      describe('with SameScope decorator', () => {
+        @Injectable()
+        class A {}
+
+        @Injectable()
+        class B {
+          constructor(@SameScope() public a: A) {}
+        }
+
+        @Injectable()
+        class C {
+          constructor(@SameScope() public a: A) {}
+        }
+
+        it('should return same instance if is same scope', () => {
+          const scope = 'scope'
+          const b = getInstanceWithScope(B, { scope })
+          const c = getInstanceWithScope(C, { scope })
+
+          expect(b.a).toBeInstanceOf(A)
+          expect(b.a).toBe(c.a)
+        })
+
+        it('should return different instance if is different scope', () => {
+          const b = getInstanceWithScope(B, { scope: 'b' })
+          const c1 = getInstanceWithScope(C, { scope: 'c1' })
+          const c2 = getInstanceWithScope(C, { scope: 'c2' })
+
+          expect(b.a).toBeInstanceOf(A)
+          expect(c1.a).toBeInstanceOf(A)
+          expect(c2.a).toBeInstanceOf(A)
+          expect(b.a === c1.a).toBeFalsy()
+          expect(c1.a === c2.a).toBeFalsy()
+        })
+      })
+    })
   })
 })

src/core/scope/index.ts

@@ -1,11 +1,12 @@
-import { InjectableFactory } from '@asuka/di'
+import { InjectableFactory, ValueProvider } from '@asuka/di'
 import { get } from 'lodash'
 
 import { ConstructorOf } from '../types'
 import { ScopeConfig } from './type'
 import { createNewInstance, createOrGetInstanceInScope } from './utils'
+import { getSameScopeInjectionParams, SameScope } from './same-scope-decorator'
 
-export { ScopeConfig }
+export { ScopeConfig, SameScope }
 
 export const TransientScope = Symbol('scope:transient')
 
@@ -14,12 +15,19 @@ export const SingletonScope = Symbol('scope:singleton')
 export function getInstanceWithScope<T>(constructor: ConstructorOf<T>, config?: ScopeConfig): T {
   const scope = get(config, 'scope', SingletonScope)
 
+  const providers = getSameScopeInjectionParams(constructor).map(
+    (sameScopeInjectionParam): ValueProvider => ({
+      provide: sameScopeInjectionParam,
+      useValue: getInstanceWithScope(sameScopeInjectionParam, { scope }),
+    }),
+  )
+
   switch (scope) {
     case SingletonScope:
       return InjectableFactory.getInstance(constructor)
     case TransientScope:
-      return createNewInstance(constructor)
+      return createNewInstance(constructor, providers)
     default:
-      return createOrGetInstanceInScope(constructor, scope)
+      return createOrGetInstanceInScope(constructor, scope, providers)
   }
 }

src/core/scope/same-scope-decorator.ts

@@ -0,0 +1,21 @@
+const SameScopeMetadataKey = Symbol('SameScopeInjectionParams')
+
+export function getSameScopeInjectionParams(target: any): any[] {
+  if (Reflect.hasMetadata(SameScopeMetadataKey, target)) {
+    return Reflect.getMetadata(SameScopeMetadataKey, target)
+  } else {
+    const sameScopeInjectionParams: any[] = []
+    Reflect.defineMetadata(SameScopeMetadataKey, sameScopeInjectionParams, target)
+    return sameScopeInjectionParams
+  }
+}
+
+function addSameScopeInjectionParam(target: any, param: object) {
+  const sameScopeInjectionParams = getSameScopeInjectionParams(target)
+  sameScopeInjectionParams.push(param)
+}
+
+export const SameScope = () => (target: any, _propertyKey: string, parameterIndex: number) => {
+  const param = Reflect.getMetadata('design:paramtypes', target)[parameterIndex]
+  addSameScopeInjectionParam(target, param)
+}

src/core/scope/utils.ts

@@ -1,4 +1,4 @@
-import { InjectableFactory } from '@asuka/di'
+import { InjectableFactory, Provider } from '@asuka/di'
 
 import { ConstructorOf } from '../types'
 import { Scope } from './type'
@@ -11,18 +11,28 @@ type Key = ConstructorOf<Instance>
 
 const map: Map<Key, ScopeMap<Scope, Instance>> = new Map()
 
-export function createNewInstance<T>(constructor: ConstructorOf<T>): T {
-  return InjectableFactory.injector.resolveAndCreateChild([constructor]).get(constructor)
+export function createNewInstance<T>(constructor: ConstructorOf<T>, providers: Provider[] = []): T {
+  return InjectableFactory.injector
+    .resolveAndCreateChild([...providers, constructor])
+    .get(constructor)
 }
 
-export function createOrGetInstanceInScope<T>(constructor: ConstructorOf<T>, scope: Scope): T {
+export function createOrGetInstanceInScope<T>(
+  constructor: ConstructorOf<T>,
+  scope: Scope,
+  providers: Provider[] = [],
+): T {
   const instanceAtScope = getInstanceFrom(constructor, scope)
 
-  return instanceAtScope ? instanceAtScope : createInstanceInScope(constructor, scope)
+  return instanceAtScope ? instanceAtScope : createInstanceInScope(constructor, scope, providers)
 }
 
-function createInstanceInScope<T>(constructor: ConstructorOf<T>, scope: Scope): T {
-  const newInstance = createNewInstance(constructor)
+function createInstanceInScope<T>(
+  constructor: ConstructorOf<T>,
+  scope: Scope,
+  providers: Provider[],
+): T {
+  const newInstance = createNewInstance(constructor, providers)
 
   setInstanceInScope(constructor, scope, newInstance)