fix(context): allow session to be passed into @inject.getter

The current session will be cloned to create an isolated scope
for the getter function to resume

packages/context/src/index.ts

@@ -12,7 +12,7 @@ export {
 } from './binding';
 
 export {Context} from './context';
-export {Constructor} from './resolver';
+export {Constructor, ResolutionSession} from './resolver';
 export {inject, Setter, Getter} from './inject';
 export {Provider} from './provider';
 export {isPromise} from './is-promise';

packages/context/src/inject.ts

@@ -188,10 +188,15 @@ export namespace inject {
   };
 }
 
-function resolveAsGetter(ctx: Context, injection: Injection) {
-  // No resolution session should be propagated into the getter
+function resolveAsGetter(
+  ctx: Context,
+  injection: Injection,
+  session?: ResolutionSession,
+) {
+  // We need to clone the session for the getter as it will be resolved later
+  if (session != null) session = session.clone();
   return function getter() {
-    return ctx.get(injection.bindingKey);
+    return ctx.get(injection.bindingKey, session);
   };
 }
 

packages/context/src/resolver.ts

@@ -39,6 +39,17 @@ export class ResolutionSession {
 
   readonly injections: Injection[] = [];
 
+  /**
+   * Take a snapshot of the ResolutionSession so that we can pass it to
+   * `@inject.getter` without interferring with the current session
+   */
+  clone() {
+    const copy = new ResolutionSession();
+    copy.bindings.push(...this.bindings);
+    copy.injections.push(...this.injections);
+    return copy;
+  }
+
   /**
    * Start to resolve a binding within the session
    * @param binding Binding

packages/context/test/unit/resolver.test.ts

@@ -10,8 +10,10 @@ import {
   instantiateClass,
   invokeMethod,
   Injection,
+  Constructor,
+  Getter,
+  ResolutionSession,
 } from '../..';
-import {ResolutionSession} from '../../src/resolver';
 
 describe('constructor injection', () => {
   let ctx: Context;
@@ -196,6 +198,38 @@ describe('constructor injection', () => {
     expect(bindingPath).to.eql('x --> y --> z');
   });
 
+  it('tracks path of bindings for @inject.getter', async () => {
+    const context = new Context();
+    let bindingPath = '';
+
+    class ZClass {
+      @inject(
+        'p',
+        {},
+        // Set up a custom resolve() to access information from the session
+        (c: Context, injection: Injection, session: ResolutionSession) => {
+          bindingPath = session.getBindingPath();
+        },
+      )
+      myProp: string;
+    }
+
+    class YClass {
+      constructor(@inject.getter('z') public z: Getter<ZClass>) {}
+    }
+
+    class XClass {
+      constructor(@inject('y') public y: YClass) {}
+    }
+
+    context.bind('x').toClass(XClass);
+    context.bind('y').toClass(YClass);
+    context.bind('z').toClass(ZClass);
+    const x: XClass = context.getSync('x');
+    await x.y.z();
+    expect(bindingPath).to.eql('x --> y --> z');
+  });
+
   it('tracks path of injections', () => {
     const context = new Context();
     let injectionPath = '';