@vtex/api 6.45.4

package/lib/service/worker/runtime/http/middlewares/settings.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+const ramda_1 = require("ramda");
+const constants_1 = require("../../../../../constants");
+const app_1 = require("./../../../../../utils/app");
+const joinIds = ramda_1.join('');
+const dependsOnApp = (appAtMajor) => (a) => {
+    const [name, major] = appAtMajor.split('@');
+    const majorInt = major.includes('.') ? major.split('.')[0] : major;
+    const version = a._resolvedDependencies[name];
+    if (!version) {
+        return false;
+    }
+    const [depMajor] = version.split('.');
+    return majorInt === depMajor;
+};
+exports.getFilteredDependencies = (appAtMajor, dependencies) => {
+    const depends = dependsOnApp(appAtMajor);
+    return dependencies.filter(depends);
+};
+exports.getDependenciesHash = (dependencies) => {
+    const dependingApps = ramda_1.pluck('id', dependencies);
+    return crypto_1.createHash('md5')
+        .update(joinIds(dependingApps))
+        .digest('hex');
+};
+exports.getDependenciesSettings = async (apps, assets, tracingConfig) => {
+    const appId = constants_1.APP.ID;
+    const metaInfos = await apps.getAppsMetaInfos(undefined, undefined, tracingConfig);
+    const appAtMajor = app_1.appIdToAppAtMajor(appId);
+    return await assets.getSettings(metaInfos, appAtMajor, undefined, tracingConfig);
+};
+exports.getServiceSettings = () => {
+    return async function settingsContext(ctx, next) {
+        const { clients: { apps, assets }, } = ctx;
+        const rootSpan = ctx.tracing.currentSpan;
+        const dependenciesSettings = await exports.getDependenciesSettings(apps, assets, { tracing: { rootSpan } });
+        // TODO: for now returning all settings, but the ideia is to do merge
+        ctx.vtex.settings = dependenciesSettings;
+        await next();
+    };
+};

package/lib/service/worker/runtime/http/middlewares/timings.d.ts

@@ -0,0 +1,3 @@
+import { IOClients } from '../../../../../clients/IOClients';
+import { ParamsContext, RecorderState, ServiceContext } from '../../typings';
+export declare function timings<T extends IOClients, U extends RecorderState, V extends ParamsContext>(ctx: ServiceContext<T, U, V>, next: () => Promise<void>): Promise<void>;

package/lib/service/worker/runtime/http/middlewares/timings.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const constants_1 = require("../../../../../constants");
+const status_1 = require("../../../../../utils/status");
+const time_1 = require("../../../../../utils/time");
+const APP_ELAPSED_TIME_LOCATOR = time_1.shrinkTimings(time_1.formatTimingName({
+    hopNumber: 0,
+    source: process.env.VTEX_APP_NAME,
+    target: '',
+}));
+const pid = chalk_1.default.magenta('[' + constants_1.PID + ']');
+const formatDate = (date) => chalk_1.default.dim('[' + date.toISOString().split('T')[1] + ']');
+const formatStatus = (status) => status >= 500 ? chalk_1.default.red(status.toString()) : (status >= 200 && status < 300 ? chalk_1.default.green(status.toString()) : status);
+const formatMillis = (millis) => millis >= 500 ? chalk_1.default.red(millis.toString()) : millis >= 200 ? chalk_1.default.yellow(millis.toString()) : chalk_1.default.green(millis.toString());
+const log = ({ vtex: { account, workspace, route: { id } }, path, method, status }, millis) => `${formatDate(new Date())}\t${pid}\t${account}/${workspace}:${id}\t${formatStatus(status)}\t${method}\t${path}\t${formatMillis(millis)} ms`;
+const logBillingInfo = ({ account, workspace, production, route: { id, type } }, millis) => JSON.stringify({
+    '__VTEX_IO_BILLING': 'true',
+    'account': account,
+    'app': constants_1.APP.ID,
+    'handler': id,
+    'isLink': constants_1.LINKED,
+    'production': production,
+    'routeType': type === 'public' ? 'public_route' : 'private_route',
+    'timestamp': Date.now(),
+    'type': 'process-time',
+    'value': millis,
+    'vendor': constants_1.APP.VENDOR,
+    'workspace': workspace,
+});
+async function timings(ctx, next) {
+    // Errors will be caught by the next middleware so we don't have to catch.
+    await next();
+    const { status: statusCode, vtex: { route: { id } }, timings: { total }, vtex } = ctx;
+    const totalMillis = time_1.hrToMillis(total);
+    console.log(log(ctx, totalMillis));
+    console.log(logBillingInfo(vtex, totalMillis));
+    const status = status_1.statusLabel(statusCode);
+    // Only batch successful responses so metrics don't consider errors
+    metrics.batch(`http-handler-${id}`, status === 'success' ? total : undefined, { [status]: 1 });
+}
+exports.timings = timings;

package/lib/service/worker/runtime/http/middlewares/vary.d.ts

@@ -0,0 +1,3 @@
+import { IOClients } from '../../../../../clients/IOClients';
+import { ParamsContext, RecorderState, ServiceContext } from '../../typings';
+export declare function vary<T extends IOClients, U extends RecorderState, V extends ParamsContext>(ctx: ServiceContext<T, U, V>, next: () => Promise<void>): Promise<void>;

package/lib/service/worker/runtime/http/middlewares/vary.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../../../../constants");
+const cachingStrategies = [
+    {
+        forbidden: [],
+        path: '/_v/private/',
+        vary: [constants_1.SEGMENT_HEADER, constants_1.SESSION_HEADER],
+    },
+    {
+        forbidden: [constants_1.SEGMENT_HEADER, constants_1.SESSION_HEADER],
+        path: '/_v/public/',
+        vary: [],
+    },
+    {
+        forbidden: [constants_1.SESSION_HEADER],
+        path: '/_v/segment/',
+        vary: [constants_1.SEGMENT_HEADER],
+    },
+];
+const shouldVaryByHeader = (ctx, header, strategy) => {
+    if (strategy && strategy.vary.includes(header)) {
+        return true;
+    }
+    if (process.env.DETERMINISTIC_VARY) {
+        return false;
+    }
+    return !!ctx.get(header);
+};
+async function vary(ctx, next) {
+    const { method, path } = ctx;
+    const strategy = cachingStrategies.find((cachingStrategy) => path.indexOf(cachingStrategy.path) === 0);
+    if (strategy) {
+        strategy.forbidden.forEach((headerName) => {
+            delete ctx.headers[headerName];
+        });
+    }
+    // We don't need to vary non GET requests, since they are never cached
+    if (method.toUpperCase() !== 'GET') {
+        await next();
+        return;
+    }
+    ctx.vary(constants_1.LOCALE_HEADER);
+    if (shouldVaryByHeader(ctx, constants_1.SEGMENT_HEADER, strategy)) {
+        ctx.vary(constants_1.SEGMENT_HEADER);
+    }
+    if (shouldVaryByHeader(ctx, constants_1.SESSION_HEADER, strategy)) {
+        ctx.vary(constants_1.SESSION_HEADER);
+    }
+    await next();
+}
+exports.vary = vary;

package/lib/service/worker/runtime/http/router.d.ts

@@ -0,0 +1,2 @@
+import { HttpRoute, ServiceContext } from '../typings';
+export declare const routerFromPublicHttpHandlers: (routes: Record<string, HttpRoute>) => (ctx: ServiceContext<import("../../../..").IOClients, import("../typings").RecorderState, import("../typings").ParamsContext>, next: () => Promise<void>) => Promise<void>;

package/lib/service/worker/runtime/http/router.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../../../constants");
+const logger_1 = require("../../../logger");
+const console_1 = require("./../../../logger/console");
+exports.routerFromPublicHttpHandlers = (routes) => {
+    return async (ctx, next) => {
+        var _a;
+        const routeId = ctx.get(constants_1.COLOSSUS_ROUTE_ID_HEADER);
+        if (!routeId) {
+            return next();
+        }
+        const handler = (_a = routes[routeId]) === null || _a === void 0 ? void 0 : _a.handler;
+        if (!handler) {
+            const msg = `Handler with id '${routeId}' not implemented.`;
+            ctx.status = 501;
+            ctx.body = msg;
+            console_1.logOnceToDevConsole(msg, logger_1.LogLevel.Error);
+            return;
+        }
+        await handler(ctx, next);
+    };
+};

package/lib/service/worker/runtime/http/routes.d.ts

@@ -0,0 +1,19 @@
+import { ServiceJSON } from '../typings';
+interface PrivateRouteInfo {
+    protocol?: 'http' | 'https';
+    vendor: string;
+    name: string;
+    major: string | number;
+    account: string;
+    workspace: string;
+    path?: string;
+}
+export declare const formatPrivateRoute: ({ protocol, vendor, name, major, account, workspace, path }: PrivateRouteInfo) => string;
+export declare const formatPublicRoute: ({ workspace, account, endpoint, path }: {
+    workspace: string;
+    account: string;
+    endpoint: string;
+    path: string;
+}) => string;
+export declare const logAvailableRoutes: (service: ServiceJSON) => void;
+export {};

package/lib/service/worker/runtime/http/routes.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../../../constants");
+exports.formatPrivateRoute = ({ protocol = 'https', vendor, name, major, account, workspace, path }) => `${protocol}://app.io.vtex.com/${vendor}.${name}/v${major}/${account}/${workspace}${path || ''}`;
+exports.formatPublicRoute = ({ workspace, account, endpoint, path }) => `https://${workspace}--${account}.${endpoint}${path}`;
+const getPath = ({ public: publicRoute, path }) => publicRoute
+    ? exports.formatPublicRoute({ workspace: constants_1.WORKSPACE, account: constants_1.ACCOUNT, endpoint: constants_1.PUBLIC_ENDPOINT, path })
+    : exports.formatPrivateRoute({ protocol: 'https', vendor: constants_1.APP.VENDOR, name: constants_1.APP.NAME, major: constants_1.APP.MAJOR, account: constants_1.ACCOUNT, workspace: constants_1.WORKSPACE, path });
+exports.logAvailableRoutes = (service) => {
+    const available = Object.values(service.routes || {}).reduce((acc, route) => `${acc}\n${getPath(route)}`, 'Available service routes:');
+    console.info(available);
+};

package/lib/service/worker/runtime/method.d.ts

@@ -0,0 +1,9 @@
+import { IOClients } from '../../../clients/IOClients';
+import { ParamsContext, RecorderState, RouteHandler, ServiceContext } from './typings';
+declare type HTTPMethods = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH' | 'DEFAULT';
+declare type MethodOptions<ClientsT extends IOClients = IOClients, StateT extends RecorderState = RecorderState, CustomT extends ParamsContext = ParamsContext> = Partial<Record<HTTPMethods, RouteHandler<ClientsT, StateT, CustomT> | Array<RouteHandler<ClientsT, StateT, CustomT>>>>;
+export declare function method<T extends IOClients, U extends RecorderState, V extends ParamsContext>(options: MethodOptions<T, U, V>): {
+    (ctx: ServiceContext<T, U, V>, next: () => Promise<void>): Promise<void>;
+    skipTimer: boolean;
+};
+export {};

package/lib/service/worker/runtime/method.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ramda_1 = require("ramda");
+const compose_1 = require("./utils/compose");
+const TEN_SECONDS_S = 10;
+function methodNotAllowed(ctx) {
+    ctx.status = 405;
+    ctx.set('cache-control', `public, max-age=${TEN_SECONDS_S}`);
+}
+function method(options) {
+    const handlers = ramda_1.mapObjIndexed(handler => compose_1.compose(Array.isArray(handler) ? handler : [handler]), options);
+    const inner = async function forMethod(ctx, next) {
+        const verb = ctx.method.toUpperCase();
+        const handler = handlers[verb] || handlers.DEFAULT || methodNotAllowed;
+        if (handler) {
+            await handler(ctx);
+        }
+        await next();
+    };
+    inner.skipTimer = true;
+    return inner;
+}
+exports.method = method;

package/lib/service/worker/runtime/statusTrack.d.ts

@@ -0,0 +1,14 @@
+import { ServiceContext } from './typings';
+export declare type StatusTrack = () => EnvMetric[];
+export interface NamedMetric {
+    name: string;
+    [key: string]: any;
+}
+export interface EnvMetric extends NamedMetric {
+    production: boolean;
+}
+export declare const isStatusTrack: (message: any) => message is "statusTrack";
+export declare const isStatusTrackBroadcast: (message: any) => message is "broadcastStatusTrack";
+export declare const statusTrackHandler: (ctx: ServiceContext<import("../../..").IOClients, import("./typings").RecorderState, import("./typings").ParamsContext>) => Promise<void>;
+export declare const trackStatus: () => void;
+export declare const broadcastStatusTrack: () => void;

package/lib/service/worker/runtime/statusTrack.js

@@ -0,0 +1,37 @@
+"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 BROADCAST_STATUS_TRACK = 'broadcastStatusTrack';
+const STATUS_TRACK = 'statusTrack';
+exports.isStatusTrack = (message) => message === STATUS_TRACK;
+exports.isStatusTrackBroadcast = (message) => message === BROADCAST_STATUS_TRACK;
+exports.statusTrackHandler = async (ctx) => {
+    var _a, _b;
+    (_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.currentSpan.setOperationName('builtin:status-track');
+    if (!constants_1.LINKED) {
+        (_b = process.send) === null || _b === void 0 ? void 0 : _b.call(process, BROADCAST_STATUS_TRACK);
+    }
+    ctx.body = [];
+    return;
+};
+exports.trackStatus = () => {
+    global.metrics.statusTrack().forEach(status => {
+        logStatus(status);
+    });
+};
+exports.broadcastStatusTrack = () => Object.values(cluster_1.default.workers).forEach(worker => worker === null || worker === void 0 ? void 0 : worker.send(STATUS_TRACK));
+const logStatus = (status) => console.log(JSON.stringify({
+    __VTEX_IO_LOG: true,
+    account: constants_1.ACCOUNT,
+    app: constants_1.APP.ID,
+    isLink: constants_1.LINKED,
+    pid: process.pid,
+    production: constants_1.PRODUCTION,
+    status,
+    type: 'metric/status',
+    workspace: constants_1.WORKSPACE,
+}));

package/lib/service/worker/runtime/typings.d.ts

@@ -0,0 +1,172 @@
+/// <reference types="node" />
+import { CancelTokenSource } from 'axios';
+import DataLoader from 'dataloader';
+import { GraphQLFieldConfig, GraphQLFieldResolver, GraphQLScalarType } from 'graphql';
+import { SchemaDirectiveVisitor } from 'graphql-tools';
+import { ParameterizedContext } from 'koa';
+import { Middleware } from 'koa-compose';
+import { Span, Tracer } from 'opentracing';
+import { ParsedUrlQuery } from 'querystring';
+import { ClientsImplementation, IOClients } from '../../../clients/IOClients';
+import { InstanceOptions } from '../../../HttpClient';
+import { IUserLandTracer } from '../../../tracing/UserLandTracer';
+import { BindingHeader } from '../../../utils/binding';
+import { IOMessage } from '../../../utils/message';
+import { TenantHeader } from '../../../utils/tenant';
+import { Logger } from '../../logger';
+import { MetricsLogger } from '../../logger/metricsLogger';
+import { MessagesLoaderV2 } from './graphql/schema/messagesLoaderV2';
+import { Recorder } from './utils/recorder';
+declare type ServerTiming = Record<string, string>;
+export declare type Maybe<T> = T | null | undefined;
+export interface TracingContext {
+    tracer: Tracer;
+    currentSpan: Span;
+}
+export interface Context<T extends IOClients> {
+    clients: T;
+    vtex: IOContext;
+    timings: Record<string, [number, number]>;
+    metrics: Record<string, [number, number]>;
+    previousTimerStart: [number, number];
+    serverTiming?: ServerTiming;
+    tracing?: TracingContext;
+}
+export interface EventContext<T extends IOClients, StateT = any> {
+    clients: T;
+    state: StateT;
+    vtex: IOContext;
+    body: any;
+    timings: Record<string, [number, number]>;
+    metrics: Record<string, [number, number]>;
+    key: string;
+    sender: string;
+    subject: string;
+}
+declare type KnownKeys<T> = {
+    [K in keyof T]: string extends K ? never : number extends K ? never : K;
+} extends {
+    [_ in keyof T]: infer U;
+} ? U : never;
+interface Loaders {
+    messages?: DataLoader<IOMessage, string>;
+    messagesV2?: MessagesLoaderV2;
+    immutableMessagesV2?: MessagesLoaderV2;
+}
+export declare type ServiceContext<ClientsT extends IOClients = IOClients, StateT extends RecorderState = RecorderState, CustomT extends ParamsContext = ParamsContext> = Pick<ParameterizedContext<StateT, Context<ClientsT>>, KnownKeys<ParameterizedContext<StateT, Context<ClientsT>>>> & CustomT & {
+    loaders?: Loaders;
+};
+export declare type RouteHandler<ClientsT extends IOClients = IOClients, StateT extends RecorderState = RecorderState, CustomT extends ParamsContext = ParamsContext> = Middleware<ServiceContext<ClientsT, StateT, CustomT>>;
+export declare type EventHandler<ClientsT extends IOClients = IOClients, StateT = void> = Middleware<EventContext<ClientsT, StateT>>;
+export declare type Resolver<ClientsT extends IOClients = IOClients, StateT extends RecorderState = RecorderState, CustomT extends ParamsContext = ParamsContext> = GraphQLFieldResolver<any, ServiceContext<ClientsT, StateT, CustomT>, any> | GraphQLFieldConfig<any, ServiceContext<ClientsT, StateT, CustomT>, any>;
+export declare type Handler = RouteHandler<IOClients, RecorderState, ParamsContext>;
+export interface HttpRoute {
+    handler: RouteHandler;
+    path: string;
+}
+export interface RecorderState {
+    recorder: Recorder;
+    body: any;
+}
+export interface ParamsContext {
+    params: any;
+    metricsLogger: MetricsLogger;
+}
+export interface ClientsConfig<ClientsT extends IOClients = IOClients> {
+    implementation?: ClientsImplementation<ClientsT>;
+    options: Record<string, InstanceOptions>;
+}
+export interface GraphQLOptions<ClientsT extends IOClients = IOClients, StateT extends RecorderState = RecorderState, CustomT extends ParamsContext = ParamsContext> {
+    resolvers: Record<string, Record<string, Resolver<ClientsT, StateT, CustomT>> | GraphQLScalarType>;
+    schema?: string;
+    schemaDirectives?: Record<string, typeof SchemaDirectiveVisitor>;
+}
+export interface ServiceConfig<ClientsT extends IOClients = IOClients, StateT extends RecorderState = RecorderState, CustomT extends ParamsContext = ParamsContext> {
+    clients?: ClientsConfig<ClientsT>;
+    events?: Record<string, EventHandler<ClientsT, StateT> | Array<EventHandler<ClientsT, StateT>>>;
+    graphql?: GraphQLOptions<ClientsT, StateT, CustomT>;
+    routes?: Record<string, RouteHandler<ClientsT, StateT, CustomT> | Array<RouteHandler<ClientsT, StateT, CustomT>>>;
+}
+export interface Cancellation {
+    cancelable: boolean;
+    cancelled: boolean;
+    source: CancelTokenSource;
+}
+export interface IOContext {
+    account: string;
+    platform: string;
+    authToken: string;
+    adminUserAuthToken?: string;
+    storeUserAuthToken?: string;
+    locale?: string;
+    production: boolean;
+    product: string;
+    recorder?: Recorder;
+    region: string;
+    route: {
+        declarer?: string;
+        id: string;
+        params: ParsedUrlQuery;
+        type: 'public' | 'private' | 'event';
+    };
+    userAgent: string;
+    workspace: string;
+    segmentToken?: string;
+    sessionToken?: string;
+    requestId: string;
+    operationId: string;
+    janusEnv?: JanusEnv;
+    serverTiming?: ServerTiming;
+    logger: Logger;
+    eventInfo?: EventBody;
+    host?: string;
+    tenant?: TenantHeader;
+    binding?: BindingHeader;
+    cancellation?: Cancellation;
+    settings?: any;
+    tracer: IUserLandTracer;
+}
+export interface EventBody {
+    sender: string;
+    subject: string;
+    key: string;
+}
+export declare type RouteSettingsType = 'pure' | 'workspace' | 'userAndWorkspace';
+export interface ServiceRoute {
+    path: string;
+    public?: boolean;
+    smartcache?: boolean;
+    extensible?: boolean;
+    settingsType?: RouteSettingsType;
+    rateLimitPerReplica?: RateLimitOptions;
+}
+export interface ServiceEvent {
+    keys?: string[];
+    sender?: string;
+    subject?: string;
+    settingsType?: RouteSettingsType;
+    rateLimitPerReplica?: RateLimitOptions;
+}
+export interface RateLimitOptions {
+    perMinute?: number;
+    concurrent?: number;
+}
+export interface RawServiceJSON {
+    stack: 'nodejs';
+    memory: number;
+    ttl?: number;
+    timeout?: number;
+    runtimeArgs?: string[];
+    routes?: Record<string, ServiceRoute>;
+    rateLimitPerReplica?: RateLimitOptions;
+    events?: Record<string, ServiceEvent>;
+    minReplicas?: number;
+    maxReplicas?: number;
+    workers?: number;
+    deterministicVary?: boolean;
+}
+export interface ServiceJSON extends RawServiceJSON {
+    workers: number;
+}
+export declare type JanusEnv = string;
+export {};