@vtex/api 6.48.0 → 6.48.1-beta

package/lib/IODataSource.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const apollo_datasource_1 = require("apollo-datasource");
+const HttpClient_1 = require("./HttpClient");
+/**
+ * @deprecated Extend one of the subclasses of IOClient instead.
+ */
+class IODataSource extends apollo_datasource_1.DataSource {
+    constructor(context, options = {}) {
+        super();
+        this.context = context;
+        this.options = options;
+        this.service = undefined;
+        this.httpClient = undefined;
+        this.initialized = false;
+    }
+    initialize(config) {
+        const { context: { vtex: context }, cache: cacheStorage } = config;
+        this.context = context;
+        this.httpClient = this.httpClientFactory({
+            context,
+            options: Object.assign({ cacheStorage }, this.options),
+            service: this.service,
+        });
+        this.initialized = true;
+    }
+    get http() {
+        if (!this.initialized) {
+            this.initialize({ context: { vtex: this.context } });
+        }
+        if (this.httpClient) {
+            return this.httpClient;
+        }
+        throw new Error('IO Datasource was not initialized nor constructed with a context');
+    }
+}
+exports.IODataSource = IODataSource;
+exports.forWorkspace = ({ context, service, options }) => (context && service)
+    ? HttpClient_1.HttpClient.forWorkspace(service, context, options || {})
+    : undefined;
+exports.forRoot = ({ context, service, options }) => (context && service)
+    ? HttpClient_1.HttpClient.forRoot(service, context, options || {})
+    : undefined;
+exports.forExternal = ({ context, service, options }) => (context && service)
+    ? HttpClient_1.HttpClient.forExternal(service, context, options || {})
+    : undefined;

package/lib/caches/LRUCache.js

@@ -37,11 +37,7 @@ class LRUCache {
         this.hits = 0;
         this.total = 0;
         this.disposed = 0;
-        this.storage = new lru_cache_1.default({
-            ...options,
-            dispose: () => this.disposed += 1,
-            noDisposeOnSet: true,
-        });
+        this.storage = new lru_cache_1.default(Object.assign({}, options, { dispose: () => this.disposed += 1, noDisposeOnSet: true }));
         this.multilayer = new MultilayeredCache_1.MultilayeredCache([this]);
     }
 }

package/lib/caches/LRUDiskCache.js

@@ -121,11 +121,7 @@ class LRUDiskCache {
             this.keyToBeDeleted = key;
             this.disposed += 1;
         };
-        const lruOptions = {
-            ...options,
-            dispose,
-            noDisposeOnSet: true,
-        };
+        const lruOptions = Object.assign({}, options, { dispose, noDisposeOnSet: true });
         this.lruStorage = new lru_cache_1.default(lruOptions);
     }
 }

package/lib/clients/Apps.d.ts

@@ -0,0 +1,84 @@
+/// <reference types="node" />
+import { IncomingMessage } from 'http';
+import { Readable, Writable } from 'stream';
+import { ZlibOptions } from 'zlib';
+import { InfraClient, InstanceOptions } from '../HttpClient';
+import { AppBundleLinked, AppFilesList, AppManifest } from '../responses';
+import { IOContext } from '../service/typings';
+export declare class Apps extends InfraClient {
+    private _routes;
+    private diskCache;
+    private memoryCache;
+    private readonly routes;
+    constructor(context: IOContext, options?: InstanceOptions);
+    installApp: (descriptor: string) => Promise<void>;
+    uninstallApp: (app: string) => Promise<import("..").IOResponse<void>>;
+    acknowledgeApp: (app: string, service: string) => Promise<void>;
+    link: (app: string, files: Change[], { zlib }?: ZipOptions) => Promise<AppBundleLinked>;
+    patch: (app: string, changes: Change[], { zlib }?: ZipOptions) => Promise<void>;
+    unlink: (app: string) => Promise<import("..").IOResponse<void>>;
+    unlinkAll: () => Promise<import("..").IOResponse<void>>;
+    saveAppSettings: (app: string, settings: any) => Promise<void>;
+    listApps: ({ oldVersion, since, service }?: ListAppsOptions) => Promise<AppsList>;
+    listAppFiles: (app: string, { prefix, nextMarker }?: ListFilesOptions) => Promise<AppFilesList>;
+    listLinks: () => Promise<string[]>;
+    getAppFile: (app: string, path: string, staleIfError?: boolean | undefined) => Promise<{
+        data: Buffer;
+        headers: any;
+    }>;
+    getAppJSON: <T extends object | null>(app: string, path: string, nullIfNotFound?: boolean | undefined) => Promise<T>;
+    getLinkedAppByWorkspaceJSON: <T extends object | null>(app: string, path: string, nullIfNotFound?: boolean | undefined) => Promise<T>;
+    getAppFileStream: (app: string, path: string) => Promise<IncomingMessage>;
+    getApp: (app: string) => Promise<AppManifest>;
+    getAppSettings: (app: string) => Promise<any>;
+    getAllAppsSettings: (listAppsOptions?: ListAppsOptions) => Promise<AppsSettings>;
+    getAppBundle: (app: string, bundlePath: string, generatePackageJson: boolean) => Promise<Readable>;
+    unpackAppBundle: (app: string, bundlePath: string, unpackPath: string, generatePackageJson: boolean) => Promise<Writable>;
+    getAppsMetaInfos: (filter?: string | undefined, staleWhileRevalidate?: boolean) => Promise<AppMetaInfo[]>;
+    getDependencies: (filter?: string) => Promise<Record<string, string[]>>;
+    updateDependencies: () => Promise<Record<string, string[]>>;
+    updateDependency: (name: string, version: string, registry: string) => Promise<void>;
+    resolveDependencies: (apps: string[], registries: string[], filter?: string) => Promise<any>;
+    resolveDependenciesWithManifest: (manifest: AppManifest, filter?: string) => Promise<Record<string, string[]>>;
+    private installRuntime;
+}
+interface ZipOptions {
+    zlib?: ZlibOptions;
+}
+export interface AppMetaInfo {
+    id: string;
+    settingsSchema?: Record<string, any>;
+    _resolvedDependencies: Record<string, string>;
+    _isRoot: boolean;
+    _buildFeatures: Record<string, string[]>;
+}
+export interface WorkspaceMetaInfo {
+    apps: AppMetaInfo[];
+}
+export interface AppsListItem {
+    app: string;
+    id: string;
+    location: string;
+}
+export interface AppsList {
+    data: AppsListItem[];
+}
+export interface Change {
+    path: string;
+    content: string | Readable | Buffer;
+}
+export interface ListAppsOptions {
+    oldVersion?: string;
+    context?: string[];
+    since?: string;
+    service?: string;
+}
+export interface ListFilesOptions {
+    prefix?: string;
+    context?: string[];
+    nextMarker?: string;
+}
+export interface AppsSettings {
+    [app: string]: any;
+}
+export {};

package/lib/clients/Apps.js

@@ -0,0 +1,326 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const archiver_1 = __importDefault(require("archiver"));
+const ramda_1 = require("ramda");
+const tar_fs_1 = require("tar-fs");
+const zlib_1 = require("zlib");
+const HttpClient_1 = require("../HttpClient");
+const utils_1 = require("../utils");
+const appsStaleIfError_1 = require("../utils/appsStaleIfError");
+const createRoutes = ({ account, workspace }) => {
+    const routes = {
+        Acknowledge: (app, service) => `${routes.App(app)}/acknowledge/${service}`,
+        App: (app) => `${routes.Apps()}/${app}`,
+        AppBundle: (locator, path) => `${routes.AppOrRegistry(locator)}/bundle/${path}`,
+        AppOrRegistry: ({ name, version, build }) => build
+            ? `${routes.Apps()}/${name}@${version}+${build}`
+            : `${routes.Registry()}/${name}/${version}`,
+        Apps: () => `${routes.Workspace}/apps`,
+        Dependencies: () => `${routes.Workspace}/dependencies`,
+        File: (locator, path) => `${routes.Files(locator)}/${path}`,
+        Files: (locator) => `${routes.AppOrRegistry(locator)}/files`,
+        Link: (app) => `${routes.Workspace}/v2/links/${app}`,
+        LinkedAppFile: (app, path) => `${routes.Workspace}/apps/${app}/files/${path}`,
+        Links: () => `${routes.Workspace}/links`,
+        Master: `/${account}/master`,
+        Meta: () => `${routes.Workspace}/v2/apps`,
+        Registry: () => `${routes.Master}/registry`,
+        ResolveDependencies: () => `${routes.Workspace}/dependencies/_resolve`,
+        ResolveDependenciesWithManifest: () => `${routes.Workspace}/v2/apps/_resolve`,
+        Settings: (app) => `${routes.App(app)}/settings`,
+        Unlink: (app) => `${routes.Links()}/${app}`,
+        Workspace: `/${account}/${workspace}`,
+    };
+    return routes;
+};
+const getVendorAndName = ({ id }) => utils_1.removeVersionFromAppId(id);
+const notFound = (e) => {
+    if (e.response && e.response.status === 404) {
+        return {};
+    }
+    throw e;
+};
+const zipObj = (keys, values) => {
+    let idx = 0;
+    const len = Math.min(keys.length, values.length);
+    const out = {};
+    while (idx < len) {
+        out[keys[idx]] = values[idx];
+        idx += 1;
+    }
+    return out;
+};
+const workspaceFields = [
+    '_resolvedDependencies',
+    'settingsSchema',
+    '_isRoot',
+    '_buildFeatures',
+].join(',');
+class Apps extends HttpClient_1.InfraClient {
+    constructor(context, options) {
+        super('apps@0.x', context, options, true);
+        this.installApp = (descriptor) => {
+            if (descriptor.startsWith('infra:service-')) {
+                return this.installRuntime(descriptor);
+            }
+            return this.http.post(this.routes.Apps(), { id: descriptor }, { metric: 'apps-install' });
+        };
+        this.uninstallApp = (app) => {
+            return this.http.delete(this.routes.App(app), { metric: 'apps-uninstall' });
+        };
+        this.acknowledgeApp = (app, service) => {
+            return this.http.put(this.routes.Acknowledge(app, service), null, { metric: 'apps-ack' });
+        };
+        this.link = async (app, files, { zlib } = {}) => {
+            if (!(files[0] && files[0].path)) {
+                throw new Error('Argument files must be an array of {path, content}, where content can be a String, a Buffer or a ReadableStream.');
+            }
+            const emptyChanges = files.filter(file => !file.content);
+            if (emptyChanges.length > 0) {
+                throw new Error(`Missing content for paths: ${emptyChanges.map(e => e.path).join('; ')}`);
+            }
+            const indexOfManifest = files.findIndex(({ path }) => path === 'manifest.json');
+            if (indexOfManifest === -1) {
+                throw new Error('No manifest.json file found in files.');
+            }
+            const zip = archiver_1.default('zip', { zlib });
+            // Throw stream errors so they reject the promise chain.
+            zip.on('error', (e) => {
+                throw e;
+            });
+            const request = this.http.put(this.routes.Link(app), zip, {
+                headers: { 'Content-Type': 'application/zip' },
+                metric: 'apps-link',
+            });
+            files.forEach(({ content, path }) => zip.append(content, { name: path }));
+            const finalize = zip.finalize();
+            try {
+                const [response] = await Promise.all([request, finalize]);
+                response.bundleSize = zip.pointer();
+                return response;
+            }
+            catch (e) {
+                e.bundleSize = zip.pointer();
+                throw e;
+            }
+        };
+        this.patch = async (app, changes, { zlib } = {}) => {
+            if (!(changes[0] && changes[0].path)) {
+                throw new Error('Argument changes must be an array of {path, content}, where content can be a String, a Buffer or a ReadableStream.');
+            }
+            const files = changes.filter(change => !!change.content);
+            const deletedFiles = changes
+                .filter(change => !change.content)
+                .map(change => change.path)
+                .join(':');
+            const zip = archiver_1.default('zip', { zlib });
+            // Throw stream errors so they reject the promise chain.
+            zip.on('error', (e) => {
+                throw e;
+            });
+            const request = this.http.patch(this.routes.Link(app), zip, {
+                headers: { 'Content-Type': 'application/zip' },
+                metric: 'apps-patch',
+                params: { deletedFiles },
+            });
+            files.forEach(({ content, path }) => zip.append(content, { name: path }));
+            const finalize = zip.finalize();
+            const [response] = await Promise.all([request, finalize]);
+            return response;
+        };
+        this.unlink = (app) => {
+            return this.http.delete(this.routes.Unlink(app));
+        };
+        this.unlinkAll = () => {
+            return this.http.delete(this.routes.Links());
+        };
+        this.saveAppSettings = (app, settings) => {
+            const headers = { 'Content-Type': 'application/json' };
+            const metric = 'apps-save';
+            return this.http.put(this.routes.Settings(app), settings, { headers, metric });
+        };
+        this.listApps = ({ oldVersion, since, service } = {}) => {
+            const params = {
+                oldVersion,
+                service,
+                since,
+            };
+            const metric = 'apps-list';
+            const inflightKey = HttpClient_1.inflightUrlWithQuery;
+            return this.http.get(this.routes.Apps(), { params, metric, inflightKey });
+        };
+        this.listAppFiles = (app, { prefix, nextMarker } = {}) => {
+            const locator = utils_1.parseAppId(app);
+            const linked = !!locator.build;
+            const params = {
+                marker: nextMarker,
+                prefix,
+            };
+            const metric = linked ? 'apps-list-files' : 'registry-list-files';
+            const inflightKey = HttpClient_1.inflightUrlWithQuery;
+            return this.http.get(this.routes.Files(locator), { params, metric, inflightKey });
+        };
+        this.listLinks = () => {
+            const inflightKey = HttpClient_1.inflightURL;
+            return this.http.get(this.routes.Links(), { metric: 'apps-list-links', inflightKey });
+        };
+        this.getAppFile = (app, path, staleIfError) => {
+            const { logger } = this.context;
+            const locator = utils_1.parseAppId(app);
+            const linked = !!locator.build;
+            const inflightKey = HttpClient_1.inflightURL;
+            if (staleIfError && this.memoryCache) {
+                appsStaleIfError_1.saveVersion(app, this.memoryCache);
+            }
+            try {
+                return this.http.getBuffer(this.routes.File(locator, path), {
+                    cacheable: linked ? HttpClient_1.CacheType.Memory : HttpClient_1.CacheType.Disk,
+                    inflightKey,
+                    metric: linked ? 'apps-get-file' : 'registry-get-file',
+                });
+            }
+            catch (error) {
+                logger.error({ error, message: 'getAppFile failed', app, path });
+                if (staleIfError && this.memoryCache) {
+                    return appsStaleIfError_1.getFallbackFile(app, path, this.memoryCache, this);
+                }
+                throw error;
+            }
+        };
+        this.getAppJSON = (app, path, nullIfNotFound) => {
+            const locator = utils_1.parseAppId(app);
+            const linked = !!locator.build;
+            const inflightKey = HttpClient_1.inflightURL;
+            return this.http.get(this.routes.File(locator, path), {
+                cacheable: linked ? HttpClient_1.CacheType.Memory : HttpClient_1.CacheType.Any,
+                inflightKey,
+                metric: linked ? 'apps-get-json' : 'registry-get-json',
+                nullIfNotFound,
+            });
+        };
+        this.getLinkedAppByWorkspaceJSON = (app, path, nullIfNotFound) => {
+            const inflightKey = HttpClient_1.inflightURL;
+            return this.http.get(this.routes.LinkedAppFile(app, path), {
+                cacheable: HttpClient_1.CacheType.Memory,
+                inflightKey,
+                metric: 'apps-linked-app-get-json',
+                nullIfNotFound,
+            });
+        };
+        this.getAppFileStream = (app, path) => {
+            const locator = utils_1.parseAppId(app);
+            const metric = locator.build ? 'apps-get-file-s' : 'registry-get-file-s';
+            return this.http.getStream(this.routes.File(locator, path), { metric });
+        };
+        this.getApp = (app) => {
+            const metric = 'apps-get-app';
+            const inflightKey = HttpClient_1.inflightURL;
+            return this.http.get(this.routes.App(app), { metric, inflightKey });
+        };
+        this.getAppSettings = (app) => {
+            const inflightKey = HttpClient_1.inflightURL;
+            const metric = 'apps-get-settings';
+            return this.http.get(this.routes.Settings(app), { inflightKey, metric });
+        };
+        this.getAllAppsSettings = (listAppsOptions = {}) => {
+            return this.listApps(listAppsOptions).then(({ data: installedApps }) => {
+                const names = installedApps.map(getVendorAndName);
+                const settingsPromises = names.map(vendorAndName => this.getAppSettings(vendorAndName).catch(notFound));
+                return Promise.all(settingsPromises).then((settings) => {
+                    return zipObj(names, settings);
+                });
+            });
+        };
+        this.getAppBundle = (app, bundlePath, generatePackageJson) => {
+            const locator = utils_1.parseAppId(app);
+            const params = generatePackageJson && { _packageJSONEngine: 'npm', _packageJSONFilter: 'vtex.render-builder@x' };
+            const metric = locator.build ? 'apps-get-bundle' : 'registry-get-bundle';
+            return this.http.getStream(this.routes.AppBundle(locator, bundlePath), {
+                headers: {
+                    Accept: 'application/x-gzip',
+                    'Accept-Encoding': 'gzip',
+                },
+                metric,
+                params,
+            });
+        };
+        this.unpackAppBundle = (app, bundlePath, unpackPath, generatePackageJson) => {
+            return this.getAppBundle(app, bundlePath, generatePackageJson)
+                .then(stream => stream
+                .pipe(zlib_1.createGunzip())
+                .pipe(tar_fs_1.extract(unpackPath)));
+        };
+        this.getAppsMetaInfos = async (filter, staleWhileRevalidate = true) => {
+            const { account, production } = this.context;
+            const metric = 'get-apps-meta';
+            const inflightKey = HttpClient_1.inflightURL;
+            const key = appsStaleIfError_1.getMetaInfoKey(account);
+            const cachedResponse = this.diskCache && await this.diskCache.get(key);
+            if (cachedResponse && this.context.recorder) {
+                this.context.recorder(cachedResponse.headers);
+            }
+            const metaInfoPromise = this.http.getRaw(this.routes.Meta(), { params: { fields: workspaceFields }, metric, inflightKey })
+                .then((response) => {
+                const { data, headers: responseHeaders } = response;
+                if (this.diskCache) {
+                    this.diskCache.set(key, {
+                        appsMetaInfo: data.apps || [],
+                        headers: responseHeaders,
+                    });
+                }
+                return response;
+            });
+            const useCachedResponse = cachedResponse && production && staleWhileRevalidate;
+            const appsMetaInfo = useCachedResponse
+                ? cachedResponse.appsMetaInfo
+                : await metaInfoPromise.then(response => response.data.apps);
+            if (filter) {
+                return appsMetaInfo.filter(appMeta => !!ramda_1.path(['_resolvedDependencies', filter], appMeta), appsMetaInfo);
+            }
+            return appsMetaInfo;
+        };
+        this.getDependencies = (filter = '') => {
+            const params = { filter };
+            const metric = 'apps-get-deps';
+            const inflightKey = HttpClient_1.inflightUrlWithQuery;
+            return this.http.get(this.routes.Dependencies(), { params, metric, inflightKey });
+        };
+        this.updateDependencies = () => {
+            return this.http.put(this.routes.Dependencies(), null, { metric: 'apps-update-deps' });
+        };
+        this.updateDependency = (name, version, registry) => {
+            return this.http.patch(this.routes.Apps(), [{ name, version, registry }], { metric: 'apps-update-dep' });
+        };
+        this.resolveDependencies = (apps, registries, filter = '') => {
+            const params = { apps, registries, filter };
+            const metric = 'apps-resolve-deps';
+            const inflightKey = HttpClient_1.inflightUrlWithQuery;
+            return this.http.get(this.routes.ResolveDependencies(), { params, metric, inflightKey });
+        };
+        this.resolveDependenciesWithManifest = (manifest, filter = '') => {
+            const params = { filter };
+            const metric = 'apps-resolve-deps-m';
+            return this.http.post(this.routes.ResolveDependenciesWithManifest(), manifest, { params, metric });
+        };
+        this.installRuntime = (descriptor) => {
+            const { account, workspace } = this.context;
+            const [name, version] = descriptor.split('@');
+            return this.http.patch(`http://apps.aws-us-east-1.vtex.io/${account}/${workspace}/apps`, [
+                {
+                    name,
+                    version,
+                },
+            ]);
+        };
+        this.diskCache = options && options.diskCache;
+        this.memoryCache = options && options.memoryCache;
+        this._routes = createRoutes(context);
+    }
+    get routes() {
+        return this._routes;
+    }
+}
+exports.Apps = Apps;

package/lib/clients/Assets.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+import { AppMetaInfo } from '..';
+import { InfraClient, InstanceOptions } from '../HttpClient';
+import { IOContext } from '../service/typings';
+export interface AssetsParams {
+    files?: string[];
+    pick?: string[];
+}
+export declare class Assets extends InfraClient {
+    private routes;
+    constructor(context: IOContext, options?: InstanceOptions);
+    getSettings(dependencies: AppMetaInfo[], appAtMajor: string, params?: AssetsParams): Promise<Record<string, any>[]>;
+    getBuildJSONForApp(app: AppMetaInfo, appVendorName: string, pick?: string | string[]): Promise<Record<string, any>>;
+    getSettingsFromFilesForApp(app: AppMetaInfo, files?: string | string[]): Promise<Record<string, any>>;
+    getFile<T extends object | null>(appId: string, file: string, nullIfNotFound?: boolean): Promise<T>;
+    getFilteredDependencies(apps: string | string[], dependencies: AppMetaInfo[]): AppMetaInfo[];
+    getAppBundleByVendor: (app: string, bundlePath: string, generatePackageJson: boolean) => Promise<Readable>;
+    protected getAppFileByAccount: <T extends object | null>(app: string, path: string, nullIfNotFound?: boolean | undefined) => Promise<T>;
+    protected getAppFileByVendor: <T extends object | null>(app: string, path: string, nullIfNotFound?: boolean | undefined) => Promise<T>;
+}

package/lib/clients/{infra/Assets.js → Assets.js}

@@ -1,18 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const ramda_1 = require("ramda");
-const HttpClient_1 = require("../../HttpClient");
-const utils_1 = require("../../utils");
-const InfraClient_1 = require("./InfraClient");
+const HttpClient_1 = require("../HttpClient");
+const utils_1 = require("../utils");
 const dependsOnApp = (appsAtMajor) => (a) => {
     let dependsOn = false;
     appsAtMajor.forEach(appAtMajor => {
         const [name, major] = appAtMajor.split('@');
-        const sanitizedMajor = major.includes('.') ? major.split('.')[0] : major;
         const version = a._resolvedDependencies[name];
         if (version) {
             const [depMajor] = version.split('.');
-            if (sanitizedMajor === depMajor) {
+            if (major === depMajor) {
                 dependsOn = true;
             }
         }
@@ -30,10 +28,10 @@ const createRoutes = (workspace) => ({
     Bundle: (scope, locator, path) => `/${scope}/${appOrRegistry(workspace, locator)}/bundle/${path}`,
     Files: (scope, locator, path) => `/${scope}/${appOrRegistry(workspace, locator)}/files/${path}`,
 });
-class Assets extends InfraClient_1.InfraClient {
+class Assets extends HttpClient_1.InfraClient {
     constructor(context, options) {
         super('apps@0.x', context, options, true);
-        this.getAppBundleByVendor = (app, bundlePath, generatePackageJson, tracingConfig) => {
+        this.getAppBundleByVendor = (app, bundlePath, generatePackageJson) => {
             const locator = utils_1.parseAppId(app);
             const params = generatePackageJson && { _packageJSONEngine: 'npm', _packageJSONFilter: 'vtex.render-builder@x' };
             const metric = locator.build ? 'apps-get-bundle' : 'registry-get-bundle';
@@ -44,117 +42,64 @@ class Assets extends InfraClient_1.InfraClient {
                 },
                 metric,
                 params,
-                tracing: {
-                    requestSpanNameSuffix: metric,
-                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
-                },
             });
         };
-        this.getAppJSONByAccount = (app, path, nullIfNotFound, tracingConfig) => {
+        this.getAppFileByAccount = (app, path, nullIfNotFound) => {
             const locator = utils_1.parseAppId(app);
             const inflightKey = HttpClient_1.inflightURL;
-            const metric = 'assets-get-json-by-account';
             return this.http.get(this.routes.Files(this.context.account, locator, path), {
                 cacheable: HttpClient_1.CacheType.Memory,
                 inflightKey,
-                metric,
+                metric: 'assets-get-json-by-account',
                 nullIfNotFound,
-                tracing: {
-                    requestSpanNameSuffix: metric,
-                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
-                },
             });
         };
-        this.getAppJSONByVendor = (app, path, nullIfNotFound, tracingConfig) => {
+        this.getAppFileByVendor = (app, path, nullIfNotFound) => {
             const locator = utils_1.parseAppId(app);
             const vendor = locator.name.split('.')[0];
             const inflightKey = HttpClient_1.inflightURL;
-            const metric = 'assets-get-json-by-vendor';
             return this.http.get(this.routes.Files(vendor, locator, path), {
                 cacheable: HttpClient_1.CacheType.Any,
                 inflightKey,
-                metric,
+                metric: 'assets-get-json-by-vendor',
                 nullIfNotFound,
-                tracing: {
-                    requestSpanNameSuffix: metric,
-                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
-                },
-            });
-        };
-        this.getAppFileByAccount = (app, path, nullIfNotFound, tracingConfig) => {
-            const locator = utils_1.parseAppId(app);
-            const inflightKey = HttpClient_1.inflightURL;
-            const metric = 'assets-get-file-by-account';
-            return this.http.getBuffer(this.routes.Files(this.context.account, locator, path), {
-                cacheable: HttpClient_1.CacheType.Any,
-                inflightKey,
-                metric,
-                nullIfNotFound,
-                tracing: {
-                    requestSpanNameSuffix: metric,
-                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
-                },
-            });
-        };
-        this.getAppFileByVendor = (app, path, nullIfNotFound, tracingConfig) => {
-            const locator = utils_1.parseAppId(app);
-            const vendor = locator.name.split('.')[0];
-            const inflightKey = HttpClient_1.inflightURL;
-            const metric = 'assets-get-file-by-vendor';
-            return this.http.getBuffer(this.routes.Files(vendor, locator, path), {
-                cacheable: HttpClient_1.CacheType.Any,
-                inflightKey,
-                metric,
-                nullIfNotFound,
-                tracing: {
-                    requestSpanNameSuffix: metric,
-                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
-                },
             });
         };
         this.routes = createRoutes(this.context.workspace);
     }
-    getSettings(dependencies, appAtMajor, params = {}, tracingConfig) {
+    getSettings(dependencies, appAtMajor, params = {}) {
         const { pick, files } = params;
         const filtered = this.getFilteredDependencies(appAtMajor, dependencies);
         return Promise.all(filtered.map(dependency => {
             const [appVendorName] = appAtMajor.split('@');
             const buildJson = useBuildJson(dependency, appVendorName);
             return buildJson
-                ? this.getBuildJSONForApp(dependency, appVendorName, pick, tracingConfig)
-                : this.getSettingsFromFilesForApp(dependency, files, tracingConfig);
+                ? this.getBuildJSONForApp(dependency, appVendorName, pick)
+                : this.getSettingsFromFilesForApp(dependency, files);
         }));
     }
-    async getBuildJSONForApp(app, appVendorName, pick = [], tracingConfig) {
+    async getBuildJSONForApp(app, appVendorName, pick = []) {
         const pickArray = Array.isArray(pick) ? pick : [pick];
-        const buildJson = await this.getJSON(app.id, `dist/${appVendorName}/build.json`, undefined, tracingConfig);
+        const buildJson = await this.getFile(app.id, `dist/${appVendorName}/build.json`);
         const result = !ramda_1.isEmpty(pickArray) ? ramda_1.pick(pickArray, buildJson) : buildJson;
         result.declarer = app.id;
         return result;
     }
-    async getSettingsFromFilesForApp(app, files = [], tracingConfig) {
+    async getSettingsFromFilesForApp(app, files = []) {
         // If there's no support for build.json, then fetch individual files and zip them into an {[file]: content} object.
         const filesArray = Array.isArray(files) ? files : [files];
-        const fetched = await Promise.all(filesArray.map(file => this.getJSON(app.id, file, true, tracingConfig)));
+        const fetched = await Promise.all(filesArray.map(file => this.getFile(app.id, file, true)));
         const result = ramda_1.zipObj(filesArray, fetched);
         result.declarer = app.id;
         return result;
     }
-    async getJSON(appId, file, nullIfNotFound, tracingConfig) {
-        const locator = utils_1.parseAppId(appId);
-        const linked = !!locator.build;
-        if (linked) {
-            return this.getAppJSONByAccount(appId, file, nullIfNotFound, tracingConfig);
-        }
-        return this.getAppJSONByVendor(appId, file, nullIfNotFound, tracingConfig);
-    }
-    async getFile(appId, file, nullIfNotFound, tracingConfig) {
+    async getFile(appId, file, nullIfNotFound) {
         const locator = utils_1.parseAppId(appId);
         const linked = !!locator.build;
         if (linked) {
-            return this.getAppFileByAccount(appId, file, nullIfNotFound, tracingConfig);
+            return this.getAppFileByAccount(appId, file, nullIfNotFound);
         }
-        return this.getAppFileByVendor(appId, file, nullIfNotFound, tracingConfig);
+        return this.getAppFileByVendor(appId, file, nullIfNotFound);
     }
     getFilteredDependencies(apps, dependencies) {
         const appsAtMajor = typeof (apps) === 'string' ? [apps] : apps;