@sap-cloud-sdk/core/dist/connectivity/scp-cf/destination/destination-from-service.js

"use strict";
var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
var __rest = (this && this.__rest) || function (s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getDestinationFromDestinationService = void 0;
var util_1 = require("@sap-cloud-sdk/util");
var jwt_1 = require("../jwt");
var cache_1 = require("../cache");
var token_accessor_1 = require("../token-accessor");
var connectivity_service_1 = require("../connectivity-service");
var environment_accessor_1 = require("../environment-accessor");
var tenant_1 = require("../tenant");
var xsuaa_service_1 = require("../xsuaa-service");
var http_agent_1 = require("../../../http-agent");
var destination_selection_strategies_1 = require("./destination-selection-strategies");
var destination_service_1 = require("./destination-service");
var destination_cache_1 = require("./destination-cache");
var logger = util_1.createLogger({
    package: 'connectivity',
    messageContext: 'destination-accessor-service'
});
var emptyDestinationByType = {
    instance: [],
    subaccount: []
};
/**
 * Retrieves a destination with the given name from the Cloud Foundry destination service.
 * Returns `null`, if no destination can be found.
 * Requires the following service bindings: destination, XSUAA
 * By default, selects subscriber over provider and instance over subaccount destinations.
 *
 * If the destinations are read from the environment, the jwt will be ignored.
 * @param name - The name of the destination to be retrieved.
 * @param options - Configuration for how to retrieve destinations from the destination service.
 * @returns A promise returning the requested destination on success.
 */
function getDestinationFromDestinationService(name, options) {
    return __awaiter(this, void 0, void 0, function () {
        return __generator(this, function (_a) {
            logger.info('Attempting to retrieve destination from destination service.');
            return [2 /*return*/, DestinationFromServiceRetriever.getDestinationFromDestinationService(name, options)];
        });
    });
}
exports.getDestinationFromDestinationService = getDestinationFromDestinationService;
/**
 * @internal
 */
var DestinationFromServiceRetriever = /** @class */ (function () {
    function DestinationFromServiceRetriever(name, options, subscriberToken, providerServiceToken) {
        this.name = name;
        this.subscriberToken = subscriberToken;
        this.providerServiceToken = providerServiceToken;
        var defaultOptions = __assign({ isolationStrategy: cache_1.IsolationStrategy.Tenant_User, selectionStrategy: destination_selection_strategies_1.subscriberFirst, useCache: false }, options);
        this.options = __assign(__assign({}, defaultOptions), options);
    }
    DestinationFromServiceRetriever.getDestinationFromDestinationService = function (name, options) {
        return __awaiter(this, void 0, void 0, function () {
            var subscriberToken, xsuaaCredentials, providerToken, da, destinationResult, destination, withProxySetting;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, DestinationFromServiceRetriever.getSubscriberToken(options)];
                    case 1:
                        subscriberToken = _a.sent();
                        xsuaaCredentials = environment_accessor_1.getXsuaaServiceCredentials(options.userJwt);
                        return [4 /*yield*/, DestinationFromServiceRetriever.getProviderServiceToken(xsuaaCredentials, options)];
                    case 2:
                        providerToken = _a.sent();
                        da = new DestinationFromServiceRetriever(name, __assign(__assign({}, options), { xsuaaCredentials: xsuaaCredentials }), subscriberToken, providerToken);
                        return [4 /*yield*/, da.searchDestinationWithSelectionStrategyAndCache()];
                    case 3:
                        destinationResult = _a.sent();
                        if (!destinationResult) {
                            return [2 /*return*/, null];
                        }
                        if (destinationResult.fromCache) {
                            return [2 /*return*/, destinationResult.destination];
                        }
                        destination = destinationResult.destination;
                        if (!(destination.authentication === 'OAuth2UserTokenExchange' ||
                            destination.authentication === 'OAuth2JWTBearer' ||
                            (destination.authentication === 'OAuth2SAMLBearerAssertion' &&
                                !da.usesSystemUser(destination)))) return [3 /*break*/, 5];
                        return [4 /*yield*/, da.fetchDestinationWithUserExchangeFlows(destinationResult)];
                    case 4:
                        destination = _a.sent();
                        _a.label = 5;
                    case 5:
                        if (!(destination.authentication === 'OAuth2Password' ||
                            destination.authentication === 'ClientCertificateAuthentication' ||
                            destination.authentication === 'OAuth2ClientCredentials' ||
                            da.usesSystemUser(destination))) return [3 /*break*/, 7];
                        return [4 /*yield*/, da.fetchDestinationWithNonUserExchangeFlows(destinationResult)];
                    case 6:
                        destination = _a.sent();
                        _a.label = 7;
                    case 7: return [4 /*yield*/, da.addProxyConfiguration(destination)];
                    case 8:
                        withProxySetting = _a.sent();
                        da.updateDestinationCache(withProxySetting, destinationResult.origin);
                        return [2 /*return*/, withProxySetting];
                }
            });
        });
    };
    DestinationFromServiceRetriever.getSubscriberToken = function (options) {
        return __awaiter(this, void 0, void 0, function () {
            var encoded, payload, encoded, clientCertJwt;
            var _a, _b;
            return __generator(this, function (_c) {
                switch (_c.label) {
                    case 0:
                        if (!options.userJwt) return [3 /*break*/, 3];
                        if (options.iss) {
                            logger.warn('You have provided the `userJwt` and `iss` options to fetch the destination. This is most likely unintentional. Ignoring `iss`.');
                        }
                        return [4 /*yield*/, token_accessor_1.serviceToken('destination', __assign({}, options))];
                    case 1:
                        encoded = _c.sent();
                        _a = {};
                        _b = {};
                        return [4 /*yield*/, jwt_1.verifyJwt(options.userJwt, options)];
                    case 2: return [2 /*return*/, (_a.userJwt = (_b.decoded = _c.sent(),
                            _b.encoded = options.userJwt,
                            _b),
                            _a.serviceJwt = { encoded: encoded, decoded: jwt_1.decodeJwt(encoded) },
                            _a)];
                    case 3:
                        if (!options.iss) return [3 /*break*/, 5];
                        logger.info('Using `iss` option to fetch a destination instead of a full JWT. No validation is performed.');
                        payload = { iss: options.iss };
                        return [4 /*yield*/, token_accessor_1.serviceToken('destination', __assign(__assign({}, options), { userJwt: payload }))];
                    case 4:
                        encoded = _c.sent();
                        clientCertJwt = { encoded: encoded, decoded: jwt_1.decodeJwt(encoded) };
                        return [2 /*return*/, { serviceJwt: clientCertJwt }];
                    case 5: return [2 /*return*/];
                }
            });
        });
    };
    DestinationFromServiceRetriever.getProviderServiceToken = function (xsuaaCredentials, options) {
        return __awaiter(this, void 0, void 0, function () {
            var userJwt, optionsWithoutJwt, encoded;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        userJwt = options.userJwt, optionsWithoutJwt = __rest(options, ["userJwt"]);
                        return [4 /*yield*/, token_accessor_1.serviceToken('destination', __assign(__assign({}, optionsWithoutJwt), { xsuaaCredentials: xsuaaCredentials }))];
                    case 1:
                        encoded = _a.sent();
                        return [2 /*return*/, { encoded: encoded, decoded: jwt_1.decodeJwt(encoded) }];
                }
            });
        });
    };
    DestinationFromServiceRetriever.prototype.searchDestinationWithSelectionStrategyAndCache = function () {
        return __awaiter(this, void 0, void 0, function () {
            var destinationSearchResult;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        if (!this.isSubscriberNeeded()) return [3 /*break*/, 2];
                        return [4 /*yield*/, this.searchSubscriberAccountForDestination()];
                    case 1:
                        destinationSearchResult =
                            _a.sent();
                        _a.label = 2;
                    case 2:
                        if (!this.isProviderNeeded(destinationSearchResult)) return [3 /*break*/, 4];
                        return [4 /*yield*/, this.searchProviderAccountForDestination()];
                    case 3:
                        destinationSearchResult =
                            _a.sent();
                        _a.label = 4;
                    case 4:
                        if (destinationSearchResult && !destinationSearchResult.fromCache) {
                            logger.debug('Successfully retrieved destination from destination service.');
                        }
                        if (destinationSearchResult && destinationSearchResult.fromCache) {
                            logger.debug("Successfully retrieved destination from destination service cache for " + destinationSearchResult.origin + " destinations.");
                        }
                        if (!destinationSearchResult) {
                            logger.info('Could not retrieve destination from destination service.');
                        }
                        return [2 /*return*/, destinationSearchResult];
                }
            });
        });
    };
    DestinationFromServiceRetriever.prototype.getInstanceAndSubaccountDestinations = function (accessToken) {
        return __awaiter(this, void 0, void 0, function () {
            var _a, instance, subaccount;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0: return [4 /*yield*/, Promise.all([
                            destination_service_1.fetchInstanceDestinations(this.destinationServiceCredentials.uri, accessToken, this.options),
                            destination_service_1.fetchSubaccountDestinations(this.destinationServiceCredentials.uri, accessToken, this.options)
                        ])];
                    case 1:
                        _a = _b.sent(), instance = _a[0], subaccount = _a[1];
                        return [2 /*return*/, {
                                instance: instance,
                                subaccount: subaccount
                            }];
                }
            });
        });
    };
    Object.defineProperty(DestinationFromServiceRetriever.prototype, "destinationServiceCredentials", {
        get: function () {
            var credentials = environment_accessor_1.getDestinationServiceCredentialsList();
            if (!credentials || credentials.length === 0) {
                throw Error('No binding to a destination service instance found. Please bind a destination service instance to your application.');
            }
            if (credentials.length > 1) {
                logger.info('Found more than one destination service instance. Using the first one.');
            }
            return credentials[0];
        },
        enumerable: false,
        configurable: true
    });
    DestinationFromServiceRetriever.prototype.fetchDestinationByToken = function (jwt) {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                return [2 /*return*/, destination_service_1.fetchDestination(this.destinationServiceCredentials.uri, jwt, this.name, this.options)];
            });
        });
    };
    DestinationFromServiceRetriever.prototype.getExchangeTenant = function (destination) {
        var _a, _b, _c;
        if (destination.authentication !== 'OAuth2ClientCredentials') {
            return undefined;
        }
        if (destination.originalProperties['tokenServiceURLType'] !== 'Common') {
            return undefined;
        }
        var subdomainSubscriber = xsuaa_service_1.getSubdomainAndZoneId((_b = (_a = this.subscriberToken) === null || _a === void 0 ? void 0 : _a.userJwt) === null || _b === void 0 ? void 0 : _b.encoded).subdomain;
        var subdomainProvider = xsuaa_service_1.getSubdomainAndZoneId((_c = this.providerServiceToken) === null || _c === void 0 ? void 0 : _c.encoded).subdomain;
        return subdomainSubscriber || subdomainProvider || undefined;
    };
    DestinationFromServiceRetriever.prototype.getAuthTokenForOAuth2ClientCrendentials = function (destinationResult) {
        return __awaiter(this, void 0, void 0, function () {
            var destination, origin, exchangeTenant, clientGrant;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        destination = destinationResult.destination, origin = destinationResult.origin;
                        exchangeTenant = this.getExchangeTenant(destination);
                        return [4 /*yield*/, token_accessor_1.serviceToken('destination', {
                                userJwt: origin === 'subscriber'
                                    ? this.subscriberToken.serviceJwt.decoded
                                    : this.providerServiceToken.decoded
                            })];
                    case 1:
                        clientGrant = _a.sent();
                        return [2 /*return*/, { authHeaderJwt: clientGrant, exchangeTenant: exchangeTenant }];
                }
            });
        });
    };
    // This covers the two technical user propagation https://help.sap.com/viewer/cca91383641e40ffbe03bdc78f00f681/Cloud/en-US/3cb7b81115c44cf594e0e3631291af94.html
    DestinationFromServiceRetriever.prototype.usesSystemUser = function (destination) {
        // put this in the non user dependent block
        if (destination.systemUser &&
            destination.authentication === 'OAuth2SAMLBearerAssertion') {
            logger.debug("System user found on destination: \"" + destination.name + "\". \nThe property SystemUser has been deprecated. \nIt is highly recommended that you stop using it.\nPossible alternatives for such technical user authentication are BasicAuthentication, OAuth2ClientCredentials, or ClientCertificateAuthentication");
            return true;
        }
        return false;
    };
    DestinationFromServiceRetriever.prototype.getAuthTokenForOAuth2UserBasedTokenExchanges = function (destinationResult) {
        return __awaiter(this, void 0, void 0, function () {
            var destination, origin, serviceJwt;
            var _a;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        destination = destinationResult.destination, origin = destinationResult.origin;
                        if (!this.subscriberToken || !jwt_1.isUserToken(this.subscriberToken.userJwt)) {
                            throw Error("No user token (JWT) has been provided. This is strictly necessary for '" + destination.authentication + "'.");
                        }
                        if (!this.isProviderAndSubscriberSameTenant()) return [3 /*break*/, 2];
                        logger.debug("UserExchange flow started without user exchange token for destination " + this.name + " of the provider account.");
                        _a = {};
                        return [4 /*yield*/, token_accessor_1.jwtBearerToken(this.subscriberToken.userJwt.encoded, environment_accessor_1.getDestinationService(), this.options)];
                    case 1: return [2 /*return*/, (_a.authHeaderJwt = _b.sent(),
                            _a)];
                    case 2:
                        serviceJwt = origin === 'subscriber'
                            ? this.subscriberToken.serviceJwt
                            : this.providerServiceToken;
                        logger.debug("UserExchange flow started for destination " + this.name + " of the " + origin + " account.");
                        return [2 /*return*/, {
                                authHeaderJwt: serviceJwt.encoded,
                                exchangeHeaderJwt: this.subscriberToken.userJwt.encoded // token considered for user and tenant
                            }];
                }
            });
        });
    };
    /**
     * @internal
     * This method calls the 'find destination by name' endpoint of the destination service using a client credentials grant.
     * For the find by name endpoint, the destination service will take care of OAuth flows and include the token in the destination.
     * @param destinationResult - Result of the getDestinations call for which the exchange flow is triggred
     * @returns Destination containing the auth token.
     */
    DestinationFromServiceRetriever.prototype.fetchDestinationWithNonUserExchangeFlows = function (destinationResult) {
        return __awaiter(this, void 0, void 0, function () {
            var token;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.getAuthTokenForOAuth2ClientCrendentials(destinationResult)];
                    case 1:
                        token = _a.sent();
                        return [2 /*return*/, this.fetchDestinationByToken(token)];
                }
            });
        });
    };
    DestinationFromServiceRetriever.prototype.fetchDestinationWithUserExchangeFlows = function (destinationResult) {
        return __awaiter(this, void 0, void 0, function () {
            var token;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.getAuthTokenForOAuth2UserBasedTokenExchanges(destinationResult)];
                    case 1:
                        token = _a.sent();
                        return [2 /*return*/, this.fetchDestinationByToken(token)];
                }
            });
        });
    };
    DestinationFromServiceRetriever.prototype.addProxyConfiguration = function (destination) {
        var _a;
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_b) {
                switch (http_agent_1.proxyStrategy(destination)) {
                    case http_agent_1.ProxyStrategy.ON_PREMISE_PROXY:
                        return [2 /*return*/, connectivity_service_1.addProxyConfigurationOnPrem(destination, (_a = this.subscriberToken) === null || _a === void 0 ? void 0 : _a.userJwt)];
                    case http_agent_1.ProxyStrategy.INTERNET_PROXY:
                    case http_agent_1.ProxyStrategy.PRIVATELINK_PROXY:
                        return [2 /*return*/, http_agent_1.addProxyConfigurationInternet(destination)];
                    case http_agent_1.ProxyStrategy.NO_PROXY:
                        return [2 /*return*/, destination];
                    default:
                        throw new Error('Illegal argument: No valid proxy configuration found in the destination input to be aded.');
                }
                return [2 /*return*/];
            });
        });
    };
    // For iss token the userJwt may be undefined.
    DestinationFromServiceRetriever.prototype.selectSubscriberJwt = function () {
        var _a;
        if (!this.subscriberToken) {
            throw new Error('Try to get subscriber token but value is undefined.');
        }
        return (((_a = this.subscriberToken.userJwt) === null || _a === void 0 ? void 0 : _a.decoded) ||
            this.subscriberToken.serviceJwt.decoded);
    };
    DestinationFromServiceRetriever.prototype.updateDestinationCache = function (destination, destinationOrigin) {
        if (!this.options.useCache) {
            return destination;
        }
        destination_cache_1.destinationCache.cacheRetrievedDestination(destinationOrigin === 'subscriber'
            ? this.selectSubscriberJwt()
            : this.providerServiceToken.decoded, destination, this.options.isolationStrategy);
    };
    DestinationFromServiceRetriever.prototype.getProviderDestinationService = function () {
        return __awaiter(this, void 0, void 0, function () {
            var provider, destination;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.getInstanceAndSubaccountDestinations(this.providerServiceToken.encoded)];
                    case 1:
                        provider = _a.sent();
                        destination = this.options.selectionStrategy({
                            subscriber: emptyDestinationByType,
                            provider: provider
                        }, this.name);
                        if (destination) {
                            return [2 /*return*/, {
                                    destination: destination,
                                    fromCache: false,
                                    origin: 'provider'
                                }];
                        }
                        return [2 /*return*/];
                }
            });
        });
    };
    DestinationFromServiceRetriever.prototype.getProviderDestinationCache = function () {
        var destination = destination_cache_1.destinationCache.retrieveDestinationFromCache(this.providerServiceToken.decoded, this.name, this.options.isolationStrategy);
        if (destination) {
            return { destination: destination, fromCache: true, origin: 'subscriber' };
        }
    };
    DestinationFromServiceRetriever.prototype.getSubscriberDestinationService = function () {
        return __awaiter(this, void 0, void 0, function () {
            var subscriber, destination;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        if (!this.subscriberToken) {
                            throw new Error('Try to get destinations from subscriber account but user JWT was not set.');
                        }
                        return [4 /*yield*/, this.getInstanceAndSubaccountDestinations(this.subscriberToken.serviceJwt.encoded)];
                    case 1:
                        subscriber = _a.sent();
                        destination = this.options.selectionStrategy({
                            subscriber: subscriber,
                            provider: emptyDestinationByType
                        }, this.name);
                        if (destination) {
                            return [2 /*return*/, { destination: destination, fromCache: false, origin: 'subscriber' }];
                        }
                        return [2 /*return*/];
                }
            });
        });
    };
    DestinationFromServiceRetriever.prototype.getSubscriberDestinationCache = function () {
        var destination = destination_cache_1.destinationCache.retrieveDestinationFromCache(this.selectSubscriberJwt(), this.name, this.options.isolationStrategy);
        if (destination) {
            return { destination: destination, fromCache: true, origin: 'subscriber' };
        }
    };
    DestinationFromServiceRetriever.prototype.isProviderAndSubscriberSameTenant = function () {
        return (this.subscriberToken &&
            tenant_1.isIdenticalTenant(this.subscriberToken.serviceJwt.decoded, this.providerServiceToken.decoded));
    };
    DestinationFromServiceRetriever.prototype.isProviderNeeded = function (resultFromSubscriber) {
        if (this.options.selectionStrategy === destination_selection_strategies_1.alwaysSubscriber) {
            return false;
        }
        if (this.options.selectionStrategy === destination_selection_strategies_1.subscriberFirst &&
            resultFromSubscriber) {
            return false;
        }
        return true;
    };
    DestinationFromServiceRetriever.prototype.isSubscriberNeeded = function () {
        if (!this.subscriberToken) {
            return false;
        }
        if (this.options.selectionStrategy === destination_selection_strategies_1.alwaysProvider) {
            return false;
        }
        return true;
    };
    DestinationFromServiceRetriever.prototype.searchProviderAccountForDestination = function () {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                return [2 /*return*/, ((this.options.useCache && this.getProviderDestinationCache()) ||
                        this.getProviderDestinationService())];
            });
        });
    };
    DestinationFromServiceRetriever.prototype.searchSubscriberAccountForDestination = function () {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                return [2 /*return*/, ((this.options.useCache && this.getSubscriberDestinationCache()) ||
                        this.getSubscriberDestinationService())];
            });
        });
    };
    return DestinationFromServiceRetriever;
}());
//# sourceMappingURL=destination-from-service.js.map