@vtex/api 6.45.4

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,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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/worker/runtime/graphql/schema/schemaDirectives/TranslateTo.d.ts

@@ -0,0 +1,7 @@
+import { GraphQLField } from 'graphql';
+import { SchemaDirectiveVisitor } from 'graphql-tools';
+import { ServiceContext } from '../../../typings';
+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,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+exports.parseTranslatableStringV2 = translations_1.parseTranslatableStringV2;
+exports.formatTranslatableStringV2 = 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,7 @@
+import { GraphQLScalarType } from 'graphql';
+export declare const nativeResolvers: {
+    IOSanitizedString: import("./sanitizedString").IOSanitizedStringType;
+    IOUpload: GraphQLScalarType;
+    Upload: GraphQLScalarType;
+};
+export declare const nativeTypeDefs: (metaData: Record<string, boolean>) => string;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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/worker/runtime/graphql/schema/typeDefs/ioUpload.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLScalarType } from 'graphql';
+export declare const scalar = "IOUpload";
+export declare const resolvers: GraphQLScalarType;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_1 = require("graphql");
+const name = 'IOUpload';
+exports.scalar = name;
+exports.resolvers = new graphql_1.GraphQLScalarType({
+    description: 'The `IOUpload` scalar type represents a file upload.',
+    name,
+    parseValue: (value) => value,
+    parseLiteral() {
+        throw new Error('‘IOUpload’ scalar literal unsupported.');
+    },
+    serialize() {
+        throw new Error('‘IOUpload’ scalar serialization unsupported.');
+    },
+});

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

@@ -0,0 +1,10 @@
+import { GraphQLScalarType } from 'graphql';
+export declare const scalar = "IOSanitizedString";
+export interface SanitizeOptions {
+    allowHTMLTags?: boolean;
+    stripIgnoreTag?: boolean;
+}
+export declare class IOSanitizedStringType extends GraphQLScalarType {
+    constructor(options?: SanitizeOptions);
+}
+export declare const resolvers: IOSanitizedStringType;

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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);
+};
+const parseValue = (value, options) => {
+    return 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 = {
+            stripIgnoreTag,
+            ...!allowHTMLTags && { whiteList: [] },
+            ...stripIgnoreTag && { escapeHtml: noop },
+        };
+        super({
+            name: options ? `Custom${defaultName}` : defaultName,
+            parseLiteral: ast => {
+                switch (ast.kind) {
+                    case graphql_1.Kind.STRING:
+                        return parseValue(ast.value, xssOptions);
+                    default:
+                        return null;
+                }
+            },
+            parseValue: value => parseValue(value, xssOptions),
+            serialize: value => serialize(value, xssOptions),
+        });
+    }
+}
+exports.IOSanitizedStringType = IOSanitizedStringType;
+exports.resolvers = new IOSanitizedStringType();

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/typings.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1 @@
+export declare const cacheControlHTTP: (ctx: import("../../typings").ServiceContext<import("../../../../..").IOClients, import("../../typings").RecorderState, import("../typings").GraphQLContext>) => string;

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 @@
+export declare const createFormatError: (ctx: import("../../typings").ServiceContext<import("../../../../..").IOClients, import("../../typings").RecorderState, import("../typings").GraphQLContext>) => (error: any) => any;

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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/worker/runtime/graphql/utils/pathname.d.ts

@@ -0,0 +1 @@
+export declare const generatePathName: (rpath: [string | number]) => string;

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

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

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,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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,
+    });
+};