Remove KogitoEditorEnvelopeServer

packages/editor/src/embedded/__tests__/embedded/EmbeddedEditor.test.tsx

@@ -14,16 +14,16 @@
  * limitations under the License.
  */
 
-import { EditorEnvelopeLocator } from "../../../api";
-import { ChannelType, KogitoEdit } from "@kogito-tooling/channel-common-api";
-import { EnvelopeServer } from "@kogito-tooling/envelope-bus/dist/channel";
+import {EditorEnvelopeLocator} from "../../../api";
+import {ChannelType, KogitoEdit} from "@kogito-tooling/channel-common-api";
+import {EnvelopeServer} from "@kogito-tooling/envelope-bus/dist/channel";
 import * as React from "react";
-import { File } from "../../common";
-import { EmbeddedEditor, EmbeddedEditorRef } from "../../embedded";
-import { incomingMessage } from "./EmbeddedEditorTestUtils";
-import { render } from "@testing-library/react";
-import { EnvelopeBusMessagePurpose } from "@kogito-tooling/envelope-bus/dist/api";
-import { KogitoEditorEnvelopeServer } from "../../../channel";
+import {File} from "../../common";
+import {EmbeddedEditor, EmbeddedEditorRef} from "../../embedded";
+import {incomingMessage} from "./EmbeddedEditorTestUtils";
+import {render} from "@testing-library/react";
+import {EnvelopeBusMessagePurpose} from "@kogito-tooling/envelope-bus/dist/api";
+import {KogitoEditorEnvelopeServer} from "../../../channel";
 
 describe("EmbeddedEditor::ONLINE", () => {
   const file: File = {
@@ -66,7 +66,6 @@ describe("EmbeddedEditor::ONLINE", () => {
   });
 
   test("EmbeddedEditor::setContent", () => {
-    const spyRespond_contentRequest = jest.spyOn(KogitoEditorEnvelopeServer.prototype, "notify_contentChanged");
     render(
       <EmbeddedEditor
         ref={editorRef}
@@ -76,16 +75,18 @@ describe("EmbeddedEditor::ONLINE", () => {
         locale={"en"}
       />
     );
+
+    const spyOnContentChangedNotification = jest.spyOn(
+      editorRef.current!.envelopeServer().envelopeApi.notifications,
+      "receive_contentChanged"
+    );
+
     editorRef.current?.setContent("content", "");
 
-    expect(spyRespond_contentRequest).toBeCalledWith({ content: "content" });
+    expect(spyOnContentChangedNotification).toBeCalledWith({ content: "content" });
   });
 
   test("EmbeddedEditor::requestContent", () => {
-    const spyRequest_contentResponse = jest.spyOn(
-      KogitoEditorEnvelopeServer.prototype,
-      "request_contentResponse"
-    );
     render(
       <EmbeddedEditor
         ref={editorRef}
@@ -95,16 +96,17 @@ describe("EmbeddedEditor::ONLINE", () => {
         locale={"en"}
       />
     );
+
+    const spyRequest_contentResponse = jest.spyOn(
+        editorRef.current!.envelopeServer().envelopeApi.requests,
+        "receive_contentRequest"
+    );
     editorRef.current?.getContent();
 
     expect(spyRequest_contentResponse).toBeCalled();
   });
 
   test("EmbeddedEditor::requestPreview", () => {
-    const spyRequest_previewResponse = jest.spyOn(
-      KogitoEditorEnvelopeServer.prototype,
-      "request_previewResponse"
-    );
     render(
       <EmbeddedEditor
         ref={editorRef}
@@ -114,6 +116,11 @@ describe("EmbeddedEditor::ONLINE", () => {
         locale={"en"}
       />
     );
+
+    const spyRequest_previewResponse = jest.spyOn(
+        editorRef.current!.envelopeServer().envelopeApi.requests,
+        "receive_previewRequest"
+    );
     editorRef.current?.getPreview();
 
     expect(spyRequest_previewResponse).toBeCalled();

packages/editor/src/embedded/embedded/EmbeddedEditor.tsx

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { EditorApi, EditorEnvelopeLocator, KogitoEditorChannelApi } from "../../api";
+import { EditorApi, EditorEnvelopeLocator, KogitoEditorChannelApi, KogitoEditorEnvelopeApi } from "../../api";
 import { ChannelType } from "@kogito-tooling/channel-common-api";
 import { useSyncedKeyboardEvents } from "@kogito-tooling/keyboard-shortcuts/dist/channel";
 import { useGuidedTourPositionProvider } from "@kogito-tooling/guided-tour/dist/channel";
@@ -25,7 +25,7 @@ import { File, useEffectAfterFirstRender } from "../common";
 import { StateControl } from "../stateControl";
 import { KogitoEditorChannelApiImpl } from "./KogitoEditorChannelApiImpl";
 import { useConnectedEnvelopeServer } from "@kogito-tooling/envelope-bus/dist/hooks";
-import { KogitoEditorEnvelopeServer } from "../../channel";
+import { EnvelopeServer } from "@kogito-tooling/envelope-bus/dist/channel";
 
 type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
 
@@ -48,7 +48,12 @@ export type Props = EmbeddedEditorChannelApiOverrides & {
 /**
  * Forward reference for the `EmbeddedEditor` to support consumers to call upon embedded operations.
  */
-export type EmbeddedEditorRef = (EditorApi & { getStateControl(): StateControl }) | null;
+export type EmbeddedEditorRef =
+  | (EditorApi & {
+      getStateControl(): StateControl;
+      envelopeServer(): EnvelopeServer<KogitoEditorChannelApi, KogitoEditorEnvelopeApi>;
+    })
+  | null;
 
 const containerStyles: CSS.Properties = {
   display: "flex",
@@ -80,10 +85,14 @@ const RefForwardingEmbeddedEditor: React.RefForwardingComponent<EmbeddedEditorRe
   }, [stateControl, props.file, props]);
 
   const envelopeServer = useMemo(() => {
-    return new KogitoEditorEnvelopeServer(
+    return new EnvelopeServer<KogitoEditorChannelApi, KogitoEditorEnvelopeApi>(
       { postMessage: message => iframeRef.current?.contentWindow?.postMessage(message, "*") },
       props.editorEnvelopeLocator.targetOrigin,
-      { fileExtension: props.file.fileExtension, resourcesPathPrefix: envelopeMapping?.resourcesPathPrefix ?? "" }
+      self =>
+        self.envelopeApi.requests.receive_initRequest(
+          { origin: self.origin, envelopeServerId: self.id },
+          { fileExtension: props.file.fileExtension, resourcesPathPrefix: envelopeMapping?.resourcesPathPrefix ?? "" }
+        )
     );
   }, []);
 
@@ -109,13 +118,15 @@ const RefForwardingEmbeddedEditor: React.RefForwardingComponent<EmbeddedEditorRe
 
       return {
         getStateControl: () => stateControl,
+        envelopeServer: () => envelopeServer,
         getElementPosition: selector =>
           envelopeServer.envelopeApi.requests.receive_guidedTourElementPositionRequest(selector),
-        redo: () => Promise.resolve(envelopeServer.notify_editorRedo()),
-        undo: () => Promise.resolve(envelopeServer.notify_editorUndo()),
-        getContent: () => envelopeServer.request_contentResponse().then(c => c.content),
-        getPreview: () => envelopeServer.request_previewResponse(),
-        setContent: async content => envelopeServer.notify_contentChanged({ content: content })
+        undo: () => Promise.resolve(envelopeServer.envelopeApi.notifications.receive_editorUndo()),
+        redo: () => Promise.resolve(envelopeServer.envelopeApi.notifications.receive_editorRedo()),
+        getContent: () => envelopeServer.envelopeApi.requests.receive_contentRequest().then(c => c.content),
+        getPreview: () => envelopeServer.envelopeApi.requests.receive_previewRequest(),
+        setContent: async content =>
+          envelopeServer.envelopeApi.notifications.receive_contentChanged({ content: content })
       };
     },
     [envelopeServer]

packages/editor/webpack.config.js

@@ -40,15 +40,6 @@ module.exports = [
     externals: [nodeExternals({ modulesDir: "../../node_modules" })],
     module: { rules: [...pfWebpackOptions.patternflyRules] }
   }),
-  merge(common, {
-    entry: {
-      "channel/index": "./src/channel/index.ts"
-    },
-    output: {
-      libraryTarget: "commonjs2"
-    },
-    externals: [nodeExternals({ modulesDir: "../../node_modules" })]
-  }),
   merge(common, {
     entry: {
       "embedded/index": "./src/embedded/index.ts"

packages/envelope-bus/src/common/EnvelopeBusMessageManager.ts

@@ -42,33 +42,59 @@ export class EnvelopeBusMessageManager<
 
   private requestIdCounter: number;
 
-  public get server(): MessageBusServer<ApiToProvide, ApiToConsume> {
-    return {
-      receive: (m, apiImpl) => this.receive(m, apiImpl)
-    };
-  }
+  public clientApi: MessageBusClientApi<ApiToConsume> = (() => {
+    const requestsCache = new Map<
+      RequestPropertyNames<ApiToConsume>,
+      (...args: ArgsType<ApiToConsume[keyof ApiToConsume]>) => Promise<any>
+    >();
+
+    const notificationsCache = new Map<
+      NotificationPropertyNames<ApiToConsume>,
+      (...args: ArgsType<ApiToConsume[keyof ApiToConsume]>) => void
+    >();
 
-  public get clientApi(): MessageBusClientApi<ApiToConsume> {
     const requests: ApiRequests<ApiToConsume> = new Proxy<ApiRequests<ApiToConsume>>({} as ApiRequests<ApiToConsume>, {
+      set: (target, name, value) => {
+        requestsCache.set(name as RequestPropertyNames<ApiToConsume>, value);
+        return true;
+      },
       get: (target, name) => {
-        return (...args: ArgsType<ApiToConsume[keyof ApiToConsume]>) =>
-          this.request(name as RequestPropertyNames<ApiToConsume>, ...args);
+        const method = name as RequestPropertyNames<ApiToConsume>;
+        return (
+          requestsCache.get(method) ??
+          requestsCache.set(method, (...args) => this.request(method, ...args) as Promise<any>).get(method)
+        );
       }
     });
 
     const notifications = new Proxy<ApiNotifications<ApiToConsume>>({} as ApiNotifications<ApiToConsume>, {
+      set: (target, name, value) => {
+        notificationsCache.set(name as NotificationPropertyNames<ApiToConsume>, value);
+        return true;
+      },
       get: (target, name) => {
-        return (...args: ArgsType<ApiToConsume[keyof ApiToConsume]>) =>
-          this.notify(name as NotificationPropertyNames<ApiToConsume>, ...args);
+        const method = name as NotificationPropertyNames<ApiToConsume>;
+        return (
+          notificationsCache.get(method) ??
+          notificationsCache.set(method, (...args) => this.notify(method, ...args)).get(method)
+        );
       }
     });
 
-    return {
+    const clientApi: MessageBusClientApi<ApiToConsume> = {
       requests,
       notifications,
       subscribe: (m, a) => this.subscribe(m, a),
       unsubscribe: (m, a) => this.unsubscribe(m, a)
     };
+
+    return clientApi;
+  })();
+
+  public get server(): MessageBusServer<ApiToProvide, ApiToConsume> {
+    return {
+      receive: (m, apiImpl) => this.receive(m, apiImpl)
+    };
   }
 
   constructor(
@@ -127,7 +153,7 @@ export class EnvelopeBusMessageManager<
       purpose: EnvelopeBusMessagePurpose.REQUEST
     });
 
-    return new Promise((resolve, reject) => {
+    return new Promise<any>((resolve, reject) => {
       this.callbacks.set(requestId, { resolve, reject });
     }) as ReturnType<ApiToConsume[M]>;
 

packages/vscode-extension/src/KogitoEditor.ts

@@ -19,13 +19,14 @@ import {
   EditorApi,
   EditorEnvelopeLocator,
   EnvelopeMapping,
-  KogitoEditorChannelApi
+  KogitoEditorChannelApi,
+  KogitoEditorEnvelopeApi
 } from "@kogito-tooling/editor/dist/api";
 import { KogitoEditorStore } from "./KogitoEditorStore";
 import { KogitoEditableDocument } from "./KogitoEditableDocument";
 import { EnvelopeBusMessage } from "@kogito-tooling/envelope-bus/dist/api";
 import { EnvelopeBusMessageBroadcaster } from "./EnvelopeBusMessageBroadcaster";
-import { KogitoEditorEnvelopeServer } from "@kogito-tooling/editor/dist/channel";
+import { EnvelopeServer } from "@kogito-tooling/envelope-bus/dist/channel";
 
 export class KogitoEditor implements EditorApi {
   private broadcastSubscription: (msg: EnvelopeBusMessage<unknown, any>) => void;
@@ -38,15 +39,16 @@ export class KogitoEditor implements EditorApi {
     private readonly envelopeMapping: EnvelopeMapping,
     private readonly envelopeLocator: EditorEnvelopeLocator,
     private readonly messageBroadcaster: EnvelopeBusMessageBroadcaster,
-    private readonly envelopeServer = new KogitoEditorEnvelopeServer(
+    private readonly envelopeServer = new EnvelopeServer<KogitoEditorChannelApi, KogitoEditorEnvelopeApi>(
       {
         postMessage: msg => this.panel.webview.postMessage(msg)
       },
       envelopeLocator.targetOrigin,
-      {
-        fileExtension: document.fileExtension,
-        resourcesPathPrefix: envelopeMapping.resourcesPathPrefix
-      }
+      self =>
+        self.envelopeApi.requests.receive_initRequest(
+          { origin: self.origin, envelopeServerId: self.id },
+          { fileExtension: document.fileExtension, resourcesPathPrefix: envelopeMapping.resourcesPathPrefix }
+        )
     )
   ) {}
 
@@ -55,23 +57,23 @@ export class KogitoEditor implements EditorApi {
   }
 
   public getContent() {
-    return this.envelopeServer.request_contentResponse().then(c => c.content);
+    return this.envelopeServer.envelopeApi.requests.receive_contentRequest().then(c => c.content);
   }
 
   public async setContent(path: string, content: string) {
-    this.envelopeServer.notify_contentChanged({ path: path, content: content });
+    this.envelopeServer.envelopeApi.notifications.receive_contentChanged({ path: path, content: content });
   }
 
   public async undo() {
-    this.envelopeServer.notify_editorUndo();
+    this.envelopeServer.envelopeApi.notifications.receive_editorUndo();
   }
 
   public async redo() {
-    this.envelopeServer.notify_editorRedo();
+    this.envelopeServer.envelopeApi.notifications.receive_editorRedo();
   }
 
   public getPreview() {
-    return this.envelopeServer.request_previewResponse();
+    return this.envelopeServer.envelopeApi.requests.receive_previewRequest();
   }
 
   public startInitPolling() {