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

package/lib/service/worker/index.js

@@ -0,0 +1,196 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startWorker = void 0;
+const http_1 = require("http");
+const koa_1 = __importDefault(require("koa"));
+const koa_compress_1 = __importDefault(require("koa-compress"));
+const koa_router_1 = __importDefault(require("koa-router"));
+const ramda_1 = require("ramda");
+const constants_1 = require("../../constants");
+const MetricsAccumulator_1 = require("../../metrics/MetricsAccumulator");
+const loaders_1 = require("../loaders");
+const console_1 = require("../logger/console");
+const logger_1 = require("../logger/logger");
+const requestMetricsMiddleware_1 = require("../metrics/requestMetricsMiddleware");
+const TracerSingleton_1 = require("../tracing/TracerSingleton");
+const tracingMiddlewares_1 = require("../tracing/tracingMiddlewares");
+const listeners_1 = require("./listeners");
+const handlers_1 = require("./runtime/builtIn/handlers");
+const middlewares_1 = require("./runtime/builtIn/middlewares");
+const events_1 = require("./runtime/events");
+const router_1 = require("./runtime/events/router");
+const graphql_1 = require("./runtime/graphql");
+const http_2 = require("./runtime/http");
+const error_1 = require("./runtime/http/middlewares/error");
+const rateLimit_1 = require("./runtime/http/middlewares/rateLimit");
+const router_2 = require("./runtime/http/router");
+const routes_1 = require("./runtime/http/routes");
+const statusTrack_1 = require("./runtime/statusTrack");
+const tokenBucket_1 = require("./runtime/utils/tokenBucket");
+const upSignal = () => {
+    const data = JSON.stringify({ statusTrack: true });
+    const options = {
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        host: 'localhost',
+        method: 'POST',
+        path: '/_up',
+        port: 5000,
+    };
+    const req = http_1.request(options);
+    req.write(data);
+    req.end();
+};
+const isUpSignal = (message) => message === constants_1.UP_SIGNAL;
+const onMessage = (service) => (message) => {
+    if (isUpSignal(message)) {
+        upSignal();
+        routes_1.logAvailableRoutes(service);
+    }
+    else if (statusTrack_1.isStatusTrack(message)) {
+        statusTrack_1.trackStatus();
+    }
+    else {
+        listeners_1.logger.warn({
+            content: message,
+            message: 'Master sent message',
+            pid: process.pid,
+        });
+    }
+};
+const createAppHttpHandlers = ({ config: { routes, clients } }, serviceJSON, globalLimiter) => {
+    if (routes && clients) {
+        return Object.keys(routes).reduce((acc, routeId) => {
+            var _a;
+            const serviceRoute = (_a = serviceJSON.routes) === null || _a === void 0 ? void 0 : _a[routeId];
+            if (!serviceRoute) {
+                throw new Error(`Could not find route: ${routeId}. Please add ${routeId} route in your service.json file`);
+            }
+            const { path: servicePath, public: publicRoute = false, extensible = false, } = serviceRoute;
+            if (publicRoute || extensible) {
+                acc.pub[routeId] = {
+                    handler: http_2.createPublicHttpRoute(clients, routes[routeId], serviceRoute, routeId, globalLimiter),
+                    path: servicePath,
+                };
+            }
+            else {
+                acc.pvt[routeId] = {
+                    handler: http_2.createPrivateHttpRoute(clients, routes[routeId], serviceRoute, routeId, globalLimiter),
+                    path: `/:account/:workspace${servicePath.replace(/\*([^/]*)/g, ':$1*')}`,
+                };
+            }
+            return acc;
+        }, {
+            pub: {},
+            pvt: {},
+        });
+    }
+    return null;
+};
+const routerFromPrivateHttpHandlers = (routes) => Object.values(routes).reduce((router, { handler, path }) => router.all(path, handler), new koa_router_1.default());
+const createAppGraphQLHandler = ({ config: { graphql, clients } }, { routes }, globalLimiter) => {
+    const route = routes === null || routes === void 0 ? void 0 : routes[graphql_1.GRAPHQL_ROUTE];
+    if (graphql && route && clients) {
+        return {
+            pvt: {
+                [graphql_1.GRAPHQL_ROUTE]: {
+                    handler: graphql_1.createGraphQLRoute(graphql, clients, route, graphql_1.GRAPHQL_ROUTE, globalLimiter),
+                    path: `/:account/:workspace${route.path}`,
+                },
+            },
+        };
+    }
+    return null;
+};
+const createAppEventHandlers = ({ config: { events, clients } }, serviceJSON, globalLimiter) => {
+    if (events && clients) {
+        return Object.keys(events).reduce((acc, eventId) => {
+            var _a;
+            const serviceEvent = (_a = serviceJSON.events) === null || _a === void 0 ? void 0 : _a[eventId];
+            acc[eventId] = events_1.createEventHandler(clients, eventId, events[eventId], serviceEvent, globalLimiter);
+            return acc;
+        }, {});
+    }
+    return null;
+};
+const createRuntimeHttpHandlers = (appEventHandlers, serviceJSON) => ({
+    pvt: {
+        __events: {
+            handler: router_1.routerFromEventHandlers(appEventHandlers),
+            path: '/:account/:workspace/_events',
+        },
+        __healthCheck: {
+            handler: handlers_1.healthcheckHandler(serviceJSON),
+            path: '/healthcheck',
+        },
+        __metricsLogger: {
+            handler: handlers_1.metricsLoggerHandler,
+            path: '/_metrics',
+        },
+        __statusTrack: {
+            handler: statusTrack_1.statusTrackHandler,
+            path: '/_status',
+        },
+        __whoami: {
+            handler: handlers_1.whoAmIHandler(serviceJSON),
+            path: '/:account/:workspace/_whoami',
+        },
+    },
+});
+const scaleClientCaches = (scaleFactor, options) => Object.entries(options || {}).forEach(([name, opts]) => {
+    if (opts && opts.memoryCache && scaleFactor > 1) {
+        const previous = opts.memoryCache.storage.max;
+        const current = previous / scaleFactor;
+        opts.memoryCache.storage.max = current;
+        console_1.logOnceToDevConsole(`Scaling ${name} cache capacity from ${previous} to ${current}`, logger_1.LogLevel.Warn);
+    }
+});
+exports.startWorker = (serviceJSON) => {
+    var _a, _b;
+    listeners_1.addProcessListeners();
+    const tracer = TracerSingleton_1.TracerSingleton.getTracer();
+    const app = new koa_1.default();
+    app.proxy = true;
+    app
+        .use(error_1.error)
+        .use(middlewares_1.prometheusLoggerMiddleware())
+        .use(tracingMiddlewares_1.addTracingMiddleware(tracer))
+        .use(requestMetricsMiddleware_1.addRequestMetricsMiddleware())
+        .use(middlewares_1.addMetricsLoggerMiddleware())
+        .use(rateLimit_1.concurrentRateLimiter((_a = serviceJSON === null || serviceJSON === void 0 ? void 0 : serviceJSON.rateLimitPerReplica) === null || _a === void 0 ? void 0 : _a.concurrent))
+        .use(koa_compress_1.default())
+        .use(middlewares_1.recorderMiddleware);
+    const service = loaders_1.getService();
+    const { config: { clients } } = service;
+    if (clients) {
+        scaleClientCaches(serviceJSON.workers, clients.options);
+    }
+    const globalLimiter = tokenBucket_1.createTokenBucket((_b = serviceJSON === null || serviceJSON === void 0 ? void 0 : serviceJSON.rateLimitPerReplica) === null || _b === void 0 ? void 0 : _b.perMinute);
+    const appHttpHandlers = createAppHttpHandlers(service, serviceJSON, globalLimiter);
+    const appEventHandlers = createAppEventHandlers(service, serviceJSON, globalLimiter);
+    const appGraphQLHandlers = createAppGraphQLHandler(service, serviceJSON, globalLimiter);
+    const runtimeHttpHandlers = createRuntimeHttpHandlers(appEventHandlers, serviceJSON);
+    const httpHandlers = [
+        appHttpHandlers,
+        appGraphQLHandlers,
+        runtimeHttpHandlers,
+    ]
+        .filter(x => x != null)
+        // TODO: Fix ramda typings. Apparently there was an update that broke things
+        .reduce(ramda_1.mergeDeepRight);
+    if (httpHandlers === null || httpHandlers === void 0 ? void 0 : httpHandlers.pub) {
+        const publicHandlersRouter = router_2.routerFromPublicHttpHandlers(httpHandlers.pub);
+        app.use(publicHandlersRouter);
+    }
+    if (httpHandlers === null || httpHandlers === void 0 ? void 0 : httpHandlers.pvt) {
+        const privateHandlersRouter = routerFromPrivateHttpHandlers(httpHandlers.pvt);
+        app.use(privateHandlersRouter.routes());
+    }
+    process.on('message', onMessage(serviceJSON));
+    return app;
+};
+global.metrics = new MetricsAccumulator_1.MetricsAccumulator();

package/lib/service/worker/listeners.d.ts

@@ -0,0 +1,3 @@
+import { Logger } from '../logger';
+export declare const logger: Logger;
+export declare const addProcessListeners: () => void;

package/lib/{utils/unhandled.js → service/worker/listeners.js}

@@ -1,18 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.addProcessListeners = exports.logger = void 0;
 const os_1 = require("os");
-const RequestCancelledError_1 = require("../errors/RequestCancelledError");
-const logger_1 = require("../service/logger");
-const logger = new logger_1.Logger({ account: 'unhandled', workspace: 'unhandled', requestId: 'unhandled', operationId: 'unhandled', production: process.env.VTEX_PRODUCTION === 'true' });
+const RequestCancelledError_1 = require("../../errors/RequestCancelledError");
+const logger_1 = require("../logger");
+exports.logger = new logger_1.Logger({ account: 'unhandled', workspace: 'unhandled', requestId: 'unhandled', operationId: 'unhandled', production: process.env.VTEX_PRODUCTION === 'true' });
 let watched;
-// Remove the any typings once we move to nodejs 10.x
-const handleSignal = (signal) => {
-    console.warn('Received signal', signal);
-    logger.warn({
-        signal,
-    });
-    // Default node behaviour
-    process.exit(128 + os_1.constants.signals[signal]);
+const handleSignal = signal => {
+    process.exit(os_1.constants.signals[signal]);
 };
 exports.addProcessListeners = () => {
     // Listeners already set up
@@ -21,9 +16,9 @@ exports.addProcessListeners = () => {
     }
     watched = process.on('uncaughtException', (err) => {
         console.error('uncaughtException', err);
-        if (err && logger) {
+        if (err && exports.logger) {
             err.type = 'uncaughtException';
-            logger.error(err);
+            exports.logger.error(err);
         }
         process.exit(420);
     });
@@ -32,9 +27,9 @@ exports.addProcessListeners = () => {
             return;
         }
         console.error('unhandledRejection', reason, promise);
-        if (reason && logger) {
+        if (reason && exports.logger) {
             reason.type = 'unhandledRejection';
-            logger.error(reason);
+            exports.logger.error(reason);
         }
     });
     process.on('warning', (warning) => {

package/lib/service/{Service.d.ts → worker/runtime/Service.d.ts}

@@ -1,5 +1,5 @@
-import { IOClients } from '../clients/IOClients';
-import { ServiceConfig } from './typings';
+import { IOClients } from '../../../clients/IOClients';
+import { ParamsContext, RecorderState, ServiceConfig } from './typings';
 /**
  * This is the client definition to allow type checking on code editors.
  * In you `index.ts`, you must `export default new Service({...})` with your
@@ -11,7 +11,7 @@ import { ServiceConfig } from './typings';
  * @template StateT The state bag in `ctx.state`
  * @template CustomT Any custom fields in `ctx`. THIS IS NOT RECOMMENDED. Use StateT instead.
  */
-export declare class Service<ClientsT extends IOClients = IOClients, StateT = void, CustomT = void> {
-    config: ServiceConfig<ClientsT, StateT, CustomT>;
-    constructor(config: ServiceConfig<ClientsT, StateT, CustomT>);
+export declare class Service<T extends IOClients, U extends RecorderState, V extends ParamsContext> {
+    config: ServiceConfig<T, U, V>;
+    constructor(config: ServiceConfig<T, U, V>);
 }

package/lib/service/{Service.js → worker/runtime/Service.js}

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Service = void 0;
+const logger_1 = require("../../logger");
 /**
  * This is the client definition to allow type checking on code editors.
  * In you `index.ts`, you must `export default new Service({...})` with your
@@ -15,7 +17,7 @@ class Service {
     constructor(config) {
         this.config = config;
         if (config.routes && config.routes.graphql) {
-            console.warn('Route id "graphql" is reserved and apps containing this routes will stop working in the near future. To create a GraphQL app, export a "graphql" key with {resolvers}.');
+            logger_1.logOnceToDevConsole(`Route id "graphql" is reserved and apps containing this routes will stop working in the near future. To create a GraphQL app, export a "graphql" key with {resolvers}.`, logger_1.LogLevel.Warn);
         }
     }
 }

package/lib/service/worker/runtime/builtIn/handlers.d.ts

@@ -0,0 +1,4 @@
+import { ServiceContext, ServiceJSON } from '../typings';
+export declare const whoAmIHandler: ({ events, routes, }: ServiceJSON) => (ctx: ServiceContext) => void;
+export declare const healthcheckHandler: ({ events, routes, }: ServiceJSON) => (ctx: ServiceContext) => void;
+export declare const metricsLoggerHandler: (ctx: ServiceContext) => void;

package/lib/service/worker/runtime/builtIn/handlers.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metricsLoggerHandler = exports.healthcheckHandler = exports.whoAmIHandler = void 0;
+exports.whoAmIHandler = ({ events, routes, }) => (ctx) => {
+    var _a, _b;
+    ctx.requestHandlerName = 'builtin:whoami';
+    (_b = (_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.currentSpan) === null || _b === void 0 ? void 0 : _b.setOperationName(ctx.requestHandlerName);
+    ctx.status = 200;
+    ctx.body = {
+        events,
+        routes,
+    };
+    ctx.set('Cache-Control', 'public, max-age=86400'); // cache for 24 hours
+};
+exports.healthcheckHandler = ({ events, routes, }) => (ctx) => {
+    var _a, _b;
+    ctx.requestHandlerName = 'builtin:healthcheck';
+    (_b = (_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.currentSpan) === null || _b === void 0 ? void 0 : _b.setOperationName(ctx.requestHandlerName);
+    ctx.status = 200;
+    ctx.body = {
+        events,
+        routes,
+    };
+};
+exports.metricsLoggerHandler = (ctx) => {
+    var _a, _b;
+    ctx.requestHandlerName = 'builtin:metrics-logger';
+    (_b = (_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.currentSpan) === null || _b === void 0 ? void 0 : _b.setOperationName(ctx.requestHandlerName);
+    ctx.status = 200;
+    ctx.body = ctx.metricsLogger.getSummaries();
+};

package/lib/service/worker/runtime/builtIn/middlewares.d.ts

@@ -0,0 +1,4 @@
+import { ServiceContext } from '../typings';
+export declare function recorderMiddleware(ctx: ServiceContext, next: () => Promise<void>): Promise<void>;
+export declare const addMetricsLoggerMiddleware: () => (ctx: ServiceContext, next: () => Promise<void>) => Promise<void>;
+export declare const prometheusLoggerMiddleware: () => (ctx: ServiceContext, next: () => Promise<void>) => Promise<void>;

package/lib/service/worker/runtime/builtIn/middlewares.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prometheusLoggerMiddleware = exports.addMetricsLoggerMiddleware = exports.recorderMiddleware = void 0;
+const prom_client_1 = require("prom-client");
+const constants_1 = require("../../../../constants");
+const metricsLogger_1 = require("../../../logger/metricsLogger");
+const EventLoopLagMeasurer_1 = require("../../../tracing/metrics/measurers/EventLoopLagMeasurer");
+const recorder_1 = require("../utils/recorder");
+async function recorderMiddleware(ctx, next) {
+    const recorder = new recorder_1.Recorder();
+    ctx.state.recorder = recorder;
+    await next();
+    recorder.flush(ctx);
+    return;
+}
+exports.recorderMiddleware = recorderMiddleware;
+exports.addMetricsLoggerMiddleware = () => {
+    const metricsLogger = new metricsLogger_1.MetricsLogger();
+    return (ctx, next) => {
+        ctx.metricsLogger = metricsLogger;
+        return next();
+    };
+};
+exports.prometheusLoggerMiddleware = () => {
+    prom_client_1.collectDefaultMetrics();
+    const eventLoopLagMeasurer = new EventLoopLagMeasurer_1.EventLoopLagMeasurer();
+    eventLoopLagMeasurer.start();
+    return async (ctx, next) => {
+        if (ctx.request.path !== '/metrics') {
+            return next();
+        }
+        const routeId = ctx.get(constants_1.COLOSSUS_ROUTE_ID_HEADER);
+        if (routeId) {
+            return next();
+        }
+        await eventLoopLagMeasurer.updateInstrumentsAndReset();
+        ctx.set('Content-Type', prom_client_1.register.contentType);
+        ctx.body = await prom_client_1.register.metrics();
+        ctx.status = 200;
+    };
+};

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

@@ -0,0 +1,4 @@
+import TokenBucket from 'tokenbucket';
+import { IOClients } from '../../../../clients/IOClients';
+import { ClientsConfig, EventHandler, ParamsContext, RecorderState, ServiceContext, ServiceEvent } from '../typings';
+export declare const createEventHandler: <T extends IOClients, U extends RecorderState, V extends ParamsContext>(clientsConfig: ClientsConfig<T>, eventId: string, handler: import("koa-compose").Middleware<import("../typings").EventContext<T, U>> | import("koa-compose").Middleware<import("../typings").EventContext<T, U>>[], serviceEvent: ServiceEvent | undefined, globalLimiter: TokenBucket | undefined) => import("koa-compose").ComposedMiddleware<ServiceContext<T, U, V>>;

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEventHandler = void 0;
+const tracingMiddlewares_1 = require("../../../tracing/tracingMiddlewares");
+const clients_1 = require("../http/middlewares/clients");
+const rateLimit_1 = require("../http/middlewares/rateLimit");
+const settings_1 = require("../http/middlewares/settings");
+const timings_1 = require("../http/middlewares/timings");
+const compose_1 = require("../utils/compose");
+const toArray_1 = require("../utils/toArray");
+const body_1 = require("./middlewares/body");
+const context_1 = require("./middlewares/context");
+exports.createEventHandler = (clientsConfig, eventId, handler, serviceEvent, globalLimiter) => {
+    var _a, _b;
+    const { implementation, options } = clientsConfig;
+    const middlewares = toArray_1.toArray(handler);
+    const pipeline = [
+        tracingMiddlewares_1.nameSpanOperationMiddleware('event-handler', eventId),
+        context_1.eventContextMiddleware,
+        body_1.parseBodyMiddleware,
+        clients_1.clients(implementation, options),
+        ...((serviceEvent === null || serviceEvent === void 0 ? void 0 : serviceEvent.settingsType) === 'workspace' || (serviceEvent === null || serviceEvent === void 0 ? void 0 : serviceEvent.settingsType) === 'userAndWorkspace' ? [settings_1.getServiceSettings()] : []),
+        timings_1.timings,
+        rateLimit_1.concurrentRateLimiter((_a = serviceEvent === null || serviceEvent === void 0 ? void 0 : serviceEvent.rateLimitPerReplica) === null || _a === void 0 ? void 0 : _a.concurrent),
+        rateLimit_1.perMinuteRateLimiter((_b = serviceEvent === null || serviceEvent === void 0 ? void 0 : serviceEvent.rateLimitPerReplica) === null || _b === void 0 ? void 0 : _b.perMinute, globalLimiter),
+        tracingMiddlewares_1.traceUserLandRemainingPipelineMiddleware(),
+        contextAdapter(middlewares),
+    ];
+    return compose_1.compose(pipeline);
+};
+function contextAdapter(middlewares) {
+    return async function middlewareCascade(ctx) {
+        const ctxEvent = {
+            body: ctx.state.body,
+            clients: ctx.clients,
+            key: ctx.vtex.eventInfo ? ctx.vtex.eventInfo.key : '',
+            metrics: ctx.metrics,
+            sender: ctx.vtex.eventInfo ? ctx.vtex.eventInfo.sender : '',
+            state: ctx.state,
+            subject: ctx.vtex.eventInfo ? ctx.vtex.eventInfo.subject : '',
+            timings: ctx.timings,
+            vtex: ctx.vtex,
+        };
+        await compose_1.composeForEvents(middlewares)(ctxEvent);
+        ctx.status = 204;
+    };
+}

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

@@ -0,0 +1,3 @@
+import { IOClients } from '../../../../../clients/IOClients';
+import { ParamsContext, RecorderState, ServiceContext } from '../../typings';
+export declare function parseBodyMiddleware<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/body.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBodyMiddleware = void 0;
+const co_body_1 = __importDefault(require("co-body"));
+const logger_1 = require("../../../../logger");
+const console_1 = require("./../../../../logger/console");
+async function parseBodyMiddleware(ctx, next) {
+    try {
+        ctx.state.body = await co_body_1.default(ctx.req);
+    }
+    catch (err) {
+        if (!(err instanceof Error)) {
+            throw err;
+        }
+        const msg = `Error parsing event body: ${err.message || err}`;
+        ctx.status = 500;
+        ctx.body = msg;
+        console_1.logOnceToDevConsole(msg, logger_1.LogLevel.Error);
+        return;
+    }
+    await next();
+}
+exports.parseBodyMiddleware = parseBodyMiddleware;

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,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventContextMiddleware = void 0;
+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 { RouteHandler, ServiceContext } from '../typings';
+export declare const routerFromEventHandlers: (events: Record<string, RouteHandler> | null) => (ctx: ServiceContext, next: () => Promise<void>) => Promise<void>;

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

@@ -0,0 +1,28 @@
+"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");
+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,28 @@
+"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';
+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,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;