quidproquo-dev-server 0.0.228

package/lib/commonjs/main.js

@@ -0,0 +1,143 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spinUpService = void 0;
+/* eslint-disable no-console */
+const body_parser_1 = __importDefault(require("body-parser"));
+const express_1 = __importDefault(require("express"));
+const multer_1 = __importDefault(require("multer"));
+const path_1 = __importDefault(require("path"));
+const quidproquo_1 = require("quidproquo");
+const route_1 = require("./entry/route");
+const allServiceConfig_1 = require("./allServiceConfig");
+const dynamicModuleLoader_1 = require("./dynamicModuleLoader");
+const getServiceBaseDomain = (qpqConfig, devServerConfig) => quidproquo_1.qpqWebServerUtils.getDomainRoot(`${devServerConfig.serverDomain}:${devServerConfig.serverPort}`, quidproquo_1.qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig), quidproquo_1.qpqCoreUtils.getApplicationModuleFeature(qpqConfig));
+const getApiDomainsFromConfig = (qpqConfig, devServerConfig) => {
+    const baseDomain = getServiceBaseDomain(qpqConfig, devServerConfig);
+    const serviceName = quidproquo_1.qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    // Get apis
+    const apiConfigs = quidproquo_1.qpqWebServerUtils.getApiConfigs(qpqConfig);
+    const apiDomains = apiConfigs.map((apiConfig) => ({
+        apiName: apiConfig.apiName,
+        service: serviceName,
+        qpqConfig,
+        domain: `${apiConfig.apiSubdomain}.${baseDomain}`,
+        devDomain: baseDomain,
+        devPath: `/${apiConfig.apiSubdomain}/${serviceName}`,
+    }));
+    return apiDomains;
+};
+const getDynamicModuleLoader = (qpqConfig) => {
+    const serviceName = quidproquo_1.qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    return (runtime) => __awaiter(void 0, void 0, void 0, function* () { return (0, dynamicModuleLoader_1.dynamicModuleLoader)(serviceName, runtime); });
+};
+const spinUpService = (devServerConfig) => __awaiter(void 0, void 0, void 0, function* () {
+    const allServiceConfig = yield (0, allServiceConfig_1.getAllServiceConfigs)(devServerConfig);
+    const app = (0, express_1.default)();
+    app.use((0, multer_1.default)().any());
+    app.use(body_parser_1.default.json({ limit: '50mb' }));
+    const apiConfigs = allServiceConfig.map((qpqConfig) => getApiDomainsFromConfig(qpqConfig, devServerConfig)).flat();
+    const adminFrontend = path_1.default.join(__dirname, '../../..', 'node_modules', 'quidproquo-web-admin', 'lib');
+    // Admin page
+    app.use('/admin', express_1.default.static(adminFrontend));
+    app.get('/admin/service/log/list', (req, res) => {
+        // Manually set CORS headers
+        res.header('Access-Control-Allow-Headers', '*');
+        res.header('Access-Control-Allow-Methods', '*');
+        res.header('Access-Control-Allow-Origin', '*');
+        res.header('Access-Control-Allow-Credentials', 'false');
+        const serviceList = allServiceConfig.map((qpqConfig) => quidproquo_1.qpqCoreUtils.getApplicationModuleName(qpqConfig)).map((name) => `api/${name}`);
+        res.json(serviceList);
+    });
+    app.use(express_1.default.json());
+    app.options('/admin/service/log/execute', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        // Manually set CORS headers
+        res.header('Access-Control-Allow-Headers', '*');
+        res.header('Access-Control-Allow-Methods', '*');
+        res.header('Access-Control-Allow-Origin', '*');
+        res.header('Access-Control-Allow-Credentials', 'false');
+        res.json({ done: true });
+    }));
+    app.get('/mf-manifest-location.json', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        // Manually set CORS headers
+        res.header('Access-Control-Allow-Headers', '*');
+        res.header('Access-Control-Allow-Methods', '*');
+        res.header('Access-Control-Allow-Origin', '*');
+        res.header('Access-Control-Allow-Credentials', 'false');
+        res.json({ location: 'http://localhost:3005/mf-manifest.json' });
+    }));
+    app.post('/admin/service/log/execute', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        // Manually set CORS headers
+        res.header('Access-Control-Allow-Headers', '*');
+        res.header('Access-Control-Allow-Methods', '*');
+        res.header('Access-Control-Allow-Origin', '*');
+        res.header('Access-Control-Allow-Credentials', 'false');
+        // TODO: Get list of services from config dynamically
+        const serviceLog = req.body;
+        let runtimeModule = quidproquo_1.askProcessEvent;
+        if (serviceLog.runtimeType === quidproquo_1.QpqRuntimeType.EXECUTE_STORY) {
+            const [srcEntry, module] = serviceLog.tags[0].split('::');
+            const loadedModule = yield (0, dynamicModuleLoader_1.dynamicModuleLoader)(serviceLog.moduleName, srcEntry);
+            runtimeModule = loadedModule[module];
+        }
+        const result = yield (0, quidproquo_1.qpqExecuteLog)(serviceLog, runtimeModule);
+        res.json(result);
+    }));
+    // Proxy for all services
+    app.all('*', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        const apiConfig = apiConfigs.find((c) => req.url.startsWith(`${c.devPath}/`));
+        if (apiConfig) {
+            console.log(`[${req.method}::${req.socket.remoteAddress}]: ${req.protocol}://${req.get('host')}${req.url}`);
+            const event = {
+                protocol: req.protocol,
+                host: req.get('host') || devServerConfig.serverDomain,
+                path: req.url.substring(apiConfig.devPath.length).split('?')[0],
+                ip: req.socket.remoteAddress || '127.0.0.1',
+                query: req.query,
+                correlation: '',
+                headers: req.headers,
+                method: req.method,
+                isBase64Encoded: false,
+                body: typeof req.body === 'object' ? JSON.stringify(req.body) : req.body,
+            };
+            if (req.files) {
+                event.files = req.files.map((file) => ({
+                    base64Data: file.buffer.toString('base64'),
+                    filename: file.originalname,
+                    mimetype: file.mimetype,
+                }));
+            }
+            const response = yield (0, route_1.route)(event, apiConfig.qpqConfig, getDynamicModuleLoader(apiConfig.qpqConfig));
+            for (const [header, value] of Object.entries(response.headers)) {
+                res.set(header, value);
+            }
+            if (response.isBase64Encoded) {
+                res.status(response.statusCode).send(Buffer.from(response.body, 'base64'));
+            }
+            else {
+                res.status(response.statusCode).send(response.body);
+            }
+        }
+        else {
+            console.log(`NotFound::[${req.method}::${req.socket.remoteAddress}]: ${req.protocol}://${req.get('host')}${req.url}`);
+            res.status(500).send({ message: 'resource does not exist' });
+        }
+    }));
+    app.listen(devServerConfig.serverPort, '0.0.0.0', () => {
+        const baseDomain = getServiceBaseDomain(allServiceConfig[0], devServerConfig);
+        console.log(`⚡️⚡️⚡️[Qpq - Dev Server]⚡️⚡️⚡️: Server is running at [http://${baseDomain}]`);
+    });
+});
+exports.spinUpService = spinUpService;

package/lib/commonjs/types/DevServerConfig.d.ts

@@ -0,0 +1,4 @@
+export type DevServerConfig = {
+    serverDomain: 'localhost';
+    serverPort: 8080;
+};

package/lib/commonjs/types/DevServerConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/commonjs/types/ExpressEvent.d.ts

@@ -0,0 +1,26 @@
+import { QPQBinaryData } from 'quidproquo';
+export interface ExpressEvent {
+    protocol: string;
+    host: string;
+    path: string;
+    ip: string;
+    method: string;
+    query: {
+        [key: string]: undefined | string | string[];
+    };
+    correlation: string;
+    isBase64Encoded: boolean;
+    body: any;
+    headers: {
+        [key: string]: undefined | string;
+    };
+    files?: QPQBinaryData[];
+}
+export interface ExpressEventResponse {
+    statusCode: number;
+    body: string;
+    headers: {
+        [key: string]: undefined | string;
+    };
+    isBase64Encoded: boolean;
+}

package/lib/commonjs/types/ExpressEvent.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/commonjs/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './DevServerConfig';
+export * from './ExpressEvent';

package/lib/commonjs/types/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./DevServerConfig"), exports);
+__exportStar(require("./ExpressEvent"), exports);

package/lib/esm/allServiceConfig.d.ts

@@ -0,0 +1,3 @@
+import { QPQConfig } from 'quidproquo';
+import { DevServerConfig } from './types';
+export declare function getAllServiceConfigs(devServerConfig: DevServerConfig): QPQConfig[];

package/lib/esm/allServiceConfig.js

@@ -0,0 +1,40 @@
+import { qpqCoreUtils, qpqWebServerUtils } from 'quidproquo';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore - Special webpack loader
+import { qpqConfigs } from 'quidproquo-dynamic-loader';
+// Create an async function to fetch all services
+export function getAllServiceConfigs(devServerConfig) {
+    // Iterate over each enum value and dynamically import the corresponding infrastructure
+    const allServices = qpqConfigs;
+    const rootDomain = `${devServerConfig.serverDomain}:${devServerConfig.serverPort}`;
+    // TODO: Make this pure
+    // Overload the domain settings to represent the local env
+    // This is kind of gross, mutating it, but this is just dev.
+    for (const qpqConfig of allServices) {
+        // Make it a production build
+        // const appSettings = qpqCoreUtils.getApplicationModuleSetting(qpqConfig);
+        // appSettings.feature = undefined;
+        // appSettings.environment = 'production';
+        const baseDomain = qpqWebServerUtils.getDomainRoot(rootDomain, qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig), qpqCoreUtils.getApplicationModuleFeature(qpqConfig));
+        // Change the domain
+        const dnsConfigs = qpqWebServerUtils.getDnsConfigs(qpqConfig);
+        for (const dnsConfig of dnsConfigs) {
+            dnsConfig.dnsBase = rootDomain;
+        }
+        // Expose global cors headers
+        const defaultRouteSettings = qpqWebServerUtils.getDefaultRouteSettings(qpqConfig);
+        for (const getDefaultRouteSetting of defaultRouteSettings) {
+            getDefaultRouteSetting.routeOptions.allowedOrigins = [
+                ...(getDefaultRouteSetting.routeOptions.allowedOrigins || []),
+                `http://${baseDomain}`,
+                '*',
+            ];
+        }
+        // Expose global cors headers
+        const routes = qpqWebServerUtils.getAllRoutes(qpqConfig);
+        for (const route of routes) {
+            route.options.allowedOrigins = [...(route.options.allowedOrigins || []), `http://${baseDomain}`, '*'];
+        }
+    }
+    return allServices;
+}

package/lib/esm/dynamicModuleLoader/dynamicModuleLoader.d.ts

@@ -0,0 +1,3 @@
+import { QPQConfig, QpqFunctionRuntime } from 'quidproquo';
+export declare const dynamicModuleLoader: <T = any>(serviceName: string, runtime: QpqFunctionRuntime) => Promise<T>;
+export declare const getQpqConfigs: () => QPQConfig[];

package/lib/esm/dynamicModuleLoader/dynamicModuleLoader.js

@@ -0,0 +1,6 @@
+import { qpqConfigs, qpqDynamicModuleLoaderForService,
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore - Special webpack loader
+ } from 'quidproquo-dynamic-loader';
+export const dynamicModuleLoader = async (serviceName, runtime) => qpqDynamicModuleLoaderForService(serviceName, runtime);
+export const getQpqConfigs = () => qpqConfigs;

package/lib/esm/dynamicModuleLoader/index.d.ts

@@ -0,0 +1 @@
+export * from './dynamicModuleLoader';

package/lib/esm/dynamicModuleLoader/index.js

@@ -0,0 +1 @@
+export * from './dynamicModuleLoader';

package/lib/esm/entry/index.d.ts

@@ -0,0 +1 @@
+export * from './route';

package/lib/esm/entry/index.js

@@ -0,0 +1 @@
+export * from './route';

package/lib/esm/entry/route.d.ts

@@ -0,0 +1,3 @@
+import { DynamicModuleLoader, QPQConfig } from 'quidproquo';
+import { ExpressEvent, ExpressEventResponse } from '../types';
+export declare const route: (expressEvent: ExpressEvent, qpqConfig: QPQConfig, dynamicModuleLoader: DynamicModuleLoader) => Promise<ExpressEventResponse>;

package/lib/esm/entry/route.js

@@ -0,0 +1,52 @@
+import { randomUUID } from 'crypto';
+import { askProcessEvent, createRuntime, ErrorTypeEnum, qpqCoreUtils, QpqRuntimeType, qpqWebServerUtils, } from 'quidproquo';
+import { getAwsActionProcessors, getLogger } from 'quidproquo-actionprocessor-awslambda';
+import { getExpressApiEventEventProcessor } from '../getActionProcessor';
+// TODO: Make this a util or something based on server time or something..
+const getDateNow = () => new Date().toISOString();
+const ErrorTypeHttpResponseMap = {
+    [ErrorTypeEnum.BadRequest]: 400,
+    [ErrorTypeEnum.Unauthorized]: 401,
+    [ErrorTypeEnum.PaymentRequired]: 402,
+    [ErrorTypeEnum.Forbidden]: 403,
+    [ErrorTypeEnum.NotFound]: 404,
+    [ErrorTypeEnum.TimeOut]: 408,
+    [ErrorTypeEnum.Conflict]: 409,
+    [ErrorTypeEnum.UnsupportedMediaType]: 415,
+    [ErrorTypeEnum.OutOfResources]: 500,
+    [ErrorTypeEnum.GenericError]: 500,
+    [ErrorTypeEnum.NotImplemented]: 501,
+    [ErrorTypeEnum.NoContent]: 204,
+    [ErrorTypeEnum.Invalid]: 422,
+};
+export const route = async (expressEvent, qpqConfig, dynamicModuleLoader) => {
+    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    const resolveStory = createRuntime(qpqConfig, {
+        depth: 0,
+        accessToken: qpqWebServerUtils.getAccessTokenFromHeaders(expressEvent.headers),
+        context: {},
+    }, async () => ({
+        ...(await getAwsActionProcessors(qpqConfig, dynamicModuleLoader)),
+        ...(await getExpressApiEventEventProcessor(qpqConfig, dynamicModuleLoader)),
+    }), getDateNow, getLogger(qpqConfig), `${serviceName}::${randomUUID()}`, QpqRuntimeType.API, dynamicModuleLoader, []);
+    const result = await resolveStory(askProcessEvent, [expressEvent]);
+    // Run the callback
+    if (!result.error) {
+        const response = {
+            statusCode: result.result.statusCode,
+            body: result.result.body,
+            headers: result.result.headers,
+            isBase64Encoded: result.result.isBase64Encoded,
+        };
+        return response;
+    }
+    const code = ErrorTypeHttpResponseMap[result.error.errorType];
+    return {
+        statusCode: code || 500,
+        body: JSON.stringify(result.error),
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        isBase64Encoded: false,
+    };
+};

package/lib/esm/getActionProcessor/core/event/express/api/getEventAutoRespondActionProcessor.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export declare const getEventAutoRespondActionProcessor: ActionProcessorListResolver;

package/lib/esm/getActionProcessor/core/event/express/api/getEventAutoRespondActionProcessor.js

@@ -0,0 +1,16 @@
+import { actionResult, EventActionType, } from 'quidproquo-core';
+import { qpqWebServerUtils } from 'quidproquo-webserver';
+const getProcessAutoRespond = (qpqConfig) => async ({ qpqEventRecord, matchResult }) => {
+    if (qpqEventRecord.method === 'OPTIONS') {
+        return actionResult({
+            status: 200,
+            isBase64Encoded: false,
+            body: '',
+            headers: qpqWebServerUtils.getCorsHeaders(qpqConfig, matchResult.config || {}, qpqEventRecord.headers),
+        });
+    }
+    return actionResult(null);
+};
+export const getEventAutoRespondActionProcessor = async (qpqConfig) => ({
+    [EventActionType.AutoRespond]: getProcessAutoRespond(qpqConfig),
+});

package/lib/esm/getActionProcessor/core/event/express/api/getEventGetRecordsActionProcessor.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export declare const getEventGetRecordsActionProcessor: ActionProcessorListResolver;

package/lib/esm/getActionProcessor/core/event/express/api/getEventGetRecordsActionProcessor.js

@@ -0,0 +1,19 @@
+import { actionResult, EventActionType, } from 'quidproquo-core';
+const getProcessGetRecords = (_qpqConfig) => async ({ eventParams: [expressEvent] }) => {
+    const path = expressEvent.path || '';
+    const internalEventRecord = {
+        path,
+        query: expressEvent.query,
+        body: expressEvent.body,
+        headers: expressEvent.headers,
+        method: expressEvent.method,
+        correlation: expressEvent.correlation,
+        sourceIp: expressEvent.ip,
+        isBase64Encoded: expressEvent.isBase64Encoded,
+        files: expressEvent.files,
+    };
+    return actionResult([internalEventRecord]);
+};
+export const getEventGetRecordsActionProcessor = async (qpqConfig) => ({
+    [EventActionType.GetRecords]: getProcessGetRecords(qpqConfig),
+});

package/lib/esm/getActionProcessor/core/event/express/api/getEventGetStorySessionActionProcessor.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export declare const getEventGetStorySessionActionProcessor: ActionProcessorListResolver;

package/lib/esm/getActionProcessor/core/event/express/api/getEventGetStorySessionActionProcessor.js

@@ -0,0 +1,7 @@
+/* eslint-disable no-void */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { actionResult, EventActionType, } from 'quidproquo-core';
+const getProcessGetStorySession = (qpqConfig) => async ({ qpqEventRecord, eventParams }) => actionResult(void 0);
+export const getEventGetStorySessionActionProcessor = async (qpqConfig) => ({
+    [EventActionType.GetStorySession]: getProcessGetStorySession(qpqConfig),
+});

package/lib/esm/getActionProcessor/core/event/express/api/getEventMatchStoryActionProcessor.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export declare const getEventMatchStoryActionProcessor: ActionProcessorListResolver;

package/lib/esm/getActionProcessor/core/event/express/api/getEventMatchStoryActionProcessor.js

@@ -0,0 +1,40 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { awsLambdaUtils } from 'quidproquo-actionprocessor-awslambda';
+import { actionResult, actionResultError, ErrorTypeEnum, EventActionType, } from 'quidproquo-core';
+import { qpqWebServerUtils, } from 'quidproquo-webserver';
+const getProcessMatchStory = (qpqConfig) => {
+    const routes = qpqWebServerUtils.getAllRoutes(qpqConfig);
+    return async ({ qpqEventRecord }) => {
+        // Sort the routes by string length
+        // Note: We may need to filter variable routes out {} as the variables are length independent
+        const sortedRoutes = routes
+            .filter((r) => r.method === qpqEventRecord.method ||
+            qpqEventRecord.method === 'OPTIONS')
+            .sort((a, b) => {
+            if (a.path.length < b.path.length)
+                return -1;
+            if (a.path.length > b.path.length)
+                return 1;
+            return 0;
+        });
+        // Find the most relevant match
+        const matchedRoute = sortedRoutes
+            .map((r) => ({
+            match: awsLambdaUtils.matchUrl(r.path, qpqEventRecord.path),
+            route: r,
+        }))
+            .find((m) => m.match.didMatch);
+        if (!matchedRoute) {
+            return actionResultError(ErrorTypeEnum.NotFound, `route not found [${qpqEventRecord.path}] - [${qpqWebServerUtils.getHeaderValue('user-agent', qpqEventRecord.headers)}]`);
+        }
+        return actionResult({
+            runtime: matchedRoute.route.runtime,
+            runtimeOptions: matchedRoute.match.params || {},
+            // TODO: Make this aware of the API that we are eventing
+            config: qpqWebServerUtils.mergeAllRouteOptions('api', matchedRoute.route, qpqConfig),
+        });
+    };
+};
+export const getEventMatchStoryActionProcessor = async (qpqConfig) => ({
+    [EventActionType.MatchStory]: getProcessMatchStory(qpqConfig),
+});

package/lib/esm/getActionProcessor/core/event/express/api/getEventTransformResponseResultActionProcessor.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export declare const getEventTransformResponseResultActionProcessor: ActionProcessorListResolver;

package/lib/esm/getActionProcessor/core/event/express/api/getEventTransformResponseResultActionProcessor.js

@@ -0,0 +1,48 @@
+import { actionResult, ErrorTypeEnum, EventActionType, } from 'quidproquo-core';
+import { qpqWebServerUtils } from 'quidproquo-webserver';
+const ErrorTypeHttpResponseMap = {
+    [ErrorTypeEnum.BadRequest]: 400,
+    [ErrorTypeEnum.Unauthorized]: 401,
+    [ErrorTypeEnum.PaymentRequired]: 402,
+    [ErrorTypeEnum.Forbidden]: 403,
+    [ErrorTypeEnum.NotFound]: 404,
+    [ErrorTypeEnum.TimeOut]: 408,
+    [ErrorTypeEnum.Conflict]: 409,
+    [ErrorTypeEnum.UnsupportedMediaType]: 415,
+    [ErrorTypeEnum.OutOfResources]: 500,
+    [ErrorTypeEnum.GenericError]: 500,
+    [ErrorTypeEnum.NotImplemented]: 501,
+    [ErrorTypeEnum.NoContent]: 204,
+    [ErrorTypeEnum.Invalid]: 422,
+};
+const getResponseFromErrorResult = (error) => {
+    const statusCode = ErrorTypeHttpResponseMap[error.errorType] || 500;
+    return qpqWebServerUtils.toJsonEventResponse({
+        errorType: error.errorType,
+        errorText: error.errorText,
+    }, statusCode);
+};
+const getProcessTransformResponseResult = (qpqConfig) => 
+// We might need to JSON.stringify the body.
+async ({ eventParams, qpqEventRecordResponses }) => {
+    const [record] = qpqEventRecordResponses;
+    const [expressEvent] = eventParams;
+    // If we have an error, we need to transform it to a response, otherwise we can just use the record as is
+    const successRecord = record.success
+        ? record.result
+        : getResponseFromErrorResult(record.error);
+    const recordHeaders = successRecord.headers || {};
+    const headers = {
+        ...qpqWebServerUtils.getCorsHeaders(qpqConfig, {}, expressEvent.headers),
+        ...recordHeaders,
+    };
+    return actionResult({
+        statusCode: successRecord.status,
+        body: successRecord.body || '',
+        isBase64Encoded: successRecord.isBase64Encoded,
+        headers,
+    });
+};
+export const getEventTransformResponseResultActionProcessor = async (qpqConfig) => ({
+    [EventActionType.TransformResponseResult]: getProcessTransformResponseResult(qpqConfig),
+});

package/lib/esm/getActionProcessor/core/event/express/api/index.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo';
+export declare const getExpressApiEventEventProcessor: ActionProcessorListResolver;

package/lib/esm/getActionProcessor/core/event/express/api/index.js

@@ -0,0 +1,12 @@
+import { getEventAutoRespondActionProcessor } from './getEventAutoRespondActionProcessor';
+import { getEventGetRecordsActionProcessor } from './getEventGetRecordsActionProcessor';
+import { getEventGetStorySessionActionProcessor } from './getEventGetStorySessionActionProcessor';
+import { getEventMatchStoryActionProcessor } from './getEventMatchStoryActionProcessor';
+import { getEventTransformResponseResultActionProcessor } from './getEventTransformResponseResultActionProcessor';
+export const getExpressApiEventEventProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getEventAutoRespondActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getEventGetRecordsActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getEventGetStorySessionActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getEventMatchStoryActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getEventTransformResponseResultActionProcessor(qpqConfig, dynamicModuleLoader)),
+});

package/lib/esm/getActionProcessor/core/event/express/api/types.d.ts

@@ -0,0 +1,8 @@
+import { MatchStoryResult } from 'quidproquo-core';
+import { HTTPEvent, HTTPEventResponse, HttpEventRouteParams, RouteOptions } from 'quidproquo-webserver';
+import { ExpressEvent, ExpressEventResponse } from '../../../../../types/ExpressEvent';
+export type EventInput = [ExpressEvent];
+export type EventOutput = ExpressEventResponse;
+export type InternalEventRecord = HTTPEvent;
+export type InternalEventOutput = HTTPEventResponse;
+export type MatchResult = MatchStoryResult<HttpEventRouteParams, RouteOptions>;

package/lib/esm/getActionProcessor/core/event/express/api/types.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/getActionProcessor/core/event/express/index.d.ts

@@ -0,0 +1 @@
+export * from './api';

package/lib/esm/getActionProcessor/core/event/express/index.js

@@ -0,0 +1 @@
+export * from './api';

package/lib/esm/getActionProcessor/core/event/index.d.ts

@@ -0,0 +1 @@
+export * from './express';

package/lib/esm/getActionProcessor/core/event/index.js

@@ -0,0 +1 @@
+export * from './express';

package/lib/esm/getActionProcessor/core/index.d.ts

@@ -0,0 +1 @@
+export * from './event';

package/lib/esm/getActionProcessor/core/index.js

@@ -0,0 +1 @@
+export * from './event';

package/lib/esm/getActionProcessor/index.d.ts

@@ -0,0 +1 @@
+export * from './core';

package/lib/esm/getActionProcessor/index.js

@@ -0,0 +1 @@
+export * from './core';

package/lib/esm/index.d.ts

@@ -0,0 +1 @@
+export * from './main';

package/lib/esm/index.js

@@ -0,0 +1 @@
+export * from './main';

package/lib/esm/main.d.ts

@@ -0,0 +1,2 @@
+import { DevServerConfig } from './types';
+export declare const spinUpService: (devServerConfig: DevServerConfig) => Promise<void>;