@loopback/context 3.16.0 → 3.18.0

package/src/context-view.ts

@@ -14,7 +14,12 @@ import {ContextEvent} from './context-event';
 import {ContextEventType, ContextObserver} from './context-observer';
 import {Subscription} from './context-subscription';
 import {Getter} from './inject';
-import {ResolutionSession} from './resolution-session';
+import {
+  asResolutionOptions,
+  ResolutionOptions,
+  ResolutionOptionsOrSession,
+  ResolutionSession,
+} from './resolution-session';
 import {isPromiseLike, resolveList, ValueOrPromise} from './value-promise';
 const debug = debugFactory('loopback:context:view');
 const nextTick = promisify(process.nextTick);
@@ -47,7 +52,8 @@ export interface ContextViewEvent<T> extends ContextEvent {
  */
 export class ContextView<T = unknown>
   extends EventEmitter
-  implements ContextObserver {
+  implements ContextObserver
+{
   /**
    * An array of cached bindings that matches the binding filter
    */
@@ -68,6 +74,7 @@ export class ContextView<T = unknown>
     public readonly context: Context,
     public readonly filter: BindingFilter,
     public readonly comparator?: BindingComparator,
+    private resolutionOptions?: Omit<ResolutionOptions, 'session'>,
   ) {
     super();
   }
@@ -187,34 +194,41 @@ export class ContextView<T = unknown>
    * Resolve values for the matching bindings
    * @param session - Resolution session
    */
-  resolve(session?: ResolutionSession): ValueOrPromise<T[]> {
+  resolve(session?: ResolutionOptionsOrSession): ValueOrPromise<T[]> {
     debug('Resolving values');
     if (this._cachedValues != null) {
       return this.getCachedValues();
     }
     const bindings = this.bindings;
     let result = resolveList(bindings, b => {
-      return b.getValue(this.context, ResolutionSession.fork(session));
+      const options = {
+        ...this.resolutionOptions,
+        ...asResolutionOptions(session),
+      };
+      options.session = ResolutionSession.fork(options.session);
+      return b.getValue(this.context, options);
     });
     if (isPromiseLike(result)) {
       result = result.then(values => {
-        this.updateCachedValues(values);
-        this.emit('resolve', values);
-        return values;
+        const list = values.filter(v => v != null) as T[];
+        this.updateCachedValues(list);
+        this.emit('resolve', list);
+        return list;
       });
     } else {
       // Clone the array so that the cached values won't be mutated
-      this.updateCachedValues(result);
-      this.emit('resolve', result);
+      const list = (result = result.filter(v => v != null) as T[]);
+      this.updateCachedValues(list);
+      this.emit('resolve', list);
     }
-    return result;
+    return result as ValueOrPromise<T[]>;
   }
 
   /**
    * Get the list of resolved values. If they are not cached, it tries to find
    * and resolve them.
    */
-  async values(session?: ResolutionSession): Promise<T[]> {
+  async values(session?: ResolutionOptionsOrSession): Promise<T[]> {
     debug('Reading values');
     // Wait for the next tick so that context event notification can be emitted
     await nextTick();
@@ -227,14 +241,16 @@ export class ContextView<T = unknown>
   /**
    * As a `Getter` function
    */
-  asGetter(session?: ResolutionSession): Getter<T[]> {
+  asGetter(session?: ResolutionOptionsOrSession): Getter<T[]> {
     return () => this.values(session);
   }
 
   /**
    * Get the single value
    */
-  async singleValue(session?: ResolutionSession): Promise<T | undefined> {
+  async singleValue(
+    session?: ResolutionOptionsOrSession,
+  ): Promise<T | undefined> {
     const values = await this.values(session);
     if (values.length === 0) return undefined;
     if (values.length === 1) return values[0];
@@ -388,7 +404,7 @@ export function createViewGetter<T = unknown>(
   ctx: Context,
   bindingFilter: BindingFilter,
   bindingComparator?: BindingComparator,
-  session?: ResolutionSession,
+  session?: ResolutionOptionsOrSession,
 ): Getter<T[]>;
 
 /**
@@ -403,7 +419,7 @@ export function createViewGetter<T = unknown>(
   ctx: Context,
   bindingFilter: BindingFilter,
   bindingComparatorOrSession?: BindingComparator | ResolutionSession,
-  session?: ResolutionSession,
+  session?: ResolutionOptionsOrSession,
 ): Getter<T[]> {
   let bindingComparator: BindingComparator | undefined = undefined;
   if (typeof bindingComparatorOrSession === 'function') {
@@ -412,7 +428,13 @@ export function createViewGetter<T = unknown>(
     session = bindingComparatorOrSession;
   }
 
-  const view = new ContextView<T>(ctx, bindingFilter, bindingComparator);
+  const options = asResolutionOptions(session);
+  const view = new ContextView<T>(
+    ctx,
+    bindingFilter,
+    bindingComparator,
+    options,
+  );
   view.open();
-  return view.asGetter(session);
+  return view.asGetter(options);
 }

package/src/context.ts

@@ -128,7 +128,7 @@ export class Context extends EventEmitter {
     // The number of listeners can grow with the number of child contexts
     // For example, each request can add a listener to the RestServer and the
     // listener is removed when the request processing is finished.
-    // See https://github.com/strongloop/loopback-next/issues/4363
+    // See https://github.com/loopbackio/loopback-next/issues/4363
     this.setMaxListeners(Infinity);
     if (typeof _parent === 'string') {
       name = _parent;
@@ -441,12 +441,14 @@ export class Context extends EventEmitter {
    * Create a view of the context chain with the given binding filter
    * @param filter - A function to match bindings
    * @param comparator - A function to sort matched bindings
+   * @param options - Resolution options
    */
   createView<T = unknown>(
     filter: BindingFilter,
     comparator?: BindingComparator,
+    options?: Omit<ResolutionOptions, 'session'>,
   ) {
-    const view = new ContextView<T>(this, filter, comparator);
+    const view = new ContextView<T>(this, filter, comparator, options);
     view.open();
     return view;
   }

package/src/inject.ts

@@ -67,7 +67,7 @@ export interface ResolverFunction {
 /**
  * An object to provide metadata for `@inject`
  */
-export interface InjectionMetadata extends ResolutionOptions {
+export interface InjectionMetadata extends Omit<ResolutionOptions, 'session'> {
   /**
    * Name of the decorator function, such as `@inject` or `@inject.setter`.
    * It's usually set by the decorator implementation.
@@ -152,20 +152,21 @@ export function inject(
     if (typeof methodDescriptorOrParameterIndex === 'number') {
       // The decorator is applied to a method parameter
       // Please note propertyKey is `undefined` for constructor
-      const paramDecorator: ParameterDecorator = ParameterDecoratorFactory.createDecorator<Injection>(
-        INJECT_PARAMETERS_KEY,
-        {
-          target,
-          member,
-          methodDescriptorOrParameterIndex,
-          bindingSelector,
-          metadata: injectionMetadata,
-          resolve,
-        },
-        // Do not deep clone the spec as only metadata is mutable and it's
-        // shallowly cloned
-        {cloneInputSpec: false, decoratorName: injectionMetadata.decorator},
-      );
+      const paramDecorator: ParameterDecorator =
+        ParameterDecoratorFactory.createDecorator<Injection>(
+          INJECT_PARAMETERS_KEY,
+          {
+            target,
+            member,
+            methodDescriptorOrParameterIndex,
+            bindingSelector,
+            metadata: injectionMetadata,
+            resolve,
+          },
+          // Do not deep clone the spec as only metadata is mutable and it's
+          // shallowly cloned
+          {cloneInputSpec: false, decoratorName: injectionMetadata.decorator},
+        );
       paramDecorator(target, member!, methodDescriptorOrParameterIndex);
     } else if (member) {
       // Property or method
@@ -186,20 +187,21 @@ export function inject(
             ),
         );
       }
-      const propDecorator: PropertyDecorator = PropertyDecoratorFactory.createDecorator<Injection>(
-        INJECT_PROPERTIES_KEY,
-        {
-          target,
-          member,
-          methodDescriptorOrParameterIndex,
-          bindingSelector,
-          metadata: injectionMetadata,
-          resolve,
-        },
-        // Do not deep clone the spec as only metadata is mutable and it's
-        // shallowly cloned
-        {cloneInputSpec: false, decoratorName: injectionMetadata.decorator},
-      );
+      const propDecorator: PropertyDecorator =
+        PropertyDecoratorFactory.createDecorator<Injection>(
+          INJECT_PROPERTIES_KEY,
+          {
+            target,
+            member,
+            methodDescriptorOrParameterIndex,
+            bindingSelector,
+            metadata: injectionMetadata,
+            resolve,
+          },
+          // Do not deep clone the spec as only metadata is mutable and it's
+          // shallowly cloned
+          {cloneInputSpec: false, decoratorName: injectionMetadata.decorator},
+        );
       propDecorator(target, member!);
     } else {
       // It won't happen here as `@inject` is not compatible with ClassDecorator
@@ -508,7 +510,7 @@ function shouldSkipBaseConstructorInjection(targetClass: Object) {
   const classDef = targetClass.toString();
   return (
     /*
-     * See https://github.com/strongloop/loopback-next/issues/2946
+     * See https://github.com/loopbackio/loopback-next/issues/2946
      * A class decorator can return a new constructor that mixes in
      * additional properties/methods.
      *
@@ -537,7 +539,7 @@ function shouldSkipBaseConstructorInjection(targetClass: Object) {
       /\s+constructor\s*\(\s*\)\s*\{\s*super\(\.\.\.arguments\)/,
     ) &&
     /*
-     * See https://github.com/strongloop/loopback-next/issues/1565
+     * See https://github.com/loopbackio/loopback-next/issues/1565
      *
      * @example
      * ```ts

package/src/interception-proxy.ts

@@ -24,7 +24,7 @@ export type AsValueOrPromise<T> = T extends Promise<unknown>
 export type AsInterceptedFunction<T> = T extends (
   ...args: InvocationArgs
 ) => infer R
-  ? (...args: InvocationArgs) => AsValueOrPromise<R>
+  ? (...args: Parameters<T>) => AsValueOrPromise<R>
   : T;
 
 /**

package/src/interceptor-chain.ts

@@ -242,7 +242,7 @@ export class GenericInterceptorChain<C extends Context = Context> {
  */
 export function invokeInterceptors<
   C extends Context = Context,
-  T = InvocationResult
+  T = InvocationResult,
 >(
   context: C,
   interceptors: GenericInterceptorOrKey<C>[],

package/src/interceptor.ts

@@ -287,7 +287,7 @@ export function intercept(...interceptorOrKeys: InterceptorOrKey[]) {
     target: any,
     method?: string,
     // Use `any` to for `TypedPropertyDescriptor`
-    // See https://github.com/strongloop/loopback-next/pull/2704
+    // See https://github.com/loopbackio/loopback-next/pull/2704
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     methodDescriptor?: TypedPropertyDescriptor<any>,
   ) {

package/src/keys.ts

@@ -71,9 +71,10 @@ export namespace ContextBindings {
   /**
    * Binding key for ConfigurationResolver
    */
-  export const CONFIGURATION_RESOLVER = BindingKey.create<ConfigurationResolver>(
-    `${BindingKey.CONFIG_NAMESPACE}.resolver`,
-  );
+  export const CONFIGURATION_RESOLVER =
+    BindingKey.create<ConfigurationResolver>(
+      `${BindingKey.CONFIG_NAMESPACE}.resolver`,
+    );
 
   /**
    * Binding key for ordered groups of global interceptors

package/src/resolution-session.ts

@@ -92,20 +92,6 @@ export class ResolutionSession {
     return copy;
   }
 
-  /**
-   * Start to resolve a binding within the session
-   * @param binding - The current binding
-   * @param session - The current resolution session
-   */
-  private static enterBinding(
-    binding: Readonly<Binding>,
-    session?: ResolutionSession,
-  ): ResolutionSession {
-    session = session ?? new ResolutionSession();
-    session.pushBinding(binding);
-    return session;
-  }
-
   /**
    * Run the given action with the given binding and session
    * @param action - A function to do some work with the resolution session
@@ -115,29 +101,16 @@ export class ResolutionSession {
   static runWithBinding(
     action: ResolutionAction,
     binding: Readonly<Binding>,
-    session?: ResolutionSession,
+    session = new ResolutionSession(),
   ) {
-    const resolutionSession = ResolutionSession.enterBinding(binding, session);
+    // Start to resolve a binding within the session
+    session.pushBinding(binding);
     return tryWithFinally(
-      () => action(resolutionSession),
-      () => resolutionSession.popBinding(),
+      () => action(session),
+      () => session.popBinding(),
     );
   }
 
-  /**
-   * Push an injection into the session
-   * @param injection - The current injection
-   * @param session - The current resolution session
-   */
-  private static enterInjection(
-    injection: Readonly<Injection>,
-    session?: ResolutionSession,
-  ): ResolutionSession {
-    session = session ?? new ResolutionSession();
-    session.pushInjection(injection);
-    return session;
-  }
-
   /**
    * Run the given action with the given injection and session
    * @param action - A function to do some work with the resolution session
@@ -147,15 +120,12 @@ export class ResolutionSession {
   static runWithInjection(
     action: ResolutionAction,
     injection: Readonly<Injection>,
-    session?: ResolutionSession,
+    session = new ResolutionSession(),
   ) {
-    const resolutionSession = ResolutionSession.enterInjection(
-      injection,
-      session,
-    );
+    session.pushInjection(injection);
     return tryWithFinally(
-      () => action(resolutionSession),
-      () => resolutionSession.popInjection(),
+      () => action(session),
+      () => session.popInjection(),
     );
   }
 
@@ -299,7 +269,7 @@ export class ResolutionSession {
    * Get the binding path as `bindingA --> bindingB --> bindingC`.
    */
   getBindingPath() {
-    return this.bindingStack.map(b => b.key).join(' --> ');
+    return this.stack.filter(isBinding).map(describe).join(' --> ');
   }
 
   /**
@@ -311,22 +281,13 @@ export class ResolutionSession {
       .join(' --> ');
   }
 
-  private static describe(e: ResolutionElement) {
-    switch (e.type) {
-      case 'injection':
-        return '@' + ResolutionSession.describeInjection(e.value).targetName;
-      case 'binding':
-        return e.value.key;
-    }
-  }
-
   /**
    * Get the resolution path including bindings and injections, for example:
    * `bindingA --> @ClassA[0] --> bindingB --> @ClassB.prototype.prop1
    * --> bindingC`.
    */
   getResolutionPath() {
-    return this.stack.map(i => ResolutionSession.describe(i)).join(' --> ');
+    return this.stack.map(describe).join(' --> ');
   }
 
   toString() {
@@ -334,6 +295,15 @@ export class ResolutionSession {
   }
 }
 
+function describe(e: ResolutionElement) {
+  switch (e.type) {
+    case 'injection':
+      return '@' + ResolutionSession.describeInjection(e.value).targetName;
+    case 'binding':
+      return e.value.key;
+  }
+}
+
 /**
  * Options for binding/dependency resolution
  */

package/src/value-promise.ts

@@ -314,4 +314,5 @@ export function uuid() {
  * @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;
+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;