@vtex/api 6.45.4

package/lib/caches/MultilayeredCache.d.ts

@@ -0,0 +1,14 @@
+import { CacheLayer } from './CacheLayer';
+import { FetchResult, MultilayerStats } from './typings';
+export declare class MultilayeredCache<K, V> implements CacheLayer<K, V> {
+    private caches;
+    private hits;
+    private total;
+    constructor(caches: Array<CacheLayer<K, V>>);
+    get: (key: K, fetcher?: (() => Promise<FetchResult<V>>) | undefined) => Promise<void | V>;
+    set: (key: K, value: V, maxAge?: number | undefined) => Promise<boolean>;
+    has: (key: K) => Promise<boolean>;
+    getStats: (name?: string) => MultilayerStats;
+    private findIndex;
+    private resetCounters;
+}

package/lib/caches/MultilayeredCache.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ramda_1 = require("ramda");
+class MultilayeredCache {
+    constructor(caches) {
+        this.caches = caches;
+        this.hits = 0;
+        this.total = 0;
+        this.get = async (key, fetcher) => {
+            let value;
+            let maxAge;
+            let successIndex = await this.findIndex(async (cache) => {
+                const [getValue, hasKey] = await Promise.all([cache.get(key), cache.has(key)]);
+                value = getValue;
+                return hasKey;
+            }, this.caches);
+            if (successIndex === -1) {
+                if (fetcher) {
+                    const fetched = await fetcher();
+                    value = fetched.value;
+                    maxAge = fetched.maxAge;
+                }
+                else {
+                    return undefined;
+                }
+                successIndex = Infinity;
+            }
+            const failedCaches = ramda_1.slice(0, successIndex, this.caches);
+            const [firstPromise] = ramda_1.map(cache => cache.set(key, value, maxAge), failedCaches);
+            await firstPromise;
+            return value;
+        };
+        this.set = async (key, value, maxAge) => {
+            const isSet = await Promise.all(ramda_1.map(cache => cache.set(key, value, maxAge), this.caches));
+            return ramda_1.any(item => item, isSet);
+        };
+        this.has = async (key) => {
+            const hasList = await Promise.all(ramda_1.map(cache => cache.has(key), this.caches));
+            return ramda_1.any(item => item, hasList);
+        };
+        this.getStats = (name = 'multilayred-cache') => {
+            const multilayerStats = {
+                hitRate: this.total > 0 ? this.hits / this.total : undefined,
+                hits: this.hits,
+                name,
+                total: this.total,
+            };
+            this.resetCounters();
+            return multilayerStats;
+        };
+        this.findIndex = async (func, array) => {
+            this.total += 1;
+            for (let index = 0; index < array.length; index++) {
+                const hasKey = await func(array[index]);
+                if (hasKey) {
+                    this.hits += 1;
+                    return index;
+                }
+            }
+            return -1;
+        };
+    }
+    resetCounters() {
+        this.hits = 0;
+        this.total = 0;
+    }
+}
+exports.MultilayeredCache = MultilayeredCache;

package/lib/caches/index.d.ts

@@ -0,0 +1,6 @@
+export * from './CacheLayer';
+export * from './DiskCache';
+export * from './LRUCache';
+export * from './LRUDiskCache';
+export * from './MultilayeredCache';
+export * from './typings';

package/lib/caches/index.js

@@ -0,0 +1,9 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./DiskCache"));
+__export(require("./LRUCache"));
+__export(require("./LRUDiskCache"));
+__export(require("./MultilayeredCache"));

package/lib/caches/typings.d.ts

@@ -0,0 +1,48 @@
+export declare type FetchResult<V> = {
+    value: V;
+    maxAge?: number;
+};
+export declare type DiskStats = {
+    hits: number;
+    total: number;
+    name: string;
+};
+export declare type LRUStats = {
+    itemCount: number;
+    length: number;
+    disposedItems: number;
+    hitRate: number | undefined;
+    hits: number;
+    max: number;
+    name: string;
+    total: number;
+};
+export declare type MultilayerStats = {
+    hitRate: number | undefined;
+    hits: number;
+    total: number;
+    name: string;
+};
+export declare type LRUDiskCacheOptions = {
+    /**
+     * The maximum size of the cache, checked by applying the length
+     * function to all values in the cache. Not setting this is kind of silly,
+     * since that's the whole purpose of this lib, but it defaults to `Infinity`.
+     */
+    max?: number;
+    /**
+     * Maximum age in ms. Items are not pro-actively pruned out as they age,
+     * but if you try to get an item that is too old, it'll drop it and return
+     * undefined instead of giving it to you.
+     */
+    maxAge?: number;
+    /**
+     * By default, if you set a `maxAge`, it'll only actually pull stale items
+     * out of the cache when you `get(key)`. (That is, it's not pre-emptively
+     * doing a `setTimeout` or anything.) If you set `stale:true`, it'll return
+     * the stale value before deleting it. If you don't set this, then it'll
+     * return `undefined` when you try to get a stale entry,
+     * as if it had already been deleted.
+     */
+    stale?: boolean;
+};

package/lib/caches/typings.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/clients/IOClient.d.ts

@@ -0,0 +1,13 @@
+import { IOContext } from '../service/worker/runtime/typings';
+import { HttpClient } from '../HttpClient/HttpClient';
+import { InstanceOptions } from '../HttpClient/typings';
+export declare type IOClientConstructor = new (context: IOContext, options?: InstanceOptions) => IOClient;
+/**
+ * A client that can be instantiated by the Serviceruntime layer.
+ */
+export declare class IOClient {
+    protected context: IOContext;
+    protected options?: InstanceOptions | undefined;
+    protected http: HttpClient;
+    constructor(context: IOContext, options?: InstanceOptions | undefined);
+}

package/lib/clients/IOClient.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const HttpClient_1 = require("../HttpClient/HttpClient");
+/**
+ * A client that can be instantiated by the Serviceruntime layer.
+ */
+class IOClient {
+    constructor(context, options) {
+        this.context = context;
+        this.options = options;
+        this.http = new HttpClient_1.HttpClient({
+            name: this.constructor.name,
+            ...context,
+            ...options,
+            metrics: options && options.metrics,
+        });
+    }
+}
+exports.IOClient = IOClient;

package/lib/clients/IOClients.d.ts

@@ -0,0 +1,37 @@
+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';
+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;
+    protected getOrSet<TClient extends IOClientConstructor>(key: string, Implementation: TClient): InstanceType<TClient>;
+}

package/lib/clients/IOClients.js

@@ -0,0 +1,89 @@
+"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");
+class IOClients {
+    constructor(clientOptions, ctx) {
+        this.clientOptions = clientOptions;
+        this.ctx = ctx;
+        this.clients = {};
+    }
+    get apps() {
+        return this.getOrSet('apps', infra_1.Apps);
+    }
+    get assets() {
+        return this.getOrSet('assets', infra_1.Assets);
+    }
+    get billing() {
+        return this.getOrSet('billing', apps_1.Billing);
+    }
+    get billingMetrics() {
+        return this.getOrSet('billingMetrics', infra_1.BillingMetrics);
+    }
+    get builder() {
+        return this.getOrSet('builder', apps_1.Builder);
+    }
+    get events() {
+        return this.getOrSet('events', infra_1.Events);
+    }
+    get id() {
+        return this.getOrSet('id', external_1.ID);
+    }
+    get licenseManager() {
+        return this.getOrSet('licenseManager', janus_1.LicenseManager);
+    }
+    get masterdata() {
+        return this.getOrSet('masterdata', external_1.MasterData);
+    }
+    get messagesGraphQL() {
+        return this.getOrSet('messagesGraphQL', apps_1.MessagesGraphQL);
+    }
+    get metadata() {
+        return this.getOrSet('metadata', infra_1.Metadata);
+    }
+    get registry() {
+        return this.getOrSet('registry', infra_1.Registry);
+    }
+    get router() {
+        return this.getOrSet('router', infra_1.Router);
+    }
+    get segment() {
+        return this.getOrSet('segment', janus_1.Segment);
+    }
+    get settings() {
+        return this.getOrSet('settings', apps_1.Settings);
+    }
+    get session() {
+        return this.getOrSet('session', janus_1.Session);
+    }
+    get tenant() {
+        return this.getOrSet('tenant', janus_1.TenantClient);
+    }
+    get vbase() {
+        return this.getOrSet('vbase', infra_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);
+    }
+    getOrSet(key, Implementation) {
+        const options = {
+            ...this.clientOptions.default,
+            ...this.clientOptions[key],
+            metrics,
+        };
+        if (!this.clients[key]) {
+            this.clients[key] = new Implementation(this.ctx, options);
+        }
+        return this.clients[key];
+    }
+}
+exports.IOClients = IOClients;

package/lib/clients/IOGraphQLClient.d.ts

@@ -0,0 +1,13 @@
+import { GraphQLClient } from '../HttpClient/GraphQLClient';
+import { InstanceOptions } from '../HttpClient/typings';
+import { IOContext } from '../service/worker/runtime/typings';
+import { IOClient } from './IOClient';
+/**
+ * A GraphQL client that can be instantiated by the Serviceruntime layer.
+ */
+export declare class IOGraphQLClient extends IOClient {
+    protected context: IOContext;
+    protected options?: InstanceOptions | undefined;
+    protected graphql: GraphQLClient;
+    constructor(context: IOContext, options?: InstanceOptions | undefined);
+}

package/lib/clients/IOGraphQLClient.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const GraphQLClient_1 = require("../HttpClient/GraphQLClient");
+const IOClient_1 = require("./IOClient");
+/**
+ * A GraphQL client that can be instantiated by the Serviceruntime layer.
+ */
+class IOGraphQLClient extends IOClient_1.IOClient {
+    constructor(context, options) {
+        super(context, options);
+        this.context = context;
+        this.options = options;
+        this.graphql = new GraphQLClient_1.GraphQLClient(this.http);
+    }
+}
+exports.IOGraphQLClient = IOGraphQLClient;

package/lib/clients/apps/AppClient.d.ts

@@ -0,0 +1,9 @@
+import { InstanceOptions } from '../../HttpClient/typings';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { IOClient } from '../IOClient';
+/**
+ * Used to perform calls on apps you declared a dependency for in your manifest.
+ */
+export declare class AppClient extends IOClient {
+    constructor(app: string, context: IOContext, options?: InstanceOptions);
+}

package/lib/clients/apps/AppClient.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const typings_1 = require("../../HttpClient/typings");
+const routes_1 = require("../../service/worker/runtime/http/routes");
+const IOClient_1 = require("../IOClient");
+const useHttps = !process.env.VTEX_IO;
+/**
+ * Used to perform calls on apps you declared a dependency for in your manifest.
+ */
+class AppClient extends IOClient_1.IOClient {
+    constructor(app, context, options) {
+        const { account, workspace, region } = context;
+        const [appName, appVersion] = app.split('@');
+        const [vendor, name] = appName.split('.'); // vtex.messages
+        const protocol = useHttps ? 'https' : 'http';
+        let baseURL;
+        if (appVersion) {
+            const [major] = appVersion.split('.');
+            baseURL = routes_1.formatPrivateRoute({ account, workspace, vendor, name, major, protocol });
+        }
+        else {
+            console.warn(`${account} in ${workspace} is using old routing for ${app}. Please change vendor.app to vendor.app@major in client ${(options && options.name) || ''}`);
+            const service = [name, vendor].join('.'); // messages.vtex
+            baseURL = `http://${service}.${region}.vtex.io/${account}/${workspace}`;
+        }
+        super(context, {
+            ...options,
+            authType: typings_1.AuthType.bearer,
+            baseURL,
+            name,
+        });
+    }
+}
+exports.AppClient = AppClient;

package/lib/clients/apps/AppGraphQLClient.d.ts

@@ -0,0 +1,9 @@
+import { InstanceOptions } from '../../HttpClient/typings';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { IOGraphQLClient } from '../IOGraphQLClient';
+/**
+ * Used to perform calls on apps you declared a dependency for in your manifest.
+ */
+export declare class AppGraphQLClient extends IOGraphQLClient {
+    constructor(app: string, context: IOContext, options?: InstanceOptions);
+}

package/lib/clients/apps/AppGraphQLClient.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const typings_1 = require("../../HttpClient/typings");
+const routes_1 = require("../../service/worker/runtime/http/routes");
+const IOGraphQLClient_1 = require("../IOGraphQLClient");
+const useHttps = !process.env.VTEX_IO;
+/**
+ * Used to perform calls on apps you declared a dependency for in your manifest.
+ */
+class AppGraphQLClient extends IOGraphQLClient_1.IOGraphQLClient {
+    constructor(app, context, options) {
+        const { account, workspace, region } = context;
+        const [appName, appVersion] = app.split('@');
+        const [vendor, name] = appName.split('.'); // vtex.messages
+        const protocol = useHttps ? 'https' : 'http';
+        let baseURL;
+        if (appVersion) {
+            const [major] = appVersion.split('.');
+            baseURL = routes_1.formatPrivateRoute({ account, workspace, major, name, vendor, protocol, path: '/_v/graphql' });
+        }
+        else {
+            console.warn(`${account} in ${workspace} is using old routing for ${app}. Please change vendor.app to vendor.app@major in client ${(options && options.name) || ''}`);
+            const service = [name, vendor].join('.'); // messages.vtex
+            baseURL = `http://${service}.${region}.vtex.io/${account}/${workspace}/_v/graphql`;
+        }
+        super(context, {
+            ...options,
+            authType: typings_1.AuthType.bearer,
+            baseURL,
+            name,
+        });
+    }
+}
+exports.AppGraphQLClient = AppGraphQLClient;