@loopback/context 3.8.2 → 3.9.3

package/src/resolution-session.ts

@@ -394,3 +394,51 @@ export interface ResolutionContext<T = unknown> {
    */
   readonly options: ResolutionOptions;
 }
+
+/**
+ * Error for context binding resolutions and dependency injections
+ */
+export class ResolutionError extends Error {
+  constructor(
+    message: string,
+    readonly resolutionCtx: Partial<ResolutionContext>,
+  ) {
+    super(ResolutionError.buildMessage(message, resolutionCtx));
+    this.name = ResolutionError.name;
+  }
+
+  private static buildDetails(resolutionCtx: Partial<ResolutionContext>) {
+    return {
+      context: resolutionCtx.context?.name ?? '',
+      binding: resolutionCtx.binding?.key ?? '',
+      resolutionPath: resolutionCtx.options?.session?.getResolutionPath() ?? '',
+    };
+  }
+
+  /**
+   * Build the error message for the resolution to include more contextual data
+   * @param reason - Cause of the error
+   * @param resolutionCtx - Resolution context
+   */
+  private static buildMessage(
+    reason: string,
+    resolutionCtx: Partial<ResolutionContext>,
+  ) {
+    const info = this.describeResolutionContext(resolutionCtx);
+    const message = `${reason} (${info})`;
+    return message;
+  }
+
+  private static describeResolutionContext(
+    resolutionCtx: Partial<ResolutionContext>,
+  ) {
+    const details = ResolutionError.buildDetails(resolutionCtx);
+    const items: string[] = [];
+    for (const [name, val] of Object.entries(details)) {
+      if (val !== '') {
+        items.push(`${name}: ${val}`);
+      }
+    }
+    return items.join(', ');
+  }
+}

package/src/resolver.ts

@@ -15,7 +15,11 @@ import {
   describeInjectedProperties,
   Injection,
 } from './inject';
-import {ResolutionOptions, ResolutionSession} from './resolution-session';
+import {
+  ResolutionError,
+  ResolutionOptions,
+  ResolutionSession,
+} from './resolution-session';
 import {
   BoundValue,
   Constructor,
@@ -230,10 +234,11 @@ export function resolveInjectedArguments(
         return extraArgs[nonInjectedIndex++];
       } else {
         const name = getTargetName(target, method, ix);
-        throw new Error(
-          `Cannot resolve injected arguments for ${name}: ` +
-            `The arguments[${ix}] is not decorated for dependency injection, ` +
-            `but a value is not supplied`,
+        throw new ResolutionError(
+          `The argument '${name}' is not decorated for dependency injection ` +
+            'but no value was supplied by the caller. Did you forget to apply ' +
+            '@inject() to the argument?',
+          {context: ctx, options: {session}},
         );
       }
     }
@@ -270,20 +275,12 @@ export function resolveInjectedProperties(
   }
   const injectedProperties = describeInjectedProperties(constructor.prototype);
 
-  return resolveMap(injectedProperties, (injection, p) => {
-    if (!injection.bindingSelector && !injection.resolve) {
-      const name = getTargetName(constructor, p);
-      throw new Error(
-        `Cannot resolve injected property ${name}: ` +
-          `The property ${p} is not decorated for dependency injection.`,
-      );
-    }
-
-    return resolve(
+  return resolveMap(injectedProperties, injection =>
+    resolve(
       ctx,
       injection,
       // Clone the session so that multiple properties can be resolved in parallel
       ResolutionSession.fork(session),
-    );
-  });
+    ),
+  );
 }

package/src/unique-id.ts

@@ -0,0 +1,24 @@
+// Copyright IBM Corp. 2018,2020. All Rights Reserved.
+// Node module: @loopback/context
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import hyperid from 'hyperid';
+
+/**
+ * Generate a (globally) unique identifier in a very fast way.
+ * Please note the ids ARE NOT formatted as UUID and have variable length.
+ * The format of generated values may change in the future.
+ *
+ * @internal
+ */
+export const generateUniqueId = hyperid({
+  fixedLength: false,
+  urlSafe: true,
+});
+
+/**
+ * A regular expression for testing values generated by generateUniqueId.
+ * @internal
+ */
+export const UNIQUE_ID_PATTERN = /[A-Za-z0-9-_]+-\d+/;

package/src/value-promise.ts

@@ -187,36 +187,63 @@ export function resolveList<T, V>(
  * @param action - A function that returns a promise or a value
  * @param finalAction - A function to be called once the action
  * is fulfilled or rejected (synchronously or asynchronously)
+ *
+ *  @typeParam T - Type for the return value
  */
 export function tryWithFinally<T>(
   action: () => ValueOrPromise<T>,
   finalAction: () => void,
+): ValueOrPromise<T> {
+  return tryCatchFinally(action, undefined, finalAction);
+}
+
+/**
+ * Try to run an action that returns a promise or a value with error and final
+ * actions to mimic `try {} catch(err) {} finally {}` for a value or promise.
+ *
+ * @param action - A function that returns a promise or a value
+ * @param errorAction - A function to be called once the action
+ * is rejected (synchronously or asynchronously). It must either return a new
+ * value or throw an error.
+ * @param finalAction - A function to be called once the action
+ * is fulfilled or rejected (synchronously or asynchronously)
+ *
+ * @typeParam T - Type for the return value
+ */
+export function tryCatchFinally<T>(
+  action: () => ValueOrPromise<T>,
+  errorAction: (err: unknown) => T | never = err => {
+    throw err;
+  },
+  finalAction: () => void = () => {},
 ): ValueOrPromise<T> {
   let result: ValueOrPromise<T>;
   try {
     result = action();
   } catch (err) {
-    finalAction();
-    throw err;
+    result = reject(err);
   }
   if (isPromiseLike(result)) {
-    // Once (promise.finally)[https://github.com/tc39/proposal-promise-finally
-    // is supported, the following can be simplifed as
-    // `result = result.finally(finalAction);`
-    result = result.then(
-      val => {
-        finalAction();
-        return val;
-      },
-      err => {
-        finalAction();
-        throw err;
-      },
-    );
-  } else {
-    finalAction();
+    return result.then(resolve, reject);
+  }
+
+  return resolve(result);
+
+  function resolve(value: T) {
+    try {
+      return value;
+    } finally {
+      finalAction();
+    }
+  }
+
+  function reject(err: unknown): T | never {
+    try {
+      return errorAction(err);
+    } finally {
+      finalAction();
+    }
   }
-  return result;
 }
 
 /**
@@ -274,6 +301,9 @@ export function transformValueOrPromise<T, V>(
 
 /**
  * A utility to generate uuid v4
+ *
+ * @deprecated Use [uuid](https://www.npmjs.com/package/uuid) or
+ * [hyperid](https://www.npmjs.com/package/hyperid) instead.
  */
 export function uuid() {
   return uuidv4();
@@ -281,5 +311,7 @@ export function uuid() {
 
 /**
  * A regular expression for testing uuid v4 PATTERN
+ * @deprecated This pattern is an internal helper used by unit-tests, we are no
+ * longer using it.
  */
 export const UUID_PATTERN = /[0-9A-F]{8}-[0-9A-F]{4}-[4][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}/i;