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

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deprecatedDirectiveTypeDefs = exports.Deprecated = void 0;
+const graphql_1 = require("graphql");
+const graphql_tools_1 = require("graphql-tools");
+const listeners_1 = require("../../../../listeners");
+let lastLog = process.hrtime();
+const LOG_PERIOD_S = 60;
+const hrtimeToS = (time) => time[0] + (time[1] / 1e9);
+class Deprecated extends graphql_tools_1.SchemaDirectiveVisitor {
+    visitArgumentDefinition(argument) {
+        this.maybeLogToSplunk({
+            description: argument.description,
+            name: argument.name,
+        });
+    }
+    visitInputFieldDefinition(field) {
+        this.maybeLogToSplunk({
+            description: field.description,
+            name: field.name,
+        });
+    }
+    visitFieldDefinition(field) {
+        const { resolve = graphql_1.defaultFieldResolver, name, type } = field;
+        const { reason } = this.args;
+        field.resolve = (root, args, ctx, info) => {
+            var _a, _b, _c;
+            this.maybeLogToSplunk({
+                headers: ctx.request.headers,
+                name,
+                query: ((_a = ctx.graphql.query) === null || _a === void 0 ? void 0 : _a.document) && (0, graphql_1.print)((_b = ctx.graphql.query) === null || _b === void 0 ? void 0 : _b.document),
+                reason,
+                variables: (_c = ctx.graphql.query) === null || _c === void 0 ? void 0 : _c.variables,
+            }, ctx.vtex.logger);
+            return resolve(root, args, ctx, info);
+        };
+    }
+    maybeLogToSplunk(payload, logger = listeners_1.logger) {
+        const now = process.hrtime();
+        const timeSinceLastLog = hrtimeToS([
+            now[0] - lastLog[0],
+            now[1] - lastLog[1],
+        ]);
+        if (timeSinceLastLog > LOG_PERIOD_S) {
+            lastLog = now;
+            logger.warn({
+                message: 'Deprecated field in use',
+                ...payload,
+            });
+        }
+    }
+}
+exports.Deprecated = Deprecated;
+exports.deprecatedDirectiveTypeDefs = `
+directive @deprecated(
+  reason: String = "No longer supported"
+) on
+    FIELD_DEFINITION
+  | INPUT_FIELD_DEFINITION
+  | ARGUMENT_DEFINITION
+  | FRAGMENT_DEFINITION
+`;

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

@@ -0,0 +1,7 @@
+import { GraphQLField } from 'graphql';
+import { SchemaDirectiveVisitor } from 'graphql-tools';
+import { GraphQLServiceContext } from '../../typings';
+export declare class Metric extends SchemaDirectiveVisitor {
+    visitFieldDefinition(field: GraphQLField<any, GraphQLServiceContext>): void;
+}
+export declare const metricDirectiveTypeDefs = "\ndirective @metric (\n  name: String\n) on FIELD_DEFINITION\n";

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metricDirectiveTypeDefs = exports.Metric = void 0;
+const graphql_1 = require("graphql");
+const graphql_tools_1 = require("graphql-tools");
+const __1 = require("../../../../../..");
+class Metric extends graphql_tools_1.SchemaDirectiveVisitor {
+    visitFieldDefinition(field) {
+        const { resolve = graphql_1.defaultFieldResolver, name: fieldName } = field;
+        const { name = `${__1.APP.NAME}-${fieldName}` } = this.args;
+        field.resolve = async (root, args, ctx, info) => {
+            let failedToResolve = false;
+            let result = null;
+            let ellapsed = [0, 0];
+            try {
+                const start = process.hrtime();
+                result = await resolve(root, args, ctx, info);
+                ellapsed = process.hrtime(start);
+            }
+            catch (error) {
+                result = error;
+                failedToResolve = true;
+            }
+            ctx.graphql.status = failedToResolve ? 'error' : 'success';
+            const payload = {
+                [ctx.graphql.status]: 1,
+            };
+            metrics.batch(`graphql-metric-${name}`, failedToResolve ? undefined : ellapsed, payload);
+            if (failedToResolve) {
+                throw result;
+            }
+            return result;
+        };
+    }
+}
+exports.Metric = Metric;
+exports.metricDirectiveTypeDefs = `
+directive @metric (
+  name: String
+) on FIELD_DEFINITION
+`;

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

@@ -6,3 +6,4 @@ export declare class SanitizeDirective extends SchemaDirectiveVisitor {
     visitArgumentDefinition(argument: GraphQLArgument): void;
     wrapType(field: any): void;
 }
+export declare const sanitizeDirectiveTypeDefs = "\ndirective @sanitize(\n  allowHTMLTags: Boolean\n  stripIgnoreTag: Boolean\n) on FIELD_DEFINITION | INPUT_FIELD_DEFINITION | ARGUMENT_DEFINITION\n";

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 (0, 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: (0, messagesLoaderV2_1.createMessagesLoader)(ctx.clients, to, dependencies),
+                };
+            }
+            const response = await resolve(root, args, ctx, info);
+            const { vtex, loaders: { messagesV2 } } = ctx;
+            const handler = (0, 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: (0, messagesLoaderV2_1.createMessagesLoader)(ctx.clients, language, dependencies),
+                };
+            }
+            const response = (await resolve(root, args, ctx, info));
+            const { vtex, loaders: { immutableMessagesV2 }, } = ctx;
+            const handler = (0, 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 = exports.formatTranslatableStringV2 = exports.parseTranslatableStringV2 = 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,14 @@
+"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,
+};
+const nativeTypeDefs = (metaData) => (0, ramda_1.reduce)((acc, scalar) => !metaData[scalar] ? `${acc}\nscalar ${scalar}\n` : acc, '', (0, ramda_1.keys)(exports.nativeResolvers));
+exports.nativeTypeDefs = nativeTypeDefs;

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,21 +1,26 @@
 "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';
 exports.scalar = defaultName;
 const noop = (html) => html;
 const serialize = (input, options) => {
-    return xss_1.filterXSS(input, options);
+    return (0, xss_1.filterXSS)(input, options);
 };
 const parseValue = (value, options) => {
-    return xss_1.filterXSS(value, options);
+    return (0, xss_1.filterXSS)(value, options);
 };
 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;
+}
+type TypeFromPromise<T> = T extends Promise<infer U> ? U : T;
+export 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 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,34 @@
+"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));
+};
+const 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(',');
+};
+exports.cacheControlHTTP = cacheControlHTTP;

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,78 @@
+"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 = (0, 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 = (0, ramda_1.pick)(ERROR_FIELD_WHITELIST, error);
+    if (!formattedError.extensions) {
+        formattedError.extensions = {
+            code: 'INTERNAL_SERVER_ERROR',
+        };
+    }
+    if (formattedError.originalError) {
+        formattedError.originalError = (0, 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,
+                ...(0, ramda_1.omit)(error_1.SENSITIVE_EXCEPTION_FIELDS, formattedError.originalError),
+                sensitive: (0, 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,
+                ...(0, ramda_1.omit)(error_1.SENSITIVE_EXCEPTION_FIELDS, mergedException),
+                sensitive: (0, ramda_1.pick)(error_1.SENSITIVE_EXCEPTION_FIELDS, mergedException),
+            };
+            formattedError.extensions.exception = (0, 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;
+};
+const createFormatError = (ctx) => {
+    const details = detailsFromCtx(ctx);
+    return (error) => formatError(error, details);
+};
+exports.createFormatError = createFormatError;

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

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

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 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>;