@loopback/service-proxy 3.2.3

package/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) IBM Corp. 2018,2019.
+Node module: @loopback/service-proxy
+This project is licensed under the MIT License, full text below.
+
+--------
+
+MIT license
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,32 @@
+# @loopback/service-proxy
+
+This module provides a common set of interfaces for interacting with service
+oriented backends such as REST APIs, SOAP Web Services, and gRPC microservices.
+
+## Installation
+
+```
+$ npm install @loopback/service-proxy
+```
+
+## Basic use
+
+See https://loopback.io/doc/en/lb4/Calling-other-APIs-and-web-services.html
+
+## Contributions
+
+- [Guidelines](https://github.com/loopbackio/loopback-next/blob/master/docs/CONTRIBUTING.md)
+- [Join the team](https://github.com/loopbackio/loopback-next/issues/110)
+
+## Tests
+
+run 'npm test' from the root folder.
+
+## Contributors
+
+See
+[all contributors](https://github.com/loopbackio/loopback-next/graphs/contributors).
+
+## License
+
+MIT

package/dist/decorators/service.decorator.d.ts

@@ -0,0 +1,17 @@
+import { MetadataAccessor, InjectionMetadata } from '@loopback/core';
+import { juggler } from '..';
+/**
+ * Type definition for decorators returned by `@serviceProxy` decorator factory
+ */
+export declare type ServiceProxyDecorator = PropertyDecorator | ParameterDecorator;
+export declare const SERVICE_PROXY_KEY: MetadataAccessor<string, ServiceProxyDecorator>;
+/**
+ * Metadata for a service proxy
+ */
+export declare class ServiceProxyMetadata implements InjectionMetadata {
+    decorator: string;
+    dataSourceName?: string;
+    dataSource?: juggler.DataSource;
+    constructor(dataSource: string | juggler.DataSource);
+}
+export declare function serviceProxy(dataSource: string | juggler.DataSource): (target: object, key: string, parameterIndex?: number | undefined) => void;

package/dist/decorators/service.decorator.js

@@ -0,0 +1,53 @@
+"use strict";
+// Copyright IBM Corp. 2018,2020. All Rights Reserved.
+// Node module: @loopback/service-proxy
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serviceProxy = exports.ServiceProxyMetadata = exports.SERVICE_PROXY_KEY = void 0;
+const core_1 = require("@loopback/core");
+const __1 = require("..");
+exports.SERVICE_PROXY_KEY = core_1.MetadataAccessor.create('service.proxy');
+/**
+ * Metadata for a service proxy
+ */
+class ServiceProxyMetadata {
+    constructor(dataSource) {
+        this.decorator = '@serviceProxy';
+        if (typeof dataSource === 'string') {
+            this.dataSourceName = dataSource;
+        }
+        else {
+            this.dataSource = dataSource;
+        }
+    }
+}
+exports.ServiceProxyMetadata = ServiceProxyMetadata;
+function serviceProxy(dataSource) {
+    return function (target, key, parameterIndex) {
+        if (key || typeof parameterIndex === 'number') {
+            const meta = new ServiceProxyMetadata(dataSource);
+            core_1.inject('', meta, resolve)(target, key, parameterIndex);
+        }
+        else {
+            throw new Error('@serviceProxy can only be applied to properties or method parameters');
+        }
+    };
+}
+exports.serviceProxy = serviceProxy;
+/**
+ * Resolve the @repository injection
+ * @param ctx - Context
+ * @param injection - Injection metadata
+ */
+async function resolve(ctx, injection) {
+    const meta = injection.metadata;
+    if (meta.dataSource)
+        return __1.getService(meta.dataSource);
+    if (meta.dataSourceName) {
+        const ds = await ctx.get('datasources.' + meta.dataSourceName);
+        return __1.getService(ds);
+    }
+    throw new Error('@serviceProxy must provide a name or an instance of DataSource');
+}
+//# sourceMappingURL=service.decorator.js.map

package/dist/decorators/service.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.decorator.js","sourceRoot":"","sources":["../../src/decorators/service.decorator.ts"],"names":[],"mappings":";AAAA,sDAAsD;AACtD,uCAAuC;AACvC,+CAA+C;AAC/C,gEAAgE;;;AAEhE,yCAMwB;AACxB,0BAAuC;AAO1B,QAAA,iBAAiB,GAAG,uBAAgB,CAAC,MAAM,CAGtD,eAAe,CAAC,CAAC;AAEnB;;GAEG;AACH,MAAa,oBAAoB;IAK/B,YAAY,UAAuC;QAJnD,cAAS,GAAG,eAAe,CAAC;QAK1B,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE;YAClC,IAAI,CAAC,cAAc,GAAG,UAAU,CAAC;SAClC;aAAM;YACL,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;SAC9B;IACH,CAAC;CACF;AAZD,oDAYC;AAED,SAAgB,YAAY,CAAC,UAAuC;IAClE,OAAO,UAAU,MAAc,EAAE,GAAW,EAAE,cAAuB;QACnE,IAAI,GAAG,IAAI,OAAO,cAAc,KAAK,QAAQ,EAAE;YAC7C,MAAM,IAAI,GAAG,IAAI,oBAAoB,CAAC,UAAU,CAAC,CAAC;YAClD,aAAM,CAAC,EAAE,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,MAAM,EAAE,GAAG,EAAE,cAAc,CAAC,CAAC;SACxD;aAAM;YACL,MAAM,IAAI,KAAK,CACb,sEAAsE,CACvE,CAAC;SACH;IACH,CAAC,CAAC;AACJ,CAAC;AAXD,oCAWC;AAED;;;;GAIG;AACH,KAAK,UAAU,OAAO,CAAC,GAAY,EAAE,SAAoB;IACvD,MAAM,IAAI,GAAG,SAAS,CAAC,QAAgC,CAAC;IACxD,IAAI,IAAI,CAAC,UAAU;QAAE,OAAO,cAAU,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IACxD,IAAI,IAAI,CAAC,cAAc,EAAE;QACvB,MAAM,EAAE,GAAG,MAAM,GAAG,CAAC,GAAG,CACtB,cAAc,GAAG,IAAI,CAAC,cAAc,CACrC,CAAC;QACF,OAAO,cAAU,CAAC,EAAE,CAAC,CAAC;KACvB;IACD,MAAM,IAAI,KAAK,CACb,gEAAgE,CACjE,CAAC;AACJ,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A common set of interfaces for interacting with service oriented backends
+ * such as REST APIs, SOAP Web Services, and gRPC microservices.
+ *
+ * @packageDocumentation
+ */
+export * from './decorators/service.decorator';
+export * from './legacy-juggler-bridge';
+export * from './mixins';

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+// Copyright IBM Corp. 2018,2020. All Rights Reserved.
+// Node module: @loopback/service-proxy
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+/**
+ * A common set of interfaces for interacting with service oriented backends
+ * such as REST APIs, SOAP Web Services, and gRPC microservices.
+ *
+ * @packageDocumentation
+ */
+tslib_1.__exportStar(require("./decorators/service.decorator"), exports);
+tslib_1.__exportStar(require("./legacy-juggler-bridge"), exports);
+tslib_1.__exportStar(require("./mixins"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,sDAAsD;AACtD,uCAAuC;AACvC,+CAA+C;AAC/C,gEAAgE;;;AAEhE;;;;;GAKG;AAEH,yEAA+C;AAC/C,kEAAwC;AACxC,mDAAyB"}

package/dist/legacy-juggler-bridge.d.ts

@@ -0,0 +1,18 @@
+import legacy from 'loopback-datasource-juggler';
+export declare namespace juggler {
+    export import DataSource = legacy.DataSource;
+}
+/**
+ * A generic service interface with any number of methods that return a promise
+ */
+export interface GenericService {
+    [methodName: string]: (...args: any[]) => Promise<any>;
+}
+/**
+ * Get a service proxy from a LoopBack 3.x data source backed by
+ * service-oriented connectors such as `rest`, `soap`, and `grpc`.
+ *
+ * @param ds - A legacy data source
+ * @typeParam T - The generic type of service interface
+ */
+export declare function getService<T = GenericService>(ds: legacy.DataSource): Promise<T>;

package/dist/legacy-juggler-bridge.js

@@ -0,0 +1,28 @@
+"use strict";
+// Copyright IBM Corp. 2018,2019. All Rights Reserved.
+// Node module: @loopback/service-proxy
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getService = exports.juggler = void 0;
+const tslib_1 = require("tslib");
+const loopback_datasource_juggler_1 = tslib_1.__importDefault(require("loopback-datasource-juggler"));
+var juggler;
+(function (juggler) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    juggler.DataSource = loopback_datasource_juggler_1.default.DataSource;
+})(juggler = exports.juggler || (exports.juggler = {}));
+/**
+ * Get a service proxy from a LoopBack 3.x data source backed by
+ * service-oriented connectors such as `rest`, `soap`, and `grpc`.
+ *
+ * @param ds - A legacy data source
+ * @typeParam T - The generic type of service interface
+ */
+async function getService(ds) {
+    await ds.connect();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return ds.DataAccessObject;
+}
+exports.getService = getService;
+//# sourceMappingURL=legacy-juggler-bridge.js.map

package/dist/legacy-juggler-bridge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacy-juggler-bridge.js","sourceRoot":"","sources":["../src/legacy-juggler-bridge.ts"],"names":[],"mappings":";AAAA,sDAAsD;AACtD,uCAAuC;AACvC,+CAA+C;AAC/C,gEAAgE;;;;AAEhE,sGAAiD;AAEjD,IAAiB,OAAO,CAGvB;AAHD,WAAiB,OAAO;IACtB,6DAA6D;IAC/C,kBAAU,GAAG,qCAAM,CAAC,UAAU,CAAC;AAC/C,CAAC,EAHgB,OAAO,GAAP,eAAO,KAAP,eAAO,QAGvB;AAUD;;;;;;GAMG;AACI,KAAK,UAAU,UAAU,CAC9B,EAAqB;IAErB,MAAM,EAAE,CAAC,OAAO,EAAE,CAAC;IACnB,8DAA8D;IAC9D,OAAO,EAAE,CAAC,gBAAuB,CAAC;AACpC,CAAC;AAND,gCAMC"}

package/dist/mixins/index.d.ts

@@ -0,0 +1 @@
+export * from './service.mixin';

package/dist/mixins/index.js

@@ -0,0 +1,9 @@
+"use strict";
+// Copyright IBM Corp. 2018,2020. All Rights Reserved.
+// Node module: @loopback/service-proxy
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./service.mixin"), exports);
+//# sourceMappingURL=index.js.map

package/dist/mixins/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/mixins/index.ts"],"names":[],"mappings":";AAAA,sDAAsD;AACtD,uCAAuC;AACvC,+CAA+C;AAC/C,gEAAgE;;;AAEhE,0DAAgC"}

package/dist/mixins/service.mixin.d.ts

@@ -0,0 +1,245 @@
+import { Binding, BindingAddress, BindingFromClassOptions, Provider, Constructor } from '@loopback/core';
+import { Application, MixinTarget, ServiceOptions, Component } from '@loopback/core';
+import * as loopbackContext from '@loopback/core';
+/**
+ * Interface for classes with `new` operator.
+ */
+export interface Class<T> {
+    new (...args: any[]): T;
+}
+/**
+ * A mixin class for Application that creates a .serviceProvider()
+ * function to register a service automatically. Also overrides
+ * component function to allow it to register repositories automatically.
+ *
+ * @example
+ * ```ts
+ * class MyApplication extends ServiceMixin(Application) {}
+ * ```
+ *
+ * Please note: the members in the mixin function are documented in a dummy class
+ * called <a href="#ServiceMixinDoc">ServiceMixinDoc</a>
+ *
+ * @param superClass - Application class
+ * @returns A new class that extends the super class with service proxy related
+ * methods
+ *
+ * @typeParam T - Type of the application class as the target for the mixin
+ */
+export declare function ServiceMixin<T extends MixinTarget<Application>>(superClass: T): {
+    new (...args: any[]): {
+        /**
+         * Add a service to this application.
+         *
+         * @deprecated Use app.service() instead
+         *
+         * @param provider - The service provider to register.
+         *
+         * @example
+         * ```ts
+         * export interface GeocoderService {
+         *   geocode(address: string): Promise<GeoPoint[]>;
+         * }
+         *
+         * export class GeocoderServiceProvider implements Provider<GeocoderService> {
+         *   constructor(
+         *     @inject('services.geocoder')
+         *     protected dataSource: juggler.DataSource = new GeocoderDataSource(),
+         *   ) {}
+         *
+         *   value(): Promise<GeocoderService> {
+         *     return getService(this.dataSource);
+         *   }
+         * }
+         *
+         * app.serviceProvider(GeocoderServiceProvider);
+         * ```
+         */
+        serviceProvider<S>(provider: Constructor<Provider<S>>, nameOrOptions?: string | ServiceOptions | undefined): Binding<S>;
+        /**
+         * Add a component to this application. Also mounts
+         * all the components services.
+         *
+         * @param component - The component to add.
+         *
+         * @example
+         * ```ts
+         *
+         * export class ProductComponent {
+         *   controllers = [ProductController];
+         *   repositories = [ProductRepo, UserRepo];
+         *   providers = {
+         *     [AUTHENTICATION_STRATEGY]: AuthStrategy,
+         *     [AUTHORIZATION_ROLE]: Role,
+         *   };
+         * };
+         *
+         * app.component(ProductComponent);
+         * ```
+         */
+        component<C extends Component = Component>(componentCtor: Constructor<C>, nameOrOptions?: string | BindingFromClassOptions | undefined): Binding<C>;
+        /**
+         * Get an instance of a component and mount all it's
+         * services. This function is intended to be used internally
+         * by component()
+         *
+         * @param component - The component to mount services of
+         */
+        mountComponentServices<C_1 extends Component = Component>(component: Constructor<C_1>, componentBindingKey?: BindingAddress<C_1> | undefined): void;
+        readonly options: loopbackContext.ApplicationConfig;
+        readonly state: string;
+        controller: <T_1>(controllerCtor: loopbackContext.ControllerClass<T_1>, nameOrOptions?: string | BindingFromClassOptions | undefined) => Binding<T_1>;
+        server: <T_2 extends loopbackContext.Server>(ctor: Constructor<T_2>, nameOrOptions?: string | BindingFromClassOptions | undefined) => Binding<T_2>;
+        servers: <T_3 extends loopbackContext.Server>(ctors: Constructor<T_3>[]) => Binding<any>[];
+        getServer: <T_4 extends loopbackContext.Server>(target: string | Constructor<T_4>) => Promise<T_4>;
+        init: () => Promise<void>;
+        onInit: (fn: () => loopbackContext.ValueOrPromise<void>) => Binding<loopbackContext.LifeCycleObserver>;
+        start: () => Promise<void>;
+        onStart: (fn: () => loopbackContext.ValueOrPromise<void>) => Binding<loopbackContext.LifeCycleObserver>;
+        stop: () => Promise<void>;
+        onStop: (fn: () => loopbackContext.ValueOrPromise<void>) => Binding<loopbackContext.LifeCycleObserver>;
+        setMetadata: (metadata: loopbackContext.ApplicationMetadata) => void;
+        lifeCycleObserver: <T_5 extends loopbackContext.LifeCycleObserver>(ctor: Constructor<T_5>, nameOrOptions?: string | BindingFromClassOptions | undefined) => Binding<T_5>;
+        service: <S_1>(cls: loopbackContext.ServiceOrProviderClass<S_1>, nameOrOptions?: string | ServiceOptions | undefined) => Binding<S_1>;
+        interceptor: (interceptor: loopbackContext.Interceptor | Constructor<Provider<loopbackContext.Interceptor>>, nameOrOptions?: string | loopbackContext.InterceptorBindingOptions | undefined) => Binding<loopbackContext.Interceptor>;
+        readonly name: string;
+        readonly subscriptionManager: loopbackContext.ContextSubscriptionManager;
+        scope: loopbackContext.BindingScope;
+        readonly parent: loopbackContext.Context | undefined;
+        emitEvent: <T_6 extends loopbackContext.ContextEvent>(type: string, event: T_6) => void;
+        emitError: (err: unknown) => void;
+        bind: <ValueType = any>(key: BindingAddress<ValueType>) => Binding<ValueType>;
+        add: (binding: Binding<unknown>) => Application;
+        configure: <ConfigValueType = any>(key?: BindingAddress<unknown> | undefined) => Binding<ConfigValueType>;
+        getConfigAsValueOrPromise: <ConfigValueType_1>(key: BindingAddress<unknown>, propertyPath?: string | undefined, resolutionOptions?: loopbackContext.ResolutionOptions | undefined) => loopbackContext.ValueOrPromise<ConfigValueType_1 | undefined>;
+        getConfig: <ConfigValueType_2>(key: BindingAddress<unknown>, propertyPath?: string | undefined, resolutionOptions?: loopbackContext.ResolutionOptions | undefined) => Promise<ConfigValueType_2 | undefined>;
+        getConfigSync: <ConfigValueType_3>(key: BindingAddress<unknown>, propertyPath?: string | undefined, resolutionOptions?: loopbackContext.ResolutionOptions | undefined) => ConfigValueType_3 | undefined;
+        unbind: (key: BindingAddress<unknown>) => boolean;
+        subscribe: (observer: loopbackContext.ContextEventObserver) => loopbackContext.Subscription;
+        unsubscribe: (observer: loopbackContext.ContextEventObserver) => boolean;
+        close: () => void;
+        isSubscribed: (observer: loopbackContext.ContextObserver) => boolean;
+        createView: <T_7 = unknown>(filter: loopbackContext.BindingFilter, comparator?: loopbackContext.BindingComparator | undefined) => loopbackContext.ContextView<T_7>;
+        contains: (key: BindingAddress<unknown>) => boolean;
+        isBound: (key: BindingAddress<unknown>) => boolean;
+        getOwnerContext: (keyOrBinding: BindingAddress<unknown> | Readonly<Binding<unknown>>) => loopbackContext.Context | undefined;
+        getScopedContext: (scope: loopbackContext.BindingScope.APPLICATION | loopbackContext.BindingScope.SERVER | loopbackContext.BindingScope.REQUEST) => loopbackContext.Context | undefined;
+        getResolutionContext: (binding: Readonly<Binding<unknown>>) => loopbackContext.Context | undefined;
+        isVisibleTo: (ctx: loopbackContext.Context) => boolean;
+        find: <ValueType_1 = any>(pattern?: string | RegExp | loopbackContext.BindingFilter | undefined) => Readonly<Binding<ValueType_1>>[];
+        findByTag: <ValueType_2 = any>(tagFilter: RegExp | loopbackContext.BindingTag) => Readonly<Binding<ValueType_2>>[];
+        get: {
+            <ValueType_3>(keyWithPath: BindingAddress<ValueType_3>, session?: loopbackContext.ResolutionSession | undefined): Promise<ValueType_3>;
+            <ValueType_4>(keyWithPath: BindingAddress<ValueType_4>, options: loopbackContext.ResolutionOptions): Promise<ValueType_4 | undefined>;
+        };
+        getSync: {
+            <ValueType_5>(keyWithPath: BindingAddress<ValueType_5>, session?: loopbackContext.ResolutionSession | undefined): ValueType_5;
+            <ValueType_6>(keyWithPath: BindingAddress<ValueType_6>, options?: loopbackContext.ResolutionOptions | undefined): ValueType_6 | undefined;
+        };
+        getBinding: {
+            <ValueType_7 = any>(key: BindingAddress<ValueType_7>): Binding<ValueType_7>;
+            <ValueType_8>(key: BindingAddress<ValueType_8>, options?: {
+                optional?: boolean | undefined;
+            } | undefined): Binding<ValueType_8> | undefined;
+        };
+        findOrCreateBinding: <T_8>(key: BindingAddress<T_8>, policy?: loopbackContext.BindingCreationPolicy | undefined) => Binding<T_8>;
+        getValueOrPromise: <ValueType_9>(keyWithPath: BindingAddress<ValueType_9>, optionsOrSession?: loopbackContext.ResolutionOptionsOrSession | undefined) => loopbackContext.ValueOrPromise<ValueType_9 | undefined>;
+        toJSON: () => loopbackContext.JSONObject;
+        inspect: (options?: loopbackContext.ContextInspectOptions | undefined) => loopbackContext.JSONObject;
+        on: {
+            (eventName: "bind" | "unbind", listener: loopbackContext.ContextEventListener): Application;
+            (event: string | symbol, listener: (...args: any[]) => void): Application;
+        };
+        once: {
+            (eventName: "bind" | "unbind", listener: loopbackContext.ContextEventListener): Application;
+            (event: string | symbol, listener: (...args: any[]) => void): Application;
+        };
+        addListener: (event: string | symbol, listener: (...args: any[]) => void) => Application;
+        removeListener: (event: string | symbol, listener: (...args: any[]) => void) => Application;
+        off: (event: string | symbol, listener: (...args: any[]) => void) => Application;
+        removeAllListeners: (event?: string | symbol | undefined) => Application;
+        setMaxListeners: (n: number) => Application;
+        getMaxListeners: () => number;
+        listeners: (event: string | symbol) => Function[];
+        rawListeners: (event: string | symbol) => Function[];
+        emit: (event: string | symbol, ...args: any[]) => boolean;
+        listenerCount: (type: string | symbol) => number;
+        prependListener: (event: string | symbol, listener: (...args: any[]) => void) => Application;
+        prependOnceListener: (event: string | symbol, listener: (...args: any[]) => void) => Application;
+        eventNames: () => (string | symbol)[];
+    };
+} & T;
+/**
+ * Interface for an Application mixed in with ServiceMixin
+ */
+export interface ApplicationWithServices extends Application {
+    serviceProvider<S>(provider: Constructor<Provider<S>>, name?: string): Binding<S>;
+    component(component: Constructor<{}>, name?: string): Binding;
+    mountComponentServices(component: Constructor<{}>): void;
+}
+/**
+ * A dummy class created to generate the tsdoc for the members in service
+ * mixin. Please don't use it.
+ *
+ * The members are implemented in function
+ * <a href="#ServiceMixin">ServiceMixin</a>
+ */
+export declare class ServiceMixinDoc {
+    constructor(...args: any[]);
+    /**
+     * Add a service to this application.
+     *
+     * @param provider - The service provider to register.
+     *
+     * @example
+     * ```ts
+     * export interface GeocoderService {
+     *   geocode(address: string): Promise<GeoPoint[]>;
+     * }
+     *
+     * export class GeocoderServiceProvider implements Provider<GeocoderService> {
+     *   constructor(
+     *     @inject('datasources.geocoder')
+     *     protected dataSource: juggler.DataSource = new GeocoderDataSource(),
+     *   ) {}
+     *
+     *   value(): Promise<GeocoderService> {
+     *     return getService(this.dataSource);
+     *   }
+     * }
+     *
+     * app.serviceProvider(GeocoderServiceProvider);
+     * ```
+     */
+    serviceProvider<S>(provider: Constructor<Provider<S>>): Binding<S>;
+    /**
+     * Add a component to this application. Also mounts
+     * all the components services.
+     *
+     * @param component - The component to add.
+     *
+     * @example
+     * ```ts
+     *
+     * export class ProductComponent {
+     *   controllers = [ProductController];
+     *   repositories = [ProductRepo, UserRepo];
+     *   providers = {
+     *     [AUTHENTICATION_STRATEGY]: AuthStrategy,
+     *     [AUTHORIZATION_ROLE]: Role,
+     *   };
+     * };
+     *
+     * app.component(ProductComponent);
+     * ```
+     */
+    component(component: Constructor<unknown>): Binding;
+    /**
+     * Get an instance of a component and mount all it's
+     * services. This function is intended to be used internally
+     * by component()
+     *
+     * @param component - The component to mount services of
+     */
+    mountComponentServices(component: Constructor<unknown>): void;
+}

package/dist/mixins/service.mixin.js

@@ -0,0 +1,182 @@
+"use strict";
+// Copyright IBM Corp. 2018,2020. All Rights Reserved.
+// Node module: @loopback/service-proxy
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceMixinDoc = exports.ServiceMixin = void 0;
+/**
+ * A mixin class for Application that creates a .serviceProvider()
+ * function to register a service automatically. Also overrides
+ * component function to allow it to register repositories automatically.
+ *
+ * @example
+ * ```ts
+ * class MyApplication extends ServiceMixin(Application) {}
+ * ```
+ *
+ * Please note: the members in the mixin function are documented in a dummy class
+ * called <a href="#ServiceMixinDoc">ServiceMixinDoc</a>
+ *
+ * @param superClass - Application class
+ * @returns A new class that extends the super class with service proxy related
+ * methods
+ *
+ * @typeParam T - Type of the application class as the target for the mixin
+ */
+function ServiceMixin(superClass) {
+    return class extends superClass {
+        /**
+         * Add a service to this application.
+         *
+         * @deprecated Use app.service() instead
+         *
+         * @param provider - The service provider to register.
+         *
+         * @example
+         * ```ts
+         * export interface GeocoderService {
+         *   geocode(address: string): Promise<GeoPoint[]>;
+         * }
+         *
+         * export class GeocoderServiceProvider implements Provider<GeocoderService> {
+         *   constructor(
+         *     @inject('services.geocoder')
+         *     protected dataSource: juggler.DataSource = new GeocoderDataSource(),
+         *   ) {}
+         *
+         *   value(): Promise<GeocoderService> {
+         *     return getService(this.dataSource);
+         *   }
+         * }
+         *
+         * app.serviceProvider(GeocoderServiceProvider);
+         * ```
+         */
+        serviceProvider(provider, nameOrOptions) {
+            return this.service(provider, nameOrOptions);
+        }
+        /**
+         * Add a component to this application. Also mounts
+         * all the components services.
+         *
+         * @param component - The component to add.
+         *
+         * @example
+         * ```ts
+         *
+         * export class ProductComponent {
+         *   controllers = [ProductController];
+         *   repositories = [ProductRepo, UserRepo];
+         *   providers = {
+         *     [AUTHENTICATION_STRATEGY]: AuthStrategy,
+         *     [AUTHORIZATION_ROLE]: Role,
+         *   };
+         * };
+         *
+         * app.component(ProductComponent);
+         * ```
+         */
+        // Unfortunately, TypeScript does not allow overriding methods inherited
+        // from mapped types. https://github.com/microsoft/TypeScript/issues/38496
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        component(componentCtor, nameOrOptions) {
+            const binding = super.component(componentCtor, nameOrOptions);
+            this.mountComponentServices(componentCtor, binding.key);
+            return binding;
+        }
+        /**
+         * Get an instance of a component and mount all it's
+         * services. This function is intended to be used internally
+         * by component()
+         *
+         * @param component - The component to mount services of
+         */
+        mountComponentServices(component, componentBindingKey) {
+            const componentKey = componentBindingKey !== null && componentBindingKey !== void 0 ? componentBindingKey : `components.${component.name}`;
+            const compInstance = this.getSync(componentKey);
+            if (compInstance.serviceProviders) {
+                for (const provider of compInstance.serviceProviders) {
+                    this.serviceProvider(provider);
+                }
+            }
+        }
+    };
+}
+exports.ServiceMixin = ServiceMixin;
+/**
+ * A dummy class created to generate the tsdoc for the members in service
+ * mixin. Please don't use it.
+ *
+ * The members are implemented in function
+ * <a href="#ServiceMixin">ServiceMixin</a>
+ */
+class ServiceMixinDoc {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(...args) {
+        throw new Error('This is a dummy class created for apidoc! Please do not use it!');
+    }
+    /**
+     * Add a service to this application.
+     *
+     * @param provider - The service provider to register.
+     *
+     * @example
+     * ```ts
+     * export interface GeocoderService {
+     *   geocode(address: string): Promise<GeoPoint[]>;
+     * }
+     *
+     * export class GeocoderServiceProvider implements Provider<GeocoderService> {
+     *   constructor(
+     *     @inject('datasources.geocoder')
+     *     protected dataSource: juggler.DataSource = new GeocoderDataSource(),
+     *   ) {}
+     *
+     *   value(): Promise<GeocoderService> {
+     *     return getService(this.dataSource);
+     *   }
+     * }
+     *
+     * app.serviceProvider(GeocoderServiceProvider);
+     * ```
+     */
+    serviceProvider(provider) {
+        throw new Error();
+    }
+    /**
+     * Add a component to this application. Also mounts
+     * all the components services.
+     *
+     * @param component - The component to add.
+     *
+     * @example
+     * ```ts
+     *
+     * export class ProductComponent {
+     *   controllers = [ProductController];
+     *   repositories = [ProductRepo, UserRepo];
+     *   providers = {
+     *     [AUTHENTICATION_STRATEGY]: AuthStrategy,
+     *     [AUTHORIZATION_ROLE]: Role,
+     *   };
+     * };
+     *
+     * app.component(ProductComponent);
+     * ```
+     */
+    component(component) {
+        throw new Error();
+    }
+    /**
+     * Get an instance of a component and mount all it's
+     * services. This function is intended to be used internally
+     * by component()
+     *
+     * @param component - The component to mount services of
+     */
+    mountComponentServices(component) { }
+}
+exports.ServiceMixinDoc = ServiceMixinDoc;
+//# sourceMappingURL=service.mixin.js.map

package/dist/mixins/service.mixin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.mixin.js","sourceRoot":"","sources":["../../src/mixins/service.mixin.ts"],"names":[],"mappings":";AAAA,sDAAsD;AACtD,uCAAuC;AACvC,+CAA+C;AAC/C,gEAAgE;;;AA+BhE;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAgB,YAAY,CAC1B,UAAa;IAEb,OAAO,KAAM,SAAQ,UAAU;QAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;WA0BG;QACH,eAAe,CACb,QAAkC,EAClC,aAAuC;YAEvC,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;QAC/C,CAAC;QAED;;;;;;;;;;;;;;;;;;;;WAoBG;QACH,wEAAwE;QACxE,0EAA0E;QAC1E,6DAA6D;QAC7D,aAAa;QACb,SAAS,CACP,aAA6B,EAC7B,aAAgD;YAEhD,MAAM,OAAO,GAAG,KAAK,CAAC,SAAS,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;YAC9D,IAAI,CAAC,sBAAsB,CAAC,aAAa,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;YACxD,OAAO,OAAO,CAAC;QACjB,CAAC;QAED;;;;;;WAMG;QACH,sBAAsB,CACpB,SAAyB,EACzB,mBAAuC;YAEvC,MAAM,YAAY,GAChB,mBAAmB,aAAnB,mBAAmB,cAAnB,mBAAmB,GAAI,cAAc,SAAS,CAAC,IAAI,EAAE,CAAC;YACxD,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAY,YAAY,CAAC,CAAC;YAE3D,IAAI,YAAY,CAAC,gBAAgB,EAAE;gBACjC,KAAK,MAAM,QAAQ,IAAI,YAAY,CAAC,gBAAgB,EAAE;oBACpD,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;iBAChC;aACF;QACH,CAAC;KACF,CAAC;AACJ,CAAC;AA9FD,oCA8FC;AAcD;;;;;;GAMG;AACH,MAAa,eAAe;IAC1B,8DAA8D;IAC9D,YAAY,GAAG,IAAW;QACxB,MAAM,IAAI,KAAK,CACb,iEAAiE,CAClE,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,eAAe,CAAI,QAAkC;QACnD,MAAM,IAAI,KAAK,EAAE,CAAC;IACpB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACI,SAAS,CAAC,SAA+B;QAC9C,MAAM,IAAI,KAAK,EAAE,CAAC;IACpB,CAAC;IAED;;;;;;OAMG;IACH,sBAAsB,CAAC,SAA+B,IAAG,CAAC;CAC3D;AAtED,0CAsEC"}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@loopback/service-proxy",
+  "description": "A common set of interfaces for interacting with service oriented backends such as REST APIs, SOAP Web Services, and gRPC microservices",
+  "version": "3.2.3",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "author": "IBM Corp.",
+  "copyright.owner": "IBM Corp.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/loopbackio/loopback-next.git",
+    "directory": "packages/service-proxy"
+  },
+  "engines": {
+    "node": "^10.16 || 12 || 14 || 16"
+  },
+  "scripts": {
+    "acceptance": "lb-mocha \"dist/__tests__/acceptance/**/*.js\"",
+    "build": "lb-tsc",
+    "clean": "lb-clean loopback-service-proxy*.tgz dist *.tsbuildinfo package",
+    "integration": "lb-mocha \"dist/__tests__/integration/**/*.js\"",
+    "pretest": "npm run build",
+    "test": "lb-mocha \"dist/__tests__/**/*.js\"",
+    "unit": "lb-mocha \"dist/__tests__/unit/**/*.js\"",
+    "verify": "npm pack && tar xf loopback-service-proxy*.tgz && tree package && npm run clean"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "README.md",
+    "dist",
+    "src",
+    "!*/__tests__"
+  ],
+  "peerDependencies": {
+    "@loopback/core": "^2.17.0"
+  },
+  "dependencies": {
+    "loopback-datasource-juggler": "^4.26.0",
+    "tslib": "^2.3.1"
+  },
+  "devDependencies": {
+    "@loopback/build": "^7.0.1",
+    "@loopback/core": "^2.17.0",
+    "@loopback/eslint-config": "^11.0.1",
+    "@loopback/testlab": "^3.4.3",
+    "@types/node": "^10.17.60"
+  },
+  "gitHead": "1df36bb1ee2e513d9e197bd6010c4cfb296d50b8"
+}

package/src/decorators/service.decorator.ts

@@ -0,0 +1,72 @@
+// Copyright IBM Corp. 2018,2020. All Rights Reserved.
+// Node module: @loopback/service-proxy
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {
+  MetadataAccessor,
+  inject,
+  Context,
+  Injection,
+  InjectionMetadata,
+} from '@loopback/core';
+import {getService, juggler} from '..';
+
+/**
+ * Type definition for decorators returned by `@serviceProxy` decorator factory
+ */
+export type ServiceProxyDecorator = PropertyDecorator | ParameterDecorator;
+
+export const SERVICE_PROXY_KEY = MetadataAccessor.create<
+  string,
+  ServiceProxyDecorator
+>('service.proxy');
+
+/**
+ * Metadata for a service proxy
+ */
+export class ServiceProxyMetadata implements InjectionMetadata {
+  decorator = '@serviceProxy';
+  dataSourceName?: string;
+  dataSource?: juggler.DataSource;
+
+  constructor(dataSource: string | juggler.DataSource) {
+    if (typeof dataSource === 'string') {
+      this.dataSourceName = dataSource;
+    } else {
+      this.dataSource = dataSource;
+    }
+  }
+}
+
+export function serviceProxy(dataSource: string | juggler.DataSource) {
+  return function (target: object, key: string, parameterIndex?: number) {
+    if (key || typeof parameterIndex === 'number') {
+      const meta = new ServiceProxyMetadata(dataSource);
+      inject('', meta, resolve)(target, key, parameterIndex);
+    } else {
+      throw new Error(
+        '@serviceProxy can only be applied to properties or method parameters',
+      );
+    }
+  };
+}
+
+/**
+ * Resolve the @repository injection
+ * @param ctx - Context
+ * @param injection - Injection metadata
+ */
+async function resolve(ctx: Context, injection: Injection) {
+  const meta = injection.metadata as ServiceProxyMetadata;
+  if (meta.dataSource) return getService(meta.dataSource);
+  if (meta.dataSourceName) {
+    const ds = await ctx.get<juggler.DataSource>(
+      'datasources.' + meta.dataSourceName,
+    );
+    return getService(ds);
+  }
+  throw new Error(
+    '@serviceProxy must provide a name or an instance of DataSource',
+  );
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+// Copyright IBM Corp. 2018,2020. All Rights Reserved.
+// Node module: @loopback/service-proxy
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+/**
+ * A common set of interfaces for interacting with service oriented backends
+ * such as REST APIs, SOAP Web Services, and gRPC microservices.
+ *
+ * @packageDocumentation
+ */
+
+export * from './decorators/service.decorator';
+export * from './legacy-juggler-bridge';
+export * from './mixins';

package/src/legacy-juggler-bridge.ts

@@ -0,0 +1,34 @@
+// Copyright IBM Corp. 2018,2019. All Rights Reserved.
+// Node module: @loopback/service-proxy
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import legacy from 'loopback-datasource-juggler';
+
+export namespace juggler {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  export import DataSource = legacy.DataSource;
+}
+
+/**
+ * A generic service interface with any number of methods that return a promise
+ */
+export interface GenericService {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  [methodName: string]: (...args: any[]) => Promise<any>;
+}
+
+/**
+ * Get a service proxy from a LoopBack 3.x data source backed by
+ * service-oriented connectors such as `rest`, `soap`, and `grpc`.
+ *
+ * @param ds - A legacy data source
+ * @typeParam T - The generic type of service interface
+ */
+export async function getService<T = GenericService>(
+  ds: legacy.DataSource,
+): Promise<T> {
+  await ds.connect();
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return ds.DataAccessObject as any;
+}

package/src/mixins/index.ts

@@ -0,0 +1,6 @@
+// Copyright IBM Corp. 2018,2020. All Rights Reserved.
+// Node module: @loopback/service-proxy
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+export * from './service.mixin';

package/src/mixins/service.mixin.ts

@@ -0,0 +1,239 @@
+// Copyright IBM Corp. 2018,2020. All Rights Reserved.
+// Node module: @loopback/service-proxy
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {
+  Binding,
+  BindingAddress,
+  BindingFromClassOptions,
+  Provider,
+  Constructor,
+} from '@loopback/core';
+import {
+  Application,
+  MixinTarget,
+  ServiceOptions,
+  Component,
+} from '@loopback/core';
+
+// FIXME(rfeng): Workaround for https://github.com/microsoft/rushstack/pull/1867
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import * as loopbackContext from '@loopback/core';
+import * as loopbackCore from '@loopback/core';
+/* eslint-enable @typescript-eslint/no-unused-vars */
+
+/**
+ * Interface for classes with `new` operator.
+ */
+export interface Class<T> {
+  // new MyClass(...args) ==> T
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  new (...args: any[]): T;
+}
+
+/**
+ * A mixin class for Application that creates a .serviceProvider()
+ * function to register a service automatically. Also overrides
+ * component function to allow it to register repositories automatically.
+ *
+ * @example
+ * ```ts
+ * class MyApplication extends ServiceMixin(Application) {}
+ * ```
+ *
+ * Please note: the members in the mixin function are documented in a dummy class
+ * called <a href="#ServiceMixinDoc">ServiceMixinDoc</a>
+ *
+ * @param superClass - Application class
+ * @returns A new class that extends the super class with service proxy related
+ * methods
+ *
+ * @typeParam T - Type of the application class as the target for the mixin
+ */
+export function ServiceMixin<T extends MixinTarget<Application>>(
+  superClass: T,
+) {
+  return class extends superClass {
+    /**
+     * Add a service to this application.
+     *
+     * @deprecated Use app.service() instead
+     *
+     * @param provider - The service provider to register.
+     *
+     * @example
+     * ```ts
+     * export interface GeocoderService {
+     *   geocode(address: string): Promise<GeoPoint[]>;
+     * }
+     *
+     * export class GeocoderServiceProvider implements Provider<GeocoderService> {
+     *   constructor(
+     *     @inject('services.geocoder')
+     *     protected dataSource: juggler.DataSource = new GeocoderDataSource(),
+     *   ) {}
+     *
+     *   value(): Promise<GeocoderService> {
+     *     return getService(this.dataSource);
+     *   }
+     * }
+     *
+     * app.serviceProvider(GeocoderServiceProvider);
+     * ```
+     */
+    serviceProvider<S>(
+      provider: Constructor<Provider<S>>,
+      nameOrOptions?: string | ServiceOptions,
+    ): Binding<S> {
+      return this.service(provider, nameOrOptions);
+    }
+
+    /**
+     * Add a component to this application. Also mounts
+     * all the components services.
+     *
+     * @param component - The component to add.
+     *
+     * @example
+     * ```ts
+     *
+     * export class ProductComponent {
+     *   controllers = [ProductController];
+     *   repositories = [ProductRepo, UserRepo];
+     *   providers = {
+     *     [AUTHENTICATION_STRATEGY]: AuthStrategy,
+     *     [AUTHORIZATION_ROLE]: Role,
+     *   };
+     * };
+     *
+     * app.component(ProductComponent);
+     * ```
+     */
+    // Unfortunately, TypeScript does not allow overriding methods inherited
+    // from mapped types. https://github.com/microsoft/TypeScript/issues/38496
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    component<C extends Component = Component>(
+      componentCtor: Constructor<C>,
+      nameOrOptions?: string | BindingFromClassOptions,
+    ) {
+      const binding = super.component(componentCtor, nameOrOptions);
+      this.mountComponentServices(componentCtor, binding.key);
+      return binding;
+    }
+
+    /**
+     * Get an instance of a component and mount all it's
+     * services. This function is intended to be used internally
+     * by component()
+     *
+     * @param component - The component to mount services of
+     */
+    mountComponentServices<C extends Component = Component>(
+      component: Constructor<C>,
+      componentBindingKey?: BindingAddress<C>,
+    ) {
+      const componentKey =
+        componentBindingKey ?? `components.${component.name}`;
+      const compInstance = this.getSync<Component>(componentKey);
+
+      if (compInstance.serviceProviders) {
+        for (const provider of compInstance.serviceProviders) {
+          this.serviceProvider(provider);
+        }
+      }
+    }
+  };
+}
+
+/**
+ * Interface for an Application mixed in with ServiceMixin
+ */
+export interface ApplicationWithServices extends Application {
+  serviceProvider<S>(
+    provider: Constructor<Provider<S>>,
+    name?: string,
+  ): Binding<S>;
+  component(component: Constructor<{}>, name?: string): Binding;
+  mountComponentServices(component: Constructor<{}>): void;
+}
+
+/**
+ * A dummy class created to generate the tsdoc for the members in service
+ * mixin. Please don't use it.
+ *
+ * The members are implemented in function
+ * <a href="#ServiceMixin">ServiceMixin</a>
+ */
+export class ServiceMixinDoc {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor(...args: any[]) {
+    throw new Error(
+      'This is a dummy class created for apidoc! Please do not use it!',
+    );
+  }
+
+  /**
+   * Add a service to this application.
+   *
+   * @param provider - The service provider to register.
+   *
+   * @example
+   * ```ts
+   * export interface GeocoderService {
+   *   geocode(address: string): Promise<GeoPoint[]>;
+   * }
+   *
+   * export class GeocoderServiceProvider implements Provider<GeocoderService> {
+   *   constructor(
+   *     @inject('datasources.geocoder')
+   *     protected dataSource: juggler.DataSource = new GeocoderDataSource(),
+   *   ) {}
+   *
+   *   value(): Promise<GeocoderService> {
+   *     return getService(this.dataSource);
+   *   }
+   * }
+   *
+   * app.serviceProvider(GeocoderServiceProvider);
+   * ```
+   */
+  serviceProvider<S>(provider: Constructor<Provider<S>>): Binding<S> {
+    throw new Error();
+  }
+
+  /**
+   * Add a component to this application. Also mounts
+   * all the components services.
+   *
+   * @param component - The component to add.
+   *
+   * @example
+   * ```ts
+   *
+   * export class ProductComponent {
+   *   controllers = [ProductController];
+   *   repositories = [ProductRepo, UserRepo];
+   *   providers = {
+   *     [AUTHENTICATION_STRATEGY]: AuthStrategy,
+   *     [AUTHORIZATION_ROLE]: Role,
+   *   };
+   * };
+   *
+   * app.component(ProductComponent);
+   * ```
+   */
+  public component(component: Constructor<unknown>): Binding {
+    throw new Error();
+  }
+
+  /**
+   * Get an instance of a component and mount all it's
+   * services. This function is intended to be used internally
+   * by component()
+   *
+   * @param component - The component to mount services of
+   */
+  mountComponentServices(component: Constructor<unknown>) {}
+}