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

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

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphqlError = void 0;
+const apollo_server_errors_1 = require("apollo-server-errors");
+const ramda_1 = require("ramda");
+const constants_1 = require("../../../../../constants");
+const RequestCancelledError_1 = require("../../../../../errors/RequestCancelledError");
+const logger_1 = require("../../../../logger");
+const error_1 = require("../utils/error");
+const pathname_1 = require("../utils/pathname");
+const TWO_SECONDS_S = 2;
+const uniqErrorsByPath = (errors) => ramda_1.uniqBy(e => e.extensions && e.extensions.exception && e.extensions.exception.request
+    ? e.extensions.exception.request.path
+    : e, errors);
+const createLogErrorToSplunk = (vtex) => (err) => {
+    var _a, _b, _c, _d, _e, _f;
+    const { route: { id }, logger, } = vtex;
+    try {
+        // Prevent logging cancellation error (it's not an error)
+        if (((_b = (_a = err === null || err === void 0 ? void 0 : err.extensions) === null || _a === void 0 ? void 0 : _a.exception) === null || _b === void 0 ? void 0 : _b.code) === RequestCancelledError_1.cancelledErrorCode) {
+            return;
+        }
+        // Add pathName to each error
+        if (err.path) {
+            err.pathName = pathname_1.generatePathName(err.path);
+        }
+        const log = {
+            ...err,
+            routeId: id,
+        };
+        // Grab level from originalError, default to "error" level.
+        let level = (_d = (_c = err === null || err === void 0 ? void 0 : err.extensions) === null || _c === void 0 ? void 0 : _c.exception) === null || _d === void 0 ? void 0 : _d.level;
+        if (!level || !(level === logger_1.LogLevel.Error || level === logger_1.LogLevel.Warn)) {
+            level = logger_1.LogLevel.Error;
+        }
+        logger.log(log, level);
+    }
+    finally {
+        if (!constants_1.LINKED && ((_f = (_e = err === null || err === void 0 ? void 0 : err.extensions) === null || _e === void 0 ? void 0 : _e.exception) === null || _f === void 0 ? void 0 : _f.sensitive)) {
+            delete err.extensions.exception.sensitive;
+        }
+    }
+};
+async function graphqlError(ctx, next) {
+    const { vtex: { production }, } = ctx;
+    let graphQLErrors = null;
+    try {
+        await next();
+        const response = ctx.graphql.graphqlResponse;
+        if (response && Array.isArray(response.errors)) {
+            const formatter = error_1.createFormatError(ctx);
+            graphQLErrors = apollo_server_errors_1.formatApolloErrors(response.errors, { formatter });
+        }
+    }
+    catch (e) {
+        if (!(e instanceof apollo_server_errors_1.ApolloError)) {
+            throw e;
+        }
+        if (e.code === RequestCancelledError_1.cancelledErrorCode) {
+            ctx.status = RequestCancelledError_1.cancelledRequestStatus;
+            return;
+        }
+        const formatError = error_1.createFormatError(ctx);
+        graphQLErrors = Array.isArray(e)
+            ? e.map(formatError)
+            : [formatError(e)];
+        // Add response
+        ctx.status = e.statusCode || 500;
+        if (e.headers) {
+            ctx.set(e.headers);
+        }
+    }
+    finally {
+        if (graphQLErrors) {
+            ctx.graphql.status = 'error';
+            // Filter errors from the same path in the query. This should
+            // avoid logging multiple errors from an array for example
+            const uniqueErrors = uniqErrorsByPath(graphQLErrors);
+            // Log each error to splunk individually
+            const logToSplunk = createLogErrorToSplunk(ctx.vtex);
+            uniqueErrors.forEach(logToSplunk);
+            // In production errors, add two second cache
+            if (production) {
+                ctx.graphql.cacheControl.maxAge = TWO_SECONDS_S;
+            }
+            else {
+                ctx.graphql.cacheControl.noCache = true;
+                ctx.graphql.cacheControl.noStore = true;
+            }
+            ctx.graphql.graphqlResponse = {
+                ...ctx.graphql.graphqlResponse,
+                errors: uniqueErrors,
+            };
+        }
+    }
+}
+exports.graphqlError = graphqlError;

package/lib/service/worker/runtime/graphql/middlewares/query.d.ts

@@ -0,0 +1,3 @@
+import { ExecutableSchema } from './../typings';
+import { GraphQLServiceContext } from '../typings';
+export declare const extractQuery: (executableSchema: ExecutableSchema) => (ctx: GraphQLServiceContext, next: () => Promise<void>) => Promise<void>;

package/lib/service/worker/runtime/graphql/middlewares/query.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractQuery = void 0;
+const co_body_1 = require("co-body");
+const graphql_1 = require("graphql");
+const url_1 = require("url");
+const constants_1 = require("../../../../../constants");
+const LRUCache_1 = require("./../../../../../caches/LRUCache");
+const documentStorage = new LRUCache_1.LRUCache({
+    max: 500,
+});
+const queryFromUrl = (url) => {
+    const parsedUrl = url_1.parse(url, true);
+    const { query: querystringObj } = parsedUrl;
+    // Having a BODY_HASH means the query is in the body
+    if (querystringObj && querystringObj[constants_1.BODY_HASH]) {
+        return null;
+    }
+    // We need to JSON.parse the variables since they are a stringified
+    // in the querystring
+    if (querystringObj && typeof querystringObj.variables === 'string') {
+        querystringObj.variables = JSON.parse(querystringObj.variables);
+    }
+    return querystringObj;
+};
+const parseAndValidateQueryToSchema = (query, schema) => {
+    const document = graphql_1.parse(query);
+    const validation = graphql_1.validate(schema, document);
+    if (Array.isArray(validation) && validation.length > 0) {
+        throw validation;
+    }
+    return document;
+};
+exports.extractQuery = (executableSchema) => async function parseAndValidateQuery(ctx, next) {
+    const { request, req } = ctx;
+    let query;
+    if (request.is('multipart/form-data')) {
+        query = request.body;
+    }
+    else if (request.method.toUpperCase() === 'POST') {
+        query = await co_body_1.json(req, { limit: '3mb' });
+    }
+    else {
+        query = queryFromUrl(request.url) || (await co_body_1.json(req, { limit: '3mb' }));
+    }
+    // Assign the query before setting the query.document because if the
+    // validation fails we don't loose the query in our error log
+    ctx.graphql.query = query;
+    query.document = (await documentStorage.getOrSet(query.query, async () => ({
+        value: parseAndValidateQueryToSchema(query.query, executableSchema.schema),
+    })));
+    await next();
+};

package/lib/service/worker/runtime/graphql/middlewares/response.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.response = void 0;
+const constants_1 = require("../../../../../constants");
+const cacheControl_1 = require("../utils/cacheControl");
+function setVaryHeaders(ctx, cacheControl) {
+    ctx.vary(constants_1.FORWARDED_HOST_HEADER);
+    if (cacheControl.scope === 'segment') {
+        ctx.vary(constants_1.SEGMENT_HEADER);
+    }
+    if (cacheControl.scope === 'private' || ctx.query.scope === 'private') {
+        ctx.vary(constants_1.SEGMENT_HEADER);
+        ctx.vary(constants_1.SESSION_HEADER);
+    }
+    else if (ctx.vtex.sessionToken) {
+        ctx.vtex.logger.warn({
+            message: 'GraphQL resolver receiving session token without private scope',
+            userAgent: ctx.get('user-agent'),
+        });
+    }
+}
+async function response(ctx, next) {
+    var _a;
+    await next();
+    const { cacheControl, status, graphqlResponse, } = ctx.graphql;
+    const cacheControlHeader = cacheControl_1.cacheControlHTTP(ctx);
+    ctx.set(constants_1.CACHE_CONTROL_HEADER, cacheControlHeader);
+    if (status === 'error') {
+        // Do not generate etag for errors
+        ctx.remove(constants_1.META_HEADER);
+        ctx.remove(constants_1.ETAG_HEADER);
+        (_a = ctx.vtex.recorder) === null || _a === void 0 ? void 0 : _a.clear();
+    }
+    if (ctx.method.toUpperCase() === 'GET') {
+        setVaryHeaders(ctx, cacheControl);
+    }
+    ctx.body = graphqlResponse;
+}
+exports.response = response;

package/lib/service/worker/runtime/graphql/middlewares/run.d.ts

@@ -0,0 +1,2 @@
+import { ExecutableSchema, GraphQLServiceContext } from '../typings';
+export declare const run: (executableSchema: ExecutableSchema) => (ctx: GraphQLServiceContext, next: () => Promise<void>) => Promise<void>;

package/lib/service/worker/runtime/graphql/middlewares/run.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+const graphql_1 = require("graphql");
+exports.run = (executableSchema) => async function runHttpQuery(ctx, next) {
+    const { graphql: { query }, } = ctx;
+    const { document, operationName, variables: variableValues } = query;
+    const schema = executableSchema.schema;
+    const response = await graphql_1.execute({
+        contextValue: ctx,
+        document,
+        fieldResolver: (root, _, __, info) => root[info.fieldName],
+        operationName,
+        rootValue: null,
+        schema,
+        variableValues,
+    });
+    ctx.graphql.graphqlResponse = response;
+    await next();
+};

package/lib/service/worker/runtime/graphql/middlewares/updateSchema.d.ts

@@ -0,0 +1,5 @@
+import { IOClients } from '../../../../../clients';
+import { GraphQLOptions, ParamsContext, RecorderState } from '../../typings';
+import { ExecutableSchema } from '../typings';
+import { GraphQLServiceContext } from '../typings';
+export declare const updateSchema: <T extends IOClients, U extends RecorderState, V extends ParamsContext>(graphql: GraphQLOptions<T, U, V>, executableSchema: ExecutableSchema) => (ctx: GraphQLServiceContext, next: () => Promise<void>) => Promise<void>;

package/lib/service/worker/runtime/graphql/middlewares/updateSchema.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateSchema = void 0;
+const constants_1 = require("../../../../../constants");
+const utils_1 = require("../../../../../utils");
+const index_1 = require("../schema/index");
+exports.updateSchema = (graphql, executableSchema) => async function updateRunnableSchema(ctx, next) {
+    const { clients: { apps }, vtex: { logger }, app, } = ctx;
+    if (!ctx.headers[constants_1.PROVIDER_HEADER]) {
+        await next();
+        return;
+    }
+    // fetches the new schema and generate a new runnable schema, updates the provider app,
+    if (executableSchema.hasProvider &&
+        (!executableSchema.provider ||
+            utils_1.majorEqualAndGreaterThan(utils_1.parseAppId(ctx.headers[constants_1.PROVIDER_HEADER]).version, utils_1.parseAppId(executableSchema.provider).version))) {
+        try {
+            const newSchema = (await apps.getAppFile(ctx.headers[constants_1.PROVIDER_HEADER], 'public/schema.graphql')).data.toString('utf-8');
+            graphql.schema = newSchema;
+            const newRunnableSchema = index_1.makeSchema(graphql);
+            executableSchema.schema = newRunnableSchema.schema;
+            executableSchema.provider = ctx.headers[constants_1.PROVIDER_HEADER];
+        }
+        catch (error) {
+            logger.error({ error, message: 'Update schema failed', app });
+        }
+    }
+    await next();
+};

package/lib/service/worker/runtime/graphql/middlewares/upload.d.ts

@@ -0,0 +1,4 @@
+import { GraphQLServiceContext } from '../typings';
+declare function graphqlUploadKoaMiddleware(ctx: GraphQLServiceContext, next: () => Promise<void>): Promise<void>;
+export declare const upload: typeof graphqlUploadKoaMiddleware;
+export {};

package/lib/service/{graphql → worker/runtime/graphql}/middlewares/upload.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.upload = void 0;
 const graphql_upload_1 = require("graphql-upload");
 const graphqlUpload = graphql_upload_1.graphqlUploadKoa({
     maxFieldSize: 1e6,

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

@@ -0,0 +1,7 @@
+import { IOClients } from '../../../../../clients/IOClients';
+import { GraphQLOptions, ParamsContext, RecorderState } from '../../typings';
+export declare type SchemaMetaData = Record<string, boolean>;
+export declare const makeSchema: <ClientsT extends IOClients = IOClients, StateT extends RecorderState = RecorderState, CustomT extends ParamsContext = ParamsContext>(options: GraphQLOptions<ClientsT, StateT, CustomT>) => {
+    schema: import("graphql").GraphQLSchema;
+    hasProvider: boolean;
+};

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSchema = void 0;
+const fs_extra_1 = require("fs-extra");
+const graphql_tools_1 = require("graphql-tools");
+const ramda_1 = require("ramda");
+const schemaDirectives_1 = require("./schemaDirectives");
+const typeDefs_1 = require("./typeDefs");
+const mergeTypeDefs = (appTypeDefs, schemaMetaData) => [appTypeDefs, typeDefs_1.nativeTypeDefs(schemaMetaData), schemaDirectives_1.nativeSchemaDirectivesTypeDefs].join('\n\n');
+const hasScalar = (typeDefs) => (scalar) => new RegExp(`scalar(\\s)+${scalar}(\\s\\n)+`).test(typeDefs);
+const extractSchemaMetaData = (typeDefs) => {
+    const scalars = ramda_1.keys(typeDefs_1.nativeResolvers);
+    const scalarsPresentInSchema = ramda_1.map(hasScalar(typeDefs), scalars);
+    return ramda_1.zipObj(scalars, scalarsPresentInSchema);
+};
+exports.makeSchema = (options) => {
+    const { resolvers: appResolvers, schema: appSchema, schemaDirectives: appDirectives } = options;
+    const appTypeDefs = appSchema || fs_extra_1.readFileSync('./service/schema.graphql', 'utf8');
+    const schemaMetaData = extractSchemaMetaData(appTypeDefs);
+    const executableSchema = graphql_tools_1.makeExecutableSchema({
+        resolvers: {
+            ...appResolvers,
+            ...typeDefs_1.nativeResolvers,
+        },
+        schemaDirectives: {
+            ...appDirectives,
+            ...schemaDirectives_1.nativeSchemaDirectives,
+        },
+        typeDefs: mergeTypeDefs(appTypeDefs, schemaMetaData),
+    });
+    return { schema: executableSchema, hasProvider: appSchema ? true : false };
+};

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,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMessagesLoader = void 0;
+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/{graphql → worker/runtime/graphql}/schema/schemaDirectives/Auth.d.ts

@@ -3,3 +3,4 @@ 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/{graphql → worker/runtime/graphql}/schema/schemaDirectives/Auth.js

@@ -3,11 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const apollo_server_core_1 = require("apollo-server-core");
+exports.authDirectiveTypeDefs = exports.Auth = void 0;
+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) {
+async function parseIdToken(authToken, vtexIdToken) {
     const url = `vtexid.vtex.com.br/api/vtexid/pub/authenticated/user?authToken=${vtexIdToken}`;
     const req = await axios_1.default.request({
         headers: {
@@ -21,7 +22,7 @@ async function getUserEmail(authToken, vtexIdToken) {
     if (!req.data) {
         return undefined;
     }
-    return req.data.user;
+    return { ...req.data };
 }
 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`;
@@ -37,20 +38,20 @@ async function getUserCanAccessResource(authToken, account, userEmail, productCo
 async function auth(ctx, authArgs) {
     const vtexIdToken = ctx.cookies.get('VtexIdclientAutCookie') || ctx.get('VtexIdclientAutCookie');
     if (!vtexIdToken) {
-        throw new apollo_server_core_1.ForbiddenError('VtexIdclientAutCookie not found.');
+        throw new apollo_server_errors_1.AuthenticationError('VtexIdclientAutCookie not found.');
     }
-    const userEmail = await getUserEmail(ctx.vtex.authToken, vtexIdToken);
-    if (!userEmail) {
-        throw new apollo_server_core_1.ForbiddenError('Could not find user specified by VtexIdclientAutCookie.');
+    const parsedToken = await parseIdToken(ctx.vtex.authToken, vtexIdToken);
+    if (!parsedToken || parsedToken.account !== ctx.vtex.account) {
+        throw new apollo_server_errors_1.AuthenticationError('Could not find user specified by VtexIdclientAutCookie.');
     }
-    const userCanAccessResource = await getUserCanAccessResource(ctx.vtex.authToken, ctx.vtex.account, userEmail, authArgs.productCode, authArgs.resourceCode);
+    const userCanAccessResource = await getUserCanAccessResource(ctx.vtex.authToken, ctx.vtex.account, parsedToken.user, authArgs.productCode, authArgs.resourceCode);
     if (!userCanAccessResource) {
-        throw new apollo_server_core_1.ForbiddenError('User indicated by VtexIdclientAutCookie is not authorized to access the indicated resource.');
+        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_core_1.UserInputError('Invalid auth schema directive args. Usage: @auth(productCode: String, resourceCode: String).');
+        throw new apollo_server_errors_1.UserInputError('Invalid auth schema directive args. Usage: @auth(productCode: String, resourceCode: String).');
     }
     return authArgs;
 }
@@ -65,3 +66,9 @@ class Auth extends graphql_tools_1.SchemaDirectiveVisitor {
     }
 }
 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,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cacheControlDirectiveTypeDefs = exports.CacheControl = void 0;
+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,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) && 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";