Switch to using messaging and startable stoppable from NPM package (#7368)

* Add custom jest resolver to fix requiring "uuid" module Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Update dependencies Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Introduce test utils for rendering and running with thrown mobx reactions Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Extract startable-stoppable to NPM package Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Extract messaging to NPM package Co-authored-by: Mikko Aspiala <mikko.aspiala@gmail.com> Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Switch to using startable-stoppable from NPM package Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Switch to using messaging from the Feature Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Remove old implementation of messaging Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Make setupping app paths happen earlier in renderer Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Fix typo Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Add kludge to make testing-library work properly from test-utils package Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Fix code style Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Add lint:fix -root script Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Fix unrelated failing unit tests Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Turn of no-floating-promises from typescript linting for being broken Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Make linting not happen for dist -directories Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Make linting failures appear as failure Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Stop running prettier twice It already gets ran as eslint-plugin. Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Make CI run unit tests for all packages by consolidating name of NPM script Co-authored-by: Mikko Aspiala <mikko.aspiala@gmail.com> Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Add missing unit tests for coverage Co-authored-by: Mikko Aspiala <mikko.aspiala@gmail.com> Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Skip coverage for test utils Co-authored-by: Mikko Aspiala <mikko.aspiala@gmail.com> Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Remove check for coverage in packages which are not ready for it Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Stop collecting coverage from index.ts files them being indirections to the implementation Co-authored-by: Mikko Aspiala <mikko.aspiala@gmail.com> Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Implement sending message to channel in main Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Add missing feature dependencies Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Add dummy implementations for requesting in main from renderer Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Re-enable communicating from main to cluster frames Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Ignore trivial files from coverage Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Update package-lock Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Extract message-bridge to separate NPM package to prevent dev dependencies being in the production bundle Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Extract computed channel to own NPM package for clear dependencies Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Consolidate electron related stuff to a directory Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Add missing publish configurations Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Ignore test implementation from coverage being not interesting Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> --------- Signed-off-by: Janne Savolainen <janne.savolainen@live.fi>
2025-05-20 05:10:56 +00:00 · 2023-03-21 11:38:43 +02:00
1 parent df49ff9b96
commit 0f1f030a06
@@ -0,0 +1,5 @@
+export interface Channel<MessageTemplate = void, ReturnTemplate = void> {
+  id: string;
+  _messageTemplate?: MessageTemplate;
+  _returnTemplate?: ReturnTemplate;
+}
@@ -0,0 +1,18 @@
+import { autoRegister } from "@ogre-tools/injectable-extension-for-auto-registration";
+import { applicationFeature } from "@k8slens/application";
+import { getFeature } from "@k8slens/feature-core";
+
+export const messagingFeature = getFeature({
+  id: "messaging",
+
+  dependencies: [applicationFeature],
+
+  register: (di) => {
+    autoRegister({
+      di,
+      targetModule: module,
+
+      getRequireContexts: () => [require.context("./", true, /\.injectable\.(ts|tsx)$/)],
+    });
+  },
+});
@@ -0,0 +1,53 @@
+/* c8 ignore next */
+export { messagingFeature } from "./feature";
+
+export { getRequestChannel } from "./request/get-request-channel";
+export { getMessageChannel } from "./message/get-message-channel";
+
+export { requestFromChannelInjectionToken } from "./request/request-from-channel-injection-token";
+
+export type { Channel } from "./channel.no-coverage";
+
+export { sendMessageToChannelInjectionToken } from "./message/message-to-channel-injection-token";
+export type { SendMessageToChannel } from "./message/message-to-channel-injection-token";
+
+export type {
+  GetMessageChannelListenerInfo,
+  MessageChannel,
+  MessageChannelHandler,
+  MessageChannelListener,
+} from "./message/message-channel-listener-injection-token";
+
+export {
+  messageChannelListenerInjectionToken,
+  getMessageChannelListenerInjectable,
+} from "./message/message-channel-listener-injection-token";
+
+export type {
+  RequestChannel,
+  RequestChannelHandler,
+} from "./request/request-channel-listener-injection-token";
+
+export type {
+  RequestFromChannel,
+  ChannelRequester,
+} from "./request/request-from-channel-injection-token";
+
+export type { EnlistMessageChannelListener } from "./message/enlist-message-channel-listener-injection-token";
+export { enlistMessageChannelListenerInjectionToken } from "./message/enlist-message-channel-listener-injection-token";
+
+export type { EnlistRequestChannelListener } from "./request/enlist-request-channel-listener-injection-token";
+export { enlistRequestChannelListenerInjectionToken } from "./request/enlist-request-channel-listener-injection-token";
+
+export type { ListeningOfChannels } from "./listening-of-channels/listening-of-channels.injectable";
+export { listeningOfChannelsInjectionToken } from "./listening-of-channels/listening-of-channels.injectable";
+
+export type {
+  GetRequestChannelListenerInjectableInfo,
+  RequestChannelListener,
+} from "./request/request-channel-listener-injection-token";
+
+export {
+  getRequestChannelListenerInjectable,
+  requestChannelListenerInjectionToken,
+} from "./request/request-channel-listener-injection-token";
@@ -0,0 +1,106 @@
+import { getInjectable, getInjectionToken } from "@ogre-tools/injectable";
+import { enlistMessageChannelListenerInjectionToken } from "../message/enlist-message-channel-listener-injection-token";
+
+import { getStartableStoppable, StartableStoppable } from "@k8slens/startable-stoppable";
+
+import { computedInjectManyInjectable } from "@ogre-tools/injectable-extension-for-mobx";
+import { IComputedValue, reaction } from "mobx";
+
+import { messageChannelListenerInjectionToken } from "../message/message-channel-listener-injection-token";
+import { requestChannelListenerInjectionToken } from "../request/request-channel-listener-injection-token";
+import { enlistRequestChannelListenerInjectionToken } from "../request/enlist-request-channel-listener-injection-token";
+import type { Channel } from "../channel.no-coverage";
+
+export type ListeningOfChannels = StartableStoppable;
+export const listeningOfChannelsInjectionToken = getInjectionToken<ListeningOfChannels>({
+  id: "listening-of-channels-injection-token",
+});
+
+const listening = <T extends { id: string; channel: Channel<unknown> }>(
+  channelListeners: IComputedValue<T[]>,
+  enlistChannelListener: (listener: T) => () => void,
+  getId: (listener: T) => string,
+) => {
+  const listenerDisposers = new Map<string, () => void>();
+
+  const reactionDisposer = reaction(
+    () => channelListeners.get(),
+    (newValues, oldValues = []) => {
+      const addedListeners = newValues.filter(
+        (newValue) => !oldValues.some((oldValue) => oldValue.id === newValue.id),
+      );
+
+      const removedListeners = oldValues.filter(
+        (oldValue) => !newValues.some((newValue) => newValue.id === oldValue.id),
+      );
+
+      addedListeners.forEach((listener) => {
+        const id = getId(listener);
+
+        if (listenerDisposers.has(id)) {
+          throw new Error(
+            `Tried to add listener for channel "${listener.channel.id}" but listener already exists.`,
+          );
+        }
+
+        const disposer = enlistChannelListener(listener);
+
+        listenerDisposers.set(id, disposer);
+      });
+
+      removedListeners.forEach((listener) => {
+        const dispose = listenerDisposers.get(getId(listener));
+
+        dispose?.();
+
+        listenerDisposers.delete(getId(listener));
+      });
+    },
+
+    { fireImmediately: true },
+  );
+
+  return () => {
+    reactionDisposer();
+    listenerDisposers.forEach((dispose) => dispose());
+  };
+};
+
+const listeningOfChannelsInjectable = getInjectable({
+  id: "listening-of-channels",
+
+  instantiate: (di) => {
+    const enlistMessageChannelListener = di.inject(enlistMessageChannelListenerInjectionToken);
+
+    const enlistRequestChannelListener = di.inject(enlistRequestChannelListenerInjectionToken);
+
+    const computedInjectMany = di.inject(computedInjectManyInjectable);
+
+    const messageChannelListeners = computedInjectMany(messageChannelListenerInjectionToken);
+
+    const requestChannelListeners = computedInjectMany(requestChannelListenerInjectionToken);
+
+    return getStartableStoppable("listening-of-channels", () => {
+      const stopListeningOfMessageChannels = listening(
+        messageChannelListeners,
+        enlistMessageChannelListener,
+        (x) => x.id,
+      );
+
+      const stopListeningOfRequestChannels = listening(
+        requestChannelListeners,
+        enlistRequestChannelListener,
+        (x) => x.channel.id,
+      );
+
+      return () => {
+        stopListeningOfMessageChannels();
+        stopListeningOfRequestChannels();
+      };
+    });
+  },
+
+  injectionToken: listeningOfChannelsInjectionToken,
+});
+
+export default listeningOfChannelsInjectable;
@@ -0,0 +1,21 @@
+import { getInjectable } from "@ogre-tools/injectable";
+import { onLoadOfApplicationInjectionToken } from "@k8slens/application";
+import { listeningOfChannelsInjectionToken } from "./listening-of-channels.injectable";
+
+const startListeningOfChannelsInjectable = getInjectable({
+  id: "start-listening-of-channels",
+
+  instantiate: (di) => {
+    const listeningOfChannels = di.inject(listeningOfChannelsInjectionToken);
+
+    return {
+      run: async () => {
+        await listeningOfChannels.start();
+      },
+    };
+  },
+
+  injectionToken: onLoadOfApplicationInjectionToken,
+});
+
+export default startListeningOfChannelsInjectable;
@@ -0,0 +1,15 @@
+import { getInjectionToken } from "@ogre-tools/injectable";
+
+import type {
+  MessageChannel,
+  MessageChannelListener,
+} from "./message-channel-listener-injection-token";
+
+export type EnlistMessageChannelListener = (
+  listener: MessageChannelListener<MessageChannel<unknown>>,
+) => () => void;
+
+export const enlistMessageChannelListenerInjectionToken =
+  getInjectionToken<EnlistMessageChannelListener>({
+    id: "listening-to-a-message-channel",
+  });
@@ -0,0 +1,5 @@
+import type { MessageChannel } from "./message-channel-listener-injection-token";
+
+export const getMessageChannel = <Request>(id: string): MessageChannel<Request> => ({
+  id,
+});
@@ -0,0 +1,51 @@
+import type { DiContainerForInjection } from "@ogre-tools/injectable";
+import { getInjectable, getInjectionToken } from "@ogre-tools/injectable";
+
+export interface MessageChannel<Message> {
+  id: string;
+  _messageSignature?: Message;
+}
+
+export type ExtraData = { processId: number; frameId: number };
+
+export type MessageChannelHandler<Channel> = Channel extends MessageChannel<infer Message>
+  ? (message: Message, data: ExtraData) => void
+  : never;
+
+export interface MessageChannelListener<Channel> {
+  id: string;
+  channel: Channel;
+  handler: MessageChannelHandler<Channel>;
+}
+
+export const messageChannelListenerInjectionToken = getInjectionToken<
+  MessageChannelListener<MessageChannel<unknown>>
+>({
+  id: "message-channel-listener",
+});
+
+export interface GetMessageChannelListenerInfo<Channel extends MessageChannel<Message>, Message> {
+  id: string;
+  channel: Channel;
+  getHandler: (di: DiContainerForInjection) => MessageChannelHandler<Channel>;
+  causesSideEffects?: boolean;
+}
+
+export const getMessageChannelListenerInjectable = <
+  Channel extends MessageChannel<Message>,
+  Message,
+>(
+  info: GetMessageChannelListenerInfo<Channel, Message>,
+) =>
+  getInjectable({
+    id: `${info.channel.id}-message-listener-${info.id}`,
+
+    instantiate: (di): MessageChannelListener<Channel> => ({
+      id: `${info.channel.id}-message-listener-${info.id}`,
+      channel: info.channel,
+      handler: info.getHandler(di),
+    }),
+
+    injectionToken: messageChannelListenerInjectionToken,
+    causesSideEffects: info.causesSideEffects,
+  });
@@ -0,0 +1,11 @@
+import { getInjectionToken } from "@ogre-tools/injectable";
+import type { MessageChannel } from "./message-channel-listener-injection-token";
+
+export interface SendMessageToChannel {
+  (channel: MessageChannel<void>): void;
+  <Message>(channel: MessageChannel<Message>, message: Message): void;
+}
+
+export const sendMessageToChannelInjectionToken = getInjectionToken<SendMessageToChannel>({
+  id: "send-message-to-message-channel",
+});
@@ -0,0 +1,15 @@
+import { getInjectionToken } from "@ogre-tools/injectable";
+
+import type {
+  RequestChannel,
+  RequestChannelListener,
+} from "./request-channel-listener-injection-token";
+
+export type EnlistRequestChannelListener = (
+  listener: RequestChannelListener<RequestChannel<unknown, unknown>>,
+) => () => void;
+
+export const enlistRequestChannelListenerInjectionToken =
+  getInjectionToken<EnlistRequestChannelListener>({
+    id: "listening-to-a-request-channel",
+  });
@@ -0,0 +1,7 @@
+import type { RequestChannel } from "./request-channel-listener-injection-token";
+
+export const getRequestChannel = <Request, Response>(
+  id: string,
+): RequestChannel<Request, Response> => ({
+  id,
+});
@@ -0,0 +1,56 @@
+import type { DiContainerForInjection } from "@ogre-tools/injectable";
+import { getInjectable, getInjectionToken } from "@ogre-tools/injectable";
+
+export interface RequestChannel<Request, Response> {
+  id: string;
+  _requestSignature?: Request;
+  _responseSignature?: Response;
+}
+
+export type RequestChannelHandler<Channel> = Channel extends RequestChannel<
+  infer Request,
+  infer Response
+>
+  ? (req: Request) => Promise<Response> | Response
+  : never;
+
+export interface RequestChannelListener<Channel> {
+  id: string;
+  channel: Channel;
+  handler: RequestChannelHandler<Channel>;
+}
+
+export const requestChannelListenerInjectionToken = getInjectionToken<
+  RequestChannelListener<RequestChannel<unknown, unknown>>
+>({
+  id: "request-channel-listener",
+});
+
+export interface GetRequestChannelListenerInjectableInfo<
+  Channel extends RequestChannel<Request, Response>,
+  Request,
+  Response,
+> {
+  id: string;
+  channel: Channel;
+  getHandler: (di: DiContainerForInjection) => RequestChannelHandler<Channel>;
+}
+
+export const getRequestChannelListenerInjectable = <
+  Channel extends RequestChannel<Request, Response>,
+  Request,
+  Response,
+>(
+  info: GetRequestChannelListenerInjectableInfo<Channel, Request, Response>,
+) =>
+  getInjectable({
+    id: `${info.channel.id}-request-listener-${info.id}`,
+
+    instantiate: (di) => ({
+      id: `${info.channel.id}-request-listener-${info.id}`,
+      channel: info.channel,
+      handler: info.getHandler(di),
+    }),
+
+    injectionToken: requestChannelListenerInjectionToken,
+  });
@@ -0,0 +1,21 @@
+import { getInjectionToken } from "@ogre-tools/injectable";
+import type { RequestChannel } from "./request-channel-listener-injection-token";
+
+export interface RequestFromChannel {
+  <Request, Response>(
+    channel: RequestChannel<Request, Response>,
+    request: Request,
+  ): Promise<Response>;
+  <Response>(channel: RequestChannel<void, Response>): Promise<Response>;
+}
+
+export type ChannelRequester<Channel> = Channel extends RequestChannel<
+  infer Request,
+  infer Response
+>
+  ? (req: Request) => Promise<Awaited<Response>>
+  : never;
+
+export const requestFromChannelInjectionToken = getInjectionToken<RequestFromChannel>({
+  id: "request-from-request-channel",
+});
@@ -0,0 +1,18 @@
+import { autoRegister } from "@ogre-tools/injectable-extension-for-auto-registration";
+import { getFeature } from "@k8slens/feature-core";
+import { messagingFeature } from "../actual/feature";
+
+export const messagingFeatureForUnitTesting = getFeature({
+  id: "messaging-for-unit-testing",
+
+  dependencies: [messagingFeature],
+
+  register: (di) => {
+    autoRegister({
+      di,
+      targetModule: module,
+
+      getRequireContexts: () => [require.context("./", true, /\.injectable\.(ts|tsx)$/)],
+    });
+  },
+});
@@ -0,0 +1 @@
+export { messagingFeatureForUnitTesting } from "./feature";
@@ -0,0 +1,31 @@
+import { sendMessageToChannelInjectionToken } from "../actual/message/message-to-channel-injection-token";
+import { enlistMessageChannelListenerInjectionToken } from "../actual/message/enlist-message-channel-listener-injection-token";
+import { requestFromChannelInjectionToken } from "../actual/request/request-from-channel-injection-token";
+import { enlistRequestChannelListenerInjectionToken } from "../actual/request/enlist-request-channel-listener-injection-token";
+import { getInjectable } from "@ogre-tools/injectable";
+
+export const sendMessageToChannelStubInjectable = getInjectable({
+  id: "send-message-to-channel-stub",
+  /* c8 ignore next */
+  instantiate: () => () => {},
+  injectionToken: sendMessageToChannelInjectionToken,
+});
+
+export const enlistMessageChannelListenerStubInjectable = getInjectable({
+  id: "enlist-message-channel-listener-stub",
+  instantiate: () => () => () => {},
+  injectionToken: enlistMessageChannelListenerInjectionToken,
+});
+
+export const requestFromChannelStubInjectable = getInjectable({
+  id: "request-from-channel-stub",
+  /* c8 ignore next */
+  instantiate: () => () => Promise.resolve(),
+  injectionToken: requestFromChannelInjectionToken,
+});
+
+export const enlistRequestChannelListenerStubInjectable = getInjectable({
+  id: "enlist-request-channel-listener-stub",
+  instantiate: () => () => () => {},
+  injectionToken: enlistRequestChannelListenerInjectionToken,
+});
				`@@ -0,0 +1 @@`
				`export { messagingFeatureForUnitTesting } from "./feature";`