refactor: add helper methods to do work with binding/injection

Author: raymondfeng

packages/context/src/binding.ts

@@ -254,28 +254,11 @@ export class Binding {
       }
     }
     if (this._getValue) {
-      const resolutionSession = ResolutionSession.enterBinding(this, session);
-      let result: ValueOrPromise<BoundValue>;
-      try {
-        result = this._getValue(ctx, resolutionSession);
-      } catch (e) {
-        resolutionSession.popBinding();
-        throw e;
-      }
-      if (isPromise(result)) {
-        result = result.then(
-          (val: BoundValue) => {
-            resolutionSession.popBinding();
-            return val;
-          },
-          err => {
-            resolutionSession.popBinding();
-            throw err;
-          },
-        );
-      } else {
-        resolutionSession.popBinding();
-      }
+      let result = ResolutionSession.runWithBinding(
+        s => this._getValue(ctx, s),
+        this,
+        session,
+      );
       return this._cacheValue(ctx, result);
     }
     return Promise.reject(

packages/context/src/resolution-session.ts

@@ -3,13 +3,22 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {Binding} from './binding';
+import {Binding, ValueOrPromise, BoundValue} from './binding';
 import {Injection} from './inject';
+import {isPromise} from './is-promise';
 import * as debugModule from 'debug';
 import {DecoratorFactory} from '@loopback/metadata';
 
 const debugSession = debugModule('loopback:context:resolver:session');
 const getTargetName = DecoratorFactory.getTargetName;
+
+/**
+ * A function to be executed with the resolution session
+ */
+export type ResolutionAction = (
+  session?: ResolutionSession,
+) => ValueOrPromise<BoundValue>;
+
 /**
  * Object to keep states for a session to resolve bindings and their
  * dependencies within a context
@@ -42,7 +51,7 @@ export class ResolutionSession {
    * @param binding Binding
    * @param session Resolution session
    */
-  static enterBinding(
+  private static enterBinding(
     binding: Binding,
     session?: ResolutionSession,
   ): ResolutionSession {
@@ -51,12 +60,48 @@ export class ResolutionSession {
     return session;
   }
 
+  /**
+   * Run the given action with the given binding and session
+   * @param action A function to do some work with the resolution session
+   * @param binding The current binding
+   * @param session The current resolution session
+   */
+  static runWithBinding(
+    action: ResolutionAction,
+    binding: Binding,
+    session?: ResolutionSession,
+  ) {
+    const resolutionSession = ResolutionSession.enterBinding(binding, session);
+    let result: ValueOrPromise<BoundValue>;
+    try {
+      result = action(resolutionSession);
+    } catch (e) {
+      resolutionSession.popBinding();
+      throw e;
+    }
+    if (isPromise(result)) {
+      result = result.then(
+        val => {
+          resolutionSession.popBinding();
+          return val;
+        },
+        err => {
+          resolutionSession.popBinding();
+          throw err;
+        },
+      );
+    } else {
+      resolutionSession.popBinding();
+    }
+    return result;
+  }
+
   /**
    * Push an injection into the session
    * @param injection Injection
    * @param session Resolution session
    */
-  static enterInjection(
+  private static enterInjection(
     injection: Injection,
     session?: ResolutionSession,
   ): ResolutionSession {
@@ -65,6 +110,45 @@ export class ResolutionSession {
     return session;
   }
 
+  /**
+   * Run the given action with the given injection and session
+   * @param action A function to do some work with the resolution session
+   * @param binding The current injection
+   * @param session The current resolution session
+   */
+  static runWithInjection(
+    action: ResolutionAction,
+    injection: Injection,
+    session?: ResolutionSession,
+  ) {
+    const resolutionSession = ResolutionSession.enterInjection(
+      injection,
+      session,
+    );
+    let result: ValueOrPromise<BoundValue>;
+    try {
+      result = action(resolutionSession);
+    } catch (e) {
+      resolutionSession.popInjection();
+      throw e;
+    }
+    if (isPromise(result)) {
+      result = result.then(
+        val => {
+          resolutionSession.popInjection();
+          return val;
+        },
+        err => {
+          resolutionSession.popInjection();
+          throw err;
+        },
+      );
+    } else {
+      resolutionSession.popInjection();
+    }
+    return result;
+  }
+
   /**
    * Describe the injection for debugging purpose
    * @param injection

packages/context/src/resolver.ts

@@ -121,35 +121,19 @@ function resolve<T>(
       ResolutionSession.describeInjection(injection),
     );
   }
-  let resolved: ValueOrPromise<T>;
-  // Push the injection onto the session
-  session = ResolutionSession.enterInjection(injection, session);
-  try {
-    if (injection.resolve) {
-      // A custom resolve function is provided
-      resolved = injection.resolve(ctx, injection, session);
-    } else {
-      // Default to resolve the value from the context by binding key
-      resolved = ctx.getValueOrPromise(injection.bindingKey, session);
-    }
-  } catch (e) {
-    session.popBinding();
-    throw e;
-  }
-  if (isPromise(resolved)) {
-    resolved = resolved.then(
-      r => {
-        session!.popInjection();
-        return r;
-      },
-      e => {
-        session!.popInjection();
-        throw e;
-      },
-    );
-  } else {
-    session.popInjection();
-  }
+  let resolved = ResolutionSession.runWithInjection(
+    s => {
+      if (injection.resolve) {
+        // A custom resolve function is provided
+        return injection.resolve(ctx, injection, s);
+      } else {
+        // Default to resolve the value from the context by binding key
+        return ctx.getValueOrPromise(injection.bindingKey, s);
+      }
+    },
+    injection,
+    session,
+  );
   return resolved;
 }