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

package/lib/service/worker/runtime/events/router.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routerFromEventHandlers = void 0;
+const constants_1 = require("../../../../constants");
+const logger_1 = require("../../../logger");
+const console_1 = require("./../../../logger/console");
+const routerFromEventHandlers = (events) => {
+    return async (ctx, next) => {
+        const handlerId = ctx.get(constants_1.EVENT_HANDLER_ID_HEADER);
+        if (!handlerId || !events) {
+            return next();
+        }
+        if (handlerId == null) {
+            ctx.response.status = 400;
+            ctx.response.body = `Request header doesn't have the field x-event-handler-id`;
+            return;
+        }
+        const handler = events[handlerId];
+        if (!handler) {
+            const msg = `Event handler not found for ${handlerId}`;
+            ctx.response.status = 404;
+            ctx.response.body = msg;
+            (0, console_1.logOnceToDevConsole)(msg, logger_1.LogLevel.Error);
+            return;
+        }
+        await handler(ctx, next);
+    };
+};
+exports.routerFromEventHandlers = routerFromEventHandlers;

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

@@ -0,0 +1,6 @@
+import TokenBucket from 'tokenbucket';
+import { IOClients } from '../../../../clients/IOClients';
+import { ClientsConfig, GraphQLOptions, ParamsContext, RecorderState, ServiceRoute } from '../typings';
+import { GraphQLContext } from './typings';
+export declare const GRAPHQL_ROUTE = "__graphql";
+export declare const createGraphQLRoute: <T extends IOClients, U extends RecorderState, V extends ParamsContext>(graphql: GraphQLOptions<T, U, V>, clientsConfig: ClientsConfig<T>, serviceRoute: ServiceRoute, routeId: string, globalLimiter: TokenBucket | undefined) => import("koa-compose").ComposedMiddleware<import("../typings").ServiceContext<T, U, V & GraphQLContext>>;

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGraphQLRoute = exports.GRAPHQL_ROUTE = void 0;
+const tracingMiddlewares_1 = require("../../../tracing/tracingMiddlewares");
+const http_1 = require("../http");
+const context_1 = require("./middlewares/context");
+const error_1 = require("./middlewares/error");
+const query_1 = require("./middlewares/query");
+const response_1 = require("./middlewares/response");
+const run_1 = require("./middlewares/run");
+const updateSchema_1 = require("./middlewares/updateSchema");
+const upload_1 = require("./middlewares/upload");
+const schema_1 = require("./schema");
+exports.GRAPHQL_ROUTE = '__graphql';
+const createGraphQLRoute = (graphql, clientsConfig, serviceRoute, routeId, globalLimiter) => {
+    const executableSchema = (0, schema_1.makeSchema)(graphql);
+    const pipeline = [
+        (0, tracingMiddlewares_1.nameSpanOperationMiddleware)('graphql-handler', exports.GRAPHQL_ROUTE),
+        (0, updateSchema_1.updateSchema)(graphql, executableSchema),
+        context_1.injectGraphqlContext,
+        response_1.response,
+        error_1.graphqlError,
+        upload_1.upload,
+        (0, query_1.extractQuery)(executableSchema),
+        (0, run_1.run)(executableSchema),
+    ];
+    return (0, http_1.createPrivateHttpRoute)(clientsConfig, pipeline, serviceRoute, routeId, globalLimiter);
+};
+exports.createGraphQLRoute = createGraphQLRoute;

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

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

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectGraphqlContext = void 0;
+const constants_1 = require("../../../../../constants");
+async function injectGraphqlContext(ctx, next) {
+    ctx.graphql = {
+        cacheControl: {
+            maxAge: constants_1.MAX_AGE.LONG,
+            noCache: false,
+            noStore: false,
+            scope: 'public',
+        },
+        status: 'success',
+    };
+    await next();
+}
+exports.injectGraphqlContext = injectGraphqlContext;

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) => (0, 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 = (0, 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 = (0, error_1.createFormatError)(ctx);
+            graphQLErrors = (0, 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 = (0, 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,54 @@
+"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 = (0, 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 = (0, graphql_1.parse)(query);
+    const validation = (0, graphql_1.validate)(schema, document);
+    if (Array.isArray(validation) && validation.length > 0) {
+        throw validation;
+    }
+    return document;
+};
+const 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 (0, co_body_1.json)(req, { limit: '3mb' });
+    }
+    else {
+        query = queryFromUrl(request.url) || (await (0, 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();
+};
+exports.extractQuery = extractQuery;

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

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,30 @@
+"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");
+const 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 ||
+            (0, utils_1.majorEqualAndGreaterThan)((0, utils_1.parseAppId)(ctx.headers[constants_1.PROVIDER_HEADER]).version, (0, 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 = (0, 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();
+};
+exports.updateSchema = updateSchema;

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,7 +1,8 @@
 "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({
+const graphqlUpload = (0, graphql_upload_1.graphqlUploadKoa)({
     maxFieldSize: 1e6,
     maxFileSize: 4 * 1e6,
     maxFiles: 10,

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 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,33 @@
+"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, (0, 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 = (0, ramda_1.keys)(typeDefs_1.nativeResolvers);
+    const scalarsPresentInSchema = (0, ramda_1.map)(hasScalar(typeDefs), scalars);
+    return (0, ramda_1.zipObj)(scalars, scalarsPresentInSchema);
+};
+const makeSchema = (options) => {
+    const { resolvers: appResolvers, schema: appSchema, schemaDirectives: appDirectives } = options;
+    const appTypeDefs = appSchema || (0, fs_extra_1.readFileSync)('./service/schema.graphql', 'utf8');
+    const schemaMetaData = extractSchemaMetaData(appTypeDefs);
+    const executableSchema = (0, 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 };
+};
+exports.makeSchema = makeSchema;

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[]) => DataLoader<Message, string>;
+export type MessagesLoaderV2 = ReturnType<typeof createMessagesLoader>;

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

@@ -0,0 +1,81 @@
+"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) => (0, 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}`;
+const 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 = (0, ramda_1.zip)(originalIndexes, translations);
+        const allIndexedTranslations = [...indexedTranslations, ...original];
+        return sortByIndex(allIndexedTranslations);
+    }, {
+        batch: true,
+        cache: true,
+        cacheKeyFn: messageToKey,
+        maxBatchSize: 200,
+    });
+};
+exports.createMessagesLoader = createMessagesLoader;

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