@loopback/context 4.0.0-alpha.6 → 4.0.0

package/dist/interception-proxy.js

@@ -0,0 +1,67 @@
+"use strict";
+// Copyright IBM Corp. 2019,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
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProxyWithInterceptors = exports.InterceptionHandler = exports.ProxySource = void 0;
+const context_1 = require("./context");
+const interceptor_1 = require("./interceptor");
+const resolution_session_1 = require("./resolution-session");
+/**
+ * Invocation source for injected proxies. It wraps a snapshot of the
+ * `ResolutionSession` that tracks the binding/injection stack.
+ */
+class ProxySource {
+    constructor(value) {
+        this.value = value;
+        this.type = 'proxy';
+    }
+    toString() {
+        return this.value.getBindingPath();
+    }
+}
+exports.ProxySource = ProxySource;
+/**
+ * A proxy handler that applies interceptors
+ *
+ * See https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Proxy
+ */
+class InterceptionHandler {
+    constructor(context = new context_1.Context(), session, source) {
+        this.context = context;
+        this.session = session;
+        this.source = source;
+    }
+    get(target, propertyName, receiver) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const targetObj = target;
+        if (typeof propertyName !== 'string')
+            return targetObj[propertyName];
+        const propertyOrMethod = targetObj[propertyName];
+        if (typeof propertyOrMethod === 'function') {
+            return (...args) => {
+                var _a;
+                return (0, interceptor_1.invokeMethodWithInterceptors)(this.context, target, propertyName, args, {
+                    source: (_a = this.source) !== null && _a !== void 0 ? _a : (this.session && new ProxySource(this.session)),
+                });
+            };
+        }
+        else {
+            return propertyOrMethod;
+        }
+    }
+}
+exports.InterceptionHandler = InterceptionHandler;
+/**
+ * Create a proxy that applies interceptors for method invocations
+ * @param target - Target class or object
+ * @param context - Context object
+ * @param session - Resolution session
+ * @param source - Invocation source
+ */
+function createProxyWithInterceptors(target, context, session, source) {
+    return new Proxy(target, new InterceptionHandler(context, resolution_session_1.ResolutionSession.fork(session), source));
+}
+exports.createProxyWithInterceptors = createProxyWithInterceptors;
+//# sourceMappingURL=interception-proxy.js.map

package/dist/interception-proxy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interception-proxy.js","sourceRoot":"","sources":["../src/interception-proxy.ts"],"names":[],"mappings":";AAAA,sDAAsD;AACtD,iCAAiC;AACjC,+CAA+C;AAC/C,gEAAgE;;;AAEhE,uCAAkC;AAClC,+CAA2D;AAE3D,6DAAuD;AAoDvD;;;GAGG;AACH,MAAa,WAAW;IAEtB,YAAqB,KAAwB;QAAxB,UAAK,GAAL,KAAK,CAAmB;QAD7C,SAAI,GAAG,OAAO,CAAC;IACiC,CAAC;IAEjD,QAAQ;QACN,OAAO,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE,CAAC;IACrC,CAAC;CACF;AAPD,kCAOC;AAED;;;;GAIG;AACH,MAAa,mBAAmB;IAC9B,YACU,UAAU,IAAI,iBAAO,EAAE,EACvB,OAA2B,EAC3B,MAAyB;QAFzB,YAAO,GAAP,OAAO,CAAgB;QACvB,YAAO,GAAP,OAAO,CAAoB;QAC3B,WAAM,GAAN,MAAM,CAAmB;IAChC,CAAC;IAEJ,GAAG,CAAC,MAAS,EAAE,YAAyB,EAAE,QAAiB;QACzD,8DAA8D;QAC9D,MAAM,SAAS,GAAG,MAAa,CAAC;QAChC,IAAI,OAAO,YAAY,KAAK,QAAQ;YAAE,OAAO,SAAS,CAAC,YAAY,CAAC,CAAC;QACrE,MAAM,gBAAgB,GAAG,SAAS,CAAC,YAAY,CAAC,CAAC;QACjD,IAAI,OAAO,gBAAgB,KAAK,UAAU,EAAE;YAC1C,OAAO,CAAC,GAAG,IAAoB,EAAE,EAAE;;gBACjC,OAAO,IAAA,0CAA4B,EACjC,IAAI,CAAC,OAAO,EACZ,MAAM,EACN,YAAY,EACZ,IAAI,EACJ;oBACE,MAAM,EACJ,MAAA,IAAI,CAAC,MAAM,mCAAI,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;iBACjE,CACF,CAAC;YACJ,CAAC,CAAC;SACH;aAAM;YACL,OAAO,gBAAgB,CAAC;SACzB;IACH,CAAC;CACF;AA7BD,kDA6BC;AAED;;;;;;GAMG;AACH,SAAgB,2BAA2B,CACzC,MAAS,EACT,OAAiB,EACjB,OAA2B,EAC3B,MAAyB;IAEzB,OAAO,IAAI,KAAK,CACd,MAAM,EACN,IAAI,mBAAmB,CAAC,OAAO,EAAE,sCAAiB,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,CACzD,CAAC;AACrB,CAAC;AAVD,kEAUC"}

package/dist/interceptor-chain.d.ts

@@ -0,0 +1,121 @@
+import { BindingFilter } from './binding-filter';
+import { BindingAddress } from './binding-key';
+import { BindingComparator } from './binding-sorter';
+import { Context } from './context';
+import { InvocationResult } from './invocation';
+import { ValueOrPromise } from './value-promise';
+/**
+ * Any type except `void`. We use this type to enforce that interceptor functions
+ * always return a value (including undefined or null).
+ */
+export declare type NonVoid = string | number | boolean | null | undefined | object;
+/**
+ * The `next` function that can be used to invoke next generic interceptor in
+ * the chain
+ */
+export declare type Next = () => ValueOrPromise<NonVoid>;
+/**
+ * An interceptor function to be invoked in a chain for the given context.
+ * It serves as the base interface for various types of interceptors, such
+ * as method invocation interceptor or request/response processing interceptor.
+ *
+ * @remarks
+ * We choose `NonVoid` as the return type to avoid possible bugs that an
+ * interceptor forgets to return the value from `next()`. For example, the code
+ * below will fail to compile.
+ *
+ * ```ts
+ * const myInterceptor: Interceptor = async (ctx, next) {
+ *   // preprocessing
+ *   // ...
+ *
+ *   // There is a subtle bug that the result from `next()` is not further
+ *   // returned back to the upstream interceptors
+ *   const result = await next();
+ *
+ *   // postprocessing
+ *   // ...
+ *   // We must have `return ...` here
+ *   // either return `result` or another value if the interceptor decides to
+ *   // have its own response
+ * }
+ * ```
+ *
+ * @typeParam C - `Context` class or a subclass of `Context`
+ * @param context - Context object
+ * @param next - A function to proceed with downstream interceptors or the
+ * target operation
+ *
+ * @returns The invocation result as a value (sync) or promise (async).
+ */
+export declare type GenericInterceptor<C extends Context = Context> = (context: C, next: Next) => ValueOrPromise<NonVoid>;
+/**
+ * Interceptor function or a binding key that resolves a generic interceptor
+ * function
+ * @typeParam C - `Context` class or a subclass of `Context`
+ * @typeParam T - Return type of `next()`
+ */
+export declare type GenericInterceptorOrKey<C extends Context = Context> = BindingAddress<GenericInterceptor<C>> | GenericInterceptor<C>;
+/**
+ * A chain of generic interceptors to be invoked for the given context
+ *
+ * @typeParam C - `Context` class or a subclass of `Context`
+ */
+export declare class GenericInterceptorChain<C extends Context = Context> {
+    private context;
+    /**
+     * A getter for an array of interceptor functions or binding keys
+     */
+    protected getInterceptors: () => GenericInterceptorOrKey<C>[];
+    /**
+     * Create an invocation chain with a list of interceptor functions or
+     * binding keys
+     * @param context - Context object
+     * @param interceptors - An array of interceptor functions or binding keys
+     */
+    constructor(context: C, interceptors: GenericInterceptorOrKey<C>[]);
+    /**
+     * Create an invocation interceptor chain with a binding filter and comparator.
+     * The interceptors are discovered from the context using the binding filter and
+     * sorted by the comparator (if provided).
+     *
+     * @param context - Context object
+     * @param filter - A binding filter function to select interceptors
+     * @param comparator - An optional comparator to sort matched interceptor bindings
+     */
+    constructor(context: C, filter: BindingFilter, comparator?: BindingComparator);
+    /**
+     * Invoke the interceptor chain
+     */
+    invokeInterceptors(finalHandler?: Next): ValueOrPromise<InvocationResult>;
+    /**
+     * Use the interceptor chain as an interceptor
+     */
+    asInterceptor(): GenericInterceptor<C>;
+    /**
+     * Invoke downstream interceptors or the target method
+     */
+    private next;
+    /**
+     * Invoke downstream interceptors
+     */
+    private invokeNextInterceptor;
+    /**
+     * Return the interceptor function or resolve the interceptor function as a binding
+     * from the context
+     *
+     * @param interceptor - Interceptor function or binding key
+     */
+    private loadInterceptor;
+}
+/**
+ * Invoke a chain of interceptors with the context
+ * @param context - Context object
+ * @param interceptors - An array of interceptor functions or binding keys
+ */
+export declare function invokeInterceptors<C extends Context = Context, T = InvocationResult>(context: C, interceptors: GenericInterceptorOrKey<C>[]): ValueOrPromise<T | undefined>;
+/**
+ * Compose a list of interceptors as a single interceptor
+ * @param interceptors - A list of interceptor functions or binding keys
+ */
+export declare function composeInterceptors<C extends Context = Context>(...interceptors: GenericInterceptorOrKey<C>[]): GenericInterceptor<C>;

package/dist/interceptor-chain.js

@@ -0,0 +1,148 @@
+"use strict";
+// Copyright IBM Corp. 2019,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
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeInterceptors = exports.invokeInterceptors = exports.GenericInterceptorChain = void 0;
+const tslib_1 = require("tslib");
+const debug_1 = (0, tslib_1.__importDefault)(require("debug"));
+const value_promise_1 = require("./value-promise");
+const debug = (0, debug_1.default)('loopback:context:interceptor-chain');
+/**
+ * Invocation state of an interceptor chain
+ */
+class InterceptorChainState {
+    /**
+     * Create a state for the interceptor chain
+     * @param interceptors - Interceptor functions or binding keys
+     * @param finalHandler - An optional final handler
+     */
+    constructor(interceptors, finalHandler = () => undefined) {
+        this.interceptors = interceptors;
+        this.finalHandler = finalHandler;
+        this._index = 0;
+    }
+    /**
+     * Get the index for the current interceptor
+     */
+    get index() {
+        return this._index;
+    }
+    /**
+     * Check if the chain is done - all interceptors are invoked
+     */
+    done() {
+        return this._index === this.interceptors.length;
+    }
+    /**
+     * Get the next interceptor to be invoked
+     */
+    next() {
+        if (this.done()) {
+            throw new Error('No more interceptor is in the chain');
+        }
+        return this.interceptors[this._index++];
+    }
+}
+/**
+ * A chain of generic interceptors to be invoked for the given context
+ *
+ * @typeParam C - `Context` class or a subclass of `Context`
+ */
+class GenericInterceptorChain {
+    // Implementation
+    constructor(context, interceptors, comparator) {
+        this.context = context;
+        if (typeof interceptors === 'function') {
+            const interceptorsView = context.createView(interceptors, comparator);
+            this.getInterceptors = () => {
+                const bindings = interceptorsView.bindings;
+                if (comparator) {
+                    bindings.sort(comparator);
+                }
+                return bindings.map(b => b.key);
+            };
+        }
+        else if (Array.isArray(interceptors)) {
+            this.getInterceptors = () => interceptors;
+        }
+    }
+    /**
+     * Invoke the interceptor chain
+     */
+    invokeInterceptors(finalHandler) {
+        // Create a state for each invocation to provide isolation
+        const state = new InterceptorChainState(this.getInterceptors(), finalHandler);
+        return this.next(state);
+    }
+    /**
+     * Use the interceptor chain as an interceptor
+     */
+    asInterceptor() {
+        return (ctx, next) => {
+            return this.invokeInterceptors(next);
+        };
+    }
+    /**
+     * Invoke downstream interceptors or the target method
+     */
+    next(state) {
+        if (state.done()) {
+            // No more interceptors
+            return state.finalHandler();
+        }
+        // Invoke the next interceptor in the chain
+        return this.invokeNextInterceptor(state);
+    }
+    /**
+     * Invoke downstream interceptors
+     */
+    invokeNextInterceptor(state) {
+        const index = state.index;
+        const interceptor = state.next();
+        const interceptorFn = this.loadInterceptor(interceptor);
+        return (0, value_promise_1.transformValueOrPromise)(interceptorFn, fn => {
+            /* istanbul ignore if */
+            if (debug.enabled) {
+                debug('Invoking interceptor %d (%s) on %s', index, fn.name);
+            }
+            return fn(this.context, () => this.next(state));
+        });
+    }
+    /**
+     * Return the interceptor function or resolve the interceptor function as a binding
+     * from the context
+     *
+     * @param interceptor - Interceptor function or binding key
+     */
+    loadInterceptor(interceptor) {
+        if (typeof interceptor === 'function')
+            return interceptor;
+        debug('Resolving interceptor binding %s', interceptor);
+        return this.context.getValueOrPromise(interceptor);
+    }
+}
+exports.GenericInterceptorChain = GenericInterceptorChain;
+/**
+ * Invoke a chain of interceptors with the context
+ * @param context - Context object
+ * @param interceptors - An array of interceptor functions or binding keys
+ */
+function invokeInterceptors(context, interceptors) {
+    const chain = new GenericInterceptorChain(context, interceptors);
+    return chain.invokeInterceptors();
+}
+exports.invokeInterceptors = invokeInterceptors;
+/**
+ * Compose a list of interceptors as a single interceptor
+ * @param interceptors - A list of interceptor functions or binding keys
+ */
+function composeInterceptors(...interceptors) {
+    return (ctx, next) => {
+        const interceptor = new GenericInterceptorChain(ctx, interceptors).asInterceptor();
+        return interceptor(ctx, next);
+    };
+}
+exports.composeInterceptors = composeInterceptors;
+//# sourceMappingURL=interceptor-chain.js.map

package/dist/interceptor-chain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interceptor-chain.js","sourceRoot":"","sources":["../src/interceptor-chain.ts"],"names":[],"mappings":"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"}

package/dist/interceptor.d.ts

@@ -0,0 +1,138 @@
+import { MetadataAccessor } from '@loopback/metadata';
+import { Binding, BindingTemplate } from './binding';
+import { BindingFromClassOptions, BindingSpec } from './binding-inspector';
+import { Context } from './context';
+import { GenericInterceptor, GenericInterceptorOrKey } from './interceptor-chain';
+import { InvocationArgs, InvocationContext, InvocationOptions, InvocationResult } from './invocation';
+import { Provider } from './provider';
+import { Constructor, ValueOrPromise } from './value-promise';
+/**
+ * A specialized InvocationContext for interceptors
+ */
+export declare class InterceptedInvocationContext extends InvocationContext {
+    /**
+     * Discover all binding keys for global interceptors (tagged by
+     * ContextTags.GLOBAL_INTERCEPTOR)
+     */
+    getGlobalInterceptorBindingKeys(): string[];
+    /**
+     * Check if the binding for a global interceptor matches the source type
+     * of the invocation
+     * @param binding - Binding
+     */
+    private applicableTo;
+    /**
+     * Sort global interceptor bindings by `globalInterceptorGroup` tags
+     * @param bindings - An array of global interceptor bindings
+     */
+    private sortGlobalInterceptorBindings;
+    /**
+     * Load all interceptors for the given invocation context. It adds
+     * interceptors from possibly three sources:
+     * 1. method level `@intercept`
+     * 2. class level `@intercept`
+     * 3. global interceptors discovered in the context
+     */
+    loadInterceptors(): InterceptorOrKey[];
+}
+/**
+ * The `BindingTemplate` function to configure a binding as a global interceptor
+ * by tagging it with `ContextTags.INTERCEPTOR`
+ * @param group - Group for ordering the interceptor
+ */
+export declare function asGlobalInterceptor(group?: string): BindingTemplate;
+/**
+ * `@globalInterceptor` decorator to mark the class as a global interceptor
+ * @param group - Group for ordering the interceptor
+ * @param specs - Extra binding specs
+ */
+export declare function globalInterceptor(group?: string, ...specs: BindingSpec[]): ClassDecorator;
+/**
+ * Interceptor function to intercept method invocations
+ */
+export interface Interceptor extends GenericInterceptor<InvocationContext> {
+}
+/**
+ * Interceptor function or binding key that can be used as parameters for
+ * `@intercept()`
+ */
+export declare type InterceptorOrKey = GenericInterceptorOrKey<InvocationContext>;
+/**
+ * Metadata key for method-level interceptors
+ */
+export declare const INTERCEPT_METHOD_KEY: MetadataAccessor<InterceptorOrKey[], MethodDecorator>;
+/**
+ * Adding interceptors from the spec to the front of existing ones. Duplicate
+ * entries are eliminated from the spec side.
+ *
+ * For example:
+ *
+ * - [log] + [cache, log] => [cache, log]
+ * - [log] + [log, cache] => [log, cache]
+ * - [] + [cache, log] => [cache, log]
+ * - [cache, log] + [] => [cache, log]
+ * - [log] + [cache] => [log, cache]
+ *
+ * @param interceptorsFromSpec - Interceptors from `@intercept`
+ * @param existingInterceptors - Interceptors already applied for the method
+ */
+export declare function mergeInterceptors(interceptorsFromSpec: InterceptorOrKey[], existingInterceptors: InterceptorOrKey[]): InterceptorOrKey[];
+/**
+ * Metadata key for method-level interceptors
+ */
+export declare const INTERCEPT_CLASS_KEY: MetadataAccessor<InterceptorOrKey[], ClassDecorator>;
+/**
+ * Decorator function `@intercept` for classes/methods to apply interceptors. It
+ * can be applied on a class and its public methods. Multiple occurrences of
+ * `@intercept` are allowed on the same target class or method. The decorator
+ * takes a list of `interceptor` functions or binding keys.
+ *
+ * @example
+ * ```ts
+ * @intercept(log, metrics)
+ * class MyController {
+ *   @intercept('caching-interceptor')
+ *   @intercept('name-validation-interceptor')
+ *   greet(name: string) {
+ *     return `Hello, ${name}`;
+ *   }
+ * }
+ * ```
+ *
+ * @param interceptorOrKeys - One or more interceptors or binding keys that are
+ * resolved to be interceptors
+ */
+export declare function intercept(...interceptorOrKeys: InterceptorOrKey[]): (target: any, method?: string | undefined, methodDescriptor?: TypedPropertyDescriptor<any> | undefined) => any;
+/**
+ * Invoke a method with the given context
+ * @param context - Context object
+ * @param target - Target class (for static methods) or object (for instance methods)
+ * @param methodName - Method name
+ * @param args - An array of argument values
+ * @param options - Options for the invocation
+ */
+export declare function invokeMethodWithInterceptors(context: Context, target: object, methodName: string, args: InvocationArgs, options?: InvocationOptions): ValueOrPromise<InvocationResult>;
+/**
+ * Options for an interceptor binding
+ */
+export interface InterceptorBindingOptions extends BindingFromClassOptions {
+    /**
+     * Global or local interceptor
+     */
+    global?: boolean;
+    /**
+     * Group name for a global interceptor
+     */
+    group?: string;
+    /**
+     * Source filter for a global interceptor
+     */
+    source?: string | string[];
+}
+/**
+ * Register an interceptor function or provider class to the given context
+ * @param ctx - Context object
+ * @param interceptor - An interceptor function or provider class
+ * @param options - Options for the interceptor binding
+ */
+export declare function registerInterceptor(ctx: Context, interceptor: Interceptor | Constructor<Provider<Interceptor>>, options?: InterceptorBindingOptions): Binding<Interceptor>;