@loopback/context 3.15.0 → 3.17.1

package/src/binding.ts

@@ -508,11 +508,21 @@ export class Binding<T = BoundValue> extends EventEmitter {
     const options = asResolutionOptions(optionsOrSession);
     const resolutionCtx = this.getResolutionContext(ctx, options);
     if (resolutionCtx == null) return undefined;
+
+    // Keep a snapshot for proxy
+    const savedSession =
+      ResolutionSession.fork(options.session) ?? new ResolutionSession();
+
     // First check cached value for non-transient
     if (this._cache) {
       if (this.scope !== BindingScope.TRANSIENT) {
         if (resolutionCtx && this._cache.has(resolutionCtx)) {
-          return this._cache.get(resolutionCtx)!;
+          const value = this._cache.get(resolutionCtx)!;
+          return this.getValueOrProxy(
+            resolutionCtx,
+            {...options, session: savedSession},
+            value,
+          );
         }
       }
     }
@@ -524,7 +534,12 @@ export class Binding<T = BoundValue> extends EventEmitter {
     if (typeof this._getValue === 'function') {
       const result = ResolutionSession.runWithBinding(
         s => {
-          const optionsWithSession = {...options, session: s};
+          const optionsWithSession = {
+            ...options,
+            session: s,
+            // Force to be the non-proxy version
+            asProxyWithInterceptors: false,
+          };
           // We already test `this._getValue` is a function. It's safe to assert
           // that `this._getValue` is not undefined.
           return this._getValue!({
@@ -535,7 +550,12 @@ export class Binding<T = BoundValue> extends EventEmitter {
         this,
         options.session,
       );
-      return this._cacheValue(resolutionCtx!, result);
+      const value = this._cacheValue(resolutionCtx!, result);
+      return this.getValueOrProxy(
+        resolutionCtx,
+        {...options, session: savedSession},
+        value,
+      );
     }
     // `@inject.binding` adds a binding without _getValue
     if (options.optional) return undefined;
@@ -547,6 +567,23 @@ export class Binding<T = BoundValue> extends EventEmitter {
     );
   }
 
+  private getValueOrProxy(
+    resolutionCtx: Context,
+    options: ResolutionOptions,
+    value: ValueOrPromise<T>,
+  ): ValueOrPromise<T> {
+    const session = options.session!;
+    session.pushBinding(this);
+    return Binding.valueOrProxy(
+      {
+        context: resolutionCtx,
+        binding: this,
+        options,
+      },
+      value,
+    );
+  }
+
   /**
    * Locate and validate the resolution context
    * @param ctx - Current context
@@ -1060,11 +1097,11 @@ function createInterceptionProxyFromInstance<T>(
 ) {
   return transformValueOrPromise(instOrPromise, inst => {
     if (typeof inst !== 'object' || inst == null) return inst;
-    return (createProxyWithInterceptors(
+    return createProxyWithInterceptors(
       // Cast inst from `T` to `object`
-      (inst as unknown) as object,
+      inst as unknown as object,
       context,
       session,
-    ) as unknown) as T;
+    ) as unknown as T;
   });
 }

package/src/context-tag-indexer.ts

@@ -16,10 +16,8 @@ export class ContextTagIndexer {
   /**
    * Index for bindings by tag names
    */
-  readonly bindingsIndexedByTag: Map<
-    string,
-    Set<Readonly<Binding<unknown>>>
-  > = new Map();
+  readonly bindingsIndexedByTag: Map<string, Set<Readonly<Binding<unknown>>>> =
+    new Map();
 
   /**
    * A listener for binding events

package/src/context-view.ts

@@ -47,7 +47,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
    */

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;

package/src/inject.ts

@@ -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;