@vtex/api 6.48.0 → 6.48.1-beta

package/lib/service/{worker/runtime/graphql/schema/schemaDirectives/TranslateTo.d.ts → graphql/schema/schemaDirectives/Translatable.d.ts}

@@ -1,7 +1,6 @@
 import { GraphQLField } from 'graphql';
 import { SchemaDirectiveVisitor } from 'graphql-tools';
 import { ServiceContext } from '../../../typings';
-export declare class TranslateTo extends SchemaDirectiveVisitor {
+export declare class Translatable extends SchemaDirectiveVisitor {
     visitFieldDefinition(field: GraphQLField<any, ServiceContext>): void;
 }
-export declare const translateToDirectiveTypeDefs = "\ndirective @translateTo(\n  language: String!\n  behavior: String\n) on FIELD_DEFINITION\n";

package/lib/service/graphql/schema/schemaDirectives/Translatable.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bluebird_1 = require("bluebird");
+const graphql_1 = require("graphql");
+const graphql_tools_1 = require("graphql-tools");
+const messagesLoader_1 = require("../messagesLoader");
+class Translatable extends graphql_tools_1.SchemaDirectiveVisitor {
+    visitFieldDefinition(field) {
+        const { resolve = graphql_1.defaultFieldResolver } = field;
+        const { behavior = 'FULL' } = this.args;
+        field.resolve = async (root, args, context, info) => {
+            const { clients: { segment }, clients, vtex: { logger } } = context;
+            if (Math.random() < 0.1) {
+                logger.warn(`Translatable directive in use by: ${context.vtex.account} (Operation Id: ${context.vtex.operationId})`);
+            }
+            if (!context.loaders || !context.loaders.messages) {
+                context.loaders = Object.assign({}, context.loaders, { messages: messagesLoader_1.messagesLoader(clients) });
+            }
+            const response = await resolve(root, args, context, info);
+            const handler = handleSingleString(context, behavior);
+            return Array.isArray(response) ? await bluebird_1.map(response, handler) : await handler(response);
+        };
+    }
+}
+exports.Translatable = Translatable;
+const handleSingleString = (context, behavior) => async (response) => {
+    // Messages only knows how to process non empty strings.
+    if ((typeof response !== 'string' && typeof response !== 'object') || Array.isArray(response) || response == null) {
+        return response;
+    }
+    const resObj = typeof response === 'string'
+        ? {
+            content: response,
+            description: '',
+            from: undefined,
+            id: response,
+        }
+        : response;
+    const { content, from, id } = resObj;
+    const { clients: { segment }, vtex: { locale } } = context;
+    const to = locale != null
+        ? locale
+        : (await segment.getSegment()).cultureInfo;
+    if (content == null && id == null) {
+        throw new Error(`@translatable directive needs a content or id to translate, but received ${JSON.stringify(response)}`);
+    }
+    // If the message is already in the target locale, return the content.
+    if (!to || from === to) {
+        return content;
+    }
+    return context.loaders.messages.load(Object.assign({}, resObj, { behavior,
+        from,
+        to }));
+};

package/lib/service/graphql/schema/schemaDirectives/TranslatableV2.d.ts

@@ -0,0 +1,13 @@
+import { GraphQLField } from 'graphql';
+import { SchemaDirectiveVisitor } from 'graphql-tools';
+import { ServiceContext } from '../../../typings';
+export declare class TranslatableV2 extends SchemaDirectiveVisitor {
+    visitFieldDefinition(field: GraphQLField<any, ServiceContext>): void;
+}
+export interface TranslatableMessageV2 {
+    from?: string;
+    content: string;
+    context?: string;
+}
+export declare const parseTranslatableStringV2: (rawMessage: string) => TranslatableMessageV2;
+export declare const formatTranslatableStringV2: ({ from, content, context }: TranslatableMessageV2) => string;

package/lib/service/graphql/schema/schemaDirectives/TranslatableV2.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bluebird_1 = require("bluebird");
+const graphql_1 = require("graphql");
+const graphql_tools_1 = require("graphql-tools");
+const ramda_1 = require("ramda");
+const messagesLoaderV2_1 = require("../messagesLoaderV2");
+const CONTEXT_REGEX = /\(\(\((?<context>(.)*)\)\)\)/;
+const FROM_REGEX = /\<\<\<(?<from>(.)*)\>\>\>/;
+const CONTENT_REGEX = /\(\(\((?<context>(.)*)\)\)\)|\<\<\<(?<from>(.)*)\>\>\>/g;
+class TranslatableV2 extends graphql_tools_1.SchemaDirectiveVisitor {
+    visitFieldDefinition(field) {
+        const { resolve = graphql_1.defaultFieldResolver } = field;
+        const { behavior = 'FULL', withAppsMetaInfo = false } = this.args;
+        field.resolve = async (root, args, ctx, info) => {
+            if (!ctx.loaders || !ctx.loaders.messagesV2) {
+                ctx.loaders = Object.assign({}, ctx.loaders, { messagesV2: messagesLoaderV2_1.messagesLoaderV2(ctx.clients) });
+            }
+            const response = await resolve(root, args, ctx, info);
+            const { vtex, loaders: { messagesV2 } } = ctx;
+            const handler = handleSingleString(vtex, messagesV2, behavior, withAppsMetaInfo);
+            return Array.isArray(response) ? await bluebird_1.map(response, handler) : await handler(response);
+        };
+    }
+}
+exports.TranslatableV2 = TranslatableV2;
+exports.parseTranslatableStringV2 = (rawMessage) => {
+    const context = ramda_1.path(['groups', 'context'], rawMessage.match(CONTEXT_REGEX) || {});
+    const from = ramda_1.path(['groups', 'from'], rawMessage.match(FROM_REGEX) || {});
+    const content = rawMessage.replace(CONTENT_REGEX, '');
+    return {
+        content: content && content.trim(),
+        context: context && context.trim(),
+        from: from && from.trim(),
+    };
+};
+exports.formatTranslatableStringV2 = ({ from, content, context }) => `${content} ${context ? `(((${context})))` : ''} ${from ? `<<<${from}>>>` : ''}`;
+const handleSingleString = (ctx, messagesV2, behavior, withAppsMetaInfo) => async (rawMessage) => {
+    // Messages only knows how to process non empty strings.
+    if (rawMessage == null) {
+        return rawMessage;
+    }
+    const { content, context, from: maybeFrom } = exports.parseTranslatableStringV2(rawMessage);
+    const { binding, locale: to, tenant } = ctx;
+    if (content == null) {
+        throw new Error(`@translatableV2 directive needs a content to translate, but received ${JSON.stringify(rawMessage)}`);
+    }
+    if (to == null) {
+        throw new Error('@translatableV2 directive needs the locale variable available in IOContext. You can do this by either setting \`ctx.vtex.locale\` directly or calling this app with \`x-vtex-locale\` header');
+    }
+    const from = maybeFrom || (binding && binding.locale) || (tenant && tenant.locale);
+    if (from == null) {
+        throw new Error('@translatableV2 directive needs a source language to translate from. You can do this by either setting \`ctx.vtex.tenant\` variable, call this app with the header \`x-vtex-tenant\` or format the string with the \`formatTranslatableStringV2\` function with the \`from\` option set');
+    }
+    // If the message is already in the target locale, return the content.
+    if (!to || from === to) {
+        return content;
+    }
+    return messagesV2.load({
+        behavior,
+        content,
+        context,
+        from,
+        to,
+        withAppsMetaInfo,
+    });
+};

package/lib/service/graphql/schema/schemaDirectives/index.d.ts

@@ -0,0 +1,13 @@
+import { Auth } from './Auth';
+import { SanitizeDirective } from './Sanitize';
+import { SmartCacheDirective } from './SmartCacheDirective';
+import { Translatable } from './Translatable';
+import { TranslatableV2 } from './TranslatableV2';
+export { parseTranslatableStringV2, formatTranslatableStringV2 } from './TranslatableV2';
+export declare const nativeSchemaDirectives: {
+    auth: typeof Auth;
+    sanitize: typeof SanitizeDirective;
+    smartcache: typeof SmartCacheDirective;
+    translatable: typeof Translatable;
+    translatableV2: typeof TranslatableV2;
+};

package/lib/service/graphql/schema/schemaDirectives/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Auth_1 = require("./Auth");
+const Sanitize_1 = require("./Sanitize");
+const SmartCacheDirective_1 = require("./SmartCacheDirective");
+const Translatable_1 = require("./Translatable");
+const TranslatableV2_1 = require("./TranslatableV2");
+var TranslatableV2_2 = require("./TranslatableV2");
+exports.parseTranslatableStringV2 = TranslatableV2_2.parseTranslatableStringV2;
+exports.formatTranslatableStringV2 = TranslatableV2_2.formatTranslatableStringV2;
+exports.nativeSchemaDirectives = {
+    auth: Auth_1.Auth,
+    sanitize: Sanitize_1.SanitizeDirective,
+    smartcache: SmartCacheDirective_1.SmartCacheDirective,
+    translatable: Translatable_1.Translatable,
+    translatableV2: TranslatableV2_1.TranslatableV2,
+};

package/lib/service/graphql/schema/typeDefs/index.d.ts

@@ -0,0 +1,16 @@
+import { GraphQLScalarType } from 'graphql';
+import { NativeResolverContext } from './ioMessage';
+export declare const scalarResolversMap: {
+    'IOMessage': (ctx: NativeResolverContext) => GraphQLScalarType;
+    'IOSanitizedString': import("./sanitizedString").IOSanitizedStringType;
+    'IOUpload': GraphQLScalarType;
+    'Upload': GraphQLScalarType;
+};
+export declare const shouldNotCacheWhenSchemaHas: string[];
+export declare const nativeResolvers: (ctx: NativeResolverContext) => {
+    'IOMessage': GraphQLScalarType;
+    'IOSanitizedString': import("./sanitizedString").IOSanitizedStringType;
+    'IOUpload': GraphQLScalarType;
+    'Upload': GraphQLScalarType;
+};
+export declare const nativeTypeDefs: (metaData: Record<string, boolean>) => string;

package/lib/service/graphql/schema/typeDefs/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const apollo_server_core_1 = require("apollo-server-core");
+const ramda_1 = require("ramda");
+const ioMessage_1 = require("./ioMessage");
+const ioUpload_1 = require("./ioUpload");
+const sanitizedString_1 = require("./sanitizedString");
+exports.scalarResolversMap = {
+    'IOMessage': ioMessage_1.resolvers,
+    'IOSanitizedString': sanitizedString_1.resolvers,
+    'IOUpload': ioUpload_1.resolvers,
+    'Upload': apollo_server_core_1.GraphQLUpload,
+};
+exports.shouldNotCacheWhenSchemaHas = ['IOMessage'];
+exports.nativeResolvers = (ctx) => ({
+    'IOMessage': exports.scalarResolversMap.IOMessage(ctx),
+    'IOSanitizedString': exports.scalarResolversMap.IOSanitizedString,
+    'IOUpload': exports.scalarResolversMap.IOUpload,
+    'Upload': exports.scalarResolversMap.Upload,
+});
+exports.nativeTypeDefs = (metaData) => ramda_1.reduce((acc, scalar) => !metaData[scalar] ? `${acc}\nscalar ${scalar}\n` : acc, '', ramda_1.keys(exports.scalarResolversMap));

package/lib/service/graphql/schema/typeDefs/ioMessage.d.ts

@@ -0,0 +1,8 @@
+import DataLoader from 'dataloader';
+import { GraphQLScalarType } from 'graphql';
+import { IOMessage } from '../../../../utils/message';
+export interface NativeResolverContext {
+    getLocaleTo: () => Promise<string>;
+    translationsLoader: DataLoader<IOMessage, string>;
+}
+export declare const resolvers: (ctx: NativeResolverContext) => GraphQLScalarType;

package/lib/service/graphql/schema/typeDefs/ioMessage.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const apollo_server_core_1 = require("apollo-server-core");
+const graphql_1 = require("graphql");
+const serialize = (ctx) => async (inputArgs) => {
+    const args = typeof inputArgs === 'string' ? { content: inputArgs, description: '', from: undefined, id: inputArgs } : inputArgs;
+    const { content, from } = args;
+    const { translationsLoader, getLocaleTo } = ctx;
+    const to = await getLocaleTo();
+    // If the message is already in the target locale, return the content.
+    if (!to || from === to) {
+        return content;
+    }
+    return await translationsLoader.load(Object.assign({}, args, { from,
+        to }));
+};
+const parseValue = (_) => {
+    throw new apollo_server_core_1.ApolloError('You cannot use IOMessage as input value', 'INVALID_INPUT_MESSAGE');
+};
+exports.resolvers = (ctx) => new graphql_1.GraphQLScalarType({
+    description: 'Internationalizeable String',
+    name: 'IOMessage',
+    parseLiteral(ast) {
+        switch (ast.kind) {
+            case graphql_1.Kind.STRING:
+                return ast.value;
+            default:
+                return null;
+        }
+    },
+    parseValue,
+    serialize: serialize(ctx),
+});

package/lib/service/{worker/runtime/graphql → graphql}/schema/typeDefs/sanitizedString.js

@@ -15,11 +15,7 @@ class IOSanitizedStringType extends graphql_1.GraphQLScalarType {
     constructor(options) {
         const allowHTMLTags = options && options.allowHTMLTags;
         const stripIgnoreTag = !options || options.stripIgnoreTag !== false;
-        const xssOptions = {
-            stripIgnoreTag,
-            ...!allowHTMLTags && { whiteList: [] },
-            ...stripIgnoreTag && { escapeHtml: noop },
-        };
+        const xssOptions = Object.assign({ stripIgnoreTag }, !allowHTMLTags && { whiteList: [] }, stripIgnoreTag && { escapeHtml: noop });
         super({
             name: options ? `Custom${defaultName}` : defaultName,
             parseLiteral: ast => {

package/lib/service/graphql/typings.d.ts

@@ -0,0 +1,21 @@
+import { HttpQueryRequest } from 'apollo-server-core';
+import { HttpQueryResponse } from 'apollo-server-core/dist/runHttpQuery';
+import { GraphQLSchema } from 'graphql';
+import { GraphQLResponse } from 'graphql-extensions';
+import { IOClients } from '../../clients/IOClients';
+import { GraphQLOptions, ServiceContext } from '../typings';
+export interface GraphQLContext {
+    graphql: GraphQLOptions<IOClients, any, any> & {
+        schema?: GraphQLSchema;
+        query?: HttpQueryRequest['query'];
+        graphqlResponse?: GraphQLResponse;
+        responseInit?: HttpQueryResponse['responseInit'];
+        status?: 'success' | 'error';
+        graphQLErrors?: any[];
+        formatters?: {
+            formatError: <T>(e: T) => T;
+            formatResponse: <T>(r: T) => T;
+        };
+    };
+}
+export declare type GraphQLServiceContext = ServiceContext<IOClients, any, GraphQLContext>;

package/lib/service/graphql/utils/cacheControl.d.ts

@@ -0,0 +1,6 @@
+import { GraphQLResponse } from 'graphql-extensions';
+export declare const cacheControl: (response: GraphQLResponse, ctx: import("../../typings").ServiceContext<import("../../..").IOClients, any, import("../typings").GraphQLContext>) => {
+    maxAge: string;
+    scope: string;
+    segment: boolean | undefined;
+};

package/lib/service/graphql/utils/cacheControl.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ramda_1 = require("ramda");
+const domain_1 = require("../../../utils/domain");
+const maxAgeEnum_1 = require("../utils/maxAgeEnum");
+const linked = !!process.env.VTEX_APP_LINK;
+const pluck = (p) => (list) => ramda_1.pluck(p, list);
+const publicRegExp = ramda_1.compose((exp) => new RegExp(exp), (exp) => `.*${exp}.*`, ramda_1.replace('.', '\\.'));
+const pickCacheControlHints = (response) => ramda_1.path(['extensions', 'cacheControl', 'hints'], response);
+const minArray = (nums) => ramda_1.reduce(ramda_1.min, maxAgeEnum_1.maxAgeEnums.LONG, nums);
+const minMaxAge = (hints) => ramda_1.compose(minArray, ramda_1.reject(ramda_1.isNil), pluck('maxAge'))(hints);
+const anyPrivate = (hints) => ramda_1.compose(ramda_1.any(ramda_1.equals('PRIVATE')), pluck('scope'))(hints);
+const anySegment = (hints) => ramda_1.compose(ramda_1.any(ramda_1.equals('SEGMENT')), pluck('scope'))(hints);
+const isPrivateRoute = ({ request: { headers } }) => ramda_1.test(/_v\/graphql\/private\/v*/, headers['x-forwarded-path'] || '');
+const isPublicEndpoint = ({ request: { headers } }) => {
+    if (headers.origin) {
+        return false;
+    }
+    const host = headers['x-forwarded-host'] || '';
+    return domain_1.PUBLIC_DOMAINS.some(endpoint => ramda_1.test(publicRegExp(endpoint), host));
+};
+exports.cacheControl = (response, ctx) => {
+    const { vtex: { production } } = ctx;
+    const hints = response && pickCacheControlHints(response);
+    const age = hints && minMaxAge(hints);
+    const isPrivate = hints && anyPrivate(hints);
+    const segment = hints && anySegment(hints);
+    const maxAge = linked
+        ? 'no-store'
+        : (isPublicEndpoint(ctx) || !production)
+            ? 'no-cache'
+            : `max-age=${age}`;
+    return {
+        maxAge,
+        scope: (isPrivate || isPrivateRoute(ctx)) ? 'private' : 'public',
+        segment,
+    };
+};

package/lib/service/graphql/utils/maxAgeEnum.d.ts

@@ -0,0 +1,6 @@
+export declare const maxAgeEnums: {
+    LONG: number;
+    MEDIUM: number;
+    SHORT: number;
+};
+export declare const defaultMaxAgeFromCtx: (ctx: import("../../typings").ServiceContext<import("../../..").IOClients, any, import("../typings").GraphQLContext>) => number;

package/lib/service/graphql/utils/maxAgeEnum.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ramda_1 = require("ramda");
+/*
+ * This file contains the enumeration -> int map for generating the max age
+ * in the graphql cacheControl
+ */
+exports.maxAgeEnums = {
+    LONG: 86400,
+    MEDIUM: 3600,
+    SHORT: 120,
+};
+exports.defaultMaxAgeFromCtx = (ctx) => {
+    const forwarded = ramda_1.path(['request', 'header', 'x-forwarded-path'], ctx);
+    const isPrivateRoute = forwarded && /_v\/graphql\/private\/v*/.test(forwarded);
+    return (isPrivateRoute) ? 0 : exports.maxAgeEnums.LONG;
+};

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

@@ -0,0 +1,3 @@
+import { ClientsImplementation, IOClients } from '../../clients/IOClients';
+import { InstanceOptions } from '../../HttpClient';
+export declare const createHttpRoute: <ClientsT extends IOClients, StateT, CustomT>(Clients: ClientsImplementation<ClientsT>, options: Record<string, InstanceOptions>) => (handler: import("koa-compose").Middleware<import("../typings").ServiceContext<ClientsT, StateT, CustomT>> | import("koa-compose").Middleware<import("../typings").ServiceContext<ClientsT, StateT, CustomT>>[]) => import("koa-compose").ComposedMiddleware<import("../typings").ServiceContext<ClientsT, StateT, CustomT>>;

package/lib/service/http/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const compose_1 = require("../utils/compose");
+const authTokens_1 = require("./middlewares/authTokens");
+const cancellationToken_1 = require("./middlewares/cancellationToken");
+const clients_1 = require("./middlewares/clients");
+const error_1 = require("./middlewares/error");
+const requestStats_1 = require("./middlewares/requestStats");
+const setCookie_1 = require("./middlewares/setCookie");
+const timings_1 = require("./middlewares/timings");
+const vary_1 = require("./middlewares/vary");
+exports.createHttpRoute = (Clients, options) => {
+    return (handler) => {
+        const middlewares = Array.isArray(handler) ? handler : [handler];
+        const pipeline = [cancellationToken_1.cancellationToken, requestStats_1.trackIncomingRequestStats, vary_1.vary, authTokens_1.authTokens, clients_1.clients(Clients, options), setCookie_1.removeSetCookie, timings_1.timings, error_1.error, ...middlewares];
+        return compose_1.compose(pipeline);
+    };
+};

package/lib/service/http/middlewares/authTokens.d.ts

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

package/lib/service/http/middlewares/cancellationToken.d.ts

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

package/lib/service/{worker/runtime/http → http}/middlewares/cancellationToken.js

@@ -4,9 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const axios_1 = __importDefault(require("axios"));
-const constants_1 = require("../../../../../constants");
 async function cancellationToken(ctx, next) {
-    if (constants_1.cancellableMethods.has(ctx.method.toUpperCase())) {
+    if (ctx.method.toUpperCase() === ('GET' || 'OPTIONS' || 'HEAD')) {
         ctx.vtex.cancellation = {
             cancelable: true,
             cancelled: false,

package/lib/service/http/middlewares/clients.d.ts

@@ -0,0 +1,4 @@
+import { ClientsImplementation, IOClients } from '../../../clients/IOClients';
+import { InstanceOptions } from '../../../HttpClient';
+import { ServiceContext } from '../../typings';
+export declare function clients<T extends IOClients, U, V>(ClientsImpl: ClientsImplementation<T>, clientOptions: Record<string, InstanceOptions>): (ctx: ServiceContext<T, U, V>, next: () => Promise<any>) => Promise<void>;

package/lib/service/http/middlewares/error.d.ts

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

package/lib/service/{worker/runtime/http → http}/middlewares/error.js

@@ -1,26 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = require("../../../../../constants");
-const RequestCancelledError_1 = require("../../../../../errors/RequestCancelledError");
-const TooManyRequestsError_1 = require("../../../../../errors/TooManyRequestsError");
-const error_1 = require("../../../../../utils/error");
-const logger_1 = require("../../../../logger");
+const Logger_1 = require("../../../clients/Logger");
+const constants_1 = require("../../../constants");
+const RequestCancelledError_1 = require("../../../errors/RequestCancelledError");
+const TooManyRequestsError_1 = require("../../../errors/TooManyRequestsError");
+const error_1 = require("../../../utils/error");
 const CACHE_CONTROL_HEADER = 'cache-control';
 const META_HEADER = 'x-vtex-meta';
 const ETAG_HEADER = 'etag';
 const TWO_SECONDS_S = 2;
 const production = process.env.VTEX_PRODUCTION === 'true';
-// todo: unify GraphQL and REST exception treatment
 const logAndRemoveSensitiveData = (ctx, err) => {
-    const { method, status, query, vtex: { operationId, requestId, route: { id, params, }, serverTiming, }, headers: { 'x-forwarded-path': forwardedPath, 'x-forwarded-host': forwardedHost, 'x-forwarded-proto': forwardedProto, 'x-vtex-caller': caller, 'x-vtex-platform': platform, 'x-vtex-product': product, 'x-vtex-locale': locale, }, } = ctx;
+    const { method, status, query, vtex: { operationId, requestId, route: { id, params, }, }, headers: { 'x-forwarded-path': forwardedPath, 'x-forwarded-host': forwardedHost, 'x-forwarded-proto': forwardedProto, 'x-vtex-caller': caller, 'x-vtex-platform': platform, 'x-vtex-product': product, 'x-vtex-locale': locale, }, } = ctx;
     // Grab level from originalError, default to "error" level.
     let level = err && err.level;
-    if (!level || !(level === logger_1.LogLevel.Error || level === logger_1.LogLevel.Warn)) {
-        level = logger_1.LogLevel.Error;
+    if (!level || !(level === Logger_1.LogLevel.Error || level === Logger_1.LogLevel.Warn)) {
+        level = Logger_1.LogLevel.Error;
     }
-    const log = {
-        ...err,
-        caller,
+    const log = Object.assign({}, err, { caller,
         forwardedHost,
         forwardedPath,
         forwardedProto,
@@ -31,11 +28,7 @@ const logAndRemoveSensitiveData = (ctx, err) => {
         platform,
         product,
         query,
-        requestId,
-        routeId: id,
-        serverTiming,
-        status,
-    };
+        requestId, routeId: id, status });
     // Use sendLog directly to avoid cleaning error twice.
     ctx.vtex.logger.log(log, level);
     if (!constants_1.LINKED) {
@@ -45,7 +38,6 @@ const logAndRemoveSensitiveData = (ctx, err) => {
     }
 };
 async function error(ctx, next) {
-    var _a;
     try {
         await next();
     }
@@ -69,7 +61,6 @@ async function error(ctx, next) {
         // Do not generate etag for errors
         ctx.remove(META_HEADER);
         ctx.remove(ETAG_HEADER);
-        (_a = ctx.vtex.recorder) === null || _a === void 0 ? void 0 : _a.clear();
         // In production errors, add two second cache
         if (production) {
             ctx.set(CACHE_CONTROL_HEADER, `public, max-age=${TWO_SECONDS_S}`);

package/lib/service/{worker/runtime/http → http}/middlewares/requestStats.d.ts

@@ -1,5 +1,5 @@
-import { IOClients } from '../../../../../clients/IOClients';
-import { ParamsContext, RecorderState, ServiceContext } from '../../typings';
+import { IOClients } from '../../../clients/IOClients';
+import { ServiceContext } from '../../typings';
 export declare const cancelMessage = "Request cancelled";
 declare class IncomingRequestStats {
     aborted: number;
@@ -13,5 +13,5 @@ declare class IncomingRequestStats {
     clear(): void;
 }
 export declare const incomingRequestStats: IncomingRequestStats;
-export declare function trackIncomingRequestStats<T extends IOClients, U extends RecorderState, V extends ParamsContext>(ctx: ServiceContext<T, U, V>, next: () => Promise<void>): Promise<void>;
+export declare function trackIncomingRequestStats<T extends IOClients, U, V>(ctx: ServiceContext<T, U, V>, next: () => Promise<any>): Promise<void>;
 export {};

package/lib/service/http/middlewares/setCookie.d.ts

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

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

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

package/lib/service/{worker/runtime/http → http}/middlewares/timings.js

@@ -4,42 +4,29 @@ var __importDefault = (this && this.__importDefault) || function (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 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,
-});
+const log = ({ vtex: { account, workspace, route: { id } }, path, method, status }, millis) => `${formatDate(new Date())}\t${account}/${workspace}:${id}\t${formatStatus(status)}\t${method}\t${path}\t${formatMillis(millis)} ms`;
 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 { status: statusCode, vtex: { route: { id } }, timings: { total } } = 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 });
+    if (ctx.serverTiming) {
+        ctx.serverTiming[APP_ELAPSED_TIME_LOCATOR] = `${totalMillis}`;
+        ctx.set('Server-Timing', time_1.reduceTimings(ctx.serverTiming));
+    }
 }
 exports.timings = timings;

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

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

package/lib/service/{worker/runtime/http → http}/middlewares/vary.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = require("../../../../../constants");
+const constants_1 = require("../../../constants");
 const cachingStrategies = [
     {
         forbidden: [],
@@ -29,9 +29,9 @@ const shouldVaryByHeader = (ctx, header, strategy) => {
 };
 async function vary(ctx, next) {
     const { method, path } = ctx;
-    const strategy = cachingStrategies.find((cachingStrategy) => path.indexOf(cachingStrategy.path) === 0);
+    const strategy = cachingStrategies.find(cachingStrategy => path.indexOf(cachingStrategy.path) === 0);
     if (strategy) {
-        strategy.forbidden.forEach((headerName) => {
+        strategy.forbidden.forEach(headerName => {
             delete ctx.headers[headerName];
         });
     }

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

@@ -1,2 +1,28 @@
-export * from './console';
-export * from './logger';
+import { IOContext } from '../../service/typings';
+export declare enum LogLevel {
+    Debug = "debug",
+    Info = "info",
+    Warn = "warn",
+    Error = "error"
+}
+export declare class Logger {
+    private account;
+    private workspace;
+    private operationId;
+    private requestId;
+    private production;
+    private executed;
+    constructor(ctx: Pick<IOContext, 'account' | 'workspace' | 'requestId' | 'operationId' | 'production'>);
+    debug: (message: any) => void;
+    info: (message: any) => void;
+    warn: (warning: any) => void;
+    error: (error: any) => void;
+    log: (message: any, level: LogLevel) => void;
+    private isThirdPartyApp;
+    /**
+     * 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;
+}