@morgan-stanley/composeui-messaging-message-router 0.1.0-alpha.10

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@morgan-stanley/composeui-messaging-message-router",
+  "version": "0.1.0-alpha.10",
+  "description": "TypeScript messaging implementation for ComposeUI. It uses the MessageRouter client library.",
+  "private": false,
+  "author": "Morgan Stanley",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "scripts": {
+    "clean:dist": "rimraf dist",
+    "clean:output": "rimraf output",
+    "clean": "npm run clean:dist && npm run clean:output",
+    "bundle": "rollup -c",
+    "build": "npm run clean && tsc && npm run bundle",
+    "test": "vitest run"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/morganstanley/ComposeUI.git"
+  },
+  "dependencies": {
+    "@morgan-stanley/composeui-messaging-abstractions": "*",
+    "@morgan-stanley/composeui-messaging-client": "*",
+    "rxjs": "^7.8.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "28.0.6",
+    "@rollup/plugin-node-resolve": "16.0.1",
+    "@types/node": "^24.5.2",
+    "jsdom": "^26.0.0",
+    "rimraf": "6.0.1",
+    "rollup": "^4.12.1",
+    "tslib": "^2.4.0",
+    "typescript": "^5.0.0",
+    "vitest": "^2.0.0"
+  },
+  "gitHead": "4dc7ce6e9965a0b0a772e8d9b8f3cf348ba875df"
+}

package/rollup.config.js

@@ -0,0 +1,16 @@
+import resolve from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+
+
+export default {
+    input: 'output/index.js',
+    output: {
+        file: 'dist/messageRouterMessaging-iife-bundle.js',
+        format: 'iife',
+        name: 'messageRouterMessaging'
+    },
+    plugins: [
+        resolve(),
+        commonjs()
+    ]
+};

package/src/AsyncDisposableWrapper.ts

@@ -0,0 +1,20 @@
+/* 
+ *  Morgan Stanley makes this available to you under the Apache License,
+ *  Version 2.0 (the "License"). You may obtain a copy of the License at
+ *       http://www.apache.org/licenses/LICENSE-2.0.
+ *  See the NOTICE file distributed with this work for additional information
+ *  regarding copyright ownership. Unless required by applicable law or agreed
+ *  to in writing, software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ *  or implied. See the License for the specific language governing permissions
+ *  and limitations under the License.
+ *  
+ */
+import { MessageRouter } from "@morgan-stanley/composeui-messaging-client";
+export class AsyncDisposableWrapper implements AsyncDisposable {
+    constructor(private readonly messageRouterClient: MessageRouter, private readonly serviceName: string) {}
+
+    public [Symbol.asyncDispose](): PromiseLike<void> {
+        return this.messageRouterClient.unregisterService(this.serviceName);
+    }
+}

package/src/MessageRouterMessaging.test.ts

@@ -0,0 +1,173 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { MessageRouterMessaging } from './MessageRouterMessaging';
+import { MessageRouter } from "@morgan-stanley/composeui-messaging-client";
+import { TopicMessageHandler } from "@morgan-stanley/composeui-messaging-abstractions";
+
+describe('MessageRouterMessaging', () => {
+    let mockMessageRouter: MessageRouter;
+    let messaging: MessageRouterMessaging;
+
+    beforeEach(() => {
+        mockMessageRouter = {
+            subscribe: vi.fn(),
+            publish: vi.fn(),
+            registerService: vi.fn(),
+            invoke: vi.fn(),
+            unregisterService: vi.fn()
+        } as any;
+
+        messaging = new MessageRouterMessaging(mockMessageRouter);
+    });
+
+    describe('subscribe', () => {
+        it('should delegate subscribe to message router', async () => {
+            const topic = 'test-topic';
+            const handler: TopicMessageHandler = vi.fn();
+            const unsubscribe = { unsubscribe: vi.fn() };
+            
+            (mockMessageRouter.subscribe as any).mockResolvedValue(unsubscribe);
+
+            const result = await messaging.subscribe(topic, handler);
+
+            expect(mockMessageRouter.subscribe).toHaveBeenCalledWith(topic, expect.any(Function));
+            expect(result).toBe(unsubscribe);
+        });
+
+        it('should handle empty messages', async () => {
+            const topic = 'test-topic';
+            const handler = vi.fn();
+            let storedCallback: Function = () => {};
+
+            (mockMessageRouter.subscribe as any).mockImplementation((t: string, callback: Function) => {
+                storedCallback = callback;
+                return Promise.resolve({ unsubscribe: vi.fn() });
+            });
+
+            await messaging.subscribe(topic, handler);
+            await storedCallback({ payload: null });
+
+            expect(handler).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('publish', () => {
+        it('should delegate publish to message router', async () => {
+            const topic = 'test-topic';
+            const message = 'test-message';
+
+            await messaging.publish(topic, message);
+
+            expect(mockMessageRouter.publish).toHaveBeenCalledWith(topic, message);
+        });
+    });
+
+    describe('registerService', () => {
+        it('should delegate service registration to message router', async () => {
+            const serviceName = 'test-service';
+            const handler = vi.fn().mockResolvedValue('response');
+
+            const disposable = await messaging.registerService(serviceName, handler);
+
+            expect(mockMessageRouter.registerService).toHaveBeenCalledWith(
+                serviceName,
+                expect.any(Function)
+            );
+
+            expect(disposable).toBeDefined();
+            expect(typeof disposable[Symbol.asyncDispose]).toBe('function');
+        });
+
+        it('should handle service calls correctly', async () => {
+            const serviceName = 'test-service';
+            const handler = vi.fn().mockResolvedValue('response');
+            let registeredHandler: Function | undefined;
+
+            (mockMessageRouter.registerService as any).mockImplementation((name: string, callback: Function) => {
+                registeredHandler = callback;
+                return Promise.resolve();
+            });
+
+            await messaging.registerService(serviceName, handler);
+            
+            if (!registeredHandler) {
+                throw new Error('Handler was not registered');
+            }
+
+            const result = await registeredHandler('endpoint', 'payload', { context: 'test' });
+            
+            expect(handler).toHaveBeenCalledWith('payload');
+            expect(result).toBe('response');
+        });
+
+        it('should handle null payload in service call', async () => {
+            const serviceName = 'test-service';
+            const handler = vi.fn().mockResolvedValue('response');
+            let registeredHandler: Function | undefined;
+
+            (mockMessageRouter.registerService as any).mockImplementation((name: string, callback: Function) => {
+                registeredHandler = callback;
+                return Promise.resolve();
+            });
+
+            await messaging.registerService(serviceName, handler);
+            
+            if (!registeredHandler) {
+                throw new Error('Handler was not registered');
+            }
+
+            const result = await registeredHandler('endpoint', null, { context: 'test' });
+            
+            expect(handler).toHaveBeenCalledWith(null);
+            expect(result).toBe('response');
+        });
+    });
+
+    describe('invokeService', () => {
+        it('should handle service invocation with payload', async () => {
+            const serviceName = 'test-service';
+            const payload = 'test-payload';
+            const response = 'test-response';
+
+            (mockMessageRouter.invoke as any).mockResolvedValue(response);
+
+            const result = await messaging.invokeService(serviceName, payload);
+
+            expect(mockMessageRouter.invoke).toHaveBeenCalledWith(serviceName, payload);
+            expect(result).toBe(response);
+        });
+
+        it('should handle service invocation without payload', async () => {
+            const serviceName = 'test-service';
+            const response = 'test-response';
+
+            (mockMessageRouter.invoke as any).mockResolvedValue(response);
+
+            const result = await messaging.invokeService(serviceName);
+
+            expect(mockMessageRouter.invoke).toHaveBeenCalledWith(serviceName);
+            expect(result).toBe(response);
+        });
+
+        it('should handle null response', async () => {
+            const serviceName = 'test-service';
+
+            (mockMessageRouter.invoke as any).mockResolvedValue(null);
+
+            const result = await messaging.invokeService(serviceName, 'payload');
+
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('AsyncDisposableWrapper', () => {
+        it('should unregister service on dispose', async () => {
+            const serviceName = 'test-service';
+            const handler = vi.fn();
+
+            const disposable = await messaging.registerService(serviceName, handler);
+            await disposable[Symbol.asyncDispose]();
+
+            expect(mockMessageRouter.unregisterService).toHaveBeenCalledWith(serviceName);
+        });
+    });
+});

package/src/MessageRouterMessaging.ts

@@ -0,0 +1,105 @@
+/* 
+ *  Morgan Stanley makes this available to you under the Apache License,
+ *  Version 2.0 (the "License"). You may obtain a copy of the License at
+ *       http://www.apache.org/licenses/LICENSE-2.0.
+ *  See the NOTICE file distributed with this work for additional information
+ *  regarding copyright ownership. Unless required by applicable law or agreed
+ *  to in writing, software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ *  or implied. See the License for the specific language governing permissions
+ *  and limitations under the License.
+ *  
+ */
+
+import { IMessaging, ServiceHandler, TopicMessageHandler } from "@morgan-stanley/composeui-messaging-abstractions";
+import { MessageRouter } from "@morgan-stanley/composeui-messaging-client";
+import { Unsubscribable } from "rxjs";
+import { AsyncDisposableWrapper } from "./AsyncDisposableWrapper";
+
+/**
+ * Implementation of IMessaging interface using MessageRouter.
+ * Provides messaging capabilities through the MessageRouter client for ComposeUI applications.
+ */
+export class MessageRouterMessaging implements IMessaging {
+    /**
+     * Creates a new instance of MessageRouterMessaging.
+     * @param messageRouterClient The MessageRouter client instance to use for communication.
+     */
+    constructor(private readonly messageRouterClient: MessageRouter) {
+    }
+
+    /**
+     * Subscribes to messages on a specific topic.
+     * @param topic The topic to subscribe to.
+     * @param subscriber Callback function that will be invoked with each received message.
+     * @param cancellationToken Optional signal to cancel the subscription setup.
+     * @returns A Promise that resolves to an Unsubscribable object for managing the subscription.
+     * @remarks If a message is received without a payload, a warning will be logged and the subscriber will not be called.
+     */
+    public subscribe(topic: string, subscriber: TopicMessageHandler, cancellationToken?: AbortSignal): Promise<Unsubscribable> {
+
+        return this.messageRouterClient.subscribe(topic, (message) => {
+            if (!message.payload) {
+                console.warn(`Received empty message on topic ${topic}`);
+                return;
+            }
+            subscriber(message.payload);
+        });
+    }
+
+    /**
+     * Publishes a message to a specific topic.
+     * @param topic The topic to publish to.
+     * @param message The message content to publish.
+     * @param cancellationToken Optional signal to cancel the publish operation.
+     * @returns A Promise that resolves when the message has been published.
+     */
+    public publish(topic: string, message: string, cancellationToken?: AbortSignal): Promise<void> {
+        return this.messageRouterClient.publish(topic, message);
+    }
+
+    /**
+     * Registers a service handler for a specific service name.
+     * @param serviceName The name of the service to register.
+     * @param serviceHandler The handler function that will process service requests.
+     * @param cancellationToken Optional signal to cancel the service registration.
+     * @returns A Promise that resolves to an AsyncDisposable for managing the service registration.
+     * @remarks The service handler will receive the payload from the request and should return a response.
+     * Both the payload and response can be null.
+     */
+    public async registerService(serviceName: string, serviceHandler: ServiceHandler, cancellationToken?: AbortSignal): Promise<AsyncDisposable> {
+        await this.messageRouterClient.registerService(serviceName, async (endpoint, payload, context) => {
+             const result = await serviceHandler(payload!);
+                return result!;
+        });
+        
+        const disposable = new AsyncDisposableWrapper(this.messageRouterClient, serviceName);
+        return disposable;
+    }
+
+    /**
+     * Invokes a registered service.
+     * @param serviceName The name of the service to invoke.
+     * @param payload Optional payload to send with the service request.
+     * @param cancellationToken Optional signal to cancel the service invocation.
+     * @returns A Promise that resolves to the service response or null if no response is received.
+     * @remarks If the payload is null, the service will be invoked without a payload.
+     * The response will be null if the service doesn't return a response or if an error occurs.
+     */
+    public async invokeService(serviceName: string, payload?: string | null, cancellationToken?: AbortSignal): Promise<string | null> {
+        if (payload == null) {
+            const result =  await this.messageRouterClient.invoke(serviceName);
+            if (!result){
+                return null;
+            }
+
+            return result;
+        }
+
+        const response = await this.messageRouterClient.invoke(serviceName, payload);
+        if (!response) {
+            return null;
+        }
+        return response;
+    }
+}

package/src/index.ts

@@ -0,0 +1,27 @@
+/* 
+ *  Morgan Stanley makes this available to you under the Apache License,
+ *  Version 2.0 (the "License"). You may obtain a copy of the License at
+ *       http://www.apache.org/licenses/LICENSE-2.0.
+ *  See the NOTICE file distributed with this work for additional information
+ *  regarding copyright ownership. Unless required by applicable law or agreed
+ *  to in writing, software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ *  or implied. See the License for the specific language governing permissions
+ *  and limitations under the License.
+ *  
+ */
+import { IMessaging } from "@morgan-stanley/composeui-messaging-abstractions";
+import { MessageRouterMessaging } from "./MessageRouterMessaging";
+import { createMessageRouter } from "@morgan-stanley/composeui-messaging-client";
+
+declare global {
+    interface Window {
+        composeui: {
+            messaging: {
+                communicator: IMessaging | undefined;
+            }
+        }
+    }
+}
+
+window.composeui.messaging.communicator = new MessageRouterMessaging(createMessageRouter());

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ES2020",
+    "moduleResolution": "node",
+    "declaration": true,
+    "outDir": "output",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "**/*.test.ts"]
+}

package/vite.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: 'node',
+    },
+})