@vtex/api 6.45.4

package/lib/errors/NotFoundError.d.ts

@@ -0,0 +1,18 @@
+import { AxiosError } from 'axios';
+import { ErrorLike } from './ResolverError';
+import { ResolverWarning } from './ResolverWarning';
+/**
+ * Indicates a requested resource was not found.
+ * ResolverWarnings are logged with level "warning" denoting they were handled by user code.
+ *
+ * @class NotFoundError
+ * @extends {ResolverWarning}
+ */
+export declare class NotFoundError extends ResolverWarning {
+    name: string;
+    /**
+     * Creates an instance of NotFoundError
+     * @param {(string | AxiosError | ErrorLike)} messageOrError Either a message string or the complete original error object.
+     */
+    constructor(messageOrError: string | AxiosError | ErrorLike);
+}

package/lib/errors/NotFoundError.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ResolverWarning_1 = require("./ResolverWarning");
+/**
+ * Indicates a requested resource was not found.
+ * ResolverWarnings are logged with level "warning" denoting they were handled by user code.
+ *
+ * @class NotFoundError
+ * @extends {ResolverWarning}
+ */
+class NotFoundError extends ResolverWarning_1.ResolverWarning {
+    /**
+     * Creates an instance of NotFoundError
+     * @param {(string | AxiosError | ErrorLike)} messageOrError Either a message string or the complete original error object.
+     */
+    constructor(messageOrError) {
+        super(messageOrError, 404, 'NOT_FOUND');
+        this.name = 'NotFoundError';
+        if (typeof messageOrError === 'string' || !messageOrError.stack) {
+            Error.captureStackTrace(this, NotFoundError);
+        }
+    }
+}
+exports.NotFoundError = NotFoundError;

package/lib/errors/RequestCancelledError.d.ts

@@ -0,0 +1,6 @@
+export declare const cancelledRequestStatus = 499;
+export declare const cancelledErrorCode = "request_cancelled";
+export declare class RequestCancelledError extends Error {
+    code: string;
+    constructor(message: string);
+}

package/lib/errors/RequestCancelledError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cancelledRequestStatus = 499;
+exports.cancelledErrorCode = 'request_cancelled';
+class RequestCancelledError extends Error {
+    constructor(message) {
+        super(message);
+        this.code = exports.cancelledErrorCode;
+    }
+}
+exports.RequestCancelledError = RequestCancelledError;

package/lib/errors/ResolverError.d.ts

@@ -0,0 +1,29 @@
+import { AxiosError } from 'axios';
+import { LogLevel } from '../service/logger';
+export interface ErrorLike {
+    name?: string;
+    message: string;
+    stack?: string;
+    [key: string]: any;
+}
+/**
+ * The generic Error class to be thrown for caught errors inside resolvers.
+ * Errors with status code greater than or equal to 500 are logged as errors.
+ * All other status codes are logged as warnings. @see ResolverWarning
+ *
+ * @class ResolverError
+ * @extends {Error}
+ */
+export declare class ResolverError extends Error {
+    status: number;
+    code: string;
+    name: string;
+    level: LogLevel;
+    /**
+     * Creates an instance of ResolverError
+     * @param {(string | AxiosError | ErrorLike)} messageOrError Either a message string or the complete original error object.
+     * @param {number} [status=500]
+     * @param {string} [code='RESOLVER_ERROR']
+     */
+    constructor(messageOrError: string | AxiosError | ErrorLike, status?: number, code?: string);
+}

package/lib/errors/ResolverError.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("../service/logger");
+const error_1 = require("../utils/error");
+/**
+ * The generic Error class to be thrown for caught errors inside resolvers.
+ * Errors with status code greater than or equal to 500 are logged as errors.
+ * All other status codes are logged as warnings. @see ResolverWarning
+ *
+ * @class ResolverError
+ * @extends {Error}
+ */
+class ResolverError extends Error {
+    /**
+     * Creates an instance of ResolverError
+     * @param {(string | AxiosError | ErrorLike)} messageOrError Either a message string or the complete original error object.
+     * @param {number} [status=500]
+     * @param {string} [code='RESOLVER_ERROR']
+     */
+    constructor(messageOrError, status = 500, code = 'RESOLVER_ERROR') {
+        super(typeof messageOrError === 'string' ? messageOrError : messageOrError.message);
+        this.status = status;
+        this.code = code;
+        this.name = 'ResolverError';
+        this.level = logger_1.LogLevel.Error;
+        if (typeof messageOrError === 'object') {
+            // Copy original error properties without circular references
+            Object.assign(this, error_1.cleanError(messageOrError));
+        }
+        if (typeof messageOrError === 'string' || !messageOrError.stack) {
+            Error.captureStackTrace(this, ResolverError);
+        }
+    }
+}
+exports.ResolverError = ResolverError;

package/lib/errors/ResolverWarning.d.ts

@@ -0,0 +1,21 @@
+import { AxiosError } from 'axios';
+import { LogLevel } from '../service/logger';
+import { ErrorLike, ResolverError } from './ResolverError';
+/**
+ * Indicates a non-fatal error occurred and was handled.
+ * ResolverWarnings are logged with level "warning" denoting they were handled by user code.
+ *
+ * @class ResolverWarning
+ * @extends {ResolverError}
+ */
+export declare class ResolverWarning extends ResolverError {
+    status: number;
+    code: string;
+    name: string;
+    level: LogLevel;
+    /**
+     * Creates an instance of ResolverWarning
+     * @param {(string | AxiosError | ErrorLike)} messageOrError Either a message string or the complete original error object.
+     */
+    constructor(messageOrError: string | AxiosError | ErrorLike, status?: number, code?: string);
+}

package/lib/errors/ResolverWarning.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("../service/logger");
+const ResolverError_1 = require("./ResolverError");
+/**
+ * Indicates a non-fatal error occurred and was handled.
+ * ResolverWarnings are logged with level "warning" denoting they were handled by user code.
+ *
+ * @class ResolverWarning
+ * @extends {ResolverError}
+ */
+class ResolverWarning extends ResolverError_1.ResolverError {
+    /**
+     * Creates an instance of ResolverWarning
+     * @param {(string | AxiosError | ErrorLike)} messageOrError Either a message string or the complete original error object.
+     */
+    constructor(messageOrError, status = 422, code = 'RESOLVER_WARNING') {
+        super(messageOrError, status, code);
+        this.status = status;
+        this.code = code;
+        this.name = 'ResolverWarning';
+        this.level = logger_1.LogLevel.Warn;
+        if (typeof messageOrError === 'string' || !messageOrError.stack) {
+            Error.captureStackTrace(this, ResolverWarning);
+        }
+    }
+}
+exports.ResolverWarning = ResolverWarning;

package/lib/errors/TooManyRequestsError.d.ts

@@ -0,0 +1,4 @@
+export declare const tooManyRequestsStatus = 429;
+export declare class TooManyRequestsError extends Error {
+    constructor(message?: string);
+}

package/lib/errors/TooManyRequestsError.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tooManyRequestsStatus = 429;
+class TooManyRequestsError extends Error {
+    constructor(message) {
+        super(message || 'TOO_MANY_REQUESTS');
+    }
+}
+exports.TooManyRequestsError = TooManyRequestsError;

package/lib/errors/UserInputError.d.ts

@@ -0,0 +1,18 @@
+import { AxiosError } from 'axios';
+import { ErrorLike } from './ResolverError';
+import { ResolverWarning } from './ResolverWarning';
+/**
+ * Indicates user input is not valid for this action.
+ * ResolverWarnings are logged with level "warning" denoting they were handled by user code.
+ *
+ * @class UserInputError
+ * @extends {ResolverWarning}
+ */
+export declare class UserInputError extends ResolverWarning {
+    name: string;
+    /**
+     * Creates an instance of UserInputError
+     * @param {(string | AxiosError | ErrorLike)} messageOrError Either a message string or the complete original error object.
+     */
+    constructor(messageOrError: string | AxiosError | ErrorLike);
+}

package/lib/errors/UserInputError.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ResolverWarning_1 = require("./ResolverWarning");
+/**
+ * Indicates user input is not valid for this action.
+ * ResolverWarnings are logged with level "warning" denoting they were handled by user code.
+ *
+ * @class UserInputError
+ * @extends {ResolverWarning}
+ */
+class UserInputError extends ResolverWarning_1.ResolverWarning {
+    /**
+     * Creates an instance of UserInputError
+     * @param {(string | AxiosError | ErrorLike)} messageOrError Either a message string or the complete original error object.
+     */
+    constructor(messageOrError) {
+        super(messageOrError, 400, 'BAD_USER_INPUT');
+        this.name = 'UserInputError';
+        if (typeof messageOrError === 'string' || !messageOrError.stack) {
+            Error.captureStackTrace(this, UserInputError);
+        }
+    }
+}
+exports.UserInputError = UserInputError;

package/lib/errors/customGraphQLError.d.ts

@@ -0,0 +1,4 @@
+export default class CustomGraphQLError extends Error {
+    graphQLErrors: any;
+    constructor(message: string, graphQLErrors: any[]);
+}

package/lib/errors/customGraphQLError.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CustomGraphQLError extends Error {
+    constructor(message, graphQLErrors) {
+        super(message);
+        this.graphQLErrors = graphQLErrors;
+    }
+}
+exports.default = CustomGraphQLError;

package/lib/errors/index.d.ts

@@ -0,0 +1,8 @@
+export * from './AuthenticationError';
+export * from './ForbiddenError';
+export * from './NotFoundError';
+export * from './ResolverError';
+export * from './ResolverWarning';
+export * from './UserInputError';
+export * from './RequestCancelledError';
+export * from './TooManyRequestsError';

package/lib/errors/index.js

@@ -0,0 +1,13 @@
+"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("./AuthenticationError"));
+__export(require("./ForbiddenError"));
+__export(require("./NotFoundError"));
+__export(require("./ResolverError"));
+__export(require("./ResolverWarning"));
+__export(require("./UserInputError"));
+__export(require("./RequestCancelledError"));
+__export(require("./TooManyRequestsError"));

package/lib/index.d.ts

@@ -0,0 +1,17 @@
+export * from './caches';
+export * from './clients';
+export * from './errors';
+export * from './HttpClient';
+export * from './metrics/MetricsAccumulator';
+export * from './responses';
+export * from './service/worker/runtime/Service';
+export * from './service/worker/runtime/method';
+export * from './service/worker/runtime/typings';
+export * from './service/worker/runtime/graphql/schema/schemaDirectives';
+export * from './service/worker/runtime/graphql/schema/messagesLoaderV2';
+export * from './service/worker/runtime/utils/recorder';
+export * from './service';
+export * from './service/logger';
+export * from './utils';
+export * from './constants';
+export * from './tracing';

package/lib/index.js

@@ -0,0 +1,21 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+process.env.FORCE_COLOR = '1';
+__export(require("./caches"));
+__export(require("./clients"));
+__export(require("./errors"));
+__export(require("./HttpClient"));
+__export(require("./metrics/MetricsAccumulator"));
+__export(require("./service/worker/runtime/Service"));
+__export(require("./service/worker/runtime/method"));
+__export(require("./service/worker/runtime/graphql/schema/schemaDirectives"));
+__export(require("./service/worker/runtime/graphql/schema/messagesLoaderV2"));
+__export(require("./service/worker/runtime/utils/recorder"));
+__export(require("./service"));
+__export(require("./service/logger"));
+__export(require("./utils"));
+__export(require("./constants"));
+__export(require("./tracing"));

package/lib/metrics/MetricsAccumulator.d.ts

@@ -0,0 +1,35 @@
+import { EnvMetric } from '../service/worker/runtime/statusTrack';
+export interface Metric {
+    name: string;
+    [key: string]: number | string | null;
+}
+interface GetStats {
+    getStats(): {
+        [key: string]: number | boolean | string | undefined;
+    };
+}
+export declare class MetricsAccumulator {
+    private metricsMillis;
+    private extensions;
+    private cacheMap;
+    private onFlushMetrics;
+    constructor();
+    batchMetric: (name: string, timeMillis?: number | undefined, extensions?: Record<string, string | number> | undefined) => void;
+    /**
+     * Batches a named metric which took `diffNs`.
+     *
+     * @param name Metric label.
+     * @param diffNs The result of calling process.hrtime() passing a previous process.hrtime() value.
+     * @param extensions Any other relevant properties of this metric.
+     *
+     * @see https://nodejs.org/api/process.html#process_process_hrtime_time
+     */
+    batch: (name: string, diffNs?: [number, number] | undefined, extensions?: Record<string, string | number> | undefined) => void;
+    addOnFlushMetric: (metricFn: () => Metric | Metric[]) => void;
+    trackCache: (name: string, cacheInstance: GetStats) => void;
+    statusTrack: () => EnvMetric[];
+    private metricToAggregate;
+    private cacheToMetric;
+    private flushMetrics;
+}
+export {};

package/lib/metrics/MetricsAccumulator.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ramda_1 = require("ramda");
+const stats_lite_1 = require("stats-lite");
+const HttpAgentSingleton_1 = require("../HttpClient/middlewares/request/HttpAgentSingleton");
+const requestStats_1 = require("../service/worker/runtime/http/middlewares/requestStats");
+const time_1 = require("../utils/time");
+// Production pods never handle development workspaces and vice-versa.
+const production = process.env.VTEX_PRODUCTION === 'true';
+let lastCpu = process.cpuUsage();
+function cpuUsage() {
+    const diff = process.cpuUsage(lastCpu);
+    lastCpu = {
+        system: lastCpu.system + diff.system,
+        user: lastCpu.user + diff.user,
+    };
+    return diff;
+}
+function getIncomingRequestStats() {
+    const stats = requestStats_1.incomingRequestStats.get();
+    requestStats_1.incomingRequestStats.clear();
+    return stats;
+}
+class MetricsAccumulator {
+    constructor() {
+        this.batchMetric = (name, timeMillis, extensions) => {
+            if (!this.metricsMillis[name]) {
+                this.metricsMillis[name] = [];
+            }
+            if (timeMillis != null) {
+                this.metricsMillis[name].push(timeMillis);
+            }
+            if (extensions) {
+                if (!this.extensions[name]) {
+                    this.extensions[name] = {};
+                }
+                for (const [key, value] of Object.entries(extensions)) {
+                    const existing = this.extensions[name][key];
+                    if (typeof value === 'string' || typeof existing === 'string') {
+                        this.extensions[name][key] = value;
+                    }
+                    else if (typeof value === 'number') {
+                        this.extensions[name][key] = (existing || 0) + value;
+                    }
+                }
+            }
+        };
+        /**
+         * Batches a named metric which took `diffNs`.
+         *
+         * @param name Metric label.
+         * @param diffNs The result of calling process.hrtime() passing a previous process.hrtime() value.
+         * @param extensions Any other relevant properties of this metric.
+         *
+         * @see https://nodejs.org/api/process.html#process_process_hrtime_time
+         */
+        this.batch = (name, diffNs, extensions) => {
+            this.batchMetric(name, diffNs ? time_1.hrToMillis(diffNs) : undefined, extensions);
+        };
+        this.addOnFlushMetric = (metricFn) => {
+            this.onFlushMetrics.push(metricFn);
+        };
+        this.trackCache = (name, cacheInstance) => {
+            this.cacheMap[name] = cacheInstance;
+        };
+        this.statusTrack = () => {
+            return this.flushMetrics();
+        };
+        this.metricToAggregate = (value, key) => {
+            const aggregate = {
+                name: key,
+                count: value.length,
+                max: Math.max(...value),
+                mean: stats_lite_1.mean(value),
+                median: stats_lite_1.median(value),
+                percentile95: stats_lite_1.percentile(value, 0.95),
+                percentile99: stats_lite_1.percentile(value, 0.99),
+                production,
+                ...this.extensions[key],
+            };
+            delete this.metricsMillis[key];
+            delete this.extensions[key];
+            return aggregate;
+        };
+        this.cacheToMetric = (value, key) => ({
+            ...value.getStats(),
+            name: `${key}-cache`,
+            production,
+        });
+        this.flushMetrics = () => {
+            const aggregateMetrics = ramda_1.values(ramda_1.mapObjIndexed(this.metricToAggregate, this.metricsMillis));
+            const systemMetrics = [
+                {
+                    ...cpuUsage(),
+                    name: 'cpu',
+                    production,
+                },
+                {
+                    ...process.memoryUsage(),
+                    name: 'memory',
+                    production,
+                },
+                {
+                    ...HttpAgentSingleton_1.HttpAgentSingleton.httpAgentStats(),
+                    name: 'httpAgent',
+                    production,
+                },
+                {
+                    ...getIncomingRequestStats(),
+                    name: 'incomingRequest',
+                    production,
+                },
+            ];
+            const onFlushMetrics = ramda_1.flatten(ramda_1.map(getMetric => getMetric(), this.onFlushMetrics));
+            const envFlushMetric = ramda_1.map(ramda_1.assoc('production', production), onFlushMetrics);
+            const cacheMetrics = ramda_1.values(ramda_1.mapObjIndexed(this.cacheToMetric, this.cacheMap));
+            return [...systemMetrics, ...aggregateMetrics, ...envFlushMetric, ...cacheMetrics];
+        };
+        this.metricsMillis = {};
+        this.extensions = {};
+        this.onFlushMetrics = [];
+        this.cacheMap = {};
+    }
+}
+exports.MetricsAccumulator = MetricsAccumulator;