@vtex/api 6.45.4

package/lib/clients/janus/Segment.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cookie_1 = __importDefault(require("cookie"));
+const ramda_1 = require("ramda");
+const constants_1 = require("../../constants");
+const HttpClient_1 = require("../../HttpClient");
+const JanusClient_1 = require("./JanusClient");
+const SEGMENT_COOKIE = 'vtex_segment';
+const SEGMENT_MAX_AGE_S = 60 * 60; // 60 minutes - segment is actually immutable
+const ALLOWED_QUERY_PREFIXES = ['utm', 'cultureInfo', 'supportedLocales', '__bindingId'];
+const filterAndSortQuery = (query) => {
+    if (!query) {
+        return null;
+    }
+    const filteredKeys = Object.keys(query)
+        .filter((k) => !!k && ALLOWED_QUERY_PREFIXES.some((prefix) => k.startsWith(prefix)))
+        .sort();
+    return filteredKeys.reduce((acc, val) => {
+        acc[val] = query[val];
+        return acc;
+    }, {});
+};
+const routes = {
+    base: '/api/segments',
+    segments: (token) => token ? `${routes.base}/${token}` : routes.base,
+};
+class Segment extends JanusClient_1.JanusClient {
+    constructor() {
+        super(...arguments);
+        /**
+         * Get the segment data using the current `ctx.vtex.segmentToken`
+         *
+         * @memberof Segment
+         */
+        this.getSegment = (tracingConfig) => this.rawSegment(this.context.segmentToken, undefined, tracingConfig).then(ramda_1.prop('data'));
+        /**
+         * Get the segment data from this specific segment token
+         *
+         * @memberof Segment
+         */
+        this.getSegmentByToken = (token, tracingConfig) => this.rawSegment(token, undefined, tracingConfig).then(ramda_1.prop('data'));
+        this.getOrCreateSegment = async (query, token, tracingConfig) => {
+            const { data: segmentData, headers: { 'set-cookie': [setCookies], }, } = await this.rawSegment(token, query, tracingConfig);
+            const parsedCookie = cookie_1.default.parse(setCookies);
+            const segmentToken = ramda_1.prop(SEGMENT_COOKIE, parsedCookie);
+            return {
+                segmentData,
+                segmentToken,
+            };
+        };
+        this.rawSegment = (token, query, tracingConfig) => {
+            const { product, workspace } = this.context;
+            const filteredQuery = filterAndSortQuery(query);
+            const metric = token ? 'segment-get-token' : 'segment-get-new';
+            return this.http.getRaw(routes.segments(token), ({
+                forceMaxAge: SEGMENT_MAX_AGE_S,
+                headers: {
+                    'Content-Type': 'application/json',
+                    [constants_1.PRODUCT_HEADER]: product || '',
+                },
+                inflightKey: HttpClient_1.inflightUrlWithQuery,
+                metric,
+                params: {
+                    ...filteredQuery,
+                    session_path: product || '',
+                    workspace,
+                },
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            }));
+        };
+    }
+}
+exports.Segment = Segment;

package/lib/clients/janus/Session.d.ts

@@ -0,0 +1,15 @@
+import { RequestTracingConfig } from '../../HttpClient';
+import { JanusClient } from './JanusClient';
+export declare class Session extends JanusClient {
+    /**
+     * Get the session data using the given token
+     */
+    getSession: (token: string, items: string[], tracingConfig?: RequestTracingConfig | undefined) => Promise<{
+        sessionData: any;
+        sessionToken: string;
+    }>;
+    /**
+     * Update the public portion of this session
+     */
+    updateSession: (key: string, value: any, items: string[], token: any, tracingConfig?: RequestTracingConfig | undefined) => Promise<void>;
+}

package/lib/clients/janus/Session.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cookie_1 = __importDefault(require("cookie"));
+const JanusClient_1 = require("./JanusClient");
+const SESSION_COOKIE = 'vtex_session';
+const routes = {
+    base: '/api/sessions',
+};
+class Session extends JanusClient_1.JanusClient {
+    constructor() {
+        super(...arguments);
+        /**
+         * Get the session data using the given token
+         */
+        this.getSession = async (token, items, tracingConfig) => {
+            var _a;
+            const metric = 'session-get';
+            const { data: sessionData, headers } = await this.http.getRaw(routes.base, {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Cookie': `vtex_session=${token};`,
+                },
+                metric,
+                params: {
+                    items: items.join(','),
+                },
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+            return {
+                sessionData,
+                sessionToken: (_a = extractSessionCookie(headers)) !== null && _a !== void 0 ? _a : token,
+            };
+        };
+        /**
+         * Update the public portion of this session
+         */
+        this.updateSession = (key, value, items, token, tracingConfig) => {
+            const data = { public: { [key]: { value } } };
+            const metric = 'session-update';
+            const config = {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Cookie': `vtex_session=${token};`,
+                },
+                metric,
+                params: {
+                    items: items.join(','),
+                },
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            };
+            return this.http.post(routes.base, data, config);
+        };
+    }
+}
+exports.Session = Session;
+function extractSessionCookie(headers) {
+    var _a;
+    for (const setCookie of (_a = headers['set-cookie']) !== null && _a !== void 0 ? _a : []) {
+        const parsedCookie = cookie_1.default.parse(setCookie);
+        const sessionCookie = parsedCookie[SESSION_COOKIE];
+        if (sessionCookie != null) {
+            return sessionCookie;
+        }
+    }
+    return null;
+}

package/lib/clients/janus/Tenant.d.ts

@@ -0,0 +1,29 @@
+import { InstanceOptions, RequestConfig } from '../../HttpClient/typings';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { JanusClient } from './JanusClient';
+export interface Binding {
+    id: string;
+    canonicalBaseAddress: string;
+    alternateBaseAddresses: string[];
+    defaultLocale: string;
+    supportedLocales: string[];
+    defaultCurrency: string;
+    supportedCurrencies: string[];
+    extraContext: Record<string, any>;
+    targetProduct: string;
+}
+export interface Tenant {
+    id: string;
+    slug: string;
+    title: string;
+    edition: string;
+    infra: string;
+    bindings: Binding[];
+    defaultCurrency: string;
+    defaultLocale: string;
+    metadata: Record<string, string>;
+}
+export declare class TenantClient extends JanusClient {
+    constructor(ctx: IOContext, opts?: InstanceOptions);
+    info: (config?: RequestConfig | undefined) => Promise<Tenant>;
+}

package/lib/clients/janus/Tenant.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const HttpClient_1 = require("../../HttpClient");
+const JanusClient_1 = require("./JanusClient");
+class TenantClient extends JanusClient_1.JanusClient {
+    constructor(ctx, opts) {
+        super(ctx, {
+            ...opts,
+            params: {
+                q: ctx.account,
+            },
+        });
+        this.info = (config) => {
+            const metric = 'get-tenant-info';
+            return this.http.get('/api/tenant/tenants', {
+                inflightKey: HttpClient_1.inflightUrlWithQuery,
+                memoizeable: true,
+                metric,
+                ...config,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...config === null || config === void 0 ? void 0 : config.tracing,
+                },
+            });
+        };
+    }
+}
+exports.TenantClient = TenantClient;

package/lib/clients/janus/index.d.ts

@@ -0,0 +1,5 @@
+export * from './JanusClient';
+export * from './LicenseManager';
+export * from './Segment';
+export * from './Session';
+export * from './Tenant';

package/lib/clients/janus/index.js

@@ -0,0 +1,10 @@
+"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("./JanusClient"));
+__export(require("./LicenseManager"));
+__export(require("./Segment"));
+__export(require("./Session"));
+__export(require("./Tenant"));

package/lib/constants.d.ts

@@ -0,0 +1,59 @@
+export declare const NODE_VTEX_API_VERSION: any;
+export declare const DEFAULT_WORKSPACE = "master";
+export declare const IS_IO: string | undefined;
+export declare const PID: number;
+export declare const CACHE_CONTROL_HEADER = "cache-control";
+export declare const SEGMENT_HEADER = "x-vtex-segment";
+export declare const SESSION_HEADER = "x-vtex-session";
+export declare const PRODUCT_HEADER = "x-vtex-product";
+export declare const LOCALE_HEADER = "x-vtex-locale";
+export declare const FORWARDED_HOST_HEADER = "x-forwarded-host";
+export declare const TENANT_HEADER = "x-vtex-tenant";
+export declare const BINDING_HEADER = "x-vtex-binding";
+export declare const META_HEADER = "x-vtex-meta";
+export declare const META_HEADER_BUCKET = "x-vtex-meta-bucket";
+export declare const ETAG_HEADER = "etag";
+export declare const ACCOUNT_HEADER = "x-vtex-account";
+export declare const CREDENTIAL_HEADER = "x-vtex-credential";
+export declare const REQUEST_ID_HEADER = "x-request-id";
+export declare const ROUTER_CACHE_HEADER = "x-router-cache";
+export declare const OPERATION_ID_HEADER = "x-vtex-operation-id";
+export declare const PLATFORM_HEADER = "x-vtex-platform";
+export declare const WORKSPACE_IS_PRODUCTION_HEADER = "x-vtex-workspace-is-production";
+export declare const WORKSPACE_HEADER = "x-vtex-workspace";
+export declare const EVENT_KEY_HEADER = "x-event-key";
+export declare const EVENT_SENDER_HEADER = "x-event-sender";
+export declare const EVENT_SUBJECT_HEADER = "x-event-subject";
+export declare const EVENT_HANDLER_ID_HEADER = "x-event-handler-id";
+export declare const COLOSSUS_ROUTE_DECLARER_HEADER = "x-colossus-route-declarer";
+export declare const COLOSSUS_ROUTE_ID_HEADER = "x-colossus-route-id";
+export declare const COLOSSUS_PARAMS_HEADER = "x-colossus-params";
+export declare const TRACE_ID_HEADER = "x-trace-id";
+export declare const PROVIDER_HEADER = "x-vtex-provider";
+export declare type VaryHeaders = typeof SEGMENT_HEADER | typeof SESSION_HEADER | typeof PRODUCT_HEADER | typeof LOCALE_HEADER;
+export declare const BODY_HASH = "__graphqlBodyHash";
+export declare const UP_SIGNAL = "UP";
+export declare const MAX_AGE: {
+    LONG: number;
+    MEDIUM: number;
+    SHORT: number;
+};
+export declare const HTTP_SERVER_PORT = 5050;
+export declare const MAX_WORKERS = 4;
+export declare const LINKED: boolean;
+export declare const REGION: string;
+export declare const PUBLIC_ENDPOINT: string;
+export declare const APP: {
+    ID: string;
+    MAJOR: string;
+    NAME: string;
+    VENDOR: string;
+    VERSION: string;
+    IS_THIRD_PARTY(): boolean;
+};
+export declare const NODE_ENV: string;
+export declare const ACCOUNT: string;
+export declare const WORKSPACE: string;
+export declare const PRODUCTION: boolean;
+export declare const INSPECT_DEBUGGER_PORT = 5858;
+export declare const cancellableMethods: Set<string>;

package/lib/constants.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const app_1 = require("./utils/app");
+// tslint:disable-next-line
+const pkg = require('../package.json');
+exports.NODE_VTEX_API_VERSION = pkg.version;
+exports.DEFAULT_WORKSPACE = 'master';
+exports.IS_IO = process.env.VTEX_IO;
+exports.PID = process.pid;
+exports.CACHE_CONTROL_HEADER = 'cache-control';
+exports.SEGMENT_HEADER = 'x-vtex-segment';
+exports.SESSION_HEADER = 'x-vtex-session';
+exports.PRODUCT_HEADER = 'x-vtex-product';
+exports.LOCALE_HEADER = 'x-vtex-locale';
+exports.FORWARDED_HOST_HEADER = 'x-forwarded-host';
+exports.TENANT_HEADER = 'x-vtex-tenant';
+exports.BINDING_HEADER = 'x-vtex-binding';
+exports.META_HEADER = 'x-vtex-meta';
+exports.META_HEADER_BUCKET = 'x-vtex-meta-bucket';
+exports.ETAG_HEADER = 'etag';
+exports.ACCOUNT_HEADER = 'x-vtex-account';
+exports.CREDENTIAL_HEADER = 'x-vtex-credential';
+exports.REQUEST_ID_HEADER = 'x-request-id';
+exports.ROUTER_CACHE_HEADER = 'x-router-cache';
+exports.OPERATION_ID_HEADER = 'x-vtex-operation-id';
+exports.PLATFORM_HEADER = 'x-vtex-platform';
+exports.WORKSPACE_IS_PRODUCTION_HEADER = 'x-vtex-workspace-is-production';
+exports.WORKSPACE_HEADER = 'x-vtex-workspace';
+exports.EVENT_KEY_HEADER = 'x-event-key';
+exports.EVENT_SENDER_HEADER = 'x-event-sender';
+exports.EVENT_SUBJECT_HEADER = 'x-event-subject';
+exports.EVENT_HANDLER_ID_HEADER = 'x-event-handler-id';
+exports.COLOSSUS_ROUTE_DECLARER_HEADER = 'x-colossus-route-declarer';
+exports.COLOSSUS_ROUTE_ID_HEADER = 'x-colossus-route-id';
+exports.COLOSSUS_PARAMS_HEADER = 'x-colossus-params';
+exports.TRACE_ID_HEADER = 'x-trace-id';
+exports.PROVIDER_HEADER = 'x-vtex-provider';
+exports.BODY_HASH = '__graphqlBodyHash';
+exports.UP_SIGNAL = 'UP';
+exports.MAX_AGE = {
+    LONG: 86400,
+    MEDIUM: 3600,
+    SHORT: 120,
+};
+exports.HTTP_SERVER_PORT = 5050;
+exports.MAX_WORKERS = 4;
+exports.LINKED = !!process.env.VTEX_APP_LINK;
+exports.REGION = process.env.VTEX_REGION;
+exports.PUBLIC_ENDPOINT = process.env.VTEX_PUBLIC_ENDPOINT || 'myvtex.com';
+exports.APP = {
+    ID: process.env.VTEX_APP_ID,
+    MAJOR: process.env.VTEX_APP_VERSION ? app_1.versionToMajor(process.env.VTEX_APP_VERSION) : '',
+    NAME: process.env.VTEX_APP_NAME,
+    VENDOR: process.env.VTEX_APP_VENDOR,
+    VERSION: process.env.VTEX_APP_VERSION,
+    IS_THIRD_PARTY() {
+        return 'vtex' !== this.VENDOR && 'gocommerce' !== this.VENDOR;
+    },
+};
+exports.NODE_ENV = process.env.NODE_ENV;
+exports.ACCOUNT = process.env.VTEX_ACCOUNT;
+exports.WORKSPACE = process.env.VTEX_WORKSPACE;
+exports.PRODUCTION = process.env.VTEX_PRODUCTION === 'true';
+exports.INSPECT_DEBUGGER_PORT = 5858;
+exports.cancellableMethods = new Set(['GET', 'OPTIONS', 'HEAD']);

package/lib/errors/AuthenticationError.d.ts

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

package/lib/errors/AuthenticationError.js

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

package/lib/errors/ForbiddenError.d.ts

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

package/lib/errors/ForbiddenError.js

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