@vtex/api 6.48.1-beta → 6.48.1-beta.3

package/lib/service/{graphql → worker/runtime/graphql}/schema/schemaDirectives/Sanitize.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeDirectiveTypeDefs = exports.SanitizeDirective = void 0;
 const graphql_1 = require("graphql");
 const graphql_tools_1 = require("graphql-tools");
 const sanitizedString_1 = require("../typeDefs/sanitizedString");
@@ -27,3 +28,9 @@ class SanitizeDirective extends graphql_tools_1.SchemaDirectiveVisitor {
     }
 }
 exports.SanitizeDirective = SanitizeDirective;
+exports.sanitizeDirectiveTypeDefs = `
+directive @sanitize(
+  allowHTMLTags: Boolean
+  stripIgnoreTag: Boolean
+) on FIELD_DEFINITION | INPUT_FIELD_DEFINITION | ARGUMENT_DEFINITION
+`;

package/lib/service/worker/runtime/graphql/schema/schemaDirectives/Settings.d.ts

@@ -0,0 +1,6 @@
+import { GraphQLField } from 'graphql';
+import { SchemaDirectiveVisitor } from 'graphql-tools';
+export declare class SettingsDirective extends SchemaDirectiveVisitor {
+    visitFieldDefinition(field: GraphQLField<any, any>): void;
+}
+export declare const settingsDirectiveTypeDefs = "\ndirective @settings(\n  settingsType: String\n) on FIELD_DEFINITION\n";

package/lib/service/worker/runtime/graphql/schema/schemaDirectives/Settings.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.settingsDirectiveTypeDefs = exports.SettingsDirective = void 0;
+const graphql_1 = require("graphql");
+const graphql_tools_1 = require("graphql-tools");
+const settings_1 = require("../../../http/middlewares/settings");
+const addSettings = async (settings, ctx) => {
+    if (settings === 'pure') {
+        return ctx;
+    }
+    const { clients: { apps, assets } } = ctx;
+    const dependenciesSettings = await settings_1.getDependenciesSettings(apps, assets);
+    if (!ctx.vtex) {
+        ctx.vtex = {};
+    }
+    ctx.vtex.settings = { ...ctx.vtex.settings, dependenciesSettings };
+};
+class SettingsDirective extends graphql_tools_1.SchemaDirectiveVisitor {
+    visitFieldDefinition(field) {
+        const { resolve = graphql_1.defaultFieldResolver } = field;
+        const { settingsType } = this.args;
+        field.resolve = async (root, args, ctx, info) => {
+            if (settingsType) {
+                await addSettings(settingsType, ctx);
+            }
+            return resolve(root, args, ctx, info);
+        };
+    }
+}
+exports.SettingsDirective = SettingsDirective;
+exports.settingsDirectiveTypeDefs = `
+directive @settings(
+  settingsType: String
+) on FIELD_DEFINITION
+`;

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

@@ -3,3 +3,4 @@ import { SchemaDirectiveVisitor } from 'graphql-tools';
 export declare class SmartCacheDirective extends SchemaDirectiveVisitor {
     visitFieldDefinition(field: GraphQLField<any, any>): void;
 }
+export declare const smartCacheDirectiveTypeDefs = "\ndirective @smartcache(\n  maxAge: String\n) on FIELD_DEFINITION\n";

package/lib/service/{graphql → worker/runtime/graphql}/schema/schemaDirectives/SmartCacheDirective.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.smartCacheDirectiveTypeDefs = exports.SmartCacheDirective = void 0;
 const graphql_1 = require("graphql");
 const graphql_tools_1 = require("graphql-tools");
-const maxAgeEnum_1 = require("../../utils/maxAgeEnum");
+const constants_1 = require("../../../../../../constants");
 const ETAG_CONTROL_HEADER = 'x-vtex-etag-control';
 const DEFAULT_ARGS = {
     maxAge: undefined,
@@ -11,10 +12,10 @@ class SmartCacheDirective extends graphql_tools_1.SchemaDirectiveVisitor {
     visitFieldDefinition(field) {
         const { resolve = graphql_1.defaultFieldResolver } = field;
         const { maxAge } = this.args || DEFAULT_ARGS;
-        const maxAgeS = maxAge && maxAgeEnum_1.maxAgeEnums[maxAge];
+        const maxAgeS = maxAge && constants_1.MAX_AGE[maxAge];
         field.resolve = (root, args, context, info) => {
             if (maxAgeS) {
-                context.set(ETAG_CONTROL_HEADER, maxAgeS);
+                context.set(ETAG_CONTROL_HEADER, `public, max-age=${maxAgeS}`);
             }
             context.vtex.recorder = context.state.recorder;
             return resolve(root, args, context, info);
@@ -22,3 +23,8 @@ class SmartCacheDirective extends graphql_tools_1.SchemaDirectiveVisitor {
     }
 }
 exports.SmartCacheDirective = SmartCacheDirective;
+exports.smartCacheDirectiveTypeDefs = `
+directive @smartcache(
+  maxAge: String
+) on FIELD_DEFINITION
+`;

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

@@ -0,0 +1,7 @@
+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 declare const translatableV2DirectiveTypeDefs = "\ndirective @translatableV2(\n  behavior: String\n  withAppsMetaInfo: Boolean\n) on FIELD_DEFINITION\n";

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translatableV2DirectiveTypeDefs = exports.TranslatableV2 = void 0;
+const graphql_1 = require("graphql");
+const graphql_tools_1 = require("graphql-tools");
+const translations_1 = require("../../utils/translations");
+const messagesLoaderV2_1 = require("../messagesLoaderV2");
+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) => {
+            var _a;
+            if (!((_a = ctx.loaders) === null || _a === void 0 ? void 0 : _a.messagesV2)) {
+                const { vtex: { locale: to } } = ctx;
+                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 dependencies = withAppsMetaInfo ? await ctx.clients.apps.getAppsMetaInfos() : undefined;
+                ctx.loaders = {
+                    ...ctx.loaders,
+                    messagesV2: messagesLoaderV2_1.createMessagesLoader(ctx.clients, to, dependencies),
+                };
+            }
+            const response = await resolve(root, args, ctx, info);
+            const { vtex, loaders: { messagesV2 } } = ctx;
+            const handler = translations_1.handleSingleString(vtex, messagesV2, behavior, 'translatableV2');
+            return Array.isArray(response)
+                ? Promise.all(response.map(handler))
+                : handler(response);
+        };
+    }
+}
+exports.TranslatableV2 = TranslatableV2;
+exports.translatableV2DirectiveTypeDefs = `
+directive @translatableV2(
+  behavior: String
+  withAppsMetaInfo: Boolean
+) on FIELD_DEFINITION
+`;

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

@@ -1,6 +1,7 @@
 import { GraphQLField } from 'graphql';
 import { SchemaDirectiveVisitor } from 'graphql-tools';
 import { ServiceContext } from '../../../typings';
-export declare class Translatable extends SchemaDirectiveVisitor {
+export declare class TranslateTo 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/worker/runtime/graphql/schema/schemaDirectives/TranslateTo.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateToDirectiveTypeDefs = exports.TranslateTo = void 0;
+const graphql_1 = require("graphql");
+const graphql_tools_1 = require("graphql-tools");
+const translations_1 = require("../../utils/translations");
+const messagesLoaderV2_1 = require("../messagesLoaderV2");
+class TranslateTo extends graphql_tools_1.SchemaDirectiveVisitor {
+    visitFieldDefinition(field) {
+        const { resolve = graphql_1.defaultFieldResolver } = field;
+        const { language, behavior = 'FULL' } = this.args;
+        field.resolve = async (root, args, ctx, info) => {
+            var _a;
+            if (!((_a = ctx.loaders) === null || _a === void 0 ? void 0 : _a.immutableMessagesV2)) {
+                const dependencies = await ctx.clients.apps.getAppsMetaInfos();
+                ctx.loaders = {
+                    ...ctx.loaders,
+                    immutableMessagesV2: messagesLoaderV2_1.createMessagesLoader(ctx.clients, language, dependencies),
+                };
+            }
+            const response = (await resolve(root, args, ctx, info));
+            const { vtex, loaders: { immutableMessagesV2 }, } = ctx;
+            const handler = translations_1.handleSingleString(vtex, immutableMessagesV2, behavior, 'translateTo');
+            return Array.isArray(response) ? Promise.all(response.map(handler)) : handler(response);
+        };
+    }
+}
+exports.TranslateTo = TranslateTo;
+exports.translateToDirectiveTypeDefs = `
+directive @translateTo(
+  language: String!
+  behavior: String
+) on FIELD_DEFINITION
+`;

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

@@ -0,0 +1,22 @@
+import { Auth } from './Auth';
+import { CacheControl } from './CacheControl';
+import { Deprecated } from './Deprecated';
+import { Metric } from './Metric';
+import { SanitizeDirective } from './Sanitize';
+import { SettingsDirective } from './Settings';
+import { SmartCacheDirective } from './SmartCacheDirective';
+import { TranslatableV2 } from './TranslatableV2';
+import { TranslateTo } from './TranslateTo';
+export { parseTranslatableStringV2, formatTranslatableStringV2 } from '../../utils/translations';
+export declare const nativeSchemaDirectives: {
+    auth: typeof Auth;
+    cacheControl: typeof CacheControl;
+    deprecated: typeof Deprecated;
+    metric: typeof Metric;
+    sanitize: typeof SanitizeDirective;
+    settings: typeof SettingsDirective;
+    smartcache: typeof SmartCacheDirective;
+    translatableV2: typeof TranslatableV2;
+    translateTo: typeof TranslateTo;
+};
+export declare const nativeSchemaDirectivesTypeDefs: string;

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nativeSchemaDirectivesTypeDefs = exports.nativeSchemaDirectives = void 0;
+const Auth_1 = require("./Auth");
+const CacheControl_1 = require("./CacheControl");
+const Deprecated_1 = require("./Deprecated");
+const Metric_1 = require("./Metric");
+const Sanitize_1 = require("./Sanitize");
+const Settings_1 = require("./Settings");
+const SmartCacheDirective_1 = require("./SmartCacheDirective");
+const TranslatableV2_1 = require("./TranslatableV2");
+const TranslateTo_1 = require("./TranslateTo");
+var translations_1 = require("../../utils/translations");
+Object.defineProperty(exports, "parseTranslatableStringV2", { enumerable: true, get: function () { return translations_1.parseTranslatableStringV2; } });
+Object.defineProperty(exports, "formatTranslatableStringV2", { enumerable: true, get: function () { return translations_1.formatTranslatableStringV2; } });
+exports.nativeSchemaDirectives = {
+    auth: Auth_1.Auth,
+    cacheControl: CacheControl_1.CacheControl,
+    deprecated: Deprecated_1.Deprecated,
+    metric: Metric_1.Metric,
+    sanitize: Sanitize_1.SanitizeDirective,
+    settings: Settings_1.SettingsDirective,
+    smartcache: SmartCacheDirective_1.SmartCacheDirective,
+    translatableV2: TranslatableV2_1.TranslatableV2,
+    translateTo: TranslateTo_1.TranslateTo,
+};
+exports.nativeSchemaDirectivesTypeDefs = [
+    Auth_1.authDirectiveTypeDefs,
+    CacheControl_1.cacheControlDirectiveTypeDefs,
+    Deprecated_1.deprecatedDirectiveTypeDefs,
+    Metric_1.metricDirectiveTypeDefs,
+    Sanitize_1.sanitizeDirectiveTypeDefs,
+    Settings_1.settingsDirectiveTypeDefs,
+    SmartCacheDirective_1.smartCacheDirectiveTypeDefs,
+    TranslatableV2_1.translatableV2DirectiveTypeDefs,
+    TranslateTo_1.translateToDirectiveTypeDefs,
+].join('\n\n');

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

@@ -0,0 +1,8 @@
+import { GraphQLScalarType } from 'graphql';
+import { SchemaMetaData } from '../../schema';
+export declare const nativeResolvers: {
+    IOSanitizedString: import("./sanitizedString").IOSanitizedStringType;
+    IOUpload: GraphQLScalarType;
+    Upload: GraphQLScalarType;
+};
+export declare const nativeTypeDefs: (metaData: SchemaMetaData) => string;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nativeTypeDefs = exports.nativeResolvers = void 0;
+const graphql_upload_1 = require("graphql-upload");
+const ramda_1 = require("ramda");
+const ioUpload_1 = require("./ioUpload");
+const sanitizedString_1 = require("./sanitizedString");
+exports.nativeResolvers = {
+    'IOSanitizedString': sanitizedString_1.resolvers,
+    'IOUpload': ioUpload_1.resolvers,
+    'Upload': graphql_upload_1.GraphQLUpload,
+};
+exports.nativeTypeDefs = (metaData) => ramda_1.reduce((acc, scalar) => !metaData[scalar] ? `${acc}\nscalar ${scalar}\n` : acc, '', ramda_1.keys(exports.nativeResolvers));

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvers = exports.scalar = void 0;
 const graphql_1 = require("graphql");
 const name = 'IOUpload';
 exports.scalar = name;

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvers = exports.IOSanitizedStringType = exports.scalar = void 0;
 const graphql_1 = require("graphql");
 const xss_1 = require("xss");
 const defaultName = 'IOSanitizedString';
@@ -15,7 +16,11 @@ class IOSanitizedStringType extends graphql_1.GraphQLScalarType {
     constructor(options) {
         const allowHTMLTags = options && options.allowHTMLTags;
         const stripIgnoreTag = !options || options.stripIgnoreTag !== false;
-        const xssOptions = Object.assign({ stripIgnoreTag }, !allowHTMLTags && { whiteList: [] }, stripIgnoreTag && { escapeHtml: noop });
+        const xssOptions = {
+            stripIgnoreTag,
+            ...!allowHTMLTags && { whiteList: [] },
+            ...stripIgnoreTag && { escapeHtml: noop },
+        };
         super({
             name: options ? `Custom${defaultName}` : defaultName,
             parseLiteral: ast => {

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

@@ -0,0 +1,31 @@
+import { DocumentNode, execute, GraphQLSchema } from 'graphql';
+import { IOClients } from '../../../../clients/IOClients';
+import { ParamsContext, RecorderState, ServiceContext } from '../typings';
+export interface Query {
+    variables?: Record<string, any>;
+    operationName?: string;
+    document: DocumentNode;
+}
+declare type TypeFromPromise<T> = T extends Promise<infer U> ? U : T;
+export declare type GraphQLResponse = TypeFromPromise<ReturnType<typeof execute>>;
+export interface GraphQLCacheControl {
+    maxAge: number;
+    scope: 'private' | 'public' | 'segment';
+    noCache: boolean;
+    noStore: boolean;
+}
+export interface GraphQLContext extends ParamsContext {
+    graphql: {
+        query?: Query;
+        graphqlResponse?: GraphQLResponse;
+        status: 'success' | 'error';
+        cacheControl: GraphQLCacheControl;
+    };
+}
+export declare type GraphQLServiceContext = ServiceContext<IOClients, RecorderState, GraphQLContext>;
+export interface ExecutableSchema {
+    schema: GraphQLSchema;
+    hasProvider: boolean;
+    provider?: string;
+}
+export {};

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

@@ -0,0 +1,2 @@
+import { GraphQLServiceContext } from '../typings';
+export declare const cacheControlHTTP: (ctx: GraphQLServiceContext) => string;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cacheControlHTTP = void 0;
+const domain_1 = require("../../../../../utils/domain");
+const PRIVATE_ROUTE_REGEX = /_v\/graphql\/private\/v*/;
+const linked = !!process.env.VTEX_APP_LINK;
+const isPrivateRoute = ({ request: { headers } }) => PRIVATE_ROUTE_REGEX.test(headers['x-forwarded-path'] || '');
+const publicRegExp = (endpoint) => new RegExp(`.*${endpoint.replace('.', '\\.')}.*`);
+const isPublicEndpoint = ({ request: { headers } }) => {
+    const host = headers['x-forwarded-host'];
+    if (headers.origin || !host) {
+        return false;
+    }
+    return domain_1.PUBLIC_DOMAINS.some(endpoint => publicRegExp(endpoint).test(host));
+};
+exports.cacheControlHTTP = (ctx) => {
+    const { graphql: { cacheControl: { maxAge, scope: scopeHint, noCache: noCacheHint, noStore: noStoreHint, }, }, vtex: { production, }, } = ctx;
+    const finalHeader = [];
+    const noCache = noCacheHint || !production || isPublicEndpoint(ctx);
+    if (noCache) {
+        finalHeader.push('no-cache');
+    }
+    const noStore = noStoreHint || linked;
+    if (noStore) {
+        finalHeader.push('no-store');
+    }
+    if (!noCache && !noStore) {
+        const scope = scopeHint === 'private' || isPrivateRoute(ctx) ? 'private' : 'public';
+        finalHeader.push(scope);
+        finalHeader.push(`max-age=${maxAge}`);
+    }
+    return finalHeader.join(',');
+};

package/lib/service/worker/runtime/graphql/utils/error.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLServiceContext } from '../typings';
+export declare const createFormatError: (ctx: GraphQLServiceContext) => (error: any) => any;

package/lib/service/worker/runtime/graphql/utils/error.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFormatError = void 0;
+const ramda_1 = require("ramda");
+const error_1 = require("../../../../../utils/error");
+const ERROR_FIELD_WHITELIST = ['message', 'path', 'stack', 'extensions', 'statusCode', 'name', 'headers', 'originalError', 'code'];
+const QUERY_FIELDS = ['query', 'operationName', 'variables'];
+const trimVariables = (variables) => {
+    if (variables) {
+        const stringifiedVariables = JSON.stringify(variables);
+        return stringifiedVariables.length <= 1024
+            ? stringifiedVariables
+            : `${stringifiedVariables.slice(0, 992)} [Truncated: variables too long]`;
+    }
+    return '';
+};
+const detailsFromCtx = (ctx) => {
+    const { headers: { 'x-forwarded-host': forwardedHost, 'x-forwarded-proto': forwardedProto, 'x-vtex-platform': platform, }, vtex: { operationId, requestId, }, } = ctx;
+    const queryRest = ramda_1.pick(QUERY_FIELDS, ctx.graphql.query || {});
+    const variables = ctx.request.is('multipart/form-data')
+        ? '[GraphQL Upload]'
+        : trimVariables(queryRest.variables);
+    const query = {
+        ...queryRest,
+        variables,
+    };
+    return {
+        forwardedHost,
+        forwardedProto,
+        operationId,
+        platform,
+        query,
+        requestId,
+    };
+};
+const formatError = (error, details) => {
+    const formattedError = ramda_1.pick(ERROR_FIELD_WHITELIST, error);
+    if (!formattedError.extensions) {
+        formattedError.extensions = {
+            code: 'INTERNAL_SERVER_ERROR',
+        };
+    }
+    if (formattedError.originalError) {
+        formattedError.originalError = error_1.cleanError(formattedError.originalError);
+        if (formattedError.stack === formattedError.originalError.stack) {
+            delete formattedError.originalError.stack;
+        }
+        if (!formattedError.extensions.exception) {
+            formattedError.extensions.exception = {
+                message: formattedError.originalError.message,
+                name: formattedError.originalError.name,
+                ...ramda_1.omit(error_1.SENSITIVE_EXCEPTION_FIELDS, formattedError.originalError),
+                sensitive: ramda_1.pick(error_1.SENSITIVE_EXCEPTION_FIELDS, formattedError.originalError),
+            };
+        }
+        else {
+            const mergedException = { ...formattedError.originalError,
+                ...formattedError.extensions.exception,
+            };
+            const extendedException = {
+                message: formattedError.originalError.message,
+                name: formattedError.originalError.name,
+                ...ramda_1.omit(error_1.SENSITIVE_EXCEPTION_FIELDS, mergedException),
+                sensitive: ramda_1.pick(error_1.SENSITIVE_EXCEPTION_FIELDS, mergedException),
+            };
+            formattedError.extensions.exception = error_1.cleanError(extendedException);
+        }
+        // Make originalError not enumerable to prevent duplicated log and response information
+        Object.defineProperty(formattedError, 'originalError', { enumerable: false });
+    }
+    Object.assign(formattedError, details);
+    return formattedError;
+};
+exports.createFormatError = (ctx) => {
+    const details = detailsFromCtx(ctx);
+    return (error) => formatError(error, details);
+};

package/lib/service/{graphql → worker/runtime/graphql}/utils/pathname.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePathName = void 0;
 const ramda_1 = require("ramda");
 exports.generatePathName = (rpath) => {
     const pathFieldNames = ramda_1.filter(value => typeof value === 'string', rpath);

package/lib/service/worker/runtime/graphql/utils/translations.d.ts

@@ -0,0 +1,14 @@
+import { Behavior } from '../../../../../clients';
+import { IOContext } from '../../typings';
+export declare const CONTEXT_REGEX: RegExp;
+export declare const FROM_REGEX: RegExp;
+export declare const CONTENT_REGEX: RegExp;
+export interface TranslatableMessageV2 {
+    from?: string;
+    content: string;
+    context?: string;
+}
+export declare type TranslationDirectiveType = 'translatableV2' | 'translateTo';
+export declare const parseTranslatableStringV2: (rawMessage: string) => TranslatableMessageV2;
+export declare const formatTranslatableStringV2: ({ from, content, context }: TranslatableMessageV2) => string;
+export declare const handleSingleString: (ctx: IOContext, loader: import("dataloader")<import("../../../../../clients").Message, string>, behavior: Behavior, directiveName: TranslationDirectiveType) => (rawMessage: string | null) => Promise<string | null>;

package/lib/service/worker/runtime/graphql/utils/translations.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSingleString = exports.formatTranslatableStringV2 = exports.parseTranslatableStringV2 = exports.CONTENT_REGEX = exports.FROM_REGEX = exports.CONTEXT_REGEX = void 0;
+exports.CONTEXT_REGEX = /\(\(\((?<context>(.)*)\)\)\)/;
+exports.FROM_REGEX = /\<\<\<(?<from>(.)*)\>\>\>/;
+exports.CONTENT_REGEX = /\(\(\((?<context>(.)*)\)\)\)|\<\<\<(?<from>(.)*)\>\>\>/g;
+exports.parseTranslatableStringV2 = (rawMessage) => {
+    var _a, _b, _c, _d;
+    const context = (_b = (_a = rawMessage.match(exports.CONTEXT_REGEX)) === null || _a === void 0 ? void 0 : _a.groups) === null || _b === void 0 ? void 0 : _b.context;
+    const from = (_d = (_c = rawMessage.match(exports.FROM_REGEX)) === null || _c === void 0 ? void 0 : _c.groups) === null || _d === void 0 ? void 0 : _d.from;
+    const content = rawMessage.replace(exports.CONTENT_REGEX, '');
+    return {
+        content: content === null || content === void 0 ? void 0 : content.trim(),
+        context: context === null || context === void 0 ? void 0 : context.trim(),
+        from: from === null || from === void 0 ? void 0 : from.trim(),
+    };
+};
+exports.formatTranslatableStringV2 = ({ from, content, context }) => `${content} ${context ? `(((${context})))` : ''} ${from ? `<<<${from}>>>` : ''}`;
+exports.handleSingleString = (ctx, loader, behavior, directiveName) => async (rawMessage) => {
+    // Messages only know how to process non empty strings.
+    if (rawMessage == null) {
+        return rawMessage;
+    }
+    const { content, context, from: maybeFrom } = exports.parseTranslatableStringV2(rawMessage);
+    const { binding, tenant } = ctx;
+    if (content == null) {
+        throw new Error(`@${directiveName} directive needs a content to translate, but received ${JSON.stringify(rawMessage)}`);
+    }
+    const from = maybeFrom || (binding === null || binding === void 0 ? void 0 : binding.locale) || (tenant === null || tenant === void 0 ? void 0 : tenant.locale);
+    if (from == null) {
+        throw new Error(`@${directiveName} 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`);
+    }
+    return loader.load({
+        behavior,
+        content,
+        context,
+        from,
+    });
+};

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

@@ -0,0 +1,5 @@
+import TokenBucket from 'tokenbucket';
+import { IOClients } from '../../../../clients/IOClients';
+import { ClientsConfig, ParamsContext, RecorderState, RouteHandler, ServiceRoute } from '../typings';
+export declare const createPrivateHttpRoute: <T extends IOClients, U extends RecorderState, V extends ParamsContext>(clientsConfig: ClientsConfig<T>, serviceHandler: import("koa-compose").Middleware<import("../typings").ServiceContext<T, U, V>> | import("koa-compose").Middleware<import("../typings").ServiceContext<T, U, V>>[], serviceRoute: ServiceRoute, routeId: string, globalLimiter: TokenBucket | undefined) => import("koa-compose").ComposedMiddleware<import("../typings").ServiceContext<T, U, V>>;
+export declare const createPublicHttpRoute: <T extends IOClients, U extends RecorderState, V extends ParamsContext>(clientsConfig: ClientsConfig<T>, serviceHandler: import("koa-compose").Middleware<import("../typings").ServiceContext<T, U, V>> | import("koa-compose").Middleware<import("../typings").ServiceContext<T, U, V>>[], serviceRoute: ServiceRoute, routeId: string, globalLimiter: TokenBucket | undefined) => import("koa-compose").ComposedMiddleware<import("../typings").ServiceContext<T, U, V>>;

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPublicHttpRoute = exports.createPrivateHttpRoute = void 0;
+const tracingMiddlewares_1 = require("../../../tracing/tracingMiddlewares");
+const compose_1 = require("../utils/compose");
+const toArray_1 = require("../utils/toArray");
+const authTokens_1 = require("./middlewares/authTokens");
+const cancellationToken_1 = require("./middlewares/cancellationToken");
+const clients_1 = require("./middlewares/clients");
+const context_1 = require("./middlewares/context");
+const rateLimit_1 = require("./middlewares/rateLimit");
+const requestStats_1 = require("./middlewares/requestStats");
+const setCookie_1 = require("./middlewares/setCookie");
+const settings_1 = require("./middlewares/settings");
+const timings_1 = require("./middlewares/timings");
+const vary_1 = require("./middlewares/vary");
+exports.createPrivateHttpRoute = (clientsConfig, serviceHandler, serviceRoute, routeId, globalLimiter) => {
+    var _a, _b;
+    const { implementation, options } = clientsConfig;
+    const middlewares = toArray_1.toArray(serviceHandler);
+    const pipeline = [
+        tracingMiddlewares_1.nameSpanOperationMiddleware('private-handler', routeId),
+        context_1.createPvtContextMiddleware(routeId, serviceRoute),
+        cancellationToken_1.cancellationToken,
+        requestStats_1.trackIncomingRequestStats,
+        vary_1.vary,
+        authTokens_1.authTokens,
+        clients_1.clients(implementation, options),
+        ...(serviceRoute.settingsType === 'workspace' || serviceRoute.settingsType === 'userAndWorkspace' ? [settings_1.getServiceSettings()] : []),
+        timings_1.timings,
+        rateLimit_1.concurrentRateLimiter((_a = serviceRoute === null || serviceRoute === void 0 ? void 0 : serviceRoute.rateLimitPerReplica) === null || _a === void 0 ? void 0 : _a.concurrent),
+        rateLimit_1.perMinuteRateLimiter((_b = serviceRoute === null || serviceRoute === void 0 ? void 0 : serviceRoute.rateLimitPerReplica) === null || _b === void 0 ? void 0 : _b.perMinute, globalLimiter),
+        tracingMiddlewares_1.traceUserLandRemainingPipelineMiddleware(),
+        ...middlewares,
+    ];
+    return compose_1.compose(pipeline);
+};
+exports.createPublicHttpRoute = (clientsConfig, serviceHandler, serviceRoute, routeId, globalLimiter) => {
+    var _a, _b;
+    const { implementation, options } = clientsConfig;
+    const middlewares = toArray_1.toArray(serviceHandler);
+    const pipeline = [
+        tracingMiddlewares_1.nameSpanOperationMiddleware('public-handler', routeId),
+        context_1.createPubContextMiddleware(routeId, serviceRoute),
+        cancellationToken_1.cancellationToken,
+        requestStats_1.trackIncomingRequestStats,
+        vary_1.vary,
+        authTokens_1.authTokens,
+        clients_1.clients(implementation, options),
+        ...(serviceRoute.settingsType === 'workspace' || serviceRoute.settingsType === 'userAndWorkspace' ? [settings_1.getServiceSettings()] : []),
+        setCookie_1.removeSetCookie,
+        timings_1.timings,
+        rateLimit_1.concurrentRateLimiter((_a = serviceRoute === null || serviceRoute === void 0 ? void 0 : serviceRoute.rateLimitPerReplica) === null || _a === void 0 ? void 0 : _a.concurrent),
+        rateLimit_1.perMinuteRateLimiter((_b = serviceRoute === null || serviceRoute === void 0 ? void 0 : serviceRoute.rateLimitPerReplica) === null || _b === void 0 ? void 0 : _b.perMinute, globalLimiter),
+        tracingMiddlewares_1.traceUserLandRemainingPipelineMiddleware(),
+        ...middlewares,
+    ];
+    return compose_1.compose(pipeline);
+};

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

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

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.authTokens = void 0;
 const JANUS_ENV_COOKIE_KEY = 'vtex-commerce-env';
 const VTEX_ID_COOKIE_KEY = 'VtexIdclientAutCookie';
 async function authTokens(ctx, next) {

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

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

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

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

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

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