@vtex/api 6.45.4

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

@@ -0,0 +1,3 @@
+import { IOClients } from '../../../../../clients/IOClients';
+import { ParamsContext, RecorderState, ServiceContext } from '../../typings';
+export declare function eventContextMiddleware<T extends IOClients, U extends RecorderState, V extends ParamsContext>(ctx: ServiceContext<T, U, V>, next: () => Promise<void>): Promise<void>;

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../../../../constants");
+const context_1 = require("../../utils/context");
+async function eventContextMiddleware(ctx, next) {
+    const { request: { header } } = ctx;
+    ctx.vtex = {
+        ...context_1.prepareHandlerCtx(header, ctx.tracing),
+        eventInfo: {
+            key: header[constants_1.EVENT_KEY_HEADER],
+            sender: header[constants_1.EVENT_SENDER_HEADER],
+            subject: header[constants_1.EVENT_SUBJECT_HEADER],
+        },
+        route: {
+            id: header[constants_1.EVENT_HANDLER_ID_HEADER],
+            params: {},
+            type: 'event',
+        },
+    };
+    await next();
+}
+exports.eventContextMiddleware = eventContextMiddleware;

package/lib/service/worker/runtime/events/router.d.ts

@@ -0,0 +1,2 @@
+import { ServiceContext } from '../typings';
+export declare const routerFromEventHandlers: (events: Record<string, import("koa-compose").Middleware<ServiceContext<import("../../../..").IOClients, import("../typings").RecorderState, import("../typings").ParamsContext>>> | null) => (ctx: ServiceContext<import("../../../..").IOClients, import("../typings").RecorderState, import("../typings").ParamsContext>, next: () => Promise<void>) => Promise<void>;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../../../constants");
+const logger_1 = require("../../../logger");
+const console_1 = require("./../../../logger/console");
+exports.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;
+            console_1.logOnceToDevConsole(msg, logger_1.LogLevel.Error);
+            return;
+        }
+        await handler(ctx, next);
+    };
+};

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,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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';
+exports.createGraphQLRoute = (graphql, clientsConfig, serviceRoute, routeId, globalLimiter) => {
+    const executableSchema = schema_1.makeSchema(graphql);
+    const pipeline = [
+        tracingMiddlewares_1.nameSpanOperationMiddleware('graphql-handler', exports.GRAPHQL_ROUTE),
+        updateSchema_1.updateSchema(graphql, executableSchema),
+        context_1.injectGraphqlContext,
+        response_1.response,
+        error_1.graphqlError,
+        upload_1.upload,
+        query_1.extractQuery(executableSchema),
+        run_1.run(executableSchema),
+    ];
+    return http_1.createPrivateHttpRoute(clientsConfig, pipeline, serviceRoute, routeId, globalLimiter);
+};

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

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

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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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.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,2 @@
+import { ExecutableSchema } from './../typings';
+export declare const extractQuery: (executableSchema: ExecutableSchema) => (ctx: import("../../typings").ServiceContext<import("../../../../..").IOClients, import("../../typings").RecorderState, import("../typings").GraphQLContext>, next: () => Promise<void>) => Promise<void>;

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

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

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

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 } from '../typings';
+export declare const run: (executableSchema: ExecutableSchema) => (ctx: import("../../typings").ServiceContext<import("../../../../..").IOClients, import("../../typings").RecorderState, import("../typings").GraphQLContext>, next: () => Promise<void>) => Promise<void>;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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,4 @@
+import { IOClients } from '../../../../../clients';
+import { GraphQLOptions, ParamsContext, RecorderState } from '../../typings';
+import { ExecutableSchema } from '../typings';
+export declare const updateSchema: <T extends IOClients, U extends RecorderState, V extends ParamsContext>(graphql: GraphQLOptions<T, U, V>, executableSchema: ExecutableSchema) => (ctx: import("../../typings").ServiceContext<IOClients, RecorderState, import("../typings").GraphQLContext>, next: () => Promise<void>) => Promise<void>;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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/worker/runtime/graphql/middlewares/upload.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_upload_1 = require("graphql-upload");
+const graphqlUpload = graphql_upload_1.graphqlUploadKoa({
+    maxFieldSize: 1e6,
+    maxFileSize: 4 * 1e6,
+    maxFiles: 10,
+});
+function graphqlUploadKoaMiddleware(ctx, next) {
+    return graphqlUpload(ctx, next);
+}
+exports.upload = graphqlUploadKoaMiddleware;

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,31 @@
+"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 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 };
+};