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

package/src/ComposeUIMessageRouterMetadataClient.spec.ts

@@ -0,0 +1,240 @@
+/* 
+ *  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 { 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";
+
+describe('MessageRouterMetadataClient tests', () => {
+    beforeEach(() => {
+        window.composeui = {
+            fdc3: {
+                config: {
+                    appId: "testAppId",
+                    instanceId: "testInstanceId"
+                },
+                channelId: "test",
+                openAppIdentifier: {
+                    openedAppContextId: "test"
+                }
+            }
+        };
+    });
+
+    it('getInfo returns no payload', async () => {
+        const messageRouterClientMock = {
+            clientId: "dummy",
+            subscribe: jest.fn(() => { return Promise.resolve({unsubscribe: () => {}});}),
+            publish: jest.fn(() => { return Promise.resolve() }),
+            connect: jest.fn(() => { return Promise.resolve() }),
+            registerEndpoint: jest.fn(() => { return Promise.resolve() }),
+            unregisterEndpoint: jest.fn(() => { return Promise.resolve() }),
+            registerService: jest.fn(() => { return Promise.resolve() }),
+            unregisterService: jest.fn(() => { return Promise.resolve() }),
+            invoke: jest.fn(() => { return Promise.resolve(undefined) }) 
+        };
+
+        const desktopAgent = new ComposeUIDesktopAgent(messageRouterClientMock);
+
+        await expect(desktopAgent.getInfo())
+            .rejects
+            .toThrow(ComposeUIErrors.NoAnswerWasProvided);
+    });
+
+    it('getInfo returns error', async() => {
+        const messageRouterClientMock = {
+            clientId: "dummy",
+            subscribe: jest.fn(() => { return Promise.resolve({unsubscribe: () => {}});}),
+            publish: jest.fn(() => { return Promise.resolve() }),
+            connect: jest.fn(() => { return Promise.resolve() }),
+            registerEndpoint: jest.fn(() => { return Promise.resolve() }),
+            unregisterEndpoint: jest.fn(() => { return Promise.resolve() }),
+            registerService: jest.fn(() => { return Promise.resolve() }),
+            unregisterService: jest.fn(() => { return Promise.resolve() }),
+            invoke: jest.fn(() => { return Promise.resolve(`${JSON.stringify({ error: "dummyError" })}`) }) 
+        };
+
+        const desktopAgent = new ComposeUIDesktopAgent(messageRouterClientMock);
+
+        await expect(desktopAgent.getInfo())
+            .rejects
+            .toThrow('dummyError');
+    });
+
+    it('getInfo returns ImplemetationMetadata', 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: implementationMetadata
+        };
+
+        const messageRouterClientMock = {
+            clientId: "dummy",
+            subscribe: jest.fn(() => { return Promise.resolve({unsubscribe: () => {}});}),
+            publish: jest.fn(() => { return Promise.resolve() }),
+            connect: jest.fn(() => { return Promise.resolve() }),
+            registerEndpoint: jest.fn(() => { return Promise.resolve() }),
+            unregisterEndpoint: jest.fn(() => { return Promise.resolve() }),
+            registerService: jest.fn(() => { return Promise.resolve() }),
+            unregisterService: jest.fn(() => { return Promise.resolve() }),
+            invoke: jest.fn(() => { return Promise.resolve(`${JSON.stringify(response)}`) }) 
+        };
+
+        const desktopAgent = new ComposeUIDesktopAgent(messageRouterClientMock);
+
+        var result = await desktopAgent.getInfo();
+        expect(result).toMatchObject(implementationMetadata);
+    });
+
+
+    it('findInstances returns no payload', async () => {
+        const messageRouterClientMock = {
+            clientId: "dummy",
+            subscribe: jest.fn(() => { return Promise.resolve({unsubscribe: () => {}});}),
+            publish: jest.fn(() => { return Promise.resolve() }),
+            connect: jest.fn(() => { return Promise.resolve() }),
+            registerEndpoint: jest.fn(() => { return Promise.resolve() }),
+            unregisterEndpoint: jest.fn(() => { return Promise.resolve() }),
+            registerService: jest.fn(() => { return Promise.resolve() }),
+            unregisterService: jest.fn(() => { return Promise.resolve() }),
+            invoke: jest.fn(() => { return Promise.resolve(undefined) }) 
+        };
+
+        const desktopAgent = new ComposeUIDesktopAgent(messageRouterClientMock);
+
+        await expect(desktopAgent.findInstances({appId: "test"}))
+            .rejects
+            .toThrow(ComposeUIErrors.NoAnswerWasProvided);
+    });
+
+    it('findInstances returns error', async() => {
+        const messageRouterClientMock = {
+            clientId: "dummy",
+            subscribe: jest.fn(() => { return Promise.resolve({unsubscribe: () => {}});}),
+            publish: jest.fn(() => { return Promise.resolve() }),
+            connect: jest.fn(() => { return Promise.resolve() }),
+            registerEndpoint: jest.fn(() => { return Promise.resolve() }),
+            unregisterEndpoint: jest.fn(() => { return Promise.resolve() }),
+            registerService: jest.fn(() => { return Promise.resolve() }),
+            unregisterService: jest.fn(() => { return Promise.resolve() }),
+            invoke: jest.fn(() => { return Promise.resolve(`${JSON.stringify({ error: "dummyError" })}`) }) 
+        };
+
+        const desktopAgent = new ComposeUIDesktopAgent(messageRouterClientMock);
+
+        await expect(desktopAgent.findInstances({appId: "test"}))
+            .rejects
+            .toThrow('dummyError');
+    });
+
+    it('findInstances return instances', async() => {
+
+        const response : Fdc3FindInstancesResponse = {
+            instances: [{appId: "test", instanceId: "id"}]
+        };
+
+        const messageRouterClientMock = {
+            clientId: "dummy",
+            subscribe: jest.fn(() => { return Promise.resolve({unsubscribe: () => {}});}),
+            publish: jest.fn(() => { return Promise.resolve() }),
+            connect: jest.fn(() => { return Promise.resolve() }),
+            registerEndpoint: jest.fn(() => { return Promise.resolve() }),
+            unregisterEndpoint: jest.fn(() => { return Promise.resolve() }),
+            registerService: jest.fn(() => { return Promise.resolve() }),
+            unregisterService: jest.fn(() => { return Promise.resolve() }),
+            invoke: jest.fn(() => { return Promise.resolve(`${JSON.stringify(response)}`) }) 
+        };
+
+        const desktopAgent = new ComposeUIDesktopAgent(messageRouterClientMock);
+
+        var result = await desktopAgent.findInstances({appId: "test"});
+        expect(result).toMatchObject([{appId: "test", instanceId: "id"}]);
+    });
+
+    it('getAppMetadata returns no payload', async () => {
+        const messageRouterClientMock = {
+            clientId: "dummy",
+            subscribe: jest.fn(() => { return Promise.resolve({unsubscribe: () => {}});}),
+            publish: jest.fn(() => { return Promise.resolve() }),
+            connect: jest.fn(() => { return Promise.resolve() }),
+            registerEndpoint: jest.fn(() => { return Promise.resolve() }),
+            unregisterEndpoint: jest.fn(() => { return Promise.resolve() }),
+            registerService: jest.fn(() => { return Promise.resolve() }),
+            unregisterService: jest.fn(() => { return Promise.resolve() }),
+            invoke: jest.fn(() => { return Promise.resolve(undefined) }) 
+        };
+
+        const desktopAgent = new ComposeUIDesktopAgent(messageRouterClientMock);
+
+        await expect(desktopAgent.getAppMetadata({appId: "test"}))
+            .rejects
+            .toThrow(ComposeUIErrors.NoAnswerWasProvided);
+    });
+
+    it('getAppMetadata returns error', async() => {
+        const messageRouterClientMock = {
+            clientId: "dummy",
+            subscribe: jest.fn(() => { return Promise.resolve({unsubscribe: () => {}});}),
+            publish: jest.fn(() => { return Promise.resolve() }),
+            connect: jest.fn(() => { return Promise.resolve() }),
+            registerEndpoint: jest.fn(() => { return Promise.resolve() }),
+            unregisterEndpoint: jest.fn(() => { return Promise.resolve() }),
+            registerService: jest.fn(() => { return Promise.resolve() }),
+            unregisterService: jest.fn(() => { return Promise.resolve() }),
+            invoke: jest.fn(() => { return Promise.resolve(`${JSON.stringify({ error: "dummyError" })}`) }) 
+        };
+
+        const desktopAgent = new ComposeUIDesktopAgent(messageRouterClientMock);
+
+        await expect(desktopAgent.getAppMetadata({appId: "test"}))
+            .rejects
+            .toThrow('dummyError');
+    });
+
+    it('getAppMetadata return instances', async() => {
+
+        const response : Fdc3GetAppMetadataResponse = {
+            appMetadata: { appId: "test" }
+        };
+
+        const messageRouterClientMock = {
+            clientId: "dummy",
+            subscribe: jest.fn(() => { return Promise.resolve({unsubscribe: () => {}});}),
+            publish: jest.fn(() => { return Promise.resolve() }),
+            connect: jest.fn(() => { return Promise.resolve() }),
+            registerEndpoint: jest.fn(() => { return Promise.resolve() }),
+            unregisterEndpoint: jest.fn(() => { return Promise.resolve() }),
+            registerService: jest.fn(() => { return Promise.resolve() }),
+            unregisterService: jest.fn(() => { return Promise.resolve() }),
+            invoke: jest.fn(() => { return Promise.resolve(`${JSON.stringify(response)}`) }) 
+        };
+
+        const desktopAgent = new ComposeUIDesktopAgent(messageRouterClientMock);
+
+        var result = await desktopAgent.getAppMetadata({appId: "test"});
+        expect(result).toMatchObject({appId: "test"});
+    });
+});

package/src/ComposeUIMessageRouterOpenClient.spec.ts

@@ -0,0 +1,239 @@
+/* 
+ *  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 { getCurrentChannel, OpenError } from "@finos/fdc3";
+import { MessageRouterOpenClient } from "./infrastructure/MessageRouterOpenClient";
+import { ComposeUIErrors } from "./infrastructure/ComposeUIErrors";
+import { Fdc3OpenResponse } from "./infrastructure/messages/Fdc3OpenResponse";
+import { MessageRouter } from "@morgan-stanley/composeui-messaging-client";
+import { Fdc3GetOpenedAppContextResponse } from "./infrastructure/messages/Fdc3GetOpenedAppContextResponse";
+import { OpenAppIdentifier } from "./infrastructure/OpenAppIdentifier";
+import { rejects } from "assert";
+
+describe('MessageRouter OpenClient tests', () => {
+    let client: MessageRouterOpenClient;
+    let messageRouterClient: MessageRouter;
+    const openAppIdentifier: OpenAppIdentifier = { openedAppContextId: "contextId" };
+
+    beforeEach(() => {
+        window.composeui = {
+            fdc3: {
+                config: {
+                    appId: "testAppId",
+                    instanceId: "testInstanceId"
+                },
+                channelId: "test",
+                openAppIdentifier: {
+                    openedAppContextId: "contextId"
+                }
+            }
+        };
+
+        messageRouterClient = {
+            clientId: "dummy",
+            subscribe: jest.fn(() => {
+                return Promise.resolve({ unsubscribe: () => { } });
+            }),
+
+            publish: jest.fn(() => { return Promise.resolve() }),
+            connect: jest.fn(() => { return Promise.resolve() }),
+            registerEndpoint: jest.fn(() => { return Promise.resolve() }),
+            unregisterEndpoint: jest.fn(() => { return Promise.resolve() }),
+            registerService: jest.fn(() => { return Promise.resolve() }),
+            unregisterService: jest.fn(() => { return Promise.resolve() }),
+            invoke: jest.fn(() => { return Promise.resolve(undefined) })
+        };
+
+        client = new MessageRouterOpenClient("fdc3InstanceId", messageRouterClient, openAppIdentifier);
+    });
+
+    it('open throws AppNotFound error as AppIdentifier not set', async() => {
+        await expect(client.open())
+            .rejects
+            .toThrow(OpenError.AppNotFound);
+    });
+
+    it('open throws NoAnswerWasProvided error as no response received by the MessageRouter server', async() => {
+        await expect(client.open("appId1"))
+            .rejects
+            .toThrow(ComposeUIErrors.NoAnswerWasProvided);
+    });
+
+    it('open throws error as error response received by the MessageRouter server', async() => {
+        const response: Fdc3OpenResponse = {
+            error: "testError"
+        };
+
+        messageRouterClient = {
+            clientId: "dummy",
+            subscribe: jest.fn(() => {
+                return Promise.resolve({ unsubscribe: () => { } });
+            }),
+
+            publish: jest.fn(() => { return Promise.resolve() }),
+            connect: jest.fn(() => { return Promise.resolve() }),
+            registerEndpoint: jest.fn(() => { return Promise.resolve() }),
+            unregisterEndpoint: jest.fn(() => { return Promise.resolve() }),
+            registerService: jest.fn(() => { return Promise.resolve() }),
+            unregisterService: jest.fn(() => { return Promise.resolve() }),
+            invoke: jest.fn(() => { return Promise.resolve(`${JSON.stringify(response)}`) })
+        };
+
+        client = new MessageRouterOpenClient("fdc3InstanceId", messageRouterClient, openAppIdentifier);
+        await expect(client.open("appId1"))
+            .rejects
+            .toThrow("testError");
+    });
+
+    it('open returns AppIdentifier response received by the MessageRouter server', async() => {
+        const response: Fdc3OpenResponse = {
+            appIdentifier: {
+                appId: "appId1",
+                instanceId: "instanceId1"
+            }
+        };
+
+        messageRouterClient = {
+            clientId: "dummy",
+            subscribe: jest.fn(() => {
+                return Promise.resolve({ unsubscribe: () => { } });
+            }),
+
+            publish: jest.fn(() => { return Promise.resolve() }),
+            connect: jest.fn(() => { return Promise.resolve() }),
+            registerEndpoint: jest.fn(() => { return Promise.resolve() }),
+            unregisterEndpoint: jest.fn(() => { return Promise.resolve() }),
+            registerService: jest.fn(() => { return Promise.resolve() }),
+            unregisterService: jest.fn(() => { return Promise.resolve() }),
+            invoke: jest.fn(() => { return Promise.resolve(`${JSON.stringify(response)}`) })
+        }
+
+        client = new MessageRouterOpenClient("fdc3InstanceId", messageRouterClient, openAppIdentifier);
+        const result = await client.open({appId: "appId1"}, {type: "fdc3.instrument"});
+        expect(result).toMatchObject({appId: "appId1", instanceId: "instanceId1"});
+    });
+
+    it('getOpenedAppContext throws error as context id is not set', async() => {
+        client = new MessageRouterOpenClient("fdc3InstanceId", messageRouterClient);
+        await expect(client.getOpenedAppContext())
+            .rejects
+            .toThrow("Context id is not defined on the window object.");
+    });
+
+    it('getOpenedAppContext throws NoAnswerWasProvided error as no response received from the MessageRouter server', async() => {
+        await expect(client.getOpenedAppContext())
+            .rejects
+            .toThrow(ComposeUIErrors.NoAnswerWasProvided);
+    });
+
+    it('getOpenedAppContext throws NoAnswerWasProvided error as not correct response received from the MessageRouter server', async() => {
+        const response = {
+            payload: "wrongPayload"
+        };
+
+        messageRouterClient = {
+            clientId: "dummy",
+            subscribe: jest.fn(() => {
+                return Promise.resolve({ unsubscribe: () => { } });
+            }),
+
+            publish: jest.fn(() => { return Promise.resolve() }),
+            connect: jest.fn(() => { return Promise.resolve() }),
+            registerEndpoint: jest.fn(() => { return Promise.resolve() }),
+            unregisterEndpoint: jest.fn(() => { return Promise.resolve() }),
+            registerService: jest.fn(() => { return Promise.resolve() }),
+            unregisterService: jest.fn(() => { return Promise.resolve() }),
+            invoke: jest.fn(() => { return Promise.resolve(`${JSON.stringify(response)}`) })
+        };
+
+        client = new MessageRouterOpenClient("fdc3InstanceId", messageRouterClient, openAppIdentifier);
+        await expect(client.getOpenedAppContext())
+            .rejects
+            .toThrow(ComposeUIErrors.NoAnswerWasProvided);
+    });
+
+    it('getOpenedAppContext throws error as error response received from the MessageRouter server', async() => {
+        const response: Fdc3GetOpenedAppContextResponse = {
+            error: "testGetOpenedAppContextError"
+        };
+
+        messageRouterClient = {
+            clientId: "dummy",
+            subscribe: jest.fn(() => {
+                return Promise.resolve({ unsubscribe: () => { } });
+            }),
+
+            publish: jest.fn(() => { return Promise.resolve() }),
+            connect: jest.fn(() => { return Promise.resolve() }),
+            registerEndpoint: jest.fn(() => { return Promise.resolve() }),
+            unregisterEndpoint: jest.fn(() => { return Promise.resolve() }),
+            registerService: jest.fn(() => { return Promise.resolve() }),
+            unregisterService: jest.fn(() => { return Promise.resolve() }),
+            invoke: jest.fn(() => { return Promise.resolve(`${JSON.stringify(response)}`) })
+        };
+
+        client = new MessageRouterOpenClient("fdc3InstanceId", messageRouterClient, openAppIdentifier);
+        await expect(client.getOpenedAppContext())
+            .rejects
+            .toThrow("testGetOpenedAppContextError");
+    });
+
+    it('getOpenedAppContext throws NoAnswerWasProvided error as no context response received from the MessageRouter server', async() => {
+        const response: Fdc3GetOpenedAppContextResponse = { };
+
+        messageRouterClient = {
+            clientId: "dummy",
+            subscribe: jest.fn(() => {
+                return Promise.resolve({ unsubscribe: () => { } });
+            }),
+
+            publish: jest.fn(() => { return Promise.resolve() }),
+            connect: jest.fn(() => { return Promise.resolve() }),
+            registerEndpoint: jest.fn(() => { return Promise.resolve() }),
+            unregisterEndpoint: jest.fn(() => { return Promise.resolve() }),
+            registerService: jest.fn(() => { return Promise.resolve() }),
+            unregisterService: jest.fn(() => { return Promise.resolve() }),
+            invoke: jest.fn(() => { return Promise.resolve(`${JSON.stringify(response)}`) })
+        };
+
+        client = new MessageRouterOpenClient("fdc3InstanceId", messageRouterClient, openAppIdentifier);
+        await expect(client.getOpenedAppContext())
+            .rejects
+            .toThrow(ComposeUIErrors.NoAnswerWasProvided);
+    });
+
+    it('getOpenedAppContext returns context', async() => {
+        const response: Fdc3GetOpenedAppContextResponse = {
+            context: {type: "fdc3.instrument"}
+        };
+
+        messageRouterClient = {
+            clientId: "dummy",
+            subscribe: jest.fn(() => {
+                return Promise.resolve({ unsubscribe: () => { } });
+            }),
+
+            publish: jest.fn(() => { return Promise.resolve() }),
+            connect: jest.fn(() => { return Promise.resolve() }),
+            registerEndpoint: jest.fn(() => { return Promise.resolve() }),
+            unregisterEndpoint: jest.fn(() => { return Promise.resolve() }),
+            registerService: jest.fn(() => { return Promise.resolve() }),
+            unregisterService: jest.fn(() => { return Promise.resolve() }),
+            invoke: jest.fn(() => { return Promise.resolve(`${JSON.stringify(response)}`) })
+        };
+
+        client = new MessageRouterOpenClient("fdc3InstanceId", messageRouterClient, openAppIdentifier);
+        const result = await client.getOpenedAppContext();
+
+        expect(result.type).toBe("fdc3.instrument");
+    });
+});

package/src/index.ts

@@ -0,0 +1,66 @@
+/* 
+ *  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 { createMessageRouter } from "@morgan-stanley/composeui-messaging-client";
+import { OpenAppIdentifier } from "./infrastructure/OpenAppIdentifier";
+
+declare global {
+    interface Window {
+        composeui: {
+            fdc3: {
+                config: AppIdentifier | undefined;
+                channelId : string | undefined;
+                openAppIdentifier: OpenAppIdentifier | 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 fdc3 = new ComposeUIDesktopAgent(createMessageRouter());
+
+    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"