feat(context): add more utils to resolve valueOrPromises

Author: raymondfeng

packages/context/src/binding.ts

@@ -13,6 +13,7 @@ import {
   BoundValue,
   ValueOrPromise,
   MapObject,
+  transformValueOrPromise,
 } from './value-promise';
 import {Provider} from './provider';
 
@@ -170,30 +171,16 @@ export class Binding<T = BoundValue> {
   ): ValueOrPromise<T> {
     // Initialize the cache as a weakmap keyed by context
     if (!this._cache) this._cache = new WeakMap<Context, T>();
-    if (isPromiseLike(result)) {
-      if (this.scope === BindingScope.SINGLETON) {
-        // Cache the value at owning context level
-        result = result.then(val => {
-          this._cache.set(ctx.getOwnerContext(this.key)!, val);
-          return val;
-        });
-      } else if (this.scope === BindingScope.CONTEXT) {
-        // Cache the value at the current context
-        result = result.then(val => {
-          this._cache.set(ctx, val);
-          return val;
-        });
-      }
-    } else {
+    return transformValueOrPromise(result, val => {
       if (this.scope === BindingScope.SINGLETON) {
         // Cache the value
-        this._cache.set(ctx.getOwnerContext(this.key)!, result);
+        this._cache.set(ctx.getOwnerContext(this.key)!, val);
       } else if (this.scope === BindingScope.CONTEXT) {
         // Cache the value at the current context
-        this._cache.set(ctx, result);
+        this._cache.set(ctx, val);
       }
-    }
-    return result;
+      return val;
+    });
   }
 
   /**
@@ -210,7 +197,7 @@ export class Binding<T = BoundValue> {
    *
    * ```
    * const result = binding.getValue(ctx);
-   * if (isPromise(result)) {
+   * if (isPromiseLike(result)) {
    *   result.then(doSomething)
    * } else {
    *   doSomething(result);
@@ -408,11 +395,7 @@ export class Binding<T = BoundValue> {
         ctx!,
         session,
       );
-      if (isPromiseLike(providerOrPromise)) {
-        return providerOrPromise.then(p => p.value());
-      } else {
-        return providerOrPromise.value();
-      }
+      return transformValueOrPromise(providerOrPromise, p => p.value());
     };
     return this;
   }

packages/context/src/index.ts

@@ -13,6 +13,8 @@ export {
   MapObject,
   resolveList,
   resolveMap,
+  resolveUntil,
+  transformValueOrPromise,
   tryWithFinally,
   getDeepProperty,
 } from './value-promise';

packages/context/src/resolver.ts

@@ -10,9 +10,9 @@ import {
   Constructor,
   ValueOrPromise,
   MapObject,
-  isPromiseLike,
   resolveList,
   resolveMap,
+  transformValueOrPromise,
 } from './value-promise';
 
 import {
@@ -56,51 +56,23 @@ export function instantiateClass<T>(
   }
   const argsOrPromise = resolveInjectedArguments(ctor, '', ctx, session);
   const propertiesOrPromise = resolveInjectedProperties(ctor, ctx, session);
-  let inst: ValueOrPromise<T>;
-  if (isPromiseLike(argsOrPromise)) {
-    // Instantiate the class asynchronously
-    inst = argsOrPromise.then(args => {
+  const inst: ValueOrPromise<T> = transformValueOrPromise(
+    argsOrPromise,
+    args => {
       /* istanbul ignore if */
       if (debug.enabled) {
         debug('Injected arguments for %s():', ctor.name, args);
       }
       return new ctor(...args);
-    });
-  } else {
+    },
+  );
+  return transformValueOrPromise(propertiesOrPromise, props => {
     /* istanbul ignore if */
     if (debug.enabled) {
-      debug('Injected arguments for %s():', ctor.name, argsOrPromise);
+      debug('Injected properties for %s:', ctor.name, props);
     }
-    // Instantiate the class synchronously
-    inst = new ctor(...argsOrPromise);
-  }
-  if (isPromiseLike(propertiesOrPromise)) {
-    return propertiesOrPromise.then(props => {
-      /* istanbul ignore if */
-      if (debug.enabled) {
-        debug('Injected properties for %s:', ctor.name, props);
-      }
-      if (isPromiseLike(inst)) {
-        // Inject the properties asynchronously
-        return inst.then(obj => Object.assign(obj, props));
-      } else {
-        // Inject the properties synchronously
-        return Object.assign(inst, props);
-      }
-    });
-  } else {
-    if (isPromiseLike(inst)) {
-      /* istanbul ignore if */
-      if (debug.enabled) {
-        debug('Injected properties for %s:', ctor.name, propertiesOrPromise);
-      }
-      // Inject the properties asynchronously
-      return inst.then(obj => Object.assign(obj, propertiesOrPromise));
-    } else {
-      // Inject the properties synchronously
-      return Object.assign(inst, propertiesOrPromise);
-    }
-  }
+    return transformValueOrPromise(inst, obj => Object.assign(obj, props));
+  });
 }
 
 /**
@@ -257,23 +229,13 @@ export function invokeMethod(
     typeof targetWithMethods[method] === 'function',
     `Method ${method} not found`,
   );
-  if (isPromiseLike(argsOrPromise)) {
-    // Invoke the target method asynchronously
-    return argsOrPromise.then(args => {
-      /* istanbul ignore if */
-      if (debug.enabled) {
-        debug('Injected arguments for %s:', methodName, args);
-      }
-      return targetWithMethods[method](...args);
-    });
-  } else {
+  return transformValueOrPromise(argsOrPromise, args => {
     /* istanbul ignore if */
     if (debug.enabled) {
-      debug('Injected arguments for %s:', methodName, argsOrPromise);
+      debug('Injected arguments for %s:', methodName, args);
     }
-    // Invoke the target method synchronously
-    return targetWithMethods[method](...argsOrPromise);
-  }
+    return targetWithMethods[method](...args);
+  });
 }
 
 /**

packages/context/src/value-promise.ts

@@ -2,7 +2,6 @@
 // Node module: @loopback/context
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
-
 /**
  * This module contains types for values and/or promises as well as a set of
  * utility methods to handle values and/or promises.
@@ -218,3 +217,55 @@ export function tryWithFinally<T>(
   }
   return result;
 }
+
+/**
+ * Resolve an iterator of source values into a result until the evaluator
+ * returns `true`
+ * @param source The iterator of source values
+ * @param resolver The resolve function that maps the source value to a result
+ * @param evaluator The evaluate function that decides when to stop
+ */
+export function resolveUntil<T, V>(
+  source: Iterator<T>,
+  resolver: (sourceVal: T) => ValueOrPromise<V | undefined>,
+  evaluator: (sourceVal: T, targetVal: V | undefined) => boolean,
+): ValueOrPromise<V | undefined> {
+  // Do iteration in loop for synchronous values to avoid stack overflow
+  while (true) {
+    const next = source.next();
+    if (next.done) return undefined; // End of the iterator
+    const sourceVal = next.value;
+    const valueOrPromise = resolver(sourceVal);
+    if (isPromiseLike(valueOrPromise)) {
+      return valueOrPromise.then(v => {
+        if (evaluator(sourceVal, v)) {
+          return v;
+        } else {
+          return resolveUntil(source, resolver, evaluator);
+        }
+      });
+    } else {
+      if (evaluator(sourceVal, valueOrPromise)) {
+        return valueOrPromise;
+      }
+      // Continue with the while loop
+    }
+  }
+}
+
+/**
+ * Transform a value or promise with a function that produces a new value or
+ * promise
+ * @param valueOrPromise The value or promise
+ * @param transformer A function that maps the source value to a value or promise
+ */
+export function transformValueOrPromise<T, V>(
+  valueOrPromise: ValueOrPromise<T>,
+  transformer: (val: T) => ValueOrPromise<V>,
+): ValueOrPromise<V> {
+  if (isPromiseLike(valueOrPromise)) {
+    return valueOrPromise.then(transformer);
+  } else {
+    return transformer(valueOrPromise);
+  }
+}