Extract messaging to NPM package

Co-authored-by: Mikko Aspiala <mikko.aspiala@gmail.com>

Signed-off-by: Janne Savolainen <janne.savolainen@live.fi>

packages/technical-features/messaging/main/.eslintrc.json

@@ -0,0 +1,6 @@
+{
+  "extends": "@k8slens/eslint-config/eslint",
+  "parserOptions": {
+    "project": "./tsconfig.json"
+  }
+}

packages/technical-features/messaging/main/.prettierrc

@@ -0,0 +1 @@
+"@k8slens/eslint-config/prettier"

packages/technical-features/messaging/main/index.ts

@@ -0,0 +1 @@
+export { messagingFeatureForMain } from "./src/feature";

packages/technical-features/messaging/main/jest.config.js

@@ -0,0 +1,2 @@
+module.exports =
+  require("@k8slens/jest").monorepoPackageConfig(__dirname).configForNode;

packages/technical-features/messaging/main/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@k8slens/messaging-for-main",
+  "private": false,
+  "version": "1.0.0-alpha.1",
+  "description": "Implementations for 'messaging' in Electron main",
+  "type": "commonjs",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lensapp/lens.git"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "author": {
+    "name": "OpenLens Authors",
+    "email": "info@k8slens.dev"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/lensapp/lens",
+  "scripts": {
+    "build": "webpack",
+    "dev": "webpack --mode=development --watch",
+    "test:unit": "jest --coverage --runInBand",
+    "lint": "lens-lint",
+    "lint:fix": "lens-lint --fix"
+  },
+  "peerDependencies": {
+    "@k8slens/application": "^6.5.0-alpha.0",
+    "@k8slens/feature-core": "^6.5.0-alpha.0",
+    "@k8slens/messaging": "^1.0.0-alpha.1",
+    "@ogre-tools/injectable": "^15.1.2",
+    "@ogre-tools/injectable-extension-for-auto-registration": "^15.1.2",
+    "electron": "^19.1.8",
+    "lodash": "^4.17.21"
+  },
+  "devDependencies": {
+    "@k8slens/eslint-config": "^6.5.0-alpha.1"
+  }
+}

packages/technical-features/messaging/main/src/channel-listeners/enlist-message-channel-listener.injectable.ts

@@ -0,0 +1,28 @@
+import { getInjectable } from "@ogre-tools/injectable";
+import type { IpcMainEvent } from "electron";
+import ipcMainInjectable from "../ipc-main/ipc-main.injectable";
+import { enlistMessageChannelListenerInjectionToken } from "@k8slens/messaging";
+
+const enlistMessageChannelListenerInjectable = getInjectable({
+  id: "enlist-message-channel-listener",
+
+  instantiate: (di) => {
+    const ipcMain = di.inject(ipcMainInjectable);
+
+    return ({ channel, handler }) => {
+      const nativeOnCallback = (_: IpcMainEvent, message: unknown) => {
+        handler(message);
+      };
+
+      ipcMain.on(channel.id, nativeOnCallback);
+
+      return () => {
+        ipcMain.off(channel.id, nativeOnCallback);
+      };
+    };
+  },
+
+  injectionToken: enlistMessageChannelListenerInjectionToken,
+});
+
+export default enlistMessageChannelListenerInjectable;

packages/technical-features/messaging/main/src/channel-listeners/enlist-message-channel-listener.test.ts

@@ -0,0 +1,103 @@
+import ipcMainInjectable from "../ipc-main/ipc-main.injectable";
+import type { IpcMain, IpcMainEvent } from "electron";
+import {
+  EnlistMessageChannelListener,
+  enlistMessageChannelListenerInjectionToken,
+} from "@k8slens/messaging";
+import { createContainer } from "@ogre-tools/injectable";
+import { registerFeature } from "@k8slens/feature-core";
+import { messagingFeatureForMain } from "../feature";
+
+describe("enlist message channel listener in main", () => {
+  let enlistMessageChannelListener: EnlistMessageChannelListener;
+  let ipcMainStub: IpcMain;
+  let onMock: jest.Mock;
+  let offMock: jest.Mock;
+
+  beforeEach(() => {
+    const di = createContainer("irrelevant");
+
+    registerFeature(di, messagingFeatureForMain);
+
+    onMock = jest.fn();
+    offMock = jest.fn();
+
+    ipcMainStub = {
+      on: onMock,
+      off: offMock,
+    } as unknown as IpcMain;
+
+    di.override(ipcMainInjectable, () => ipcMainStub);
+
+    enlistMessageChannelListener = di.inject(
+      enlistMessageChannelListenerInjectionToken
+    );
+  });
+
+  describe("when called", () => {
+    let handlerMock: jest.Mock;
+    let disposer: () => void;
+
+    beforeEach(() => {
+      handlerMock = jest.fn();
+
+      disposer = enlistMessageChannelListener({
+        id: "some-listener",
+        channel: { id: "some-channel-id" },
+        handler: handlerMock,
+      });
+    });
+
+    it("does not call handler yet", () => {
+      expect(handlerMock).not.toHaveBeenCalled();
+    });
+
+    it("registers the listener", () => {
+      expect(onMock).toHaveBeenCalledWith(
+        "some-channel-id",
+        expect.any(Function)
+      );
+    });
+
+    it("does not de-register the listener yet", () => {
+      expect(offMock).not.toHaveBeenCalled();
+    });
+
+    describe("when message arrives", () => {
+      beforeEach(() => {
+        onMock.mock.calls[0][1]({} as IpcMainEvent, "some-message");
+      });
+
+      it("calls the handler with the message", () => {
+        expect(handlerMock).toHaveBeenCalledWith("some-message");
+      });
+
+      it("when disposing the listener, de-registers the listener", () => {
+        disposer();
+
+        expect(offMock).toHaveBeenCalledWith(
+          "some-channel-id",
+          expect.any(Function)
+        );
+      });
+    });
+
+    it("given number as message, when message arrives, calls the handler with the message", () => {
+      onMock.mock.calls[0][1]({} as IpcMainEvent, 42);
+
+      expect(handlerMock).toHaveBeenCalledWith(42);
+    });
+
+    it("given boolean as message, when message arrives, calls the handler with the message", () => {
+      onMock.mock.calls[0][1]({} as IpcMainEvent, true);
+
+      expect(handlerMock).toHaveBeenCalledWith(true);
+    });
+
+    it("given object as message, when message arrives, calls the handler with the message", () => {
+      onMock.mock.calls[0][1]({} as IpcMainEvent, { some: "object" });
+
+      expect(handlerMock).toHaveBeenCalledWith({ some: "object" });
+    });
+  });
+});

packages/technical-features/messaging/main/src/channel-listeners/enlist-request-channel-listener.injectable.ts

@@ -0,0 +1,37 @@
+import { getInjectable } from "@ogre-tools/injectable";
+import type { IpcMainInvokeEvent } from "electron";
+import ipcMainInjectable from "../ipc-main/ipc-main.injectable";
+import type {
+  RequestChannel,
+  RequestChannelListener,
+} from "@k8slens/messaging";
+import { enlistRequestChannelListenerInjectionToken } from "@k8slens/messaging";
+
+export type EnlistRequestChannelListener = <
+  TChannel extends RequestChannel<unknown, unknown>
+>(
+  listener: RequestChannelListener<TChannel>
+) => () => void;
+
+const enlistRequestChannelListenerInjectable = getInjectable({
+  id: "enlist-request-channel-listener-for-main",
+
+  instantiate: (di): EnlistRequestChannelListener => {
+    const ipcMain = di.inject(ipcMainInjectable);
+
+    return ({ channel, handler }) => {
+      const nativeHandleCallback = (_: IpcMainInvokeEvent, request: unknown) =>
+        handler(request);
+
+      ipcMain.handle(channel.id, nativeHandleCallback);
+
+      return () => {
+        ipcMain.off(channel.id, nativeHandleCallback);
+      };
+    };
+  },
+
+  injectionToken: enlistRequestChannelListenerInjectionToken,
+});
+
+export default enlistRequestChannelListenerInjectable;

packages/technical-features/messaging/main/src/channel-listeners/enlist-request-channel-listener.test.ts

@@ -0,0 +1,158 @@
+import ipcMainInjectable from "../ipc-main/ipc-main.injectable";
+import type { IpcMain, IpcMainInvokeEvent } from "electron";
+import type { AsyncFnMock } from "@async-fn/jest";
+import asyncFn from "@async-fn/jest";
+import type { EnlistRequestChannelListener } from "./enlist-request-channel-listener.injectable";
+import enlistRequestChannelListenerInjectable from "./enlist-request-channel-listener.injectable";
+import type { RequestChannel, RequestChannelHandler } from "@k8slens/messaging";
+import { getPromiseStatus } from "@k8slens/test-utils";
+import { createContainer } from "@ogre-tools/injectable";
+import { registerFeature } from "@k8slens/feature-core";
+import { messagingFeatureForMain } from "../feature";
+
+type TestRequestChannel = RequestChannel<unknown, unknown>;
+
+const testRequestChannel: TestRequestChannel = {
+  id: "some-channel-id",
+};
+
+describe("enlist request channel listener in main", () => {
+  let enlistRequestChannelListener: EnlistRequestChannelListener;
+  let ipcMainStub: IpcMain;
+  let handleMock: jest.Mock;
+  let offMock: jest.Mock;
+
+  beforeEach(() => {
+    const di = createContainer("irrelevant");
+
+    registerFeature(di, messagingFeatureForMain);
+
+    handleMock = jest.fn();
+    offMock = jest.fn();
+
+    ipcMainStub = {
+      handle: handleMock,
+      off: offMock,
+    } as unknown as IpcMain;
+
+    di.override(ipcMainInjectable, () => ipcMainStub);
+
+    enlistRequestChannelListener = di.inject(
+      enlistRequestChannelListenerInjectable
+    );
+  });
+
+  describe("when called", () => {
+    let handlerMock: AsyncFnMock<RequestChannelHandler<TestRequestChannel>>;
+    let disposer: () => void;
+
+    beforeEach(() => {
+      handlerMock = asyncFn();
+
+      disposer = enlistRequestChannelListener({
+        id: "some-listener",
+        channel: testRequestChannel,
+        handler: handlerMock,
+      });
+    });
+
+    it("does not call handler yet", () => {
+      expect(handlerMock).not.toHaveBeenCalled();
+    });
+
+    it("registers the listener", () => {
+      expect(handleMock).toHaveBeenCalledWith(
+        "some-channel-id",
+        expect.any(Function)
+      );
+    });
+
+    it("does not de-register the listener yet", () => {
+      expect(offMock).not.toHaveBeenCalled();
+    });
+
+    describe("when request arrives", () => {
+      let actualPromise: Promise<any>;
+
+      beforeEach(() => {
+        actualPromise = handleMock.mock.calls[0][1](
+          {} as IpcMainInvokeEvent,
+          "some-request"
+        );
+      });
+
+      it("calls the handler with the request", () => {
+        expect(handlerMock).toHaveBeenCalledWith("some-request");
+      });
+
+      it("does not resolve yet", async () => {
+        const promiseStatus = await getPromiseStatus(actualPromise);
+
+        expect(promiseStatus.fulfilled).toBe(false);
+      });
+
+      describe("when handler resolves with response, listener resolves with the response", () => {
+        beforeEach(async () => {
+          await handlerMock.resolve("some-response");
+        });
+
+        it("resolves with the response", async () => {
+          const actual = await actualPromise;
+
+          expect(actual).toBe("some-response");
+        });
+
+        it("when disposing the listener, de-registers the listener", () => {
+          disposer();
+
+          expect(offMock).toHaveBeenCalledWith(
+            "some-channel-id",
+            expect.any(Function)
+          );
+        });
+      });
+
+      it("given number as response, when handler resolves with response, listener resolves with stringified response", async () => {
+        await handlerMock.resolve(42);
+
+        const actual = await actualPromise;
+
+        expect(actual).toBe(42);
+      });
+
+      it("given boolean as response, when handler resolves with response, listener resolves with stringified response", async () => {
+        await handlerMock.resolve(true);
+
+        const actual = await actualPromise;
+
+        expect(actual).toBe(true);
+      });
+
+      it("given object as response, when handler resolves with response, listener resolves with response", async () => {
+        await handlerMock.resolve({ some: "object" });
+
+        const actual = await actualPromise;
+
+        expect(actual).toEqual({ some: "object" });
+      });
+    });
+
+    it("given number as request, when request arrives, calls the handler with the request", () => {
+      handleMock.mock.calls[0][1]({} as IpcMainInvokeEvent, 42);
+
+      expect(handlerMock).toHaveBeenCalledWith(42);
+    });
+
+    it("given boolean as request, when request arrives, calls the handler with the request", () => {
+      handleMock.mock.calls[0][1]({} as IpcMainInvokeEvent, true);
+
+      expect(handlerMock).toHaveBeenCalledWith(true);
+    });
+
+    it("given object as request, when request arrives, calls the handler with the request", () => {
+      handleMock.mock.calls[0][1]({} as IpcMainInvokeEvent, { some: "object" });
+
+      expect(handlerMock).toHaveBeenCalledWith({ some: "object" });
+    });
+  });
+});

packages/technical-features/messaging/main/src/feature.ts

@@ -0,0 +1,17 @@
+import { autoRegister } from "@ogre-tools/injectable-extension-for-auto-registration";
+import { getFeature } from "@k8slens/feature-core";
+
+export const messagingFeatureForMain = getFeature({
+  id: "messaging-for-main",
+
+  register: (di) => {
+    autoRegister({
+      di,
+      targetModule: module,
+
+      getRequireContexts: () => [
+        require.context("./", true, /\.injectable\.(ts|tsx)$/),
+      ],
+    });
+  },
+});

packages/technical-features/messaging/main/src/ipc-main/ipc-main.injectable.ts

@@ -0,0 +1,10 @@
+import { getInjectable } from "@ogre-tools/injectable";
+import { ipcMain } from "electron";
+
+const ipcMainInjectable = getInjectable({
+  id: "ipc-main",
+  instantiate: () => ipcMain,
+  causesSideEffects: true,
+});
+
+export default ipcMainInjectable;

packages/technical-features/messaging/main/src/ipc-main/ipc-main.test.ts

@@ -0,0 +1,21 @@
+import { createContainer, DiContainer } from "@ogre-tools/injectable";
+import { registerFeature } from "@k8slens/feature-core";
+import ipcMainInjectable from "./ipc-main.injectable";
+import { ipcMain } from "electron";
+import { messagingFeatureForMain } from "../feature";
+
+describe("ipc-main", () => {
+  let di: DiContainer;
+
+  beforeEach(() => {
+    di = createContainer("irrelevant");
+
+    registerFeature(di, messagingFeatureForMain);
+  });
+
+  it("is the actual IPC-main of Electron", () => {
+    const actual = di.inject(ipcMainInjectable);
+
+    expect(actual).toBe(ipcMain);
+  });
+});

packages/technical-features/messaging/main/src/listening-of-channels.test.ts

@@ -0,0 +1,38 @@
+import { createContainer, getInjectable } from "@ogre-tools/injectable";
+import { registerFeature } from "@k8slens/feature-core";
+import { feature } from "./feature";
+import { listeningOfChannelsInjectionToken } from "@k8slens/messaging";
+import { getStartableStoppable } from "@k8slens/startable-stoppable";
+import { runManyFor } from "@k8slens/run-many";
+import { onLoadOfApplicationInjectionToken } from "@k8slens/application";
+
+describe("listening-of-channels", () => {
+  it("when on application load, starts listening of channels", async () => {
+    const di = createContainer("irrelevant");
+
+    registerFeature(di, feature);
+
+    const listeningOfChannelsMock = jest.fn(() => () => {});
+
+    const listeningOfChannelsInjectableStub = getInjectable({
+      id: "some-runnable",
+
+      instantiate: () =>
+        getStartableStoppable("some-listening-of-channels-implementation", () =>
+          listeningOfChannelsMock()
+        ),
+
+      injectionToken: listeningOfChannelsInjectionToken,
+    });
+
+    di.register(listeningOfChannelsInjectableStub);
+
+    const onLoadOfApplication = runManyFor(di)(
+      onLoadOfApplicationInjectionToken
+    );
+
+    await onLoadOfApplication();
+
+    expect(listeningOfChannelsMock).toHaveBeenCalled();
+  });
+});

packages/technical-features/messaging/main/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "@k8slens/typescript/config/base.json",
+  "include": ["**/*.ts"]
+}

packages/technical-features/messaging/main/webpack.config.js

@@ -0,0 +1 @@
+module.exports = require("@k8slens/webpack").configForNode;