@vtex/api 6.47.0 → 6.48.1-beta

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

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ramda_1 = require("ramda");
+const Logger_1 = require("../../../clients/Logger");
+const constants_1 = require("../../../constants");
+const RequestCancelledError_1 = require("../../../errors/RequestCancelledError");
+const array_1 = require("../utils/array");
+const pathname_1 = require("../utils/pathname");
+const CACHE_CONTROL_HEADER = 'cache-control';
+const META_HEADER = 'x-vtex-meta';
+const ETAG_HEADER = 'etag';
+const TWO_SECONDS_S = 2;
+const arrayHasError = ramda_1.any(ramda_1.has('errors'));
+const filterErrors = ramda_1.filter(ramda_1.has('errors'));
+const chainErrors = ramda_1.chain(ramda_1.prop('errors'));
+const hasError = ramda_1.compose(arrayHasError, array_1.toArray);
+const parseError = ramda_1.compose(chainErrors, filterErrors, array_1.toArray);
+const parseErrorResponse = (response) => {
+    if (hasError(response)) {
+        return parseError(response);
+    }
+    return null;
+};
+async function graphqlError(ctx, next) {
+    const { vtex: { production, route: { id, }, }, } = ctx;
+    let graphQLErrors = null;
+    try {
+        await next();
+        graphQLErrors = parseErrorResponse(ctx.graphql.graphqlResponse || {});
+    }
+    catch (e) {
+        if (e.code === RequestCancelledError_1.cancelledErrorCode) {
+            ctx.status = RequestCancelledError_1.cancelledRequestStatus;
+            return;
+        }
+        const formatError = ctx.graphql.formatters.formatError;
+        if (e.isGraphQLError) {
+            const response = JSON.parse(e.message);
+            graphQLErrors = parseError(response);
+            ctx.body = response;
+        }
+        else {
+            graphQLErrors = [formatError(e)];
+            ctx.body = { errors: graphQLErrors };
+        }
+        // Add response
+        ctx.status = e.statusCode || 500;
+        if (e.headers) {
+            ctx.set(e.headers);
+        }
+    }
+    finally {
+        if (graphQLErrors) {
+            const uniqueErrors = ramda_1.uniqBy((e) => {
+                if (e.extensions.exception && e.extensions.exception.request) {
+                    return e.extensions.exception.request.path;
+                }
+                return e;
+            }, graphQLErrors);
+            // Reduce size of `variables` prop in the errors.
+            ramda_1.map((e) => {
+                if (e.query && e.query.variables) {
+                    const stringifiedVariables = JSON.stringify(e.query.variables);
+                    e.query.variables = stringifiedVariables.length <= 1024 ? stringifiedVariables : '[variables too long]';
+                }
+            }, uniqueErrors);
+            console.error(`[node-vtex-api graphql errors] total=${graphQLErrors.length} unique=${uniqueErrors.length}`, uniqueErrors);
+            ctx.graphql.status = 'error';
+            // Do not generate etag for errors
+            ctx.remove(META_HEADER);
+            ctx.remove(ETAG_HEADER);
+            // In production errors, add two second cache
+            if (production) {
+                ctx.set(CACHE_CONTROL_HEADER, `public, max-age=${TWO_SECONDS_S}`);
+            }
+            else {
+                ctx.set(CACHE_CONTROL_HEADER, `no-cache, no-store`);
+            }
+            // Log each error to splunk individually
+            ramda_1.forEach((err) => {
+                // Prevent logging cancellation error (it's not an error)
+                if (!err.extensions.exception || err.extensions.exception.code !== RequestCancelledError_1.cancelledErrorCode) {
+                    // Add pathName to each error
+                    if (err.path) {
+                        err.pathName = pathname_1.generatePathName(err.path);
+                    }
+                    const log = Object.assign({}, err, { routeId: id });
+                    // Grab level from originalError, default to "error" level.
+                    let level = err.extensions.exception && err.extensions.exception.level;
+                    if (!level || !(level === Logger_1.LogLevel.Error || level === Logger_1.LogLevel.Warn)) {
+                        level = Logger_1.LogLevel.Error;
+                    }
+                    ctx.vtex.logger.log(log, level);
+                }
+                if (!constants_1.LINKED && err.extensions.exception && err.extensions.exception.sensitive) {
+                    delete err.extensions.exception.sensitive;
+                }
+            }, uniqueErrors);
+            // Expose graphQLErrors with pathNames to timings middleware
+            ctx.graphql.graphQLErrors = uniqueErrors;
+        }
+        else {
+            ctx.graphql.status = 'success';
+        }
+    }
+}
+exports.graphqlError = graphqlError;

package/lib/service/graphql/middlewares/formatters.d.ts

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

package/lib/service/graphql/middlewares/formatters.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const apollo_server_errors_1 = require("apollo-server-errors");
+const ramda_1 = require("ramda");
+const error_1 = require("../../../utils/error");
+const ERROR_FIELD_WHITELIST = ['message', 'path', 'stack', 'extensions', 'statusCode', 'name', 'headers', 'originalError', 'code'];
+// formatError overrides the default option in runHttpQuery, which
+// does not keep track of the error stack. All non-enumerable
+// properties of Error (including stack) need to be returned
+// explicitly, otherwise will not show up after a JSON.stringify call
+const createFormatError = (details) => (error) => {
+    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 = Object.assign({ 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 mergedExceptions = Object.assign({}, formattedError.originalError, formattedError.extensions.exception);
+            const extendedException = Object.assign({ message: formattedError.originalError.message, name: formattedError.originalError.name }, ramda_1.omit(error_1.SENSITIVE_EXCEPTION_FIELDS, mergedExceptions), { sensitive: ramda_1.pick(error_1.SENSITIVE_EXCEPTION_FIELDS, mergedExceptions) });
+            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;
+};
+const createFormatResponse = (formatter) => (response) => {
+    const { errors = null } = response || {};
+    return Object.assign({}, response, { errors: Array.isArray(errors) ? apollo_server_errors_1.formatApolloErrors(errors, { formatter }) : undefined });
+};
+async function createFormatters(ctx, next) {
+    const { headers: { 'x-forwarded-host': forwardedHost, 'x-forwarded-proto': forwardedProto, 'x-vtex-platform': platform, }, vtex: { operationId, requestId, }, } = ctx;
+    // Do not log variables for file uploads
+    const variables = ctx.request.is('multipart/form-data')
+        ? '[GraphQL Upload]'
+        : ctx.graphql.query && ctx.graphql.query.variables;
+    const query = Object.assign({}, ctx.graphql.query, { variables });
+    const details = {
+        forwardedHost,
+        forwardedProto,
+        operationId,
+        platform,
+        query,
+        requestId,
+    };
+    const formatError = createFormatError(details);
+    const formatResponse = createFormatResponse(formatError);
+    ctx.graphql.formatters = {
+        formatError,
+        formatResponse,
+    };
+    await next();
+}
+exports.createFormatters = createFormatters;

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

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

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const co_body_1 = require("co-body");
+const ramda_1 = require("ramda");
+const url_1 = require("url");
+const constants_1 = require("../../../constants");
+const parseVariables = (query) => {
+    if (query && query[constants_1.BODY_HASH]) {
+        return null;
+    }
+    if (query && typeof query.variables === 'string') {
+        query.variables = JSON.parse(query.variables);
+    }
+    return query;
+};
+const queryFromUrl = ramda_1.compose(parseVariables, ramda_1.prop('query'), ramda_1.partialRight(url_1.parse, [true]));
+async function parseQuery(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);
+    }
+    else {
+        query = queryFromUrl(request.url) || await co_body_1.json(req);
+    }
+    ctx.graphql.query = query;
+    await next();
+}
+exports.parseQuery = parseQuery;

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ramda_1 = require("ramda");
+const constants_1 = require("../../../constants");
+const cacheControl_1 = require("../utils/cacheControl");
+const DEV_FIELDS = ['data', 'errors', 'extensions'];
+const PROD_FIELDS = ['data', 'errors'];
+function setVaryHeaders(ctx, scope, segment) {
+    ctx.vary(constants_1.FORWARDED_HOST_HEADER);
+    if (segment) {
+        ctx.vary(constants_1.SEGMENT_HEADER);
+    }
+    if (scope === 'private' || ctx.query.scope === 'private') {
+        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) {
+    const { responseInit, graphqlResponse } = ctx.graphql;
+    const { production } = ctx.vtex;
+    const { maxAge = '', scope = '', segment = null, } = graphqlResponse ? cacheControl_1.cacheControl(graphqlResponse, ctx) : {};
+    const cacheControlHeader = ramda_1.reject(ramda_1.isEmpty, [maxAge, scope]).join(',');
+    ctx.set(Object.assign({}, responseInit && responseInit.headers, { 'Cache-Control': cacheControlHeader }));
+    if (ctx.method.toUpperCase() === 'GET') {
+        setVaryHeaders(ctx, scope, segment);
+    }
+    const fields = production ? PROD_FIELDS : DEV_FIELDS;
+    ctx.body = ramda_1.pick(fields, graphqlResponse);
+    await next();
+}
+exports.response = response;

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

@@ -0,0 +1,4 @@
+import { LRUCache } from '../../../caches';
+import { GraphQLServiceContext } from '../typings';
+export declare const graphqlRuntimeCacheStorage: LRUCache<string, string>;
+export declare function run(ctx: GraphQLServiceContext, next: () => Promise<void>): Promise<void>;

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const apollo_server_core_1 = require("apollo-server-core");
+const caches_1 = require("../../../caches");
+const maxAgeEnum_1 = require("../utils/maxAgeEnum");
+exports.graphqlRuntimeCacheStorage = new caches_1.LRUCache({
+    max: 100,
+});
+const persistedQueries = {
+    cache: exports.graphqlRuntimeCacheStorage,
+};
+const linked = !!process.env.VTEX_APP_LINK;
+async function run(ctx, next) {
+    const { method, graphql, request, } = ctx;
+    const { dataSources, formatters, query, schema, } = graphql;
+    const { formatError, formatResponse, } = formatters;
+    // We don't want resolvers to have access to the GraphQL context,
+    // so we delete it here and restore it after execution.
+    delete ctx.graphql;
+    try {
+        const { graphqlResponse, responseInit } = await apollo_server_core_1.runHttpQuery([], {
+            method,
+            options: {
+                cacheControl: {
+                    calculateHttpHeaders: true,
+                    defaultMaxAge: maxAgeEnum_1.defaultMaxAgeFromCtx(ctx),
+                    stripFormattedExtensions: false,
+                },
+                context: ctx,
+                dataSources,
+                debug: linked,
+                documentStore: exports.graphqlRuntimeCacheStorage,
+                formatError,
+                formatResponse,
+                parseOptions: {
+                    noLocation: !linked,
+                },
+                persistedQueries,
+                schema,
+                tracing: linked,
+            },
+            query: query,
+            request,
+        });
+        ctx.graphql = graphql;
+        ctx.graphql.responseInit = responseInit;
+        ctx.graphql.graphqlResponse = JSON.parse(graphqlResponse);
+    }
+    catch (err) {
+        ctx.graphql = graphql;
+        throw err;
+    }
+    await next();
+}
+exports.run = run;

package/lib/service/graphql/middlewares/schema.d.ts

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

package/lib/service/graphql/middlewares/schema.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("../schema");
+async function injectSchema(ctx, next) {
+    ctx.graphql.schema = schema_1.makeSchema(ctx);
+    await next();
+}
+exports.injectSchema = injectSchema;

package/lib/service/graphql/middlewares/timings.d.ts

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

package/lib/service/graphql/middlewares/timings.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function graphqlTimings(ctx, next) {
+    const start = process.hrtime();
+    // Errors will be caught by the next middleware so we don't have to catch.
+    await next();
+    // Batch success or error metric for entire operation
+    metrics.batch(`graphql-operation-${ctx.graphql.status}`, process.hrtime(start));
+}
+exports.graphqlTimings = graphqlTimings;

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

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

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

@@ -0,0 +1,3 @@
+import { GraphQLSchema } from 'graphql';
+export declare type SchemaMetaData = Record<string, boolean>;
+export declare const makeSchema: (ctx: import("../../typings").ServiceContext<import("../../..").IOClients, any, import("../typings").GraphQLContext>) => GraphQLSchema;

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_extra_1 = require("fs-extra");
+const graphql_tools_1 = require("graphql-tools");
+const ramda_1 = require("ramda");
+const messagesLoader_1 = require("./messagesLoader");
+const schemaDirectives_1 = require("./schemaDirectives");
+const typeDefs_1 = require("./typeDefs");
+const cache = {
+    executableSchema: null,
+    schemaMetaData: null,
+    typeDefs: null,
+};
+let appTypeDefs;
+try {
+    appTypeDefs = fs_extra_1.readFileSync('./service/schema.graphql', 'utf8');
+    // tslint:disable-next-line:no-empty
+}
+catch (err) { }
+exports.makeSchema = (ctx) => {
+    const { graphql: { resolvers: appResolvers, schemaDirectives: appDirectives, }, clients: { segment }, vtex: { locale }, } = ctx;
+    if (cache.executableSchema) {
+        return cache.executableSchema;
+    }
+    const schemaMetaData = extractSchemaMetaData(appTypeDefs);
+    // The target translation locale is only necessary if this GraphQL app uses the `IOMessage` resolver.
+    const getLocaleTo = async () => {
+        if (locale) {
+            return locale;
+        }
+        const { cultureInfo } = await segment.getSegment();
+        return cultureInfo;
+    };
+    const resolverContext = {
+        getLocaleTo,
+        translationsLoader: messagesLoader_1.messagesLoader(ctx.clients),
+    };
+    const executableSchema = graphql_tools_1.makeExecutableSchema({
+        resolvers: Object.assign({}, appResolvers, typeDefs_1.nativeResolvers(resolverContext)),
+        schemaDirectives: Object.assign({}, appDirectives, schemaDirectives_1.nativeSchemaDirectives),
+        typeDefs: getOrSetTypeDefs(schemaMetaData),
+    });
+    if (isSchemaCacheable(schemaMetaData)) {
+        cache.executableSchema = executableSchema;
+    }
+    return executableSchema;
+};
+const getOrSetTypeDefs = (schemaMetaData) => {
+    if (!cache.typeDefs) {
+        cache.typeDefs = [
+            appTypeDefs,
+            typeDefs_1.nativeTypeDefs(schemaMetaData),
+        ].join('\n\n');
+    }
+    return cache.typeDefs;
+};
+const hasScalar = (typeDefs) => (scalar) => new RegExp(`scalar(\\s)+${scalar}(\\s\\n)+`).test(typeDefs);
+const extractSchemaMetaData = (typeDefs) => {
+    if (!cache.schemaMetaData) {
+        const scalars = ramda_1.keys(typeDefs_1.scalarResolversMap);
+        const scalarsPresentInSchema = ramda_1.map(hasScalar(typeDefs), scalars);
+        cache.schemaMetaData = ramda_1.zipObj(scalars, scalarsPresentInSchema);
+    }
+    return cache.schemaMetaData;
+};
+const isSchemaCacheable = (schemaMetaData) => !ramda_1.any(scalar => schemaMetaData[scalar], typeDefs_1.shouldNotCacheWhenSchemaHas);

package/lib/service/graphql/schema/messagesLoader.d.ts

@@ -0,0 +1,4 @@
+import DataLoader from 'dataloader';
+import { IOClients } from '../../../clients/IOClients';
+import { IOMessage } from '../../../utils/message';
+export declare const messagesLoader: (clients: IOClients) => DataLoader<IOMessage, string>;

package/lib/service/graphql/schema/messagesLoader.js

@@ -0,0 +1,41 @@
+"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 message_1 = require("../../../utils/message");
+const sortByProvider = (indexedMessages) => ramda_1.sortBy(([_, message]) => message_1.providerFromMessage(message), indexedMessages);
+const sortByIndex = (indexedTranslations) => ramda_1.sortBy(([index, _]) => Number(index), indexedTranslations);
+exports.messagesLoader = (clients) => new dataloader_1.default(async (messages) => {
+    const to = messages[0].to;
+    const from = messages[0].from;
+    const indexedMessages = ramda_1.toPairs(messages);
+    const sortedIndexedMessages = sortByProvider(indexedMessages);
+    const originalIndexes = ramda_1.pluck(0, sortedIndexedMessages);
+    const sortedMessages = ramda_1.pluck(1, sortedIndexedMessages);
+    const messagesByProvider = {};
+    const indexByProvider = {};
+    sortedMessages.forEach((message, index) => {
+        const provider = message_1.providerFromMessage(message);
+        if (!messagesByProvider[provider]) {
+            messagesByProvider[provider] = [];
+            indexByProvider[provider] = [];
+        }
+        messagesByProvider[provider].push(ramda_1.pick(['id', 'content', 'description', 'behavior'], message));
+        indexByProvider[provider].push(index);
+    });
+    const messagesInput = ramda_1.compose(ramda_1.values, ramda_1.mapObjIndexed((messagesArray, provider) => ({
+        messages: ramda_1.map(message_1.removeProviderFromId, messagesArray),
+        provider,
+    })))(messagesByProvider);
+    const translations = await clients.messagesGraphQL.translate({
+        from,
+        messages: messagesInput,
+        to,
+    });
+    const indexedTranslations = ramda_1.zip(originalIndexes, translations);
+    const translationsInOriginalOrder = sortByIndex(indexedTranslations);
+    return ramda_1.pluck(1, translationsInOriginalOrder);
+});

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

@@ -0,0 +1,5 @@
+import DataLoader from 'dataloader';
+import { IOClients } from '../../../clients/IOClients';
+import { IOMessageV2 } from './../../../clients/MessagesGraphQL';
+export declare const messagesLoaderV2: (clients: IOClients) => DataLoader<IOMessageV2, string>;
+export declare type MessagesLoaderV2 = ReturnType<typeof messagesLoaderV2>;

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

@@ -0,0 +1,44 @@
+"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);
+const sortByIndex = (indexedTranslations) => ramda_1.sortBy(([index, _]) => Number(index), indexedTranslations);
+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;
+}, []);
+exports.messagesLoaderV2 = (clients) => new dataloader_1.default(async (messages) => {
+    const to = messages[0].to;
+    const indexedMessages = ramda_1.toPairs(messages);
+    const sortedIndexedMessages = sortByContentAndFrom(indexedMessages);
+    const originalIndexes = ramda_1.pluck(0, sortedIndexedMessages);
+    const sortedMessages = ramda_1.pluck(1, sortedIndexedMessages);
+    const indexedByFrom = indexMessagesByFrom(sortedMessages);
+    const depTree = ramda_1.any(ioMessage => !!ioMessage.withAppsMetaInfo, messages) ? JSON.stringify(await clients.apps.getAppsMetaInfos()) : '';
+    const translations = await clients.messagesGraphQL.translateV2({
+        depTree,
+        indexedByFrom,
+        to,
+    });
+    const indexedTranslations = ramda_1.zip(originalIndexes, translations);
+    const translationsInOriginalOrder = sortByIndex(indexedTranslations);
+    return ramda_1.pluck(1, translationsInOriginalOrder);
+});

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

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

@@ -3,7 +3,7 @@ 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 apollo_server_core_1 = require("apollo-server-core");
 const axios_1 = __importDefault(require("axios"));
 const graphql_1 = require("graphql");
 const graphql_tools_1 = require("graphql-tools");
@@ -37,20 +37,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_errors_1.ForbiddenError('VtexIdclientAutCookie not found.');
+        throw new apollo_server_core_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.');
+        throw new apollo_server_core_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.');
+        throw new apollo_server_core_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).');
+        throw new apollo_server_core_1.UserInputError('Invalid auth schema directive args. Usage: @auth(productCode: String, resourceCode: String).');
     }
     return authArgs;
 }
@@ -65,9 +65,3 @@ 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 → graphql}/schema/schemaDirectives/Sanitize.d.ts

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

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

@@ -27,9 +27,3 @@ class SanitizeDirective extends graphql_tools_1.SchemaDirectiveVisitor {
     }
 }
 exports.SanitizeDirective = SanitizeDirective;
-exports.sanitizeDirectiveTypeDefs = `
-directive @sanitize(
-  allowHTMLTags: Boolean
-  stripIgnoreTag: Boolean
-) on FIELD_DEFINITION | INPUT_FIELD_DEFINITION | ARGUMENT_DEFINITION
-`;

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

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

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

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

@@ -1,7 +1,6 @@
 import { GraphQLField } from 'graphql';
 import { SchemaDirectiveVisitor } from 'graphql-tools';
 import { ServiceContext } from '../../../typings';
-export declare class TranslateTo extends SchemaDirectiveVisitor {
+export declare class Translatable 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";