@vtex/api 6.45.4

package/lib/HttpClient/middlewares/request/setupAxios/interceptors/tracing/spanSetup.d.ts

@@ -0,0 +1,4 @@
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
+import { Span } from 'opentracing';
+export declare const injectRequestInfoOnSpan: (span: Span, http: AxiosInstance, config: AxiosRequestConfig) => void;
+export declare const injectResponseInfoOnSpan: (span: Span, response: AxiosResponse<any> | undefined) => void;

package/lib/HttpClient/middlewares/request/setupAxios/interceptors/tracing/spanSetup.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const buildFullPath_1 = __importDefault(require("axios/lib/core/buildFullPath"));
+const constants_1 = require("../../../../../../constants");
+const Tags_1 = require("../../../../../../tracing/Tags");
+const utils_1 = require("../../../../../../tracing/utils");
+exports.injectRequestInfoOnSpan = (span, http, config) => {
+    span.addTags({
+        [Tags_1.OpentracingTags.SPAN_KIND]: Tags_1.OpentracingTags.SPAN_KIND_RPC_CLIENT,
+        [Tags_1.OpentracingTags.HTTP_METHOD]: config.method,
+        [Tags_1.OpentracingTags.HTTP_URL]: buildFullPath_1.default(config.baseURL, http.getUri(config)),
+    });
+    span.log({ 'request-headers': utils_1.cloneAndSanitizeHeaders(config.headers) });
+};
+// Response may be undefined in case of client timeout, invalid URL, ...
+exports.injectResponseInfoOnSpan = (span, response) => {
+    if (!response) {
+        span.setTag("http.no_response" /* HTTP_NO_RESPONSE */, 'true');
+        return;
+    }
+    span.log({ 'response-headers': utils_1.cloneAndSanitizeHeaders(response.headers) });
+    span.setTag(Tags_1.OpentracingTags.HTTP_STATUS_CODE, response.status);
+    if (response.headers[constants_1.ROUTER_CACHE_HEADER]) {
+        span.setTag("http.cache.router" /* HTTP_ROUTER_CACHE_RESULT */, response.headers[constants_1.ROUTER_CACHE_HEADER]);
+    }
+};

package/lib/HttpClient/middlewares/tracing.d.ts

@@ -0,0 +1,15 @@
+import { MiddlewaresTracingContext, RequestConfig } from '..';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { MiddlewareContext } from '../typings';
+interface HttpClientTracingMiddlewareConfig {
+    clientName: string;
+    tracer: IOContext['tracer'];
+    logger: IOContext['logger'];
+    hasMemoryCacheMiddleware: boolean;
+    hasDiskCacheMiddleware: boolean;
+}
+export interface TraceableRequestConfig extends RequestConfig {
+    tracing: MiddlewaresTracingContext;
+}
+export declare const createHttpClientTracingMiddleware: ({ tracer, logger, clientName, hasMemoryCacheMiddleware, hasDiskCacheMiddleware, }: HttpClientTracingMiddlewareConfig) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
+export {};

package/lib/HttpClient/middlewares/tracing.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tracing_1 = require("../../tracing");
+const Tags_1 = require("../../tracing/Tags");
+const cache_1 = require("./cache");
+exports.createHttpClientTracingMiddleware = ({ tracer, logger, clientName, hasMemoryCacheMiddleware, hasDiskCacheMiddleware, }) => {
+    return async function tracingMiddleware(ctx, next) {
+        const { rootSpan, requestSpanNameSuffix, referenceType = tracing_1.SpanReferenceTypes.CHILD_OF } = ctx.config.tracing || {};
+        const spanName = requestSpanNameSuffix ? `request:${requestSpanNameSuffix}` : 'request';
+        const span = rootSpan
+            ? tracer.startSpan(spanName, {
+                references: [tracing_1.createSpanReference(rootSpan, referenceType)],
+            })
+            : tracer.startSpan(spanName);
+        ctx.tracing = {
+            ...ctx.config.tracing,
+            isSampled: tracing_1.getTraceInfo(span).isSampled,
+            logger,
+            rootSpan: span,
+            tracer,
+        };
+        ctx.config.tracing = ctx.tracing;
+        const hasMemoCache = !(!cache_1.isLocallyCacheable(ctx.config, cache_1.CacheType.Any) || !ctx.config.memoizable);
+        const hasMemoryCache = hasMemoryCacheMiddleware && !!cache_1.isLocallyCacheable(ctx.config, cache_1.CacheType.Memory);
+        const hasDiskCache = hasDiskCacheMiddleware && !!cache_1.isLocallyCacheable(ctx.config, cache_1.CacheType.Disk);
+        span.addTags({
+            ["http.cache.memoization.enabled" /* HTTP_MEMOIZATION_CACHE_ENABLED */]: hasMemoCache,
+            ["http.cache.memory.enabled" /* HTTP_MEMORY_CACHE_ENABLED */]: hasMemoryCache,
+            ["http.cache.disk.enabled" /* HTTP_DISK_CACHE_ENABLED */]: hasDiskCache,
+            ["http.client.name" /* HTTP_CLIENT_NAME */]: clientName,
+        });
+        let response;
+        try {
+            await next();
+            response = ctx.response;
+        }
+        catch (err) {
+            response = err.response;
+            if (ctx.tracing.isSampled) {
+                tracing_1.ErrorReport.create({ originalError: err }).injectOnSpan(span, logger);
+            }
+            throw err;
+        }
+        finally {
+            if (response) {
+                span.setTag(Tags_1.OpentracingTags.HTTP_STATUS_CODE, response.status);
+            }
+            else {
+                span.setTag("http.no_response" /* HTTP_NO_RESPONSE */, true);
+            }
+            span.finish();
+        }
+    };
+};

package/lib/HttpClient/typings.d.ts

@@ -0,0 +1,123 @@
+/// <reference types="node" />
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { Middleware } from 'koa-compose';
+import { Span } from 'opentracing';
+import { CacheLayer } from '../caches/CacheLayer';
+import { MetricsAccumulator } from '../metrics/MetricsAccumulator';
+import { IOContext } from '../service/worker/runtime/typings';
+import { SpanReferenceTypes } from '../tracing';
+import { IUserLandTracer } from '../tracing/UserLandTracer';
+import { Cached, CacheType } from './middlewares/cache';
+export declare type InflightKeyGenerator = (x: RequestConfig) => string;
+interface RequestTracingUserConfig {
+    rootSpan?: Span;
+    referenceType?: SpanReferenceTypes;
+    requestSpanNameSuffix?: string;
+}
+export interface RequestTracingConfig {
+    tracing?: RequestTracingUserConfig;
+}
+export interface RequestConfig extends AxiosRequestConfig, RequestTracingConfig {
+    retries?: number;
+    exponentialTimeoutCoefficient?: number;
+    initialBackoffDelay?: number;
+    exponentialBackoffCoefficient?: number;
+    retryCount?: number;
+    /**
+     * Identifies the type of request for metrification purposes. Should vary with client method.
+     */
+    metric?: string;
+    /**
+     * In verbose mode, a counter will be incremented for each request made with the same `metric` label.
+     */
+    count?: number;
+    /**
+     * In verbose mode, a label will be created with a counter for each request made with the same `metric` label.
+     */
+    label?: string;
+    /**
+     * Outputs verbose logs to console for this request.
+     */
+    verbose?: boolean;
+    production?: boolean;
+    cacheable?: CacheType;
+    memoizeable?: boolean;
+    inflightKey?: InflightKeyGenerator;
+    forceMaxAge?: number;
+    responseEncoding?: BufferEncoding;
+    nullIfNotFound?: boolean;
+    ignoreRecorder?: boolean;
+}
+export interface CacheHit {
+    disk?: 0 | 1;
+    memory?: 0 | 1;
+    revalidated?: 0 | 1;
+    router?: 0 | 1;
+}
+export interface MiddlewaresTracingContext extends Omit<RequestTracingUserConfig, 'rootSpan'> {
+    tracer: IUserLandTracer;
+    logger: IOContext['logger'];
+    rootSpan: Span;
+    isSampled: boolean;
+}
+export interface MiddlewareContext {
+    config: RequestConfig;
+    tracing?: MiddlewaresTracingContext;
+    response?: AxiosResponse;
+    cacheHit?: CacheHit;
+    inflightHit?: boolean;
+    memoizedHit?: boolean;
+}
+export declare type CacheStorage = CacheLayer<string, Cached>;
+export interface InstanceOptions {
+    authType?: AuthType;
+    timeout?: number;
+    memoryCache?: CacheLayer<string, Cached>;
+    diskCache?: CacheLayer<string, Cached>;
+    baseURL?: string;
+    retries?: number;
+    exponentialTimeoutCoefficient?: number;
+    initialBackoffDelay?: number;
+    exponentialBackoffCoefficient?: number;
+    metrics?: MetricsAccumulator;
+    /**
+     * Maximum number of concurrent requests
+     *
+     * @type {number}
+     * @memberof InstanceOptions
+     */
+    concurrency?: number;
+    /**
+     * Default headers to be sent with every request
+     *
+     * @type {Record<string, string>}
+     * @memberof InstanceOptions
+     */
+    headers?: Record<string, string>;
+    /**
+     * Default query string parameters to be sent with every request
+     *
+     * @type {Record<string, string>}
+     * @memberof InstanceOptions
+     */
+    params?: Record<string, string>;
+    middlewares?: Array<Middleware<MiddlewareContext>>;
+    verbose?: boolean;
+    name?: string;
+    serverTimings?: Record<string, string>;
+    httpsAgent?: AxiosRequestConfig['httpsAgent'];
+}
+export interface IOResponse<T> {
+    data: T;
+    headers: Record<string, string>;
+    status: number;
+}
+export declare enum AuthType {
+    basic = "Basic",
+    bearer = "Bearer",
+    /**
+     * Supported for legacy reasons - this is not spec compliant!
+     */
+    token = "token"
+}
+export {};

package/lib/HttpClient/typings.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var AuthType;
+(function (AuthType) {
+    AuthType["basic"] = "Basic";
+    AuthType["bearer"] = "Bearer";
+    /**
+     * Supported for legacy reasons - this is not spec compliant!
+     */
+    AuthType["token"] = "token";
+})(AuthType = exports.AuthType || (exports.AuthType = {}));

package/lib/caches/CacheLayer.d.ts

@@ -0,0 +1,7 @@
+import { FetchResult } from './typings';
+export interface CacheLayer<K, V> {
+    get(key: K, fetcher?: () => Promise<FetchResult<V>>): Promise<V | void> | V | void;
+    has(key: K): Promise<boolean> | boolean;
+    set(key: K, value: V, maxAge?: number | void): Promise<boolean> | boolean;
+    getStats?(name?: string): any;
+}

package/lib/caches/CacheLayer.js

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

package/lib/caches/DiskCache.d.ts

@@ -0,0 +1,17 @@
+import { CacheLayer } from './CacheLayer';
+import { DiskStats } from './typings';
+import { outputJSON, readJSON } from 'fs-extra';
+export declare class DiskCache<V> implements CacheLayer<string, V> {
+    private cachePath;
+    private readFile;
+    private writeFile;
+    private hits;
+    private total;
+    private lock;
+    constructor(cachePath: string, readFile?: typeof readJSON, writeFile?: typeof outputJSON);
+    has: (key: string) => boolean;
+    getStats: (name?: string) => DiskStats;
+    get: (key: string) => Promise<void | V>;
+    set: (key: string, value: V) => Promise<boolean>;
+    private getPathKey;
+}

package/lib/caches/DiskCache.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const rwlock_1 = __importDefault(require("rwlock"));
+class DiskCache {
+    constructor(cachePath, readFile = fs_extra_1.readJSON, writeFile = fs_extra_1.outputJSON) {
+        this.cachePath = cachePath;
+        this.readFile = readFile;
+        this.writeFile = writeFile;
+        this.hits = 0;
+        this.total = 0;
+        this.has = (key) => {
+            const pathKey = this.getPathKey(key);
+            return fs_extra_1.pathExistsSync(pathKey);
+        };
+        this.getStats = (name = 'disk-cache') => {
+            const stats = {
+                hits: this.hits,
+                name,
+                total: this.total,
+            };
+            this.hits = 0;
+            this.total = 0;
+            return stats;
+        };
+        this.get = async (key) => {
+            const pathKey = this.getPathKey(key);
+            this.total += 1;
+            const data = await new Promise(resolve => {
+                this.lock.readLock(key, async (release) => {
+                    try {
+                        const fileData = await this.readFile(pathKey);
+                        release();
+                        this.hits += 1;
+                        resolve(fileData);
+                    }
+                    catch (e) {
+                        release();
+                        resolve(undefined);
+                    }
+                });
+            });
+            return data;
+        };
+        this.set = async (key, value) => {
+            const pathKey = this.getPathKey(key);
+            const failure = await new Promise(resolve => {
+                this.lock.writeLock(key, async (release) => {
+                    try {
+                        const writePromise = await this.writeFile(pathKey, value);
+                        release();
+                        resolve(writePromise);
+                    }
+                    catch (e) {
+                        release();
+                        resolve(true);
+                    }
+                });
+            });
+            return !failure;
+        };
+        this.getPathKey = (key) => path_1.join(this.cachePath, key);
+        this.lock = new rwlock_1.default();
+    }
+}
+exports.DiskCache = DiskCache;

package/lib/caches/LRUCache.d.ts

@@ -0,0 +1,16 @@
+import LRU from 'lru-cache';
+import { CacheLayer } from './CacheLayer';
+import { FetchResult, LRUStats } from './typings';
+export declare class LRUCache<K, V> implements CacheLayer<K, V> {
+    private multilayer;
+    private storage;
+    private hits;
+    private total;
+    private disposed;
+    constructor(options: LRU.Options<K, V>);
+    get: (key: K) => void | V;
+    getOrSet: (key: K, fetcher?: (() => Promise<FetchResult<V>>) | undefined) => Promise<void | V>;
+    set: (key: K, value: V, maxAge?: number | undefined) => boolean;
+    has: (key: K) => boolean;
+    getStats: (name?: string) => LRUStats;
+}

package/lib/caches/LRUCache.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lru_cache_1 = __importDefault(require("lru-cache"));
+const MultilayeredCache_1 = require("./MultilayeredCache");
+class LRUCache {
+    constructor(options) {
+        this.get = (key) => {
+            const value = this.storage.get(key);
+            if (this.storage.has(key)) {
+                this.hits += 1;
+            }
+            this.total += 1;
+            return value;
+        };
+        this.getOrSet = async (key, fetcher) => this.multilayer.get(key, fetcher);
+        this.set = (key, value, maxAge) => this.storage.set(key, value, maxAge);
+        this.has = (key) => this.storage.has(key);
+        this.getStats = (name = 'lru-cache') => {
+            const stats = {
+                disposedItems: this.disposed,
+                hitRate: this.total > 0 ? this.hits / this.total : undefined,
+                hits: this.hits,
+                itemCount: this.storage.itemCount,
+                length: this.storage.length,
+                max: this.storage.max,
+                name,
+                total: this.total,
+            };
+            this.hits = 0;
+            this.total = 0;
+            this.disposed = 0;
+            return stats;
+        };
+        this.hits = 0;
+        this.total = 0;
+        this.disposed = 0;
+        this.storage = new lru_cache_1.default({
+            ...options,
+            dispose: () => this.disposed += 1,
+            noDisposeOnSet: true,
+        });
+        this.multilayer = new MultilayeredCache_1.MultilayeredCache([this]);
+    }
+}
+exports.LRUCache = LRUCache;

package/lib/caches/LRUDiskCache.d.ts

@@ -0,0 +1,21 @@
+import { CacheLayer } from './CacheLayer';
+import { LRUDiskCacheOptions, LRUStats } from './typings';
+import { outputJSON, readJSON } from 'fs-extra';
+export declare class LRUDiskCache<V> implements CacheLayer<string, V> {
+    private cachePath;
+    private readFile;
+    private writeFile;
+    private lock;
+    private disposed;
+    private hits;
+    private total;
+    private lruStorage;
+    private keyToBeDeleted;
+    constructor(cachePath: string, options: LRUDiskCacheOptions, readFile?: typeof readJSON, writeFile?: typeof outputJSON);
+    has: (key: string) => boolean;
+    getStats: (name?: string) => LRUStats;
+    get: (key: string) => Promise<void | V>;
+    set: (key: string, value: V, maxAge?: number | undefined) => Promise<boolean>;
+    private getPathKey;
+    private deleteFile;
+}

package/lib/caches/LRUDiskCache.js

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_extra_1 = require("fs-extra");
+const lru_cache_1 = __importDefault(require("lru-cache"));
+const path_1 = require("path");
+const rwlock_1 = __importDefault(require("rwlock"));
+class LRUDiskCache {
+    constructor(cachePath, options, readFile = fs_extra_1.readJSON, writeFile = fs_extra_1.outputJSON) {
+        this.cachePath = cachePath;
+        this.readFile = readFile;
+        this.writeFile = writeFile;
+        this.hits = 0;
+        this.total = 0;
+        this.has = (key) => this.lruStorage.has(key);
+        this.getStats = (name = 'disk-lru-cache') => {
+            const stats = {
+                disposedItems: this.disposed,
+                hitRate: this.total > 0 ? this.hits / this.total : undefined,
+                hits: this.hits,
+                itemCount: this.lruStorage.itemCount,
+                length: this.lruStorage.length,
+                max: this.lruStorage.max,
+                name,
+                total: this.total,
+            };
+            this.hits = 0;
+            this.total = 0;
+            this.disposed = 0;
+            return stats;
+        };
+        this.get = async (key) => {
+            const timeOfDeath = this.lruStorage.get(key);
+            this.total += 1;
+            if (timeOfDeath === undefined) {
+                // if it is an outdated file when stale=false
+                if (this.keyToBeDeleted) {
+                    await this.deleteFile(key);
+                }
+                return undefined;
+            }
+            const pathKey = this.getPathKey(key);
+            const data = await new Promise(resolve => {
+                this.lock.readLock(key, async (release) => {
+                    try {
+                        const fileData = await this.readFile(pathKey);
+                        release();
+                        this.hits += 1;
+                        resolve(fileData);
+                    }
+                    catch (e) {
+                        release();
+                        resolve(undefined);
+                    }
+                });
+            });
+            // if it is an outdated file when stale=true
+            if (timeOfDeath < Date.now()) {
+                this.lruStorage.del(key);
+                await this.deleteFile(key);
+            }
+            return data;
+        };
+        this.set = async (key, value, maxAge) => {
+            let timeOfDeath = NaN;
+            if (maxAge) {
+                timeOfDeath = maxAge + Date.now();
+                this.lruStorage.set(key, timeOfDeath, maxAge);
+            }
+            else {
+                this.lruStorage.set(key, NaN);
+            }
+            if (this.keyToBeDeleted && this.keyToBeDeleted !== key) {
+                await this.deleteFile(this.keyToBeDeleted);
+            }
+            const pathKey = this.getPathKey(key);
+            const failure = await new Promise(resolve => {
+                this.lock.writeLock(key, async (release) => {
+                    try {
+                        const writePromise = await this.writeFile(pathKey, value);
+                        release();
+                        resolve(writePromise);
+                    }
+                    catch (e) {
+                        release();
+                        resolve(true);
+                    }
+                });
+            });
+            return !failure;
+        };
+        this.getPathKey = (key) => {
+            return path_1.join(this.cachePath, key);
+        };
+        this.deleteFile = async (key) => {
+            const pathKey = this.getPathKey(key);
+            this.keyToBeDeleted = '';
+            const failure = new Promise(resolve => {
+                this.lock.writeLock(key, async (release) => {
+                    try {
+                        const removePromise = await fs_extra_1.remove(pathKey);
+                        release();
+                        resolve(removePromise);
+                    }
+                    catch (e) {
+                        release();
+                        resolve(true);
+                    }
+                });
+            });
+            return !failure;
+        };
+        this.hits = 0;
+        this.total = 0;
+        this.disposed = 0;
+        this.keyToBeDeleted = '';
+        this.lock = new rwlock_1.default();
+        const dispose = (key) => {
+            this.keyToBeDeleted = key;
+            this.disposed += 1;
+        };
+        const lruOptions = {
+            ...options,
+            dispose,
+            noDisposeOnSet: true,
+        };
+        this.lruStorage = new lru_cache_1.default(lruOptions);
+    }
+}
+exports.LRUDiskCache = LRUDiskCache;