quidproquo-dev-server 0.0.239 → 0.0.241

package/lib/commonjs/implementations/webSocket/webSocketImplementation.js

@@ -0,0 +1,134 @@
+"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.webSocketImplementation = exports.sendMessageToWebSocketConnection = void 0;
+const quidproquo_core_1 = require("quidproquo-core");
+const quidproquo_webserver_1 = require("quidproquo-webserver");
+const http_1 = require("http");
+const ws_1 = require("ws");
+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 globals = {
+    allServers: [],
+};
+const findConnection = (service, apiName) => {
+    const serverInfo = globals.allServers.find((s) => s.service === service && s.apiName === apiName);
+    return serverInfo;
+};
+const sendMessageToWebSocketConnection = (service, websocketApiName, connectionId, payload) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const wsConnection = (_b = (_a = findConnection(service, websocketApiName)) === null || _a === void 0 ? void 0 : _a.connections) === null || _b === void 0 ? void 0 : _b[connectionId];
+    if (!wsConnection) {
+        return;
+    }
+    wsConnection.send(JSON.stringify(payload));
+});
+exports.sendMessageToWebSocketConnection = sendMessageToWebSocketConnection;
+const startServer = (settingsMap, devServerConfig) => {
+    const webSocketServer = new ws_1.WebSocketServer({ noServer: true });
+    console.log(`WebSocket: ws://${devServerConfig.serverDomain}:${devServerConfig.webSocketPort}/${settingsMap.service}/${settingsMap.apiName}`);
+    webSocketServer.on('connection', (ws, req) => {
+        const connectionId = req.headers['sec-websocket-key'] || crypto.randomUUID();
+        const sourceIp = req.socket.remoteAddress === '::1' || !req.socket.remoteAddress ? '127.0.0.1' : req.socket.remoteAddress;
+        const userAgent = req.headers['user-agent'] || 'unknown agent';
+        const server = findConnection(settingsMap.service, settingsMap.apiName);
+        server.connections[connectionId] = ws;
+        const processWsEvent = (wsEvent) => (0, logic_1.processEvent)(wsEvent, settingsMap.qpqConfig, getDynamicModuleLoader(settingsMap.qpqConfig, devServerConfig), actionProcessor_1.getWsWebsocketEventEventProcessor, quidproquo_core_1.QpqRuntimeType.WEBSOCKET_EVENT);
+        const onConnectEvent = {
+            apiName: settingsMap.apiName,
+            service: settingsMap.service,
+            eventType: quidproquo_webserver_1.WebSocketEventType.Connect,
+            body: undefined,
+            messageId: crypto.randomUUID(),
+            connectionId: connectionId,
+            requestTimeEpoch: Date.now(),
+            sourceIp: sourceIp,
+            userAgent: userAgent,
+        };
+        processWsEvent(onConnectEvent);
+        ws.on('error', console.error);
+        ws.on('message', (data, isBinary) => {
+            console.log('isBinary: ', isBinary);
+            const onMessageEvent = {
+                apiName: settingsMap.apiName,
+                service: settingsMap.service,
+                eventType: quidproquo_webserver_1.WebSocketEventType.Message,
+                body: data,
+                messageId: crypto.randomUUID(),
+                connectionId: connectionId,
+                requestTimeEpoch: Date.now(),
+                sourceIp: sourceIp,
+                userAgent: userAgent,
+            };
+            processWsEvent(onMessageEvent);
+        });
+        ws.on('close', () => {
+            delete server.connections[connectionId];
+            const onCloseEvent = {
+                apiName: settingsMap.apiName,
+                service: settingsMap.service,
+                eventType: quidproquo_webserver_1.WebSocketEventType.Disconnect,
+                body: undefined,
+                messageId: crypto.randomUUID(),
+                connectionId: connectionId,
+                requestTimeEpoch: Date.now(),
+                sourceIp: sourceIp,
+                userAgent: userAgent,
+            };
+            processWsEvent(onCloseEvent);
+        });
+    });
+    return Object.assign(Object.assign({}, settingsMap), { server: webSocketServer, connections: {} });
+};
+const getWebSocketQPQWebServerConfigSettingMaps = (qpqConfigs) => {
+    return qpqConfigs
+        .flatMap((qpqConfig) => {
+        const service = quidproquo_core_1.qpqCoreUtils.getApplicationModuleName(qpqConfig);
+        return quidproquo_webserver_1.qpqWebServerUtils.getWebsocketSettings(qpqConfig).flatMap((wsc) => {
+            const item = {
+                apiName: wsc.apiName,
+                service,
+                setting: wsc,
+                qpqConfig,
+            };
+            return item;
+        });
+    })
+        .filter((item, index, arr) => { var _a, _b; return arr[index].apiName !== item.apiName || !((_a = item.setting.owner) === null || _a === void 0 ? void 0 : _a.module) || arr[index].service === ((_b = item.setting.owner) === null || _b === void 0 ? void 0 : _b.module); });
+};
+const webSocketImplementation = (devServerConfig) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!devServerConfig.webSocketPort) {
+        return;
+    }
+    const webSocketQPQWebServerConfigSettingMaps = getWebSocketQPQWebServerConfigSettingMaps(devServerConfig.qpqConfigs);
+    const server = (0, http_1.createServer)();
+    globals.allServers = webSocketQPQWebServerConfigSettingMaps.map((x) => startServer(x, devServerConfig));
+    server.on('upgrade', (request, socket, head) => {
+        const { pathname } = new URL(request.url || '', 'wss://base.url');
+        const serverInfo = globals.allServers.find((s) => pathname === `/${s.service}/${s.apiName}`);
+        if (serverInfo) {
+            serverInfo.server.handleUpgrade(request, socket, head, (ws) => {
+                serverInfo.server.emit('connection', ws, request);
+            });
+        }
+        else {
+            socket.destroy();
+        }
+    });
+    server.listen(devServerConfig.webSocketPort, 'localhost');
+    // Never ends
+    yield new Promise(() => { });
+});
+exports.webSocketImplementation = webSocketImplementation;

package/lib/commonjs/logic/eventBus.js

@@ -38,6 +38,9 @@ class EventBus extends events_1.EventEmitter {
     }
     publish(eventType, payload) {
         return __awaiter(this, void 0, void 0, function* () {
+            // console.log('------------------------------------------------------------');
+            // console.log('\n\nEventBus - publish: [', eventType, ']', '[', payload?.type, ']');
+            // console.log('------------------------------------------------------------');
             this.emit(eventType, payload);
         });
     }

package/lib/commonjs/main.js

@@ -33,6 +33,7 @@ const startDevServer = (devServerConfig) => __awaiter(void 0, void 0, void 0, fu
         (0, implementations_1.serviceFunctionImplementation)(devServerConfig),
         (0, implementations_1.eventBusImplementation)(devServerConfig),
         (0, implementations_1.queueImplementation)(devServerConfig),
+        (0, implementations_1.webSocketImplementation)(devServerConfig),
     ]);
 });
 exports.startDevServer = startDevServer;

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

@@ -1,7 +1,8 @@
 import { QPQConfig, QpqFunctionRuntime } from 'quidproquo-core';
 export type DevServerConfig = {
     serverDomain: 'localhost';
-    serverPort: 8080;
+    serverPort: number;
+    webSocketPort?: number;
     dynamicModuleLoader: <T = any>(serviceName: string, modulePath: QpqFunctionRuntime) => Promise<T>;
     qpqConfigs: QPQConfig[];
 };

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

@@ -1,3 +1,4 @@
 export * from './express';
 export * from './node';
 export * from './queue';
+export * from './ws';

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

@@ -1,3 +1,4 @@
 export * from './express';
 export * from './node';
 export * from './queue';
+export * from './ws';

package/lib/esm/actionProcessor/core/event/queue/getEventMatchStoryActionProcessor.js

@@ -2,7 +2,6 @@ import { awsLambdaUtils } from 'quidproquo-actionprocessor-awslambda';
 import { actionResult, actionResultError, ErrorTypeEnum, EventActionType, qpqCoreUtils, } from 'quidproquo-core';
 const getProcessMatchStory = (qpqConfig) => {
     return async ({ qpqEventRecord, eventParams: [event] }) => {
-        console.log('qpqEventRecord', JSON.stringify(qpqEventRecord, null, 2));
         const queueQueueProcessors = qpqCoreUtils.getQueueQueueProcessors(event.queueName, qpqConfig);
         const queueTypes = Object.keys(queueQueueProcessors).sort();
         // Find the most relevant match

package/lib/esm/actionProcessor/core/event/ws/index.d.ts

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

package/lib/esm/actionProcessor/core/event/ws/index.js

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

package/lib/esm/actionProcessor/core/event/ws/websocket/getEventAutoRespondActionProcessor.d.ts

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

package/lib/esm/actionProcessor/core/event/ws/websocket/getEventAutoRespondActionProcessor.js

@@ -0,0 +1,9 @@
+import { actionResult, EventActionType, } from 'quidproquo-core';
+const getProcessAutoRespond = (qpqConfig) => {
+    return async ({ qpqEventRecord, matchResult }) => {
+        return actionResult(null);
+    };
+};
+export const getEventAutoRespondActionProcessor = async (qpqConfig) => ({
+    [EventActionType.AutoRespond]: getProcessAutoRespond(qpqConfig),
+});

package/lib/esm/actionProcessor/core/event/ws/websocket/getEventGetRecordsActionProcessor.d.ts

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

package/lib/esm/actionProcessor/core/event/ws/websocket/getEventGetRecordsActionProcessor.js

@@ -0,0 +1,38 @@
+import { actionResult, EventActionType, } from 'quidproquo-core';
+function processBody(body) {
+    if (!body) {
+        return undefined; // If the body is undefined, return undefined
+    }
+    // Convert the body to a string
+    if (Array.isArray(body)) {
+        // Merge Buffer[] into a single Buffer and convert to string
+        return Buffer.concat(body).toString();
+    }
+    else if (body instanceof ArrayBuffer) {
+        // Convert ArrayBuffer to string
+        return Buffer.from(body).toString();
+    }
+    else if (Buffer.isBuffer(body)) {
+        return body.toString(); // Convert Buffer to string
+    }
+    throw new Error('Unsupported body type');
+}
+const getProcessGetRecords = (qpqConfig) => {
+    return async ({ eventParams: [wsEvent] }) => {
+        const internalEventRecord = {
+            eventType: wsEvent.eventType,
+            messageId: wsEvent.messageId,
+            connectionId: wsEvent.connectionId,
+            requestTimeEpoch: wsEvent.requestTimeEpoch,
+            sourceIp: wsEvent.sourceIp,
+            userAgent: wsEvent.userAgent,
+            requestTime: new Date(wsEvent.requestTimeEpoch).toISOString(),
+            body: processBody(wsEvent.body),
+            apiName: wsEvent.apiName,
+        };
+        return actionResult([internalEventRecord]);
+    };
+};
+export const getEventGetRecordsActionProcessor = async (qpqConfig) => ({
+    [EventActionType.GetRecords]: getProcessGetRecords(qpqConfig),
+});

package/lib/esm/actionProcessor/core/event/ws/websocket/getEventGetStorySessionActionProcessor.d.ts

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

package/lib/esm/actionProcessor/core/event/ws/websocket/getEventGetStorySessionActionProcessor.js

@@ -0,0 +1,9 @@
+import { actionResult, EventActionType, } from 'quidproquo-core';
+const getProcessGetStorySession = (qpqConfig) => {
+    return async ({ qpqEventRecord, eventParams }) => {
+        return actionResult(void 0);
+    };
+};
+export const getEventGetStorySessionActionProcessor = async (qpqConfig) => ({
+    [EventActionType.GetStorySession]: getProcessGetStorySession(qpqConfig),
+});

package/lib/esm/actionProcessor/core/event/ws/websocket/getEventMatchStoryActionProcessor.d.ts

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

package/lib/esm/actionProcessor/core/event/ws/websocket/getEventMatchStoryActionProcessor.js

@@ -0,0 +1,26 @@
+import { actionResult, actionResultError, ErrorTypeEnum, EventActionType, } from 'quidproquo-core';
+import { qpqWebServerUtils, WebSocketEventType } from 'quidproquo-webserver';
+const getProcessMatchStory = (qpqConfig) => {
+    return async ({ qpqEventRecord, eventParams }) => {
+        const webSocketConfig = qpqWebServerUtils.getWebsocketEntryByApiName(qpqEventRecord.apiName, qpqConfig);
+        switch (qpqEventRecord.eventType) {
+            case WebSocketEventType.Connect:
+                return actionResult({
+                    runtime: webSocketConfig.eventProcessors.onConnect,
+                });
+            case WebSocketEventType.Disconnect:
+                return actionResult({
+                    runtime: webSocketConfig.eventProcessors.onDisconnect,
+                });
+            case WebSocketEventType.Message:
+                return actionResult({
+                    runtime: webSocketConfig.eventProcessors.onMessage,
+                });
+            default:
+                return actionResultError(ErrorTypeEnum.NotFound, `Websocket lambda not implemented for ${qpqEventRecord.eventType}`);
+        }
+    };
+};
+export const getEventMatchStoryActionProcessor = async (qpqConfig) => ({
+    [EventActionType.MatchStory]: getProcessMatchStory(qpqConfig),
+});

package/lib/esm/actionProcessor/core/event/ws/websocket/getEventTransformResponseResultActionProcessor.d.ts

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

package/lib/esm/actionProcessor/core/event/ws/websocket/getEventTransformResponseResultActionProcessor.js

@@ -0,0 +1,14 @@
+import { actionResult, actionResultError, EventActionType, } from 'quidproquo-core';
+const getProcessTransformResponseResult = (qpqConfig) => {
+    return async ({ eventParams, qpqEventRecordResponses }) => {
+        const [record] = qpqEventRecordResponses;
+        if (!record.success) {
+            return actionResultError(record.error.errorType, record.error.errorText, record.error.errorStack);
+        }
+        // Transform back to api gateway
+        return actionResult(void 0);
+    };
+};
+export const getEventTransformResponseResultActionProcessor = async (qpqConfig) => ({
+    [EventActionType.TransformResponseResult]: getProcessTransformResponseResult(qpqConfig),
+});

package/lib/esm/actionProcessor/core/event/ws/websocket/index.d.ts

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

package/lib/esm/actionProcessor/core/event/ws/websocket/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 getWsWebsocketEventEventProcessor = 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/actionProcessor/core/event/ws/websocket/types.d.ts

@@ -0,0 +1,8 @@
+import { MatchStoryResult } from 'quidproquo-core';
+import { WebsocketEvent, WebsocketEventResponse } from 'quidproquo-webserver';
+import { WsEvent } from '../../../../../implementations/webSocket';
+export type EventInput = [WsEvent];
+export type EventOutput = void;
+export type InternalEventRecord = WebsocketEvent<string | Blob | ArrayBuffer>;
+export type InternalEventOutput = WebsocketEventResponse;
+export type MatchResult = MatchStoryResult<any, any>;

package/lib/esm/actionProcessor/core/event/ws/websocket/types.js

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

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

@@ -1,4 +1,6 @@
 import { getServiceFunctionActionProcessor } from './serviceFunctionOverride';
+import { getWebsocketActionProcessor } from './websocket';
 export const getWebserverActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
     ...(await getServiceFunctionActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getWebsocketActionProcessor(qpqConfig, dynamicModuleLoader)),
 });

package/lib/esm/actionProcessor/webserver/websocket/getWebsocketSendMessageActionProcessor.d.ts

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

package/lib/esm/actionProcessor/webserver/websocket/getWebsocketSendMessageActionProcessor.js

@@ -0,0 +1,19 @@
+import { actionResult, actionResultErrorFromCaughtError, qpqCoreUtils, } from 'quidproquo-core';
+import { qpqWebServerUtils, WebsocketActionType } from 'quidproquo-webserver';
+import { sendMessageToWebSocketConnection } from '../../../implementations/webSocket/webSocketImplementation';
+const getProcessSendMessage = (qpqConfig) => {
+    return async ({ connectionId, payload, websocketApiName }) => {
+        const websocketConfig = qpqWebServerUtils.getWebsocketEntryByApiName(websocketApiName, qpqConfig);
+        const service = websocketConfig.owner?.module || qpqCoreUtils.getApplicationModuleName(qpqConfig);
+        try {
+            await sendMessageToWebSocketConnection(service, websocketApiName, connectionId, payload);
+            return actionResult(void 0);
+        }
+        catch (error) {
+            return actionResultErrorFromCaughtError(error, {});
+        }
+    };
+};
+export const getWebsocketSendMessageActionProcessor = async (qpqConfig) => ({
+    [WebsocketActionType.SendMessage]: getProcessSendMessage(qpqConfig),
+});

package/lib/esm/actionProcessor/webserver/websocket/index.d.ts

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

package/lib/esm/actionProcessor/webserver/websocket/index.js

@@ -0,0 +1,4 @@
+import { getWebsocketSendMessageActionProcessor } from './getWebsocketSendMessageActionProcessor';
+export const getWebsocketActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getWebsocketSendMessageActionProcessor(qpqConfig, dynamicModuleLoader)),
+});

package/lib/esm/implementations/eventBusImplementation.js

@@ -1,40 +1,60 @@
-import { EventBusActionType, qpqCoreUtils, QueueActionType } from 'quidproquo-core';
-import { v4 as uuidV4 } from 'uuid';
-import { eventBus } from '../logic';
-const processQueueEventBusSubscriptions = async (qpqConfig, ebMessage) => {
-    const allEventBuses = qpqCoreUtils.getAllEventBusConfigs(qpqConfig).filter((ebc) => {
-        return ((!ebc.owner?.application || ebc.owner?.application === ebMessage.targetApplication) &&
-            (!ebc.owner?.environment || ebc.owner?.environment === ebMessage.targetEnvironment) &&
-            (!ebc.owner?.module || ebc.owner?.module === ebMessage.targetModule) &&
-            ((!ebc.owner?.feature && !ebMessage.targetFeature) || ebc.owner?.feature === ebMessage.targetFeature));
+// import { EventBusActionType, QPQConfig, qpqCoreUtils, QpqFunctionRuntime, QueueActionType } from 'quidproquo-core';
+/*
+const processQueueEventBusSubscriptions = async (qpqConfig: QPQConfig, ebMessage: AnyEventBusMessageWithSession) => {
+  const allEventBuses = qpqCoreUtils.getAllEventBusConfigs(qpqConfig).filter((ebc) => {
+    const thisService = qpqCoreUtils.getApplicationModuleName(qpqConfig);
+
+    const srcApplication = ebc.owner?.application || qpqCoreUtils.getApplicationName(qpqConfig);
+    const srcEnvironment = ebc.owner?.environment || qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig);
+    const srcFeature = ebc.owner?.feature || qpqCoreUtils.getApplicationModuleFeature(qpqConfig);
+    const srcModule = ebc.owner?.module || qpqCoreUtils.getApplicationModuleName(qpqConfig);
+
+    return (
+      srcApplication === ebMessage.targetApplication &&
+      srcEnvironment === ebMessage.targetEnvironment &&
+      thisService == srcModule &&
+      srcModule === ebMessage.targetModule &&
+      ((!srcFeature && !ebMessage.targetFeature) || srcFeature === ebMessage.targetFeature)
+    );
+  });
+
+  // All the queues that we should publish to
+  const queues = qpqCoreUtils.getQueues(qpqConfig).filter((q) => {
+    return !!q.eventBusSubscriptions.find((ebsub) => {
+      return allEventBuses.some((eb) => ebsub === eb.owner?.resourceNameOverride || (!eb.owner?.resourceNameOverride && ebsub === eb.name));
     });
-    // All the queues that we should publish to
-    const queues = qpqCoreUtils.getQueues(qpqConfig).filter((q) => {
-        return !!q.eventBusSubscriptions.find((ebsub) => {
-            return allEventBuses.some((eb) => ebsub === eb.owner?.resourceNameOverride || (!eb.owner?.resourceNameOverride && ebsub === eb.name));
-        });
-    });
-    for (const queue of queues) {
-        const queueMessage = {
-            payload: ebMessage.payload,
-            type: ebMessage.type,
-            storySession: ebMessage.storySession,
-            queueName: queue.name,
-            targetApplication: queue.owner?.application || qpqCoreUtils.getApplicationName(qpqConfig),
-            targetEnvironment: queue.owner?.environment || qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig),
-            targetFeature: queue.owner?.feature || qpqCoreUtils.getApplicationModuleFeature(qpqConfig),
-            targetModule: queue.owner?.module || qpqCoreUtils.getApplicationModuleName(qpqConfig),
-            messageId: uuidV4(),
-        };
-        eventBus.publish(QueueActionType.SendMessages, queueMessage);
-    }
+  });
+
+  console.log('allEventBuses: ', queues);
+
+  for (const queue of queues) {
+    const queueMessage: AnyQueueMessageWithSession = {
+      payload: ebMessage.payload,
+      type: ebMessage.type,
+
+      storySession: ebMessage.storySession,
+
+      queueName: queue.name,
+
+      targetApplication: queue.owner?.application || qpqCoreUtils.getApplicationName(qpqConfig),
+      targetEnvironment: queue.owner?.environment || qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig),
+      targetFeature: queue.owner?.feature || qpqCoreUtils.getApplicationModuleFeature(qpqConfig),
+      targetModule: queue.owner?.module || qpqCoreUtils.getApplicationModuleName(qpqConfig),
+
+      messageId: uuidV4(),
+    };
+
+    eventBus.publish(QueueActionType.SendMessages, queueMessage);
+  }
 };
+*/
 export const eventBusImplementation = async (devServerConfig) => {
-    eventBus.on(EventBusActionType.SendMessages, async (payload, correlation) => {
-        for (const qpqConfig of devServerConfig.qpqConfigs) {
-            await processQueueEventBusSubscriptions(qpqConfig, payload);
-        }
-    });
+    // eventBus.on(EventBusActionType.SendMessages, async (payload: AnyEventBusMessageWithSession, correlation: string) => {
+    //   console.log('Event Buss Ready to process!');
+    //   for (const qpqConfig of devServerConfig.qpqConfigs) {
+    //     await processQueueEventBusSubscriptions(qpqConfig, payload);
+    //   }
+    // });
     // Never ends
     await new Promise(() => { });
 };

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

@@ -2,3 +2,4 @@ export * from './apiImplementation';
 export * from './eventBusImplementation';
 export * from './queueImplementation';
 export * from './serviceFunctionImplementation';
+export * from './webSocket';

package/lib/esm/implementations/index.js

@@ -2,3 +2,4 @@ export * from './apiImplementation';
 export * from './eventBusImplementation';
 export * from './queueImplementation';
 export * from './serviceFunctionImplementation';
+export * from './webSocket';

package/lib/esm/implementations/queueImplementation.js

@@ -1,4 +1,5 @@
-import { qpqCoreUtils, QpqRuntimeType, QueueActionType } from 'quidproquo-core';
+import { EventBusActionType, qpqCoreUtils, QpqRuntimeType, QueueActionType } from 'quidproquo-core';
+import { v4 as uuidV4 } from 'uuid';
 import { getQueueEventProcessor } from '../actionProcessor/core/event/queue';
 import { eventBus, processEvent } from '../logic';
 const getDynamicModuleLoader = (qpqConfig, devServerConfig) => {
@@ -16,19 +17,58 @@ const processQueueMessages = async (qpqConfig, payload, devServerConfig) => {
         return;
     }
     const feature = qpqCoreUtils.getApplicationModuleFeature(qpqConfig);
-    if ((!!payload.targetFeature || !!feature) && payload.targetFeature !== qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig)) {
+    if ((!!payload.targetFeature || !!feature) && payload.targetFeature !== feature) {
         return;
     }
-    console.log('Ready to process: ', JSON.stringify(payload, null, 2));
     await processEvent(payload, qpqConfig, getDynamicModuleLoader(qpqConfig, devServerConfig), getQueueEventProcessor, QpqRuntimeType.QUEUE_EVENT);
 };
+const processQueueEventBusSubscriptions = async (qpqConfig, ebMessage) => {
+    const thisServiceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    const allEventBuses = qpqCoreUtils.getAllEventBusConfigs(qpqConfig).filter((ebc) => {
+        const srcApplication = ebc.owner?.application || qpqCoreUtils.getApplicationName(qpqConfig);
+        const srcEnvironment = ebc.owner?.environment || qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig);
+        const srcFeature = ebc.owner?.feature || qpqCoreUtils.getApplicationModuleFeature(qpqConfig);
+        const srcModule = ebc.owner?.module || qpqCoreUtils.getApplicationModuleName(qpqConfig);
+        return (srcApplication === ebMessage.targetApplication &&
+            srcEnvironment === ebMessage.targetEnvironment &&
+            srcModule === ebMessage.targetModule &&
+            ((!srcFeature && !ebMessage.targetFeature) || srcFeature === ebMessage.targetFeature));
+    });
+    // All the queues that we should publish to
+    const queues = qpqCoreUtils
+        .getQueues(qpqConfig)
+        .filter((q) => {
+        return !!q.eventBusSubscriptions.find((ebsub) => {
+            return allEventBuses.some((eb) => ebsub === eb.name);
+        });
+    })
+        .filter((q) => !q.owner?.module || q.owner?.module === thisServiceName);
+    for (const queue of queues) {
+        const queueMessage = {
+            payload: ebMessage.payload,
+            type: ebMessage.type,
+            storySession: ebMessage.storySession,
+            queueName: queue.name,
+            targetApplication: queue.owner?.application || qpqCoreUtils.getApplicationName(qpqConfig),
+            targetEnvironment: queue.owner?.environment || qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig),
+            targetFeature: queue.owner?.feature || qpqCoreUtils.getApplicationModuleFeature(qpqConfig),
+            targetModule: queue.owner?.module || qpqCoreUtils.getApplicationModuleName(qpqConfig),
+            messageId: uuidV4(),
+        };
+        eventBus.publish(QueueActionType.SendMessages, queueMessage);
+    }
+};
 export const queueImplementation = async (devServerConfig) => {
     eventBus.on(QueueActionType.SendMessages, async (payload, correlation) => {
-        console.log('Got QUEUE send message event');
         for (const qpqConfig of devServerConfig.qpqConfigs) {
             await processQueueMessages(qpqConfig, payload, devServerConfig);
         }
     });
+    eventBus.on(EventBusActionType.SendMessages, async (payload, correlation) => {
+        for (const qpqConfig of devServerConfig.qpqConfigs) {
+            await processQueueEventBusSubscriptions(qpqConfig, payload);
+        }
+    });
     // Never ends
     await new Promise(() => { });
 };

package/lib/esm/implementations/webSocket/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './webSocketImplementation';

package/lib/esm/implementations/webSocket/index.js

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './webSocketImplementation';

package/lib/esm/implementations/webSocket/types/WsEvent.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { WebSocketEventType } from 'quidproquo';
+export type WsEvent = {
+    apiName: string;
+    service: string;
+    eventType: WebSocketEventType;
+    body?: ArrayBuffer | Buffer | Buffer[];
+    messageId: string;
+    connectionId: string;
+    requestTimeEpoch: number;
+    sourceIp: string;
+    userAgent: string;
+};

package/lib/esm/implementations/webSocket/types/WsEvent.js

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

package/lib/esm/implementations/webSocket/types/index.d.ts

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

package/lib/esm/implementations/webSocket/types/index.js

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

package/lib/esm/implementations/webSocket/webSocketImplementation.d.ts

@@ -0,0 +1,3 @@
+import { DevServerConfig } from '../../types';
+export declare const sendMessageToWebSocketConnection: (service: string, websocketApiName: string, connectionId: string, payload: any) => Promise<void>;
+export declare const webSocketImplementation: (devServerConfig: DevServerConfig) => Promise<void>;