@vtex/api 6.45.4

package/lib/service/worker/runtime/graphql/schema/messagesLoaderV2.d.ts

@@ -0,0 +1,6 @@
+import DataLoader from 'dataloader';
+import { Message } from '../../../../../clients/apps/MessagesGraphQL';
+import { AppMetaInfo } from '../../../../../clients/infra/Apps';
+import { IOClients } from './../../../../../clients/IOClients';
+export declare const createMessagesLoader: ({ messagesGraphQL, assets }: IOClients, to: string, dependencies?: AppMetaInfo[] | undefined) => DataLoader<Message, string>;
+export declare type MessagesLoaderV2 = ReturnType<typeof createMessagesLoader>;

package/lib/service/worker/runtime/graphql/schema/messagesLoaderV2.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dataloader_1 = __importDefault(require("dataloader"));
+const ramda_1 = require("ramda");
+const sortByContentAndFrom = (indexedMessages) => ramda_1.sortBy(([_, { content, from }]) => `__from:${from}__content:${content}`, indexedMessages);
+// O(n) counting sort implementation
+const sortByIndex = (indexedTranslations) => indexedTranslations.reduce((acc, [index, data]) => {
+    acc[index] = data;
+    return acc;
+}, []);
+const indexMessagesByFrom = (messages) => messages.reduce((acc, { from, context, content, behavior }) => {
+    const lastIndexed = acc.length && acc[acc.length - 1];
+    const formatted = {
+        behavior,
+        content,
+        context,
+    };
+    if (lastIndexed && lastIndexed.from === from) {
+        lastIndexed.messages.push(formatted);
+    }
+    else {
+        acc.push({
+            from,
+            messages: [formatted],
+        });
+    }
+    return acc;
+}, []);
+const toPairs = (x) => x.map((xx, it) => [it, xx]);
+const splitIndex = (indexed) => indexed.reduce((acc, [index, data]) => {
+    acc[0].push(index);
+    acc[1].push(data);
+    return acc;
+}, [[], []]);
+const filterFromEqualsTo = (indexedMessages, to) => indexedMessages.reduce((acc, indexed) => {
+    const [index, { content, from }] = indexed;
+    if (to === from.toLowerCase() || !content) {
+        acc.original.push([index, content]);
+    }
+    else {
+        acc.toTranslate.push(indexed);
+    }
+    return acc;
+}, {
+    original: [],
+    toTranslate: [],
+});
+const messageToKey = ({ content, context, from }) => `:content:${content}:context:${context}:from:${from}`;
+exports.createMessagesLoader = ({ messagesGraphQL, assets }, to, dependencies) => {
+    const loweredTo = to.toLowerCase();
+    const messagesDeps = dependencies && assets.getFilteredDependencies('vtex.messages@1.x', dependencies);
+    const depTree = messagesDeps && JSON.stringify(messagesDeps);
+    return new dataloader_1.default(async (messages) => {
+        const indexedMessages = toPairs(messages);
+        const { toTranslate, original } = filterFromEqualsTo(indexedMessages, loweredTo);
+        // In case we have nothing to translate
+        if (toTranslate.length === 0) {
+            return messages.map(({ content }) => content);
+        }
+        const sortedIndexedMessages = sortByContentAndFrom(toTranslate);
+        const [originalIndexes, sortedMessages] = splitIndex(sortedIndexedMessages);
+        const indexedByFrom = indexMessagesByFrom(sortedMessages);
+        const args = { indexedByFrom, to };
+        const translations = depTree
+            ? await messagesGraphQL.translateWithDependencies({ ...args, depTree })
+            : await messagesGraphQL.translate(args);
+        const indexedTranslations = ramda_1.zip(originalIndexes, translations);
+        const allIndexedTranslations = [...indexedTranslations, ...original];
+        return sortByIndex(allIndexedTranslations);
+    }, {
+        batch: true,
+        cache: true,
+        cacheKeyFn: messageToKey,
+        maxBatchSize: 200,
+    });
+};

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

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

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

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const apollo_server_errors_1 = require("apollo-server-errors");
+const axios_1 = __importDefault(require("axios"));
+const graphql_1 = require("graphql");
+const graphql_tools_1 = require("graphql-tools");
+async function getUserEmail(authToken, vtexIdToken) {
+    const url = `vtexid.vtex.com.br/api/vtexid/pub/authenticated/user?authToken=${vtexIdToken}`;
+    const req = await axios_1.default.request({
+        headers: {
+            'Accept': 'application/json',
+            'Proxy-Authorization': authToken,
+            'X-VTEX-Proxy-To': `https://${url}`,
+        },
+        method: 'get',
+        url: `http://${url}`,
+    });
+    if (!req.data) {
+        return undefined;
+    }
+    return req.data.user;
+}
+async function getUserCanAccessResource(authToken, account, userEmail, productCode, resourceCode) {
+    const url = `http://${account}.vtexcommercestable.com.br/api/license-manager/pvt/accounts/${account}/products/${productCode}/logins/${userEmail}/resources/${resourceCode}/granted`;
+    const req = await axios_1.default.request({
+        headers: {
+            'Authorization': authToken,
+        },
+        method: 'get',
+        url,
+    });
+    return req.data;
+}
+async function auth(ctx, authArgs) {
+    const vtexIdToken = ctx.cookies.get('VtexIdclientAutCookie') || ctx.get('VtexIdclientAutCookie');
+    if (!vtexIdToken) {
+        throw new apollo_server_errors_1.ForbiddenError('VtexIdclientAutCookie not found.');
+    }
+    const userEmail = await getUserEmail(ctx.vtex.authToken, vtexIdToken);
+    if (!userEmail) {
+        throw new apollo_server_errors_1.ForbiddenError('Could not find user specified by VtexIdclientAutCookie.');
+    }
+    const userCanAccessResource = await getUserCanAccessResource(ctx.vtex.authToken, ctx.vtex.account, userEmail, authArgs.productCode, authArgs.resourceCode);
+    if (!userCanAccessResource) {
+        throw new apollo_server_errors_1.ForbiddenError('User indicated by VtexIdclientAutCookie is not authorized to access the indicated resource.');
+    }
+}
+function parseArgs(authArgs) {
+    if (!authArgs.productCode || !authArgs.resourceCode) {
+        throw new apollo_server_errors_1.UserInputError('Invalid auth schema directive args. Usage: @auth(productCode: String, resourceCode: String).');
+    }
+    return authArgs;
+}
+class Auth extends graphql_tools_1.SchemaDirectiveVisitor {
+    visitFieldDefinition(field) {
+        const { resolve = graphql_1.defaultFieldResolver } = field;
+        field.resolve = async (root, args, ctx, info) => {
+            const authArgs = parseArgs(this.args);
+            await auth(ctx, authArgs);
+            return resolve(root, args, ctx, info);
+        };
+    }
+}
+exports.Auth = Auth;
+exports.authDirectiveTypeDefs = `
+directive @auth(
+  productCode: String
+  resourceCode: String
+) on FIELD_DEFINITION
+`;

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

@@ -0,0 +1,7 @@
+import { GraphQLField } from 'graphql';
+import { SchemaDirectiveVisitor } from 'graphql-tools';
+import { GraphQLServiceContext } from '../../typings';
+export declare class CacheControl extends SchemaDirectiveVisitor {
+    visitFieldDefinition(field: GraphQLField<any, GraphQLServiceContext>): void;
+}
+export declare const cacheControlDirectiveTypeDefs = "\n\nenum IOCacheControlScope {\n  SEGMENT\n  PUBLIC\n  PRIVATE\n}\n\ndirective @cacheControl(\n  maxAge: Int\n  scope: IOCacheControlScope\n) on FIELD_DEFINITION\n";

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_1 = require("graphql");
+const graphql_tools_1 = require("graphql-tools");
+class CacheControl extends graphql_tools_1.SchemaDirectiveVisitor {
+    visitFieldDefinition(field) {
+        const { resolve = graphql_1.defaultFieldResolver } = field;
+        const { maxAge: directiveMaxAge, scope: directiveScope, } = this.args;
+        field.resolve = (root, args, ctx, info) => {
+            const { maxAge, scope, } = ctx.graphql.cacheControl;
+            if (Number.isInteger(directiveMaxAge) && directiveMaxAge < maxAge) {
+                ctx.graphql.cacheControl.maxAge = directiveMaxAge;
+            }
+            if (directiveScope === 'PRIVATE') {
+                ctx.graphql.cacheControl.scope = 'private';
+            }
+            else if (directiveScope === 'SEGMENT' && scope === 'public') {
+                ctx.graphql.cacheControl.scope = 'segment';
+            }
+            return resolve(root, args, ctx, info);
+        };
+    }
+}
+exports.CacheControl = CacheControl;
+exports.cacheControlDirectiveTypeDefs = `
+
+enum IOCacheControlScope {
+  SEGMENT
+  PUBLIC
+  PRIVATE
+}
+
+directive @cacheControl(
+  maxAge: Int
+  scope: IOCacheControlScope
+) on FIELD_DEFINITION
+`;

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

@@ -0,0 +1,11 @@
+import { GraphQLArgument, GraphQLField, GraphQLInputField } from 'graphql';
+import { SchemaDirectiveVisitor } from 'graphql-tools';
+import { Logger } from '../../../../../logger/logger';
+import { GraphQLServiceContext } from '../../typings';
+export declare class Deprecated extends SchemaDirectiveVisitor {
+    visitArgumentDefinition(argument: GraphQLArgument): void;
+    visitInputFieldDefinition(field: GraphQLInputField): void;
+    visitFieldDefinition(field: GraphQLField<any, GraphQLServiceContext>): void;
+    protected maybeLogToSplunk<T>(payload: T, logger?: Logger): void;
+}
+export declare const deprecatedDirectiveTypeDefs = "\ndirective @deprecated(\n  reason: String = \"No longer supported\"\n) on\n    FIELD_DEFINITION\n  | INPUT_FIELD_DEFINITION\n  | ARGUMENT_DEFINITION\n  | FRAGMENT_DEFINITION\n";

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

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

@@ -0,0 +1,9 @@
+import { GraphQLArgument, GraphQLField, GraphQLInputField } from 'graphql';
+import { SchemaDirectiveVisitor } from 'graphql-tools';
+export declare class SanitizeDirective extends SchemaDirectiveVisitor {
+    visitFieldDefinition(field: GraphQLField<any, any>): void;
+    visitInputFieldDefinition(field: GraphQLInputField): void;
+    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/worker/runtime/graphql/schema/schemaDirectives/Sanitize.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_1 = require("graphql");
+const graphql_tools_1 = require("graphql-tools");
+const sanitizedString_1 = require("../typeDefs/sanitizedString");
+class SanitizeDirective extends graphql_tools_1.SchemaDirectiveVisitor {
+    visitFieldDefinition(field) {
+        this.wrapType(field);
+    }
+    visitInputFieldDefinition(field) {
+        this.wrapType(field);
+    }
+    visitArgumentDefinition(argument) {
+        this.wrapType(argument);
+    }
+    wrapType(field) {
+        const options = this.args;
+        if (field.type instanceof graphql_1.GraphQLNonNull && field.type.ofType instanceof graphql_1.GraphQLScalarType) {
+            field.type = new graphql_1.GraphQLNonNull(new sanitizedString_1.IOSanitizedStringType(options));
+        }
+        else if (field.type instanceof graphql_1.GraphQLScalarType) {
+            field.type = new sanitizedString_1.IOSanitizedStringType(options);
+        }
+        else {
+            throw new Error('Can not apply @sanitize directive to non-scalar GraphQL type');
+        }
+    }
+}
+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,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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/worker/runtime/graphql/schema/schemaDirectives/SmartCacheDirective.d.ts

@@ -0,0 +1,6 @@
+import { GraphQLField } from 'graphql';
+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/worker/runtime/graphql/schema/schemaDirectives/SmartCacheDirective.js

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