@morgan-stanley/composeui-fdc3 0.1.0-alpha.10

package/src/ComposeUIMessagingMetadataClient.spec.ts

@@ -0,0 +1,132 @@
+/* 
+ *  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 { describe, it, expect, beforeEach, vi } from 'vitest';
+import { ImplementationMetadata } from '@finos/fdc3';
+import { ComposeUIDesktopAgent } from './ComposeUIDesktopAgent';
+import { ComposeUIErrors } from './infrastructure/ComposeUIErrors';
+import { Fdc3GetInfoResponse } from './infrastructure/messages/Fdc3GetInfoResponse';
+import { Fdc3FindInstancesResponse } from './infrastructure/messages/Fdc3FindInstancesResponse';
+import { Fdc3GetAppMetadataResponse } from './infrastructure/messages/Fdc3GetAppMetadataResponse';
+import { IMessaging, JsonMessaging } from '@morgan-stanley/composeui-messaging-abstractions';
+
+describe('MessagingMetadataClient tests', () => {
+  beforeEach(() => {
+    // @ts-ignore
+    window.composeui = {
+      fdc3: {
+        config: { appId: 'testAppId', instanceId: 'testInstanceId' },
+        channelId: 'test',
+        openAppIdentifier: { openedAppContextId: 'test' }
+      }
+    };
+  });
+
+  const baseMessagingMock = (): IMessaging => ({
+    subscribe: vi.fn(() => Promise.resolve({ unsubscribe: () => {} })),
+    publish: vi.fn(() => Promise.resolve()),
+    registerService: vi.fn(() =>
+      Promise.resolve({
+        unsubscribe: () => {},
+        [Symbol.asyncDispose]: () => Promise.resolve()
+      })
+    ),
+    invokeService: vi.fn(() => Promise.resolve(null))
+  });
+
+  it('getInfo throws NoAnswerWasProvided', async () => {
+    const messagingMock = baseMessagingMock();
+    const agent = new ComposeUIDesktopAgent(new JsonMessaging(messagingMock));
+    await expect(agent.getInfo()).rejects.toThrow(ComposeUIErrors.NoAnswerWasProvided);
+  });
+
+  it('getInfo throws backend error', async () => {
+    const response = { error: 'dummyError' };
+    const messagingMock = baseMessagingMock();
+    messagingMock.invokeService = vi.fn(() => Promise.resolve(JSON.stringify(response)));
+    const agent = new ComposeUIDesktopAgent(new JsonMessaging(messagingMock));
+    await expect(agent.getInfo()).rejects.toThrow('dummyError');
+  });
+
+  it('getInfo returns ImplementationMetadata', async () => {
+    const implementationMetadata: ImplementationMetadata = {
+      fdc3Version: '2.0.0',
+      provider: 'ComposeUI',
+      providerVersion: '1.0.0',
+      optionalFeatures: {
+        OriginatingAppMetadata: false,
+        UserChannelMembershipAPIs: true
+      },
+      appMetadata: { appId: 'dummyAppId' }
+    };
+    const response: Fdc3GetInfoResponse = { implementationMetadata };
+    const messagingMock = baseMessagingMock();
+    messagingMock.invokeService = vi.fn(() => Promise.resolve(JSON.stringify(response)));
+    const agent = new ComposeUIDesktopAgent(new JsonMessaging(messagingMock));
+    const result = await agent.getInfo();
+    expect(result).toMatchObject(implementationMetadata);
+  });
+
+  it('findInstances throws NoAnswerWasProvided', async () => {
+    const messagingMock = baseMessagingMock();
+    const agent = new ComposeUIDesktopAgent(new JsonMessaging(messagingMock));
+    await expect(agent.findInstances({ appId: 'test' })).rejects.toThrow(
+      ComposeUIErrors.NoAnswerWasProvided
+    );
+  });
+
+  it('findInstances throws backend error', async () => {
+    const messagingMock = baseMessagingMock();
+    messagingMock.invokeService = vi.fn(() =>
+      Promise.resolve(JSON.stringify({ error: 'dummyError' }))
+    );
+    const agent = new ComposeUIDesktopAgent(new JsonMessaging(messagingMock));
+    await expect(agent.findInstances({ appId: 'test' })).rejects.toThrow('dummyError');
+  });
+
+  it('findInstances returns instances', async () => {
+    const response: Fdc3FindInstancesResponse = {
+      instances: [{ appId: 'test', instanceId: 'id' }]
+    };
+    const messagingMock = baseMessagingMock();
+    messagingMock.invokeService = vi.fn(() => Promise.resolve(JSON.stringify(response)));
+    const agent = new ComposeUIDesktopAgent(new JsonMessaging(messagingMock));
+    const result = await agent.findInstances({ appId: 'test' });
+    expect(result).toMatchObject([{ appId: 'test', instanceId: 'id' }]);
+  });
+
+  it('getAppMetadata throws NoAnswerWasProvided', async () => {
+    const messagingMock = baseMessagingMock();
+    const agent = new ComposeUIDesktopAgent(new JsonMessaging(messagingMock));
+    await expect(agent.getAppMetadata({ appId: 'test' })).rejects.toThrow(
+      ComposeUIErrors.NoAnswerWasProvided
+    );
+  });
+
+  it('getAppMetadata throws backend error', async () => {
+    const messagingMock = baseMessagingMock();
+    messagingMock.invokeService = vi.fn(() =>
+      Promise.resolve(JSON.stringify({ error: 'dummyError' }))
+    );
+    const agent = new ComposeUIDesktopAgent(new JsonMessaging(messagingMock));
+    await expect(agent.getAppMetadata({ appId: 'test' })).rejects.toThrow('dummyError');
+  });
+
+  it('getAppMetadata returns appMetadata', async () => {
+    const response: Fdc3GetAppMetadataResponse = { appMetadata: { appId: 'test' } };
+    const messagingMock = baseMessagingMock();
+    messagingMock.invokeService = vi.fn(() => Promise.resolve(JSON.stringify(response)));
+    const agent = new ComposeUIDesktopAgent(new JsonMessaging(messagingMock));
+    const result = await agent.getAppMetadata({ appId: 'test' });
+    expect(result).toMatchObject({ appId: 'test' });
+  });
+});

package/src/ComposeUIMessagingOpenClient.spec.ts

@@ -0,0 +1,146 @@
+/* 
+ *  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 { describe, it, expect, beforeEach, vi } from 'vitest';
+import { OpenError } from '@finos/fdc3';
+import { MessagingOpenClient } from './infrastructure/MessagingOpenClient';
+import { ComposeUIErrors } from './infrastructure/ComposeUIErrors';
+import { Fdc3OpenResponse } from './infrastructure/messages/Fdc3OpenResponse';
+import { Fdc3GetOpenedAppContextResponse } from './infrastructure/messages/Fdc3GetOpenedAppContextResponse';
+import { OpenAppIdentifier } from './infrastructure/OpenAppIdentifier';
+import { IMessaging, JsonMessaging } from '@morgan-stanley/composeui-messaging-abstractions';
+
+describe('MessagingOpenClient tests', () => {
+  let client: MessagingOpenClient;
+  let jsonMessaging: JsonMessaging;
+  const openAppIdentifier: OpenAppIdentifier = { openedAppContextId: 'contextId' };
+
+  const baseMessagingMock = (): IMessaging => ({
+    subscribe: vi.fn(() => Promise.resolve({ unsubscribe: () => {} })),
+    publish: vi.fn(() => Promise.resolve()),
+    registerService: vi.fn(() =>
+      Promise.resolve({
+        unsubscribe: () => {},
+        [Symbol.asyncDispose]: () => Promise.resolve()
+      })
+    ),
+    invokeService: vi.fn(() => Promise.resolve(null))
+  });
+
+  beforeEach(() => {
+    // @ts-ignore
+    window.composeui = {
+      fdc3: {
+        config: { appId: 'testAppId', instanceId: 'testInstanceId' },
+        channelId: 'test',
+        openAppIdentifier: { openedAppContextId: 'contextId' }
+      }
+    };
+    const messagingMock = baseMessagingMock();
+    jsonMessaging = new JsonMessaging(messagingMock);
+    client = new MessagingOpenClient('fdc3InstanceId', jsonMessaging, openAppIdentifier);
+  });
+
+  it('open throws AppNotFound when no AppIdentifier provided', async () => {
+    await expect(client.open()).rejects.toThrow(OpenError.AppNotFound);
+  });
+
+  it('open throws NoAnswerWasProvided when backend returns undefined', async () => {
+    await expect(client.open('appId1')).rejects.toThrow(ComposeUIErrors.NoAnswerWasProvided);
+  });
+
+  it('open throws backend error from error response', async () => {
+    const response: Fdc3OpenResponse = { error: 'testError' };
+    const messagingMock = baseMessagingMock();
+    messagingMock.invokeService = vi.fn(() =>
+      Promise.resolve(JSON.stringify(response))
+    );
+    jsonMessaging = new JsonMessaging(messagingMock);
+    client = new MessagingOpenClient('fdc3InstanceId', jsonMessaging, openAppIdentifier);
+    await expect(client.open('appId1')).rejects.toThrow('testError');
+  });
+
+  it('open returns AppIdentifier on success', async () => {
+    const response: Fdc3OpenResponse = {
+      appIdentifier: { appId: 'appId1', instanceId: 'instanceId1' }
+    };
+    const messagingMock = baseMessagingMock();
+    messagingMock.invokeService = vi.fn(() =>
+      Promise.resolve(JSON.stringify(response))
+    );
+    jsonMessaging = new JsonMessaging(messagingMock);
+    client = new MessagingOpenClient('fdc3InstanceId', jsonMessaging, openAppIdentifier);
+    const result = await client.open({ appId: 'appId1' }, { type: 'fdc3.instrument' });
+    expect(result).toMatchObject({ appId: 'appId1', instanceId: 'instanceId1' });
+  });
+
+  it('getOpenedAppContext throws when context id not set', async () => {
+    client = new MessagingOpenClient('fdc3InstanceId', jsonMessaging);
+    await expect(client.getOpenedAppContext()).rejects.toThrow(
+      'Context id is not defined on the window object.'
+    );
+  });
+
+  it('getOpenedAppContext throws NoAnswerWasProvided on undefined response', async () => {
+    await expect(client.getOpenedAppContext()).rejects.toThrow(
+      ComposeUIErrors.NoAnswerWasProvided
+    );
+  });
+
+  it('getOpenedAppContext throws NoAnswerWasProvided on wrong payload shape', async () => {
+    const messagingMock = baseMessagingMock();
+    messagingMock.invokeService = vi.fn(() =>
+      Promise.resolve(JSON.stringify({ payload: 'wrongPayload' }))
+    );
+    jsonMessaging = new JsonMessaging(messagingMock);
+    client = new MessagingOpenClient('fdc3InstanceId', jsonMessaging, openAppIdentifier);
+    await expect(client.getOpenedAppContext()).rejects.toThrow(
+      ComposeUIErrors.NoAnswerWasProvided
+    );
+  });
+
+  it('getOpenedAppContext throws backend error', async () => {
+    const response: Fdc3GetOpenedAppContextResponse = { error: 'testGetOpenedAppContextError' };
+    const messagingMock = baseMessagingMock();
+    messagingMock.invokeService = vi.fn(() =>
+      Promise.resolve(JSON.stringify(response))
+    );
+    jsonMessaging = new JsonMessaging(messagingMock);
+    client = new MessagingOpenClient('fdc3InstanceId', jsonMessaging, openAppIdentifier);
+    await expect(client.getOpenedAppContext()).rejects.toThrow('testGetOpenedAppContextError');
+  });
+
+  it('getOpenedAppContext throws NoAnswerWasProvided when context missing', async () => {
+    const response: Fdc3GetOpenedAppContextResponse = {};
+    const messagingMock = baseMessagingMock();
+    messagingMock.invokeService = vi.fn(() =>
+      Promise.resolve(JSON.stringify(response))
+    );
+    jsonMessaging = new JsonMessaging(messagingMock);
+    client = new MessagingOpenClient('fdc3InstanceId', jsonMessaging, openAppIdentifier);
+    await expect(client.getOpenedAppContext()).rejects.toThrow(
+      ComposeUIErrors.NoAnswerWasProvided
+    );
+  });
+
+  it('getOpenedAppContext returns context', async () => {
+    const response: Fdc3GetOpenedAppContextResponse = { context: { type: 'fdc3.instrument' } };
+    const messagingMock = baseMessagingMock();
+    messagingMock.invokeService = vi.fn(() =>
+      Promise.resolve(JSON.stringify(response))
+    );
+    jsonMessaging = new JsonMessaging(messagingMock);
+    client = new MessagingOpenClient('fdc3InstanceId', jsonMessaging, openAppIdentifier);
+    const result = await client.getOpenedAppContext();
+    expect(result.type).toBe('fdc3.instrument');
+  });
+});

package/src/index.ts

@@ -0,0 +1,70 @@
+/* 
+ *  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 { AppIdentifier, DesktopAgent } from "@finos/fdc3";
+import { ComposeUIDesktopAgent } from "./ComposeUIDesktopAgent";
+import { IMessaging } from "@morgan-stanley/composeui-messaging-abstractions";
+import { OpenAppIdentifier } from "./infrastructure/OpenAppIdentifier";
+
+declare global {
+    interface Window {
+        composeui: {
+            fdc3: {
+                config: AppIdentifier | undefined;
+                channelId : string | undefined;
+                openAppIdentifier: OpenAppIdentifier | undefined;
+            },
+            messaging: {
+                communicator: IMessaging | undefined;
+            }
+        }
+        fdc3: DesktopAgent;
+    }
+}
+
+async function initialize(): Promise<void> {
+    //TODO: decide if we want to join to a channel by default.
+    let channelId: string | undefined = window.composeui.fdc3.channelId;
+    const openAppIdentifier: OpenAppIdentifier | undefined = window.composeui.fdc3.openAppIdentifier;
+    const messaging = window.composeui.messaging.communicator as IMessaging;
+    const fdc3 = new ComposeUIDesktopAgent(messaging);
+
+    if (channelId) {
+        await fdc3.joinUserChannel(channelId)
+            .then(async() => {
+                if (openAppIdentifier) {
+                    await fdc3.getOpenedAppContext()
+                        .then(() => {
+                            window.fdc3 = fdc3;
+                            window.dispatchEvent(new Event("fdc3Ready"));
+                        })
+                } else {
+                    window.fdc3 = fdc3;
+                    window.dispatchEvent(new Event("fdc3Ready"));
+                }
+            });
+    } else {
+        if (openAppIdentifier) {
+            await fdc3.getOpenedAppContext().then(() => {
+                window.fdc3 = fdc3;
+                window.dispatchEvent(new Event("fdc3Ready"));
+            })
+        } else {
+            window.fdc3 = fdc3;
+            window.dispatchEvent(new Event("fdc3Ready"));
+        }
+    }
+}
+
+initialize();

package/src/infrastructure/ChannelFactory.ts

@@ -0,0 +1,25 @@
+/* 
+ *  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 { Channel, ContextHandler, IntentHandler, Listener, PrivateChannel } from "@finos/fdc3";
+import { ChannelType } from "./ChannelType";
+
+export interface ChannelFactory {
+    getChannel(channelId: string, channelType: ChannelType): Promise<Channel>;
+    createPrivateChannel(): Promise<PrivateChannel>;
+    createAppChannel(channelId: string): Promise<Channel>;
+    joinUserChannel(channelId: string): Promise<Channel>;
+    getUserChannels(): Promise<Channel[]>;
+    getIntentListener(intent: string, handler: IntentHandler): Promise<Listener>;
+    getContextListener(openHandled: boolean, channel?: Channel, handler?: ContextHandler, contextType?: string | null): Promise<Listener>;
+}

package/src/infrastructure/ChannelItem.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 { DisplayMetadata } from "@finos/fdc3";
+import { ChannelType } from "./ChannelType";
+
+export interface ChannelItem {
+    id: string;
+    type: ChannelType;
+    displayMetadata?: DisplayMetadata;
+}

package/src/infrastructure/ChannelType.ts

@@ -0,0 +1,14 @@
+/* 
+ *  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.
+ *  
+ */
+
+export type ChannelType = "user" | "app" | "private"

package/src/infrastructure/ComposeUIChannel.ts

@@ -0,0 +1,86 @@
+/* 
+ *  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 { Channel, Context, ContextHandler, DisplayMetadata, Listener } from "@finos/fdc3";
+import { JsonMessaging } from "@morgan-stanley/composeui-messaging-abstractions";
+import { ChannelType } from "./ChannelType";
+import { ComposeUIContextListener } from "./ComposeUIContextListener";
+import { Fdc3GetCurrentContextRequest } from "./messages/Fdc3GetCurrentContextRequest";
+import { ComposeUITopic } from "./ComposeUITopic";
+
+export class ComposeUIChannel implements Channel {
+    id: string;
+    type: "user" | "app" | "private";
+    displayMetadata?: DisplayMetadata;
+
+    protected jsonMessaging: JsonMessaging;
+    private lastContexts: Map<string, Context> = new Map<string, Context>();
+    private lastContext?: Context;
+    private openHandled: boolean = true; //by default true so if a channel was created then it has no effect
+
+    constructor(id: string, type: ChannelType, jsonMessaging: JsonMessaging, displayMetadata?: DisplayMetadata) {
+        this.id = id;
+        this.type = type;
+        this.jsonMessaging = jsonMessaging;
+        this.displayMetadata = displayMetadata;
+    }
+
+    //Broadcasting on the composeui/fdc3/v2.0/broadcast topic
+    public async broadcast(context: Context): Promise<void> {
+        //Setting the last published context message.
+        this.lastContexts.set(context.type, context);
+        this.lastContext = context;
+        const topic = ComposeUITopic.broadcast(this.id, this.type);
+        await this.jsonMessaging.publishJson(topic, context);
+    }
+
+    public async getCurrentContext(contextType?: string | undefined): Promise<Context | null> {
+        const message = new Fdc3GetCurrentContextRequest(contextType);
+        const response = await this.jsonMessaging.invokeJsonService<Fdc3GetCurrentContextRequest, Context>(ComposeUITopic.getCurrentContext(this.id, this.type), message);
+        if (response) {
+            if (response) {
+                this.lastContext = response;
+                this.lastContexts.set(response.type, response);
+            }
+        }
+        return this.retrieveCurrentContext(contextType);
+    }
+
+    private retrieveCurrentContext(contextType?: string): Context | null {
+        let context;
+        if (contextType) {
+            context = this.lastContexts.get(contextType);
+        } else {
+            context = this.lastContext;
+        }
+
+        return context ?? null;
+    }
+
+    public addContextListener(contextType: string | null, handler: ContextHandler): Promise<Listener>;
+    public addContextListener(handler: ContextHandler): Promise<Listener>;
+    public async addContextListener(contextType: any, handler?: any): Promise<Listener> {
+        if (contextType != null && typeof contextType != 'string') {
+            handler = contextType;
+            contextType = null;
+        }
+
+        const listener = new ComposeUIContextListener(this.openHandled, this.jsonMessaging, handler, contextType);
+        await listener.subscribe(this.id, this.type);
+        return listener;
+    }
+
+    public setOpenHandled(openHandled: boolean): void {
+        this.openHandled = openHandled;
+    }
+}

package/src/infrastructure/ComposeUIContextListener.ts

@@ -0,0 +1,148 @@
+/* 
+ *  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 { Context, ContextHandler, Listener } from "@finos/fdc3";
+import { JsonMessaging } from "@morgan-stanley/composeui-messaging-abstractions";
+import { ChannelType } from "./ChannelType";
+import { Unsubscribable } from "rxjs";
+import { ComposeUITopic } from "./ComposeUITopic";
+import { Fdc3RemoveContextListenerRequest } from "./messages/Fdc3RemoveContextListenerRequest";
+import { Fdc3RemoveContextListenerResponse } from "./messages/Fdc3RemoveContextListenerResponse";
+import { ComposeUIErrors } from "./ComposeUIErrors";
+import { Fdc3AddContextListenerRequest } from "./messages/Fdc3AddContextListenerRequest";
+import { Fdc3AddContextListenerResponse } from "./messages/Fdc3AddContextListenerResponse";
+
+export class ComposeUIContextListener implements Listener {
+    private readonly jsonMessaging: JsonMessaging;
+    private unsubscribable?: Unsubscribable;
+    private readonly handler: ContextHandler;
+    public readonly contextType?: string;
+    private isSubscribed: boolean = false;
+    private id?: string;
+    private unsubscribeCallback?: (x: ComposeUIContextListener) => void;
+    private openHandled: boolean;
+    private contexts: Context[] = [];
+
+    constructor(openHandled: boolean, jsonMessaging: JsonMessaging, handler: ContextHandler, contextType?: string) {
+        this.openHandled = openHandled;
+        this.jsonMessaging = jsonMessaging;
+        this.handler = handler;
+        this.contextType = contextType;
+    }
+
+    public async subscribe(channelId: string, channelType: ChannelType): Promise<void> {
+        await this.registerContextListener(channelId, channelType);
+        const subscribeTopic = ComposeUITopic.broadcast(channelId, channelType);
+
+        this.unsubscribable = await this.jsonMessaging.subscribeJson<Context>(subscribeTopic, async (context: Context) => {
+            if (!this.contextType || this.contextType == context!.type) {
+                if (this.openHandled === true) {
+                    this.handler!(context!);
+                } else {
+                    this.contexts.push(context);
+                }
+            }
+        });
+
+        this.isSubscribed = true;
+    }
+
+    public async handleContextMessage(context: Context): Promise<void> {
+        if (!this.isSubscribed) {
+            throw new Error("The current listener is not subscribed.");
+        }
+
+        if (this.contextType && this.contextType != null && this.contextType != context.type) {
+            throw new Error(`The current listener is not able to handle context type ${context.type}. It is registered to handle ${this.contextType}.`)
+        }
+        
+        //If the opened app did not resolved the context that was received by the fdc3.open call, we cache the item.
+        if (this.openHandled !== true) {
+            this.contexts.push(context);
+            return;
+        }
+
+        this.handler(context);
+    }
+
+    public setUnsubscribeCallback(unsubscribeCallback: (x: ComposeUIContextListener) => void): void {
+        this.unsubscribeCallback = unsubscribeCallback;
+    }
+
+    //TODO: Decide if we want to have this functionality as the standard does not include it. Currently this method is not used.
+    public setOpenHandled(openHandled: boolean): void {
+        this.openHandled = openHandled;
+
+        if (this.openHandled === true) {
+            this.contexts.forEach(context => {
+                this.handler(context)
+            });
+
+            this.contexts = [];
+        }
+    }
+
+    public async unsubscribe(): Promise<void> {
+        if (!this.unsubscribable || !this.isSubscribed) {
+            return;
+        }
+        
+        try {
+            await this.leaveChannel();
+        } catch(err) {
+            console.log(err);
+        }
+
+        this.unsubscribable.unsubscribe();
+        this.isSubscribed = false;
+
+        if (this.unsubscribeCallback) {
+            this.unsubscribeCallback(this);
+        }
+    }
+
+    private async registerContextListener(channelId: string, channelType: ChannelType) :Promise<void>{
+        const request = new Fdc3AddContextListenerRequest(window.composeui.fdc3.config?.instanceId!, this.contextType, channelId, channelType);
+        const response = await this.jsonMessaging.invokeJsonService<Fdc3AddContextListenerRequest, Fdc3AddContextListenerResponse>(ComposeUITopic.addContextListener(), request);
+
+        if (!response) {
+            throw new Error(ComposeUIErrors.NoAnswerWasProvided);
+        }
+
+        if (response.error) {
+            throw new Error(response.error);
+        } else if (!response.success) {
+            throw new Error(ComposeUIErrors.SubscribeFailure);
+        }
+
+        this.id = response.id!;
+    }
+
+    private async leaveChannel() : Promise<void> {
+        const request = new Fdc3RemoveContextListenerRequest(window.composeui.fdc3.config?.instanceId!, this.id!, this.contextType);
+        const response = await this.jsonMessaging.invokeJsonService<Fdc3RemoveContextListenerRequest, Fdc3RemoveContextListenerResponse>(ComposeUITopic.removeContextListener(), request);
+        if (!response) {
+            throw new Error(ComposeUIErrors.NoAnswerWasProvided);
+        }
+
+        if (response.error) {
+            throw new Error(response.error);
+        }
+
+        if (!response.success) {
+            throw new Error(ComposeUIErrors.UnsubscribeFailure);
+        }
+        
+        return;
+    }
+}

package/src/infrastructure/ComposeUIErrors.ts

@@ -0,0 +1,21 @@
+/* 
+ *  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.
+ *  
+ */
+
+export enum ComposeUIErrors {
+    NoAnswerWasProvided = 'No answer was provided by the DesktopAgent backend.',
+    InstanceIdNotFound = 'InstanceId was not found on window object. To run Fdc3\'s ComposeUI implementation instance config should be set on window config.',
+    CurrentChannelNotSet = 'The current channel has not been set.',
+    UnsubscribeFailure = 'The Listener could not unsubscribe.',
+    SubscribeFailure = 'The Listener could not subscribe.',
+    AppIdentifierTypeFailure = 'Using string type for app argument is not supported. Please use undefined | AppIdentifier types!'
+}