@vtex/api 6.45.4

package/lib/responses.d.ts

@@ -0,0 +1,79 @@
+import { BillingOptions } from './utils/billingOptions';
+export interface Policy {
+    name: string;
+    attrs?: {
+        [name: string]: string;
+    };
+}
+interface PublicAppManifest {
+    vendor: string;
+    name: string;
+    version: string;
+    title?: string;
+    description?: string;
+    mustUpdateAt?: string;
+    builders: {
+        [name: string]: string;
+    };
+    categories?: string[];
+    dependencies?: {
+        [name: string]: string;
+    };
+    peerDependencies?: {
+        [name: string]: string;
+    };
+    settingsSchema?: any;
+    registries?: string[];
+    credentialType?: string;
+    policies?: Policy[];
+    billingOptions?: BillingOptions;
+}
+export interface AppManifest extends PublicAppManifest {
+    [internal: string]: any;
+    _resolvedDependencies?: {
+        [name: string]: string[];
+    };
+}
+export interface FileListItem {
+    path: string;
+    hash: string;
+}
+export interface AppFilesList {
+    data: FileListItem[];
+}
+export interface BucketMetadata {
+    state: string;
+    lastModified: string;
+    hash: string;
+}
+export interface AppBundleResponse {
+    message: string;
+    id: string;
+}
+export declare type AppBundlePublished = AppBundleResponse & {
+    bundleSize?: number;
+};
+export declare type AppBundleLinked = AppBundleResponse & {
+    bundleSize?: number;
+};
+export declare type AppState = 'stable' | 'releaseCandidate';
+export interface HouseKeeperState {
+    infra: string[];
+    edition: string[];
+    runtimes: string[];
+    apps: Array<{
+        id: string;
+        source: string;
+    }>;
+}
+export interface HouseKeeperUpdates extends HouseKeeperState {
+    editionApps?: {
+        install?: string[];
+        uninstall?: string[];
+    };
+}
+export interface HousekeeperStatesAndUpdates {
+    state: HouseKeeperState;
+    updates: HouseKeeperUpdates;
+}
+export {};

package/lib/responses.js

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

package/lib/service/index.d.ts

@@ -0,0 +1,2 @@
+export declare const startApp: () => void;
+export { appPath } from './loaders';

package/lib/service/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cluster_1 = __importDefault(require("cluster"));
+const constants_1 = require("../constants");
+const loaders_1 = require("./loaders");
+const logger_1 = require("./logger");
+const master_1 = require("./master");
+const worker_1 = require("./worker");
+exports.startApp = () => {
+    const serviceJSON = loaders_1.getServiceJSON();
+    try {
+        // if it is a master process then call setting up worker process
+        if (cluster_1.default.isMaster) {
+            master_1.startMaster(serviceJSON);
+        }
+        else {
+            // to setup server configurations and share port address for incoming requests
+            worker_1.startWorker(serviceJSON).listen(constants_1.HTTP_SERVER_PORT);
+        }
+    }
+    catch (err) {
+        logger_1.logOnceToDevConsole(err.stack || err.message, logger_1.LogLevel.Error);
+        process.exit(2);
+    }
+};
+var loaders_2 = require("./loaders");
+exports.appPath = loaders_2.appPath;

package/lib/service/loaders.d.ts

@@ -0,0 +1,8 @@
+import { IOClients } from '../clients/IOClients';
+import { Service } from './worker/runtime/Service';
+import { ParamsContext, RecorderState, ServiceJSON } from './worker/runtime/typings';
+export declare const appPath: string;
+export declare const bundlePath: string;
+export declare const serviceJsonPath: string;
+export declare const getServiceJSON: () => ServiceJSON;
+export declare const getService: () => Service<IOClients, RecorderState, ParamsContext>;

package/lib/service/loaders.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const os_1 = require("os");
+const path_1 = require("path");
+const IOClients_1 = require("../clients/IOClients");
+const constants_1 = require("../constants");
+exports.appPath = path_1.join(process.cwd(), './service/src/node/');
+exports.bundlePath = path_1.join(exports.appPath, 'index');
+exports.serviceJsonPath = path_1.join(process.cwd(), './service/service.json');
+const getWorkers = (workers) => {
+    // We need to have only one worker while linking so the debugger
+    // works properly
+    if (constants_1.LINKED) {
+        return 1;
+    }
+    // If user didn't set workers property, let's use the cpu count
+    const workersFromUser = workers && Number.isInteger(workers) ? workers : os_1.cpus().length;
+    // never spawns more than MAX_WORKERS
+    return Math.min(workersFromUser, constants_1.MAX_WORKERS);
+};
+exports.getServiceJSON = () => {
+    const service = require(exports.serviceJsonPath);
+    return {
+        ...service,
+        workers: getWorkers(service.workers),
+    };
+};
+const defaultClients = {
+    options: {
+        messages: {
+            concurrency: 10,
+            retries: 2,
+            timeout: 1000,
+        },
+        messagesGraphQL: {
+            concurrency: 10,
+            retries: 2,
+            timeout: 1000,
+        },
+    },
+};
+exports.getService = () => {
+    var _a;
+    const { default: service } = require(exports.bundlePath);
+    const { config: { clients } } = service;
+    service.config.clients = {
+        implementation: (_a = clients === null || clients === void 0 ? void 0 : clients.implementation) !== null && _a !== void 0 ? _a : IOClients_1.IOClients,
+        options: {
+            ...defaultClients.options,
+            ...clients === null || clients === void 0 ? void 0 : clients.options,
+        },
+    };
+    return service;
+};

package/lib/service/logger/console.d.ts

@@ -0,0 +1,10 @@
+import { LogLevel } from './logger';
+export interface LogMessage {
+    cmd: typeof LOG_ONCE;
+    message: string;
+    level: LogLevel;
+}
+export declare const LOG_ONCE = "logOnce";
+export declare const isLog: (message: any) => message is LogMessage;
+export declare const log: (message: any, level: LogLevel) => void;
+export declare const logOnceToDevConsole: (message: any, level: LogLevel) => void;

package/lib/service/logger/console.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cluster_1 = require("cluster");
+const caches_1 = require("../../caches");
+const history = new caches_1.LRUCache({
+    max: 42,
+});
+exports.LOG_ONCE = 'logOnce';
+exports.isLog = (message) => (message === null || message === void 0 ? void 0 : message.cmd) === exports.LOG_ONCE;
+exports.log = (message, level) => {
+    const logger = console[level];
+    if (typeof logger === 'function') {
+        logger(message);
+    }
+};
+// Since we are now using clusters, if we simply console.log something,
+// it may overwhelm the programmer's console with lots of repeated info.
+// This function should be used when you want to warn about something
+// only once
+exports.logOnceToDevConsole = (message, level) => {
+    const strigified = JSON.stringify(message);
+    if (!history.has(strigified)) {
+        history.set(strigified, true);
+        if (cluster_1.isMaster) {
+            exports.log(message, level);
+        }
+        else if (cluster_1.isWorker && process.send) {
+            const logMessage = {
+                cmd: exports.LOG_ONCE,
+                level,
+                message,
+            };
+            process.send(logMessage);
+        }
+    }
+};

package/lib/service/logger/index.d.ts

@@ -0,0 +1,2 @@
+export * from './console';
+export * from './logger';

package/lib/service/logger/index.js

@@ -0,0 +1,7 @@
+"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("./console"));
+__export(require("./logger"));

package/lib/service/logger/logger.d.ts

@@ -0,0 +1,35 @@
+import { IUserLandTracer } from '../../tracing';
+import { IOContext } from '../worker/runtime/typings';
+export interface LoggerTracingContext {
+    requestTracer: IUserLandTracer;
+}
+export declare enum LogLevel {
+    Debug = "debug",
+    Info = "info",
+    Warn = "warn",
+    Error = "error"
+}
+interface LoggerContext extends Pick<IOContext, 'account' | 'workspace' | 'requestId' | 'operationId' | 'production'> {
+    tracer?: IOContext['tracer'];
+}
+export declare class Logger {
+    private account;
+    private workspace;
+    private operationId;
+    private requestId;
+    private production;
+    private tracingState?;
+    constructor(ctx: LoggerContext);
+    debug: (message: any) => void;
+    info: (message: any) => void;
+    warn: (warning: any) => void;
+    error: (error: any) => void;
+    log: (message: any, level: LogLevel) => void;
+    /**
+     * Logs splunk query so the developer can search for the errors in splunk.
+     * This function runs only once in the lifetime of the Logger class so we
+     * don't mess up with the developer's terminal
+     */
+    private logSplunkQuery;
+}
+export {};

package/lib/service/logger/logger.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../constants");
+const error_1 = require("../../utils/error");
+const console_1 = require("./console");
+const linked = !!process.env.VTEX_APP_LINK;
+const app = constants_1.APP.ID;
+const EMPTY_MESSAGE = 'Logger.log was called with null or undefined message';
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["Debug"] = "debug";
+    LogLevel["Info"] = "info";
+    LogLevel["Warn"] = "warn";
+    LogLevel["Error"] = "error";
+})(LogLevel = exports.LogLevel || (exports.LogLevel = {}));
+class Logger {
+    constructor(ctx) {
+        this.debug = (message) => this.log(message, LogLevel.Debug);
+        this.info = (message) => this.log(message, LogLevel.Info);
+        this.warn = (warning) => this.log(warning, LogLevel.Warn);
+        this.error = (error) => this.log(error, LogLevel.Error);
+        this.log = (message, level) => {
+            var _a;
+            const data = message ? error_1.cleanError(message) : EMPTY_MESSAGE;
+            /* tslint:disable:object-literal-sort-keys */
+            const inflatedLog = {
+                __VTEX_IO_LOG: true,
+                level,
+                app,
+                account: this.account,
+                workspace: this.workspace,
+                production: this.production,
+                data,
+                operationId: this.operationId,
+                requestId: this.requestId,
+                ...(((_a = this.tracingState) === null || _a === void 0 ? void 0 : _a.isTraceSampled) ? { traceId: this.tracingState.traceId } : null),
+            };
+            // Mark third-party apps logs to send to skidder
+            if (constants_1.APP.IS_THIRD_PARTY()) {
+                Object.assign(inflatedLog, {
+                    __SKIDDER_TOPIC_1: `skidder.vendor.${constants_1.APP.VENDOR}`,
+                    __SKIDDER_TOPIC_2: `skidder.app.${constants_1.APP.VENDOR}.${constants_1.APP.NAME}`,
+                });
+            }
+            console.log(JSON.stringify(inflatedLog));
+            // Warn the developer how to retrieve the error in splunk
+            this.logSplunkQuery();
+        };
+        /**
+         * Logs splunk query so the developer can search for the errors in splunk.
+         * This function runs only once in the lifetime of the Logger class so we
+         * don't mess up with the developer's terminal
+         */
+        this.logSplunkQuery = () => {
+            if (linked) {
+                const message = `Try this query at Splunk to retrieve error log: 'index=io_vtex_logs app="${app}" account=${this.account} workspace=${this.workspace} level=error OR level=warn'`;
+                console_1.logOnceToDevConsole(message, LogLevel.Info);
+            }
+        };
+        this.account = ctx.account;
+        this.workspace = ctx.workspace;
+        this.requestId = ctx.requestId;
+        this.operationId = ctx.operationId;
+        this.production = ctx.production;
+        if (ctx.tracer) {
+            this.tracingState = {
+                isTraceSampled: ctx.tracer.isTraceSampled,
+                traceId: ctx.tracer.traceId,
+            };
+        }
+    }
+}
+exports.Logger = Logger;

package/lib/service/logger/metricsLogger.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="node" />
+interface ProcessEnv {
+    appName: string;
+    appVersion: string;
+    region: string;
+    vendor: string;
+    production: boolean;
+}
+interface Key {
+    name: string;
+}
+interface Metric {
+    Count: number;
+    Data: {
+        key: Key;
+        processEnv: ProcessEnv;
+        summary: NumericSummary | NodeJS.MemoryUsage | NodeJS.CpuUsage;
+    };
+    Max: number;
+    Min: number;
+    Name: string;
+    Sum: number;
+    Timestamp: number;
+    Unit: string;
+}
+interface NumericSummary {
+    count: number;
+    max: number;
+    median: number;
+    min: number;
+    percentile95: number;
+    percentile99: number;
+    sum: number;
+}
+export declare class MetricsLogger {
+    add: (key: Key, value: number) => void;
+    getSummaries: () => Metric[];
+    constructor();
+}
+export {};

package/lib/service/logger/metricsLogger.js

@@ -0,0 +1,149 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fast_json_stable_stringify_1 = __importDefault(require("fast-json-stable-stringify"));
+const ramda_1 = require("ramda");
+const stats_lite_1 = require("stats-lite");
+const constants_1 = require("../../constants");
+const diff_1 = require("../worker/runtime/utils/diff");
+const runtimeBaseDefaultMetricNames = ['routeStats'];
+const runtimeNodeDefaultMetricNames = {
+    cpuUsage: 'cpuUsage',
+    memoryUsage: 'memoryUsage',
+};
+const invalidMetricNames = runtimeBaseDefaultMetricNames.concat(Object.values(runtimeNodeDefaultMetricNames));
+class MetricsLogger {
+    constructor() {
+        //////////////////////
+        // private attributes
+        //////////////////////
+        let samples = {};
+        let lastCpu = diff_1.cpuSnapshot();
+        //////////////////////
+        // private methods definitions
+        //////////////////////
+        const summaries = ramda_1.compose(ramda_1.reject(ramda_1.isNil), ramda_1.values, ramda_1.mapObjIndexed(getSummary));
+        function getDefaultStoredashProperties() {
+            return {
+                Count: 1,
+                Max: 0,
+                Min: 0,
+                Name: 'runtime',
+                Sum: 0,
+                Timestamp: (new Date()).getTime(),
+                Unit: '',
+            };
+        }
+        function getProcessEnv() {
+            return {
+                appName: process.env.VTEX_APP_NAME || '',
+                appVersion: process.env.VTEX_APP_VERSION || '',
+                production: constants_1.PRODUCTION,
+                region: process.env.VTEX_REGION || '',
+                vendor: process.env.VTEX_APP_VENDOR || '',
+            };
+        }
+        function getCpuUsage() {
+            const cpu = diff_1.cpuSnapshot();
+            const cpuDiff = diff_1.snapshotDiff(cpu, lastCpu);
+            lastCpu = cpu;
+            const metric = {
+                Data: {
+                    key: {
+                        name: runtimeNodeDefaultMetricNames.cpuUsage,
+                    },
+                    processEnv: getProcessEnv(),
+                    summary: cpuDiff,
+                },
+                ...getDefaultStoredashProperties(),
+            };
+            return metric;
+        }
+        function getMemoryUsage() {
+            const metric = {
+                Data: {
+                    key: {
+                        name: runtimeNodeDefaultMetricNames.memoryUsage,
+                    },
+                    processEnv: getProcessEnv(),
+                    summary: process.memoryUsage(),
+                },
+                ...getDefaultStoredashProperties(),
+            };
+            return metric;
+        }
+        function getRuntimeSummaries() {
+            return [getCpuUsage(), getMemoryUsage()];
+        }
+        function getSummary(vals, strKey) {
+            if (strKey in samples) {
+                const summary = getNumericSummary(vals);
+                const keyObj = JSON.parse(strKey);
+                const metric = {
+                    Data: {
+                        key: keyObj,
+                        processEnv: getProcessEnv(),
+                        summary,
+                    },
+                    ...getDefaultStoredashProperties(),
+                };
+                return metric;
+            }
+            return null;
+        }
+        // TODO: create some kind of alert/log if metric is not valid
+        function validKey(key) {
+            if (!('name' in key)) {
+                return false;
+            }
+            if (invalidMetricNames.includes(key.name)) {
+                return false;
+            }
+            try {
+                fast_json_stable_stringify_1.default(key);
+            }
+            catch {
+                return false;
+            }
+            return true;
+        }
+        function getStrKey(key) {
+            return fast_json_stable_stringify_1.default(key);
+        }
+        function getNumericSummary(vals) {
+            return {
+                count: vals.length,
+                max: Math.max(...vals),
+                median: stats_lite_1.median(vals),
+                min: Math.min(...vals),
+                percentile95: stats_lite_1.percentile(vals, 0.95),
+                percentile99: stats_lite_1.percentile(vals, 0.99),
+                sum: stats_lite_1.sum(vals),
+            };
+        }
+        //////////////////////
+        // public methods definitions
+        //////////////////////
+        this.add = (key, value) => {
+            if (validKey(key)) {
+                const strKey = getStrKey(key);
+                if (!(strKey in samples)) {
+                    samples[strKey] = [];
+                }
+                samples[strKey].push(value);
+            }
+        };
+        this.getSummaries = () => {
+            const appSummaries = summaries(samples);
+            samples = {};
+            const runtimeSummaries = getRuntimeSummaries();
+            return runtimeSummaries.concat(appSummaries);
+        };
+        //////////////////////
+        // real constructor
+        //////////////////////
+    }
+}
+exports.MetricsLogger = MetricsLogger;