quidproquo-dev-server 0.0.237 → 0.0.239

package/lib/commonjs/actionProcessor/core/queue/getQueueSendMessageActionProcessor.js

@@ -0,0 +1,46 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQueueSendMessagesActionProcessor = void 0;
+const quidproquo_core_1 = require("quidproquo-core");
+const quidproquo_core_2 = require("quidproquo-core");
+const uuid_1 = require("uuid");
+const eventBus_1 = require("../../../logic/eventBus");
+const getProcessQueueSendMessage = (qpqConfig) => {
+    return ({ queueName, queueMessages, context }, session) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        const queueConfig = quidproquo_core_1.qpqCoreUtils.getQueueByName(qpqConfig, queueName);
+        if (!queueConfig) {
+            return (0, quidproquo_core_1.actionResultError)(quidproquo_core_1.ErrorTypeEnum.NotFound, `Queue ${queueName} not found`);
+        }
+        for (const queueMessage of queueMessages) {
+            const queueEvent = {
+                payload: queueMessage.payload,
+                type: queueMessage.type,
+                storySession: Object.assign(Object.assign({}, session), { context }),
+                messageId: (0, uuid_1.v4)(),
+                queueName: queueName,
+                targetApplication: ((_a = queueConfig.owner) === null || _a === void 0 ? void 0 : _a.application) || quidproquo_core_1.qpqCoreUtils.getApplicationName(qpqConfig),
+                targetEnvironment: ((_b = queueConfig.owner) === null || _b === void 0 ? void 0 : _b.environment) || quidproquo_core_1.qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig),
+                targetFeature: ((_c = queueConfig.owner) === null || _c === void 0 ? void 0 : _c.feature) || quidproquo_core_1.qpqCoreUtils.getApplicationModuleFeature(qpqConfig),
+                targetModule: ((_d = queueConfig.owner) === null || _d === void 0 ? void 0 : _d.module) || quidproquo_core_1.qpqCoreUtils.getApplicationModuleName(qpqConfig),
+            };
+            eventBus_1.eventBus.publish(quidproquo_core_2.QueueActionType.SendMessages, queueEvent);
+        }
+        return (0, quidproquo_core_2.actionResult)(void 0);
+    });
+};
+const getQueueSendMessagesActionProcessor = (qpqConfig) => __awaiter(void 0, void 0, void 0, function* () {
+    return ({
+        [quidproquo_core_2.QueueActionType.SendMessages]: getProcessQueueSendMessage(qpqConfig),
+    });
+});
+exports.getQueueSendMessagesActionProcessor = getQueueSendMessagesActionProcessor;

package/lib/commonjs/actionProcessor/core/queue/index.d.ts

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

package/lib/commonjs/actionProcessor/core/queue/index.js

@@ -0,0 +1,17 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQueueActionProcessor = void 0;
+const getQueueSendMessageActionProcessor_1 = require("./getQueueSendMessageActionProcessor");
+const getQueueActionProcessor = (qpqConfig, dynamicModuleLoader) => __awaiter(void 0, void 0, void 0, function* () {
+    return (Object.assign({}, (yield (0, getQueueSendMessageActionProcessor_1.getQueueSendMessagesActionProcessor)(qpqConfig, dynamicModuleLoader))));
+});
+exports.getQueueActionProcessor = getQueueActionProcessor;

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

@@ -1 +1,4 @@
-export * from './graphDatabaseOverride';
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export * from './core';
+export * from './webserver';
+export declare const getDevServerActionProcessors: ActionProcessorListResolver;

package/lib/commonjs/actionProcessor/index.js

@@ -13,5 +13,25 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 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);
 };
+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());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./graphDatabaseOverride"), exports);
+exports.getDevServerActionProcessors = void 0;
+const quidproquo_actionprocessor_awslambda_1 = require("quidproquo-actionprocessor-awslambda");
+const quidproquo_actionprocessor_node_1 = require("quidproquo-actionprocessor-node");
+const core_1 = require("./core");
+const webserver_1 = require("./webserver");
+__exportStar(require("./core"), exports);
+__exportStar(require("./webserver"), exports);
+const getDevServerActionProcessors = (qpqConfig, dynamicModuleLoader) => __awaiter(void 0, void 0, void 0, function* () {
+    const storyActionProcessor = Object.assign(Object.assign(Object.assign(Object.assign({}, (yield (0, quidproquo_actionprocessor_awslambda_1.getAwsActionProcessors)(qpqConfig, dynamicModuleLoader))), (yield (0, core_1.getCoreActionProcessor)(qpqConfig, dynamicModuleLoader))), (yield (0, webserver_1.getWebserverActionProcessor)(qpqConfig, dynamicModuleLoader))), (yield (0, quidproquo_actionprocessor_node_1.getCustomActionActionProcessor)(qpqConfig, dynamicModuleLoader)));
+    return storyActionProcessor;
+});
+exports.getDevServerActionProcessors = getDevServerActionProcessors;

package/lib/commonjs/actionProcessor/webserver/index.d.ts

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

package/lib/commonjs/actionProcessor/webserver/index.js

@@ -0,0 +1,17 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWebserverActionProcessor = void 0;
+const serviceFunctionOverride_1 = require("./serviceFunctionOverride");
+const getWebserverActionProcessor = (qpqConfig, dynamicModuleLoader) => __awaiter(void 0, void 0, void 0, function* () {
+    return (Object.assign({}, (yield (0, serviceFunctionOverride_1.getServiceFunctionActionProcessor)(qpqConfig, dynamicModuleLoader))));
+});
+exports.getWebserverActionProcessor = getWebserverActionProcessor;

package/lib/commonjs/actionProcessor/webserver/serviceFunctionOverride/getServiceFunctionExecuteActionProcessor.d.ts

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

package/lib/commonjs/actionProcessor/webserver/serviceFunctionOverride/getServiceFunctionExecuteActionProcessor.js

@@ -0,0 +1,41 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServiceFunctionExecuteActionProcessor = void 0;
+const quidproquo_core_1 = require("quidproquo-core");
+const quidproquo_webserver_1 = require("quidproquo-webserver");
+const eventBus_1 = require("../../../logic/eventBus");
+const getProcessExecute = (qpqConfig, dynamicModuleLoader) => {
+    return ({ functionName, service, payload, context, isAsync }, session) => __awaiter(void 0, void 0, void 0, function* () {
+        const serviceFunctionEvent = {
+            functionName: functionName,
+            serviceName: service,
+            payload: payload,
+            storySession: Object.assign(Object.assign({}, session), { context }),
+        };
+        const eventPromise = eventBus_1.eventBus.publishAndWaitForResponse(quidproquo_webserver_1.ServiceFunctionActionType.Execute, serviceFunctionEvent);
+        if (isAsync) {
+            return (0, quidproquo_core_1.actionResult)(void 0);
+        }
+        const response = yield eventPromise;
+        if (response.error) {
+            return (0, quidproquo_core_1.actionResultError)(response.error.errorType, response.error.errorText, response.error.errorStack);
+        }
+        console.log('Result', response.result);
+        return (0, quidproquo_core_1.actionResult)(response.result);
+    });
+};
+const getServiceFunctionExecuteActionProcessor = (qpqConfig, dynamicModuleLoader) => __awaiter(void 0, void 0, void 0, function* () {
+    return ({
+        [quidproquo_webserver_1.ServiceFunctionActionType.Execute]: getProcessExecute(qpqConfig, dynamicModuleLoader),
+    });
+});
+exports.getServiceFunctionExecuteActionProcessor = getServiceFunctionExecuteActionProcessor;

package/lib/commonjs/actionProcessor/webserver/serviceFunctionOverride/index.d.ts

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

package/lib/commonjs/actionProcessor/webserver/serviceFunctionOverride/index.js

@@ -0,0 +1,17 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServiceFunctionActionProcessor = void 0;
+const getServiceFunctionExecuteActionProcessor_1 = require("./getServiceFunctionExecuteActionProcessor");
+const getServiceFunctionActionProcessor = (qpqConfig, dynamicModuleLoader) => __awaiter(void 0, void 0, void 0, function* () {
+    return (Object.assign({}, (yield (0, getServiceFunctionExecuteActionProcessor_1.getServiceFunctionExecuteActionProcessor)(qpqConfig, dynamicModuleLoader))));
+});
+exports.getServiceFunctionActionProcessor = getServiceFunctionActionProcessor;

package/lib/commonjs/implementations/apiImplementation.d.ts

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

package/lib/commonjs/implementations/apiImplementation.js

@@ -0,0 +1,145 @@
+"use strict";
+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.apiImplementation = void 0;
+const quidproquo_core_1 = require("quidproquo-core");
+const quidproquo_webserver_1 = require("quidproquo-webserver");
+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 actionProcessor_1 = require("../actionProcessor");
+const allServiceConfig_1 = require("../allServiceConfig");
+const logic_1 = require("../logic");
+const getServiceBaseDomain = (qpqConfig, devServerConfig) => quidproquo_webserver_1.qpqWebServerUtils.getDomainRoot(`${devServerConfig.serverDomain}:${devServerConfig.serverPort}`, quidproquo_core_1.qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig), quidproquo_core_1.qpqCoreUtils.getApplicationModuleFeature(qpqConfig));
+const getApiDomainsFromConfig = (qpqConfig, devServerConfig) => {
+    const baseDomain = getServiceBaseDomain(qpqConfig, devServerConfig);
+    const serviceName = quidproquo_core_1.qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    // Get apis
+    const apiConfigs = quidproquo_webserver_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, devServerConfig) => {
+    const serviceName = quidproquo_core_1.qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    return (runtime) => __awaiter(void 0, void 0, void 0, function* () { return devServerConfig.dynamicModuleLoader(serviceName, runtime); });
+};
+const apiImplementation = (devServerConfig) => __awaiter(void 0, void 0, void 0, function* () {
+    const allServiceConfig = (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();
+    console.log(apiConfigs.map((ac) => ac.devPath));
+    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_core_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_core_1.askProcessEvent;
+        if (serviceLog.runtimeType === quidproquo_core_1.QpqRuntimeType.EXECUTE_STORY) {
+            const [srcEntry, module] = serviceLog.tags[0].split('::');
+            const loadedModule = yield devServerConfig.dynamicModuleLoader(serviceLog.moduleName, srcEntry);
+            runtimeModule = loadedModule[module];
+        }
+        const result = yield (0, quidproquo_core_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, logic_1.processEvent)(event, apiConfig.qpqConfig, getDynamicModuleLoader(apiConfig.qpqConfig, devServerConfig), actionProcessor_1.getExpressApiEventEventProcessor, quidproquo_core_1.QpqRuntimeType.API);
+            if (response.result) {
+                for (const [header, value] of Object.entries(response.result.headers)) {
+                    res.set(header, value);
+                }
+                if (response.result.isBase64Encoded) {
+                    res.status(response.result.statusCode).send(Buffer.from(response.result.body, 'base64'));
+                }
+                else {
+                    res.status(response.result.statusCode).send(response.result.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.apiImplementation = apiImplementation;

package/lib/commonjs/implementations/eventBusImplementation.d.ts

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

package/lib/commonjs/implementations/eventBusImplementation.js

@@ -0,0 +1,55 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventBusImplementation = void 0;
+const quidproquo_core_1 = require("quidproquo-core");
+const uuid_1 = require("uuid");
+const logic_1 = require("../logic");
+const processQueueEventBusSubscriptions = (qpqConfig, ebMessage) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c, _d;
+    const allEventBuses = quidproquo_core_1.qpqCoreUtils.getAllEventBusConfigs(qpqConfig).filter((ebc) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        return ((!((_a = ebc.owner) === null || _a === void 0 ? void 0 : _a.application) || ((_b = ebc.owner) === null || _b === void 0 ? void 0 : _b.application) === ebMessage.targetApplication) &&
+            (!((_c = ebc.owner) === null || _c === void 0 ? void 0 : _c.environment) || ((_d = ebc.owner) === null || _d === void 0 ? void 0 : _d.environment) === ebMessage.targetEnvironment) &&
+            (!((_e = ebc.owner) === null || _e === void 0 ? void 0 : _e.module) || ((_f = ebc.owner) === null || _f === void 0 ? void 0 : _f.module) === ebMessage.targetModule) &&
+            ((!((_g = ebc.owner) === null || _g === void 0 ? void 0 : _g.feature) && !ebMessage.targetFeature) || ((_h = ebc.owner) === null || _h === void 0 ? void 0 : _h.feature) === ebMessage.targetFeature));
+    });
+    // All the queues that we should publish to
+    const queues = quidproquo_core_1.qpqCoreUtils.getQueues(qpqConfig).filter((q) => {
+        return !!q.eventBusSubscriptions.find((ebsub) => {
+            return allEventBuses.some((eb) => { var _a, _b; return ebsub === ((_a = eb.owner) === null || _a === void 0 ? void 0 : _a.resourceNameOverride) || (!((_b = eb.owner) === null || _b === void 0 ? void 0 : _b.resourceNameOverride) && ebsub === eb.name); });
+        });
+    });
+    for (const queue of queues) {
+        const queueMessage = {
+            payload: ebMessage.payload,
+            type: ebMessage.type,
+            storySession: ebMessage.storySession,
+            queueName: queue.name,
+            targetApplication: ((_a = queue.owner) === null || _a === void 0 ? void 0 : _a.application) || quidproquo_core_1.qpqCoreUtils.getApplicationName(qpqConfig),
+            targetEnvironment: ((_b = queue.owner) === null || _b === void 0 ? void 0 : _b.environment) || quidproquo_core_1.qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig),
+            targetFeature: ((_c = queue.owner) === null || _c === void 0 ? void 0 : _c.feature) || quidproquo_core_1.qpqCoreUtils.getApplicationModuleFeature(qpqConfig),
+            targetModule: ((_d = queue.owner) === null || _d === void 0 ? void 0 : _d.module) || quidproquo_core_1.qpqCoreUtils.getApplicationModuleName(qpqConfig),
+            messageId: (0, uuid_1.v4)(),
+        };
+        logic_1.eventBus.publish(quidproquo_core_1.QueueActionType.SendMessages, queueMessage);
+    }
+});
+const eventBusImplementation = (devServerConfig) => __awaiter(void 0, void 0, void 0, function* () {
+    logic_1.eventBus.on(quidproquo_core_1.EventBusActionType.SendMessages, (payload, correlation) => __awaiter(void 0, void 0, void 0, function* () {
+        for (const qpqConfig of devServerConfig.qpqConfigs) {
+            yield processQueueEventBusSubscriptions(qpqConfig, payload);
+        }
+    }));
+    // Never ends
+    yield new Promise(() => { });
+});
+exports.eventBusImplementation = eventBusImplementation;

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

@@ -1 +1,4 @@
-export * from './route';
+export * from './apiImplementation';
+export * from './eventBusImplementation';
+export * from './queueImplementation';
+export * from './serviceFunctionImplementation';

package/lib/commonjs/implementations/index.js

@@ -14,4 +14,7 @@ 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("./route"), exports);
+__exportStar(require("./apiImplementation"), exports);
+__exportStar(require("./eventBusImplementation"), exports);
+__exportStar(require("./queueImplementation"), exports);
+__exportStar(require("./serviceFunctionImplementation"), exports);

package/lib/commonjs/implementations/queueImplementation.d.ts

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

package/lib/commonjs/implementations/queueImplementation.js

@@ -0,0 +1,47 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queueImplementation = void 0;
+const quidproquo_core_1 = require("quidproquo-core");
+const queue_1 = require("../actionProcessor/core/event/queue");
+const logic_1 = require("../logic");
+const getDynamicModuleLoader = (qpqConfig, devServerConfig) => {
+    const serviceName = quidproquo_core_1.qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    return (runtime) => __awaiter(void 0, void 0, void 0, function* () { return devServerConfig.dynamicModuleLoader(serviceName, runtime); });
+};
+const processQueueMessages = (qpqConfig, payload, devServerConfig) => __awaiter(void 0, void 0, void 0, function* () {
+    if (payload.targetEnvironment !== quidproquo_core_1.qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig)) {
+        return;
+    }
+    if (payload.targetApplication !== quidproquo_core_1.qpqCoreUtils.getApplicationName(qpqConfig)) {
+        return;
+    }
+    if (payload.targetModule !== quidproquo_core_1.qpqCoreUtils.getApplicationModuleName(qpqConfig)) {
+        return;
+    }
+    const feature = quidproquo_core_1.qpqCoreUtils.getApplicationModuleFeature(qpqConfig);
+    if ((!!payload.targetFeature || !!feature) && payload.targetFeature !== quidproquo_core_1.qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig)) {
+        return;
+    }
+    console.log('Ready to process: ', JSON.stringify(payload, null, 2));
+    yield (0, logic_1.processEvent)(payload, qpqConfig, getDynamicModuleLoader(qpqConfig, devServerConfig), queue_1.getQueueEventProcessor, quidproquo_core_1.QpqRuntimeType.QUEUE_EVENT);
+});
+const queueImplementation = (devServerConfig) => __awaiter(void 0, void 0, void 0, function* () {
+    logic_1.eventBus.on(quidproquo_core_1.QueueActionType.SendMessages, (payload, correlation) => __awaiter(void 0, void 0, void 0, function* () {
+        console.log('Got QUEUE send message event');
+        for (const qpqConfig of devServerConfig.qpqConfigs) {
+            yield processQueueMessages(qpqConfig, payload, devServerConfig);
+        }
+    }));
+    // Never ends
+    yield new Promise(() => { });
+});
+exports.queueImplementation = queueImplementation;

package/lib/commonjs/implementations/serviceFunctionImplementation.d.ts

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

package/lib/commonjs/implementations/serviceFunctionImplementation.js

@@ -0,0 +1,34 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serviceFunctionImplementation = void 0;
+const quidproquo_core_1 = require("quidproquo-core");
+const quidproquo_webserver_1 = require("quidproquo-webserver");
+const actionProcessor_1 = require("../actionProcessor");
+const logic_1 = require("../logic");
+const getDynamicModuleLoader = (qpqConfig, devServerConfig) => {
+    const serviceName = quidproquo_core_1.qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    return (runtime) => __awaiter(void 0, void 0, void 0, function* () { return devServerConfig.dynamicModuleLoader(serviceName, runtime); });
+};
+const serviceFunctionImplementation = (devServerConfig) => __awaiter(void 0, void 0, void 0, function* () {
+    logic_1.eventBus.on(quidproquo_webserver_1.ServiceFunctionActionType.Execute, (payload, correlation) => __awaiter(void 0, void 0, void 0, function* () {
+        // We need to find the qpqConfig for this service.
+        const qpqConfig = devServerConfig.qpqConfigs.find((qpqConfig) => quidproquo_core_1.qpqCoreUtils.getApplicationModuleName(qpqConfig) === payload.serviceName);
+        const eventPromise = yield (0, logic_1.processEvent)(payload, qpqConfig, getDynamicModuleLoader(qpqConfig, devServerConfig), actionProcessor_1.getNodeServiceFunctionEventProcessor, quidproquo_core_1.QpqRuntimeType.SERVICE_FUNCTION_EXE);
+        if (correlation) {
+            // Emit the response back on the unique responseEvent channel
+            logic_1.eventBus.emit(correlation, eventPromise);
+        }
+    }));
+    // Never ends
+    yield new Promise(() => { });
+});
+exports.serviceFunctionImplementation = serviceFunctionImplementation;

package/lib/commonjs/logic/eventBus.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+declare class EventBus extends EventEmitter {
+    private static instance;
+    private constructor();
+    static getInstance(): EventBus;
+    publishAndWaitForResponse(eventType: string, payload: any): Promise<any>;
+    publish(eventType: string, payload: any): Promise<void>;
+}
+export declare const eventBus: EventBus;
+export {};

package/lib/commonjs/logic/eventBus.js

@@ -0,0 +1,46 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventBus = void 0;
+// EventBus.ts
+const events_1 = require("events");
+const uuid_1 = require("uuid");
+class EventBus extends events_1.EventEmitter {
+    constructor() {
+        super();
+    }
+    static getInstance() {
+        if (!EventBus.instance) {
+            EventBus.instance = new EventBus();
+        }
+        return EventBus.instance;
+    }
+    publishAndWaitForResponse(eventType, payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => {
+                const responseCorrelation = (0, uuid_1.v4)();
+                // Listen for the response once
+                this.once(responseCorrelation, (response) => {
+                    resolve(response);
+                });
+                // Emit the event along with the response event name
+                this.emit(eventType, payload, responseCorrelation);
+            });
+        });
+    }
+    publish(eventType, payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.emit(eventType, payload);
+        });
+    }
+}
+// Exporting a singleton instance of EventBus
+exports.eventBus = EventBus.getInstance();

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

@@ -0,0 +1,2 @@
+export * from './eventBus';
+export * from './processEvent';

package/lib/commonjs/{getActionProcessor → logic}/index.js

@@ -14,4 +14,5 @@ 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("./core"), exports);
+__exportStar(require("./eventBus"), exports);
+__exportStar(require("./processEvent"), exports);

package/lib/commonjs/logic/processEvent.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver, DynamicModuleLoader, QPQConfig, QpqRuntimeType, StoryResult } from 'quidproquo-core';
+export declare const processEvent: <E, ER>(expressEvent: E, qpqConfig: QPQConfig, dynamicModuleLoader: DynamicModuleLoader, getActionProcessors: ActionProcessorListResolver, qpqRuntimeType: QpqRuntimeType) => Promise<StoryResult<[E], ER>>;

package/lib/commonjs/logic/processEvent.js

@@ -0,0 +1,32 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processEvent = void 0;
+const quidproquo_actionprocessor_awslambda_1 = require("quidproquo-actionprocessor-awslambda");
+const quidproquo_core_1 = require("quidproquo-core");
+const crypto_1 = require("crypto");
+const actionProcessor_1 = require("../actionProcessor");
+// TODO: Make this a util or something based on server time or something..
+const getDateNow = () => new Date().toISOString();
+const processEvent = (expressEvent, qpqConfig, dynamicModuleLoader, getActionProcessors, qpqRuntimeType) => __awaiter(void 0, void 0, void 0, function* () {
+    const serviceName = quidproquo_core_1.qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    const logger = (0, quidproquo_actionprocessor_awslambda_1.getLogger)(qpqConfig);
+    const resolveStory = (0, quidproquo_core_1.createRuntime)(qpqConfig, {
+        depth: 0,
+        context: {},
+    }, () => __awaiter(void 0, void 0, void 0, function* () {
+        return (Object.assign(Object.assign({}, (yield (0, actionProcessor_1.getDevServerActionProcessors)(qpqConfig, dynamicModuleLoader))), (yield getActionProcessors(qpqConfig, dynamicModuleLoader))));
+    }), getDateNow, logger, `${serviceName}::${(0, crypto_1.randomUUID)()}`, qpqRuntimeType, dynamicModuleLoader, []);
+    const result = yield resolveStory(quidproquo_core_1.askProcessEvent, [expressEvent]);
+    yield logger.waitToFinishWriting();
+    return result;
+});
+exports.processEvent = processEvent;