@vtex/api 6.47.0 → 6.48.1-beta

package/lib/clients/Billing.d.ts

@@ -0,0 +1,11 @@
+import { AppClient, InstanceOptions } from '../HttpClient';
+import { IOContext } from '../service/typings';
+export declare class Billing extends AppClient {
+    constructor(context: IOContext, options?: InstanceOptions);
+    status: () => Promise<ContractStatus>;
+}
+export declare enum ContractStatus {
+    ACTIVE = "active_contract",
+    INACTIVE = "inactive_contract",
+    NO_CONTRACT = "no_contract"
+}

package/lib/clients/{apps/Billing.js → Billing.js}

@@ -1,15 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const AppClient_1 = require("./AppClient");
-class Billing extends AppClient_1.AppClient {
+const HttpClient_1 = require("../HttpClient");
+class Billing extends HttpClient_1.AppClient {
     constructor(context, options) {
         super('vtex.billing@0.x', context, options);
-        this.status = (tracingConfig) => this.http.get('/_v/contractStatus', {
-            tracing: {
-                requestSpanNameSuffix: 'billing-status',
-                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
-            },
-        });
+        this.status = () => this.http.get('/_v/contractStatus');
     }
 }
 exports.Billing = Billing;

package/lib/clients/BillingMetrics.d.ts

@@ -0,0 +1,12 @@
+import { InfraClient, InstanceOptions } from '../HttpClient';
+import { IOContext } from '../service/typings';
+export declare class BillingMetrics extends InfraClient {
+    constructor(context: IOContext, options?: InstanceOptions);
+    sendMetric: (metric: BillingMetric) => Promise<BillingMetric>;
+}
+export interface BillingMetric {
+    value: number;
+    unit: string;
+    metricId: string;
+    timestamp?: number;
+}

package/lib/clients/BillingMetrics.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const HttpClient_1 = require("../HttpClient");
+class BillingMetrics extends HttpClient_1.InfraClient {
+    constructor(context, options) {
+        super('colossus@0.x', context, options);
+        this.sendMetric = (metric) => this.http.post('/metrics', metric);
+    }
+}
+exports.BillingMetrics = BillingMetrics;

package/lib/clients/{apps/Builder.d.ts → Builder.d.ts}

@@ -1,24 +1,23 @@
 /// <reference types="node" />
 import { ZlibOptions } from 'zlib';
-import { InstanceOptions, RequestTracingConfig } from '../../HttpClient';
-import { IOContext } from '../../service/worker/runtime/typings';
-import { Change } from '../infra/Apps';
-import { File } from '../infra/Registry';
-import { AppClient } from './AppClient';
+import { AppClient, InstanceOptions } from '../HttpClient';
+import { IOContext } from '../service/typings';
+import { Change } from './Apps';
+import { File } from './Registry';
 export declare class Builder extends AppClient {
     private stickyHost;
     constructor(ioContext: IOContext, opts?: InstanceOptions);
-    availability: (app: string, hintIndex: number, tracingConfig?: RequestTracingConfig | undefined) => Promise<{
+    availability: (app: string, hintIndex: number) => Promise<{
         host: string;
         hostname: string | undefined;
         score: number;
     }>;
-    clean: (app: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<BuildResult>;
-    getPinnedDependencies: (tracingConfig?: RequestTracingConfig | undefined) => Promise<any>;
-    linkApp: (app: string, files: File[], zipOptions?: ZipOptions, params?: RequestParams, tracingConfig?: RequestTracingConfig | undefined) => Promise<BuildResult>;
-    publishApp: (app: string, files: File[], zipOptions?: ZipOptions, params?: RequestParams, tracingConfig?: RequestTracingConfig | undefined) => Promise<BuildResult>;
-    relinkApp: (app: string, changes: Change[], params?: RequestParams, tracingConfig?: RequestTracingConfig | undefined) => Promise<BuildResult>;
-    testApp: (app: string, files: File[], zipOptions?: ZipOptions, params?: RequestParams, tracingConfig?: RequestTracingConfig | undefined) => Promise<BuildResult>;
+    clean: (app: string) => Promise<BuildResult>;
+    getPinnedDependencies: () => Promise<any>;
+    linkApp: (app: string, files: File[], zipOptions?: ZipOptions, params?: RequestParams) => Promise<BuildResult>;
+    publishApp: (app: string, files: File[], zipOptions?: ZipOptions, params?: RequestParams) => Promise<BuildResult>;
+    relinkApp: (app: string, changes: Change[], params?: RequestParams) => Promise<BuildResult>;
+    testApp: (app: string, files: File[], zipOptions?: ZipOptions, params?: RequestParams) => Promise<BuildResult>;
     private zipAndSend;
 }
 interface RequestParams {

package/lib/clients/{apps/Builder.js → Builder.js}

@@ -4,8 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const archiver_1 = __importDefault(require("archiver"));
-const cache_1 = require("../../HttpClient/middlewares/cache");
-const AppClient_1 = require("./AppClient");
+const HttpClient_1 = require("../HttpClient");
+const cache_1 = require("../HttpClient/middlewares/cache");
 const routes = {
     Availability: (app) => `${routes.Builder}/availability/${app}`,
     Builder: '/_v/builder/0',
@@ -16,10 +16,10 @@ const routes = {
     Relink: (app) => `${routes.Builder}/relink/${app}`,
     Test: (app) => `${routes.Builder}/test/${app}`,
 };
-class Builder extends AppClient_1.AppClient {
+class Builder extends HttpClient_1.AppClient {
     constructor(ioContext, opts) {
         super('vtex.builder-hub@0.x', ioContext, opts);
-        this.availability = async (app, hintIndex, tracingConfig) => {
+        this.availability = async (app, hintIndex) => {
             const stickyHint = hintIndex === undefined || hintIndex === null ?
                 `request:${this.context.account}:${this.context.workspace}:${app}` :
                 `request:${this.context.account}:${this.context.workspace}:${app}:${hintIndex}`;
@@ -28,53 +28,33 @@ class Builder extends AppClient_1.AppClient {
                 'x-vtex-sticky-host': stickyHint,
             };
             const metric = 'bh-availability';
-            const { data: { availability }, headers: { 'x-vtex-sticky-host': host }, } = await this.http.getRaw(routes.Availability(app), { cacheable: cache_1.CacheType.None, headers, metric, tracing: {
-                    requestSpanNameSuffix: metric,
-                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
-                } });
+            const { data: { availability }, headers: { 'x-vtex-sticky-host': host }, } = await this.http.getRaw(routes.Availability(app), { headers, metric, cacheable: cache_1.CacheType.None });
             const { hostname, score } = availability;
             return { host, hostname, score };
         };
-        this.clean = (app, tracingConfig) => {
-            const headers = {
-                'Content-Type': 'application/json',
-                ...this.stickyHost && { 'x-vtex-sticky-host': this.stickyHost },
-            };
+        this.clean = (app) => {
+            const headers = Object.assign({ 'Content-Type': 'application/json' }, this.stickyHost && { 'x-vtex-sticky-host': this.stickyHost });
             const metric = 'bh-clean';
-            return this.http.post(routes.Clean(app), { headers, metric, tracing: {
-                    requestSpanNameSuffix: metric,
-                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
-                } });
+            return this.http.post(routes.Clean(app), { headers, metric });
         };
-        this.getPinnedDependencies = (tracingConfig) => {
-            return this.http.get(routes.PinnedDependencies(), {
-                tracing: {
-                    requestSpanNameSuffix: 'pinned-dependencies',
-                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
-                },
-            });
+        this.getPinnedDependencies = () => {
+            return this.http.get(routes.PinnedDependencies());
         };
-        this.linkApp = (app, files, zipOptions = { sticky: true }, params = {}, tracingConfig) => {
-            return this.zipAndSend(routes.Link(app), app, files, zipOptions, params, tracingConfig);
+        this.linkApp = (app, files, zipOptions = { sticky: true }, params = {}) => {
+            return this.zipAndSend(routes.Link(app), app, files, zipOptions, params);
         };
-        this.publishApp = (app, files, zipOptions = { sticky: true }, params = {}, tracingConfig) => {
-            return this.zipAndSend(routes.Publish(app), app, files, zipOptions, params, tracingConfig);
+        this.publishApp = (app, files, zipOptions = { sticky: true }, params = {}) => {
+            return this.zipAndSend(routes.Publish(app), app, files, zipOptions, params);
         };
-        this.relinkApp = (app, changes, params = {}, tracingConfig) => {
-            const headers = {
-                'Content-Type': 'application/json',
-                ...this.stickyHost && { 'x-vtex-sticky-host': this.stickyHost },
-            };
+        this.relinkApp = (app, changes, params = {}) => {
+            const headers = Object.assign({ 'Content-Type': 'application/json' }, this.stickyHost && { 'x-vtex-sticky-host': this.stickyHost });
             const metric = 'bh-relink';
-            return this.http.put(routes.Relink(app), changes, { headers, metric, params, tracing: {
-                    requestSpanNameSuffix: metric,
-                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
-                } });
+            return this.http.put(routes.Relink(app), changes, { headers, metric, params });
         };
-        this.testApp = (app, files, zipOptions = { sticky: true }, params = {}, tracingConfig) => {
-            return this.zipAndSend(routes.Test(app), app, files, zipOptions, params, tracingConfig);
+        this.testApp = (app, files, zipOptions = { sticky: true }, params = {}) => {
+            return this.zipAndSend(routes.Test(app), app, files, zipOptions, params);
         };
-        this.zipAndSend = async (route, app, files, { tag, sticky, stickyHint, zlib } = {}, requestParams = {}, tracingConfig) => {
+        this.zipAndSend = async (route, app, files, { tag, sticky, stickyHint, zlib } = {}, requestParams = {}) => {
             if (!(files[0] && files[0].path && files[0].content)) {
                 throw new Error('Argument files must be an array of {path, content}, where content can be a String, a Buffer or a ReadableStream.');
             }
@@ -89,18 +69,11 @@ class Builder extends AppClient_1.AppClient {
             });
             const hint = stickyHint || `request:${this.context.account}:${this.context.workspace}:${app}`;
             const metric = 'bh-zip-send';
-            const params = tag ? { ...requestParams, tag } : requestParams;
+            const params = tag ? Object.assign({}, requestParams, { tag }) : requestParams;
             const request = this.http.postRaw(route, zip, {
-                headers: {
-                    'Content-Type': 'application/octet-stream',
-                    ...sticky && { 'x-vtex-sticky-host': this.stickyHost || hint },
-                },
+                headers: Object.assign({ 'Content-Type': 'application/octet-stream' }, sticky && { 'x-vtex-sticky-host': this.stickyHost || hint }),
                 metric,
                 params,
-                tracing: {
-                    requestSpanNameSuffix: metric,
-                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
-                },
             });
             files.forEach(({ content, path }) => zip.append(content, { name: path }));
             const finalize = zip.finalize();

package/lib/clients/Events.d.ts

@@ -0,0 +1,6 @@
+import { InfraClient, InstanceOptions } from '../HttpClient';
+import { IOContext } from '../service/typings';
+export declare class Events extends InfraClient {
+    constructor(context: IOContext, options?: InstanceOptions);
+    sendEvent: (subject: string, route: string, message?: any) => Promise<void>;
+}

package/lib/clients/Events.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const HttpClient_1 = require("../HttpClient");
+const eventRoute = (route) => `/events/${route}`;
+class Events extends HttpClient_1.InfraClient {
+    constructor(context, options) {
+        super('courier@0.x', Object.assign({}, context, { recorder: undefined }), options);
+        this.sendEvent = (subject, route, message) => {
+            const resource = subject === '' || subject === '-'
+                ? ''
+                : `vrn:apps:aws-us-east-1:${this.context.account}:${this.context.workspace}:/apps/${subject}`;
+            return this.http.put(eventRoute(route), message, {
+                metric: 'events-send',
+                params: { resource },
+            });
+        };
+    }
+}
+exports.Events = Events;

package/lib/clients/Housekeeper.d.ts

@@ -0,0 +1,11 @@
+import { InfraClient, InstanceOptions } from '../HttpClient';
+import { HousekeeperStatesAndUpdates } from '../responses';
+import { IOContext } from '../service/typings';
+export declare class Housekeeper extends InfraClient {
+    private _routes;
+    private readonly routes;
+    constructor(context: IOContext, options?: InstanceOptions);
+    apply: (data: HousekeeperStatesAndUpdates) => Promise<void>;
+    perform: () => Promise<void>;
+    resolve: () => Promise<HousekeeperStatesAndUpdates>;
+}

package/lib/clients/Housekeeper.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const HttpClient_1 = require("../HttpClient");
+const createRoutes = ({ account, workspace }) => {
+    const routes = {
+        Apply: () => `v2/housekeeping/apply`,
+        Perform: () => `v2/_housekeeping/perform`,
+        Resolve: () => `v2/housekeeping/resolve`,
+    };
+    return routes;
+};
+class Housekeeper extends HttpClient_1.InfraClient {
+    constructor(context, options) {
+        super('housekeeper@0.x', context, options);
+        this.apply = async (data) => this.http.post(this.routes.Apply(), data, { metric: 'housekeeper-apply' });
+        this.perform = async () => this.http.post(this.routes.Perform(), {}, { metric: 'housekeeper-perform' });
+        this.resolve = async () => this.http.get(this.routes.Resolve(), { metric: 'housekeeper-resolve' });
+        this._routes = createRoutes(context);
+    }
+    get routes() {
+        return this._routes;
+    }
+}
+exports.Housekeeper = Housekeeper;

package/lib/clients/ID.d.ts

@@ -0,0 +1,22 @@
+import { ExternalClient, InstanceOptions } from '../HttpClient';
+import { IOContext } from '../service/typings';
+export declare class ID extends ExternalClient {
+    constructor(context: IOContext, opts?: InstanceOptions);
+    getTemporaryToken: () => Promise<string>;
+    sendCodeToEmail: (token: string, email: string) => Promise<any>;
+    getEmailCodeAuthenticationToken: (token: string, email: string, code: string) => Promise<AuthenticationResponse>;
+    getPasswordAuthenticationToken: (token: string, email: string, password: string) => Promise<AuthenticationResponse>;
+}
+export interface AuthenticationResponse {
+    promptMFA: boolean;
+    clientToken: any;
+    authCookie: {
+        Name: string;
+        Value: string;
+    };
+    accountAuthCookie: any;
+    expiresIn: number;
+    userId: string;
+    phoneNumber: string;
+    scope: any;
+}

package/lib/clients/ID.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const HttpClient_1 = require("../HttpClient");
+const routes = {
+    SEND: '/accesskey/send',
+    START: '/start',
+    VALIDATE: '/accesskey/validate',
+    VALIDATE_CLASSIC: '/classic/validate',
+};
+const VTEXID_ENDPOINTS = {
+    STABLE: 'https://vtexid.vtex.com.br/api/vtexid/pub/authentication',
+};
+const endpoint = (env) => {
+    return VTEXID_ENDPOINTS[env] || env;
+};
+class ID extends HttpClient_1.ExternalClient {
+    constructor(context, opts) {
+        super(endpoint(VTEXID_ENDPOINTS.STABLE), context, opts);
+        this.getTemporaryToken = () => {
+            const metric = 'vtexid-temp-token';
+            return this.http.get(routes.START, { metric }).then(({ authenticationToken }) => authenticationToken);
+        };
+        this.sendCodeToEmail = (token, email) => {
+            const params = { authenticationToken: token, email };
+            const metric = 'vtexid-send-code';
+            return this.http.get(routes.SEND, { params, metric });
+        };
+        this.getEmailCodeAuthenticationToken = (token, email, code) => {
+            const params = {
+                accesskey: code,
+                authenticationToken: token,
+                login: email,
+            };
+            const metric = 'vtexid-email-token';
+            return this.http.get(routes.VALIDATE, { params, metric });
+        };
+        this.getPasswordAuthenticationToken = (token, email, password) => {
+            const params = {
+                authenticationToken: token,
+                login: email,
+                password,
+            };
+            const metric = 'vtexid-pass-token';
+            return this.http.get(routes.VALIDATE_CLASSIC, { params, metric });
+        };
+    }
+}
+exports.ID = ID;

package/lib/clients/IOClients.d.ts

@@ -1,37 +1,32 @@
-import { InstanceOptions } from '../HttpClient';
-import { IOContext } from '../service/worker/runtime/typings';
-import { Billing, Builder, MessagesGraphQL, Settings } from './apps';
-import { CatalogGraphQL } from './apps/catalogGraphQL/index';
-import { ID, MasterData, PaymentProvider } from './external';
-import { Apps, Assets, BillingMetrics, Events, Metadata, Registry, Router, VBase, Workspaces } from './infra';
-import { IOClientConstructor } from './IOClient';
-import { LicenseManager, Segment, Session, TenantClient } from './janus';
+import { Apps, Assets, Billing, BillingMetrics, Builder, Events, ID, LicenseManager, Logger, Messages, MessagesGraphQL, Metadata, Registry, Router, Segment, Session, Settings, VBase, Workspaces } from '.';
+import { InstanceOptions, IOClientConstructor } from '../HttpClient';
+import { IOContext } from '../service/typings';
+import { TenantClient } from './Tenant';
 export declare type ClientsImplementation<T extends IOClients> = new (clientOptions: Record<string, InstanceOptions>, ctx: IOContext) => T;
 export declare class IOClients {
     private clientOptions;
     private ctx;
     private clients;
     constructor(clientOptions: Record<string, InstanceOptions>, ctx: IOContext);
-    get apps(): Apps;
-    get assets(): Assets;
-    get billing(): Billing;
-    get billingMetrics(): BillingMetrics;
-    get builder(): Builder;
-    get events(): Events;
-    get id(): ID;
-    get licenseManager(): LicenseManager;
-    get masterdata(): MasterData;
-    get messagesGraphQL(): MessagesGraphQL;
-    get metadata(): Metadata;
-    get registry(): Registry;
-    get router(): Router;
-    get segment(): Segment;
-    get settings(): Settings;
-    get session(): Session;
-    get tenant(): TenantClient;
-    get vbase(): VBase;
-    get workspaces(): Workspaces;
-    get catalogGraphQL(): CatalogGraphQL;
-    get paymentProvider(): PaymentProvider;
+    readonly apps: Apps;
+    readonly assets: Assets;
+    readonly billing: Billing;
+    readonly billingMetrics: BillingMetrics;
+    readonly builder: Builder;
+    readonly events: Events;
+    readonly id: ID;
+    readonly licenseManager: LicenseManager;
+    readonly logger: Logger;
+    readonly messages: Messages;
+    readonly messagesGraphQL: MessagesGraphQL;
+    readonly metadata: Metadata;
+    readonly registry: Registry;
+    readonly router: Router;
+    readonly segment: Segment;
+    readonly settings: Settings;
+    readonly session: Session;
+    readonly tenant: TenantClient;
+    readonly vbase: VBase;
+    readonly workspaces: Workspaces;
     protected getOrSet<TClient extends IOClientConstructor>(key: string, Implementation: TClient): InstanceType<TClient>;
 }

package/lib/clients/IOClients.js

@@ -1,10 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const apps_1 = require("./apps");
-const index_1 = require("./apps/catalogGraphQL/index");
-const external_1 = require("./external");
-const infra_1 = require("./infra");
-const janus_1 = require("./janus");
+const _1 = require(".");
+const Tenant_1 = require("./Tenant");
 class IOClients {
     constructor(clientOptions, ctx) {
         this.clientOptions = clientOptions;
@@ -12,74 +9,67 @@ class IOClients {
         this.clients = {};
     }
     get apps() {
-        return this.getOrSet('apps', infra_1.Apps);
+        return this.getOrSet('apps', _1.Apps);
     }
     get assets() {
-        return this.getOrSet('assets', infra_1.Assets);
+        return this.getOrSet('assets', _1.Assets);
     }
     get billing() {
-        return this.getOrSet('billing', apps_1.Billing);
+        return this.getOrSet('billing', _1.Billing);
     }
     get billingMetrics() {
-        return this.getOrSet('billingMetrics', infra_1.BillingMetrics);
+        return this.getOrSet('billingMetrics', _1.BillingMetrics);
     }
     get builder() {
-        return this.getOrSet('builder', apps_1.Builder);
+        return this.getOrSet('builder', _1.Builder);
     }
     get events() {
-        return this.getOrSet('events', infra_1.Events);
+        return this.getOrSet('events', _1.Events);
     }
     get id() {
-        return this.getOrSet('id', external_1.ID);
+        return this.getOrSet('id', _1.ID);
     }
     get licenseManager() {
-        return this.getOrSet('licenseManager', janus_1.LicenseManager);
+        return this.getOrSet('licenseManager', _1.LicenseManager);
     }
-    get masterdata() {
-        return this.getOrSet('masterdata', external_1.MasterData);
+    get logger() {
+        return this.getOrSet('logger', _1.Logger);
+    }
+    get messages() {
+        return this.getOrSet('messages', _1.Messages);
     }
     get messagesGraphQL() {
-        return this.getOrSet('messagesGraphQL', apps_1.MessagesGraphQL);
+        return this.getOrSet('messagesGraphQL', _1.MessagesGraphQL);
     }
     get metadata() {
-        return this.getOrSet('metadata', infra_1.Metadata);
+        return this.getOrSet('metadata', _1.Metadata);
     }
     get registry() {
-        return this.getOrSet('registry', infra_1.Registry);
+        return this.getOrSet('registry', _1.Registry);
     }
     get router() {
-        return this.getOrSet('router', infra_1.Router);
+        return this.getOrSet('router', _1.Router);
     }
     get segment() {
-        return this.getOrSet('segment', janus_1.Segment);
+        return this.getOrSet('segment', _1.Segment);
     }
     get settings() {
-        return this.getOrSet('settings', apps_1.Settings);
+        return this.getOrSet('settings', _1.Settings);
     }
     get session() {
-        return this.getOrSet('session', janus_1.Session);
+        return this.getOrSet('session', _1.Session);
     }
     get tenant() {
-        return this.getOrSet('tenant', janus_1.TenantClient);
+        return this.getOrSet('tenant', Tenant_1.TenantClient);
     }
     get vbase() {
-        return this.getOrSet('vbase', infra_1.VBase);
+        return this.getOrSet('vbase', _1.VBase);
     }
     get workspaces() {
-        return this.getOrSet('workspaces', infra_1.Workspaces);
-    }
-    get catalogGraphQL() {
-        return this.getOrSet('catalogGraphQL', index_1.CatalogGraphQL);
-    }
-    get paymentProvider() {
-        return this.getOrSet('paymentProvider', external_1.PaymentProvider);
+        return this.getOrSet('workspaces', _1.Workspaces);
     }
     getOrSet(key, Implementation) {
-        const options = {
-            ...this.clientOptions.default,
-            ...this.clientOptions[key],
-            metrics,
-        };
+        const options = Object.assign({}, this.clientOptions.default, this.clientOptions[key], { metrics });
         if (!this.clients[key]) {
             this.clients[key] = new Implementation(this.ctx, options);
         }

package/lib/clients/LicenseManager.d.ts

@@ -0,0 +1,6 @@
+import { JanusClient } from '../HttpClient';
+export declare class LicenseManager extends JanusClient {
+    getAccountData(VtexIdclientAutCookie: string): Promise<any>;
+    getTopbarData(VtexIdclientAutCookie: string): Promise<any>;
+    canAccessResource(VtexIdclientAutCookie: string, resourceKey: string): Promise<boolean>;
+}

package/lib/clients/{janus/LicenseManager.js → LicenseManager.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const qs_1 = require("qs");
-const JanusClient_1 = require("./JanusClient");
+const HttpClient_1 = require("../HttpClient");
 const TWO_MINUTES_S = 2 * 60;
 const BASE_URL = '/api/license-manager';
 const routes = {
@@ -12,46 +12,31 @@ const routes = {
 const inflightKey = ({ baseURL, url, params }) => {
     return baseURL + url + qs_1.stringify(params, { arrayFormat: 'repeat', addQueryPrefix: true });
 };
-class LicenseManager extends JanusClient_1.JanusClient {
-    getAccountData(VtexIdclientAutCookie, tracingConfig) {
-        const metric = 'lm-account-data';
+class LicenseManager extends HttpClient_1.JanusClient {
+    getAccountData(VtexIdclientAutCookie) {
         return this.http.get(routes.accountData, {
             forceMaxAge: TWO_MINUTES_S,
             headers: {
                 VtexIdclientAutCookie,
             },
             inflightKey,
-            metric,
-            tracing: {
-                requestSpanNameSuffix: metric,
-                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
-            },
+            metric: 'lm-account-data',
         });
     }
-    getTopbarData(VtexIdclientAutCookie, tracingConfig) {
-        const metric = 'lm-topbar-data';
+    getTopbarData(VtexIdclientAutCookie) {
         return this.http.get(routes.topbarData, {
             headers: {
                 VtexIdclientAutCookie,
             },
-            metric,
-            tracing: {
-                requestSpanNameSuffix: metric,
-                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
-            },
+            metric: 'lm-topbar-data',
         });
     }
-    canAccessResource(VtexIdclientAutCookie, resourceKey, tracingConfig) {
-        const metric = 'lm-resource-access';
+    canAccessResource(VtexIdclientAutCookie, resourceKey) {
         return this.http.get(`${routes.resourceAccess}/${resourceKey}/access`, {
             headers: {
                 VtexIdclientAutCookie,
             },
-            metric,
-            tracing: {
-                requestSpanNameSuffix: metric,
-                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
-            },
+            metric: 'lm-resource-access',
         }).then(() => true, () => false);
     }
 }

package/lib/clients/Logger.d.ts

@@ -0,0 +1,27 @@
+import { InfraClient, InstanceOptions } from '../HttpClient';
+import { IOContext } from '../service/typings';
+export declare enum LogLevel {
+    Debug = "debug",
+    Info = "info",
+    Warn = "warn",
+    Error = "error"
+}
+export declare class Logger extends InfraClient {
+    private logger;
+    constructor(context: IOContext, options?: InstanceOptions);
+    debug: (message: any, subject?: string) => Promise<void>;
+    info: (message: any, subject?: string) => Promise<void>;
+    warn: (warning: any, subject?: string) => Promise<void>;
+    error: (error: any, subject?: string) => Promise<void>;
+    sendLog: (_: string, message: any, level: LogLevel) => Promise<void>;
+}
+export interface ErrorLog {
+    code: string;
+    message: string;
+    response?: {
+        status: number;
+        data: string;
+        headers: Record<string, string>;
+    };
+    [key: string]: any;
+}