Helper to resolve proxy from URL in any environment, or using extension-API (#5690)

* Permit modular directory structures for behaviours in spirit of "Screaming Architecture"

Co-authored-by: Janne Savolainen <janne.savolainen@live.fi>

Signed-off-by: Iku-turso <mikko.aspiala@gmail.com>

* Implement env-agnostic helper to resolve proxy from URL

Co-authored-by: Janne Savolainen <janne.savolainen@live.fi>

Signed-off-by: Iku-turso <mikko.aspiala@gmail.com>

* Implement way to resolve a proxy, that is not reliant on existing windows

Co-authored-by: Janne Savolainen <janne.savolainen@live.fi>

Signed-off-by: Iku-turso <mikko.aspiala@gmail.com>

* Restore reliancy on existing windows for resolving proxy for fears of Electron events misbehaving because of a temp-window used in case no windows are open

Co-authored-by: Janne Savolainen <janne.savolainen@live.fi>

Signed-off-by: Iku-turso <mikko.aspiala@gmail.com>

* Make resolving a proxy throw if no browser window is available

Co-authored-by: Janne Savolainen <janne.savolainen@live.fi>

Signed-off-by: Iku-turso <mikko.aspiala@gmail.com>

* Extract minimal abstraction for specifically logging error instead of also warn, info, etc.

Co-authored-by: Janne Savolainen <janne.savolainen@live.fi>

Signed-off-by: Iku-turso <mikko.aspiala@gmail.com>

* Make decorator for error logging not create orphan promise for easier controllability

Co-authored-by: Janne Savolainen <janne.savolainen@live.fi>

Signed-off-by: Iku-turso <mikko.aspiala@gmail.com>

* Add error logging to resolving of proxy

Co-authored-by: Janne Savolainen <janne.savolainen@live.fi>

Signed-off-by: Iku-turso <mikko.aspiala@gmail.com>

* Expose resolving of proxy in extension-API

Co-authored-by: Janne Savolainen <janne.savolainen@live.fi>

Signed-off-by: Iku-turso <mikko.aspiala@gmail.com>

* Add missing general override

Co-authored-by: Janne Savolainen <janne.savolainen@live.fi>

Signed-off-by: Iku-turso <mikko.aspiala@gmail.com>

* Add test to add documentation

Co-authored-by: Janne Savolainen <janne.savolainen@live.fi>

Signed-off-by: Iku-turso <mikko.aspiala@gmail.com>

* Disperse implementation of resolve-proxy back to conventional directory structure instead of an experimental one

Co-authored-by: Janne Savolainen <janne.savolainen@live.fi>

Signed-off-by: Iku-turso <mikko.aspiala@gmail.com>

* Revert "Permit modular directory structures for behaviours in spirit of "Screaming Architecture""

This reverts commit 75e1231b0e61b74d030d12365352226e7f1ce500.

Co-authored-by: Janne Savolainen <janne.savolainen@live.fi>

Signed-off-by: Iku-turso <mikko.aspiala@gmail.com>

* Rename a helper for less ambiguity

Co-authored-by: Janne Savolainen <janne.savolainen@live.fi>

Signed-off-by: Iku-turso <mikko.aspiala@gmail.com>

* Add tsdoc for "resolveSystemProxy" exposed in Extension-API

Co-authored-by: Janne Savolainen <janne.savolainen@live.fi>

Signed-off-by: Iku-turso <mikko.aspiala@gmail.com>

src/main/getDiForUnitTesting.ts

@@ -99,6 +99,7 @@ import rollbackHelmReleaseInjectable from "./helm/helm-service/rollback-helm-rel
 import updateHelmReleaseInjectable from "./helm/helm-service/update-helm-release.injectable";
 import waitUntilBundledExtensionsAreLoadedInjectable from "./start-main-application/lens-window/application-window/wait-until-bundled-extensions-are-loaded.injectable";
 import { registerMobX } from "@ogre-tools/injectable-extension-for-mobx";
+import electronInjectable from "./utils/resolve-system-proxy/electron.injectable";
 
 export function getDiForUnitTesting(opts: { doGeneralOverrides?: boolean } = {}) {
   const {
@@ -124,6 +125,7 @@ export function getDiForUnitTesting(opts: { doGeneralOverrides?: boolean } = {})
   di.preventSideEffects();
 
   if (doGeneralOverrides) {
+    di.override(electronInjectable, () => ({}));
     di.override(waitUntilBundledExtensionsAreLoadedInjectable, () => async () => {});
     di.override(getRandomIdInjectable, () => () => "some-irrelevant-random-id");
     di.override(hotbarStoreInjectable, () => ({ load: () => {} }));

src/main/utils/resolve-system-proxy/electron.injectable.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import electron from "electron";
+
+const electronInjectable = getInjectable({
+  id: "electron",
+  instantiate: () => electron,
+  causesSideEffects: true,
+});
+
+export default electronInjectable;

src/main/utils/resolve-system-proxy/resolve-system-proxy-channel-responder.injectable.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import resolveSystemProxyChannelInjectable from "../../../common/utils/resolve-system-proxy/resolve-system-proxy-channel.injectable";
+import resolveSystemProxyInjectable from "./resolve-system-proxy.injectable";
+import { requestChannelListenerInjectionToken } from "../../../common/utils/channel/request-channel-listener-injection-token";
+
+const resolveSystemProxyChannelResponderInjectable = getInjectable({
+  id: "resolve-system-proxy-channel-responder",
+
+  instantiate: (di) => ({
+    channel: di.inject(resolveSystemProxyChannelInjectable),
+    handler: di.inject(resolveSystemProxyInjectable),
+  }),
+
+  injectionToken: requestChannelListenerInjectionToken,
+});
+
+export default resolveSystemProxyChannelResponderInjectable;

src/main/utils/resolve-system-proxy/resolve-system-proxy-from-electron.injectable.ts

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import electronInjectable from "./electron.injectable";
+import withErrorLoggingInjectable from "../../../common/utils/with-error-logging/with-error-logging.injectable";
+
+const resolveSystemProxyFromElectronInjectable = getInjectable({
+  id: "resolve-system-proxy-from-electron",
+
+  instantiate: (di) => {
+    const electron = di.inject(electronInjectable);
+    const withErrorLoggingFor = di.inject(withErrorLoggingInjectable);
+
+    const withErrorLogging = withErrorLoggingFor(() => "Error resolving proxy");
+
+    return withErrorLogging(async (url: string) => {
+      const webContent = electron.webContents
+        .getAllWebContents()
+        .find((x) => !x.isDestroyed());
+
+      if (!webContent) {
+        throw new Error(`Tried to resolve proxy for "${url}", but no browser window was available`);
+      }
+
+      return await webContent.session.resolveProxy(url);
+    });
+  },
+});
+
+export default resolveSystemProxyFromElectronInjectable;

src/main/utils/resolve-system-proxy/resolve-system-proxy-from-electron.test.ts

@@ -0,0 +1,138 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+import { getDiForUnitTesting } from "../../getDiForUnitTesting";
+import resolveSystemProxyFromElectronInjectable from "./resolve-system-proxy-from-electron.injectable";
+import electronInjectable from "./electron.injectable";
+import type { AsyncFnMock } from "@async-fn/jest";
+import asyncFn from "@async-fn/jest";
+import type electron from "electron";
+import { getPromiseStatus } from "../../../common/test-utils/get-promise-status";
+import logErrorInjectable from "../../../common/log-error.injectable";
+import type { DiContainer } from "@ogre-tools/injectable";
+
+describe("technical: resolve-system-proxy-from-electron", () => {
+  let resolveSystemProxyMock: AsyncFnMock<(url: string) => Promise<string>>;
+  let logErrorMock: jest.Mock;
+  let di: DiContainer;
+  let actualPromise: Promise<string>;
+
+  beforeEach(() => {
+    di = getDiForUnitTesting();
+
+    logErrorMock = jest.fn();
+    di.override(logErrorInjectable, () => logErrorMock);
+  });
+
+  describe("given there are non-destroyed Lens windows, when called with URL", () => {
+    beforeEach(() => {
+      resolveSystemProxyMock = asyncFn();
+
+      di.override(
+        electronInjectable,
+
+        () =>
+          ({
+            webContents: {
+              getAllWebContents: () => [
+                {
+                  isDestroyed: () => true,
+
+                  session: {
+                    resolveProxy: () => {
+                      throw new Error("should never come here");
+                    },
+                  },
+                },
+
+                {
+                  isDestroyed: () => false,
+                  session: { resolveProxy: resolveSystemProxyMock },
+                },
+
+                {
+                  isDestroyed: () => false,
+
+                  session: {
+                    resolveProxy: () => {
+                      throw new Error("should never come here");
+                    },
+                  },
+                },
+              ],
+            },
+          } as unknown as typeof electron),
+      );
+
+      const resolveSystemProxyFromElectron = di.inject(
+        resolveSystemProxyFromElectronInjectable,
+      );
+
+      actualPromise = resolveSystemProxyFromElectron("some-url");
+    });
+
+    it("calls to resolve proxy from the first window", () => {
+      expect(resolveSystemProxyMock).toHaveBeenCalledWith("some-url");
+    });
+
+    it("does not resolve yet", async () => {
+      const promiseStatus = await getPromiseStatus(actualPromise);
+
+      expect(promiseStatus.fulfilled).toBe(false);
+    });
+
+    it("when call for proxy, resolves with the proxy", async () => {
+      resolveSystemProxyMock.resolve("some-proxy");
+
+      expect(await actualPromise).toBe("some-proxy");
+    });
+  });
+
+  describe("given there are only destroyed Lens windows, when called with URL", () => {
+    let error: any;
+
+    beforeEach(async () => {
+      di.override(
+        electronInjectable,
+        () =>
+          ({
+            webContents: {
+              getAllWebContents: () => [
+                {
+                  isDestroyed: () => true,
+
+                  session: {
+                    resolveProxy: () => {
+                      throw new Error("should never come here");
+                    },
+                  },
+                },
+              ],
+            },
+          } as unknown as typeof electron),
+      );
+
+      resolveSystemProxyMock = asyncFn();
+
+      const resolveSystemProxyFromElectron = di.inject(
+        resolveSystemProxyFromElectronInjectable,
+      );
+
+      try {
+        await resolveSystemProxyFromElectron("some-url");
+      } catch (e) {
+        error = e;
+      }
+    });
+
+    it("throws error", () => {
+      expect(error.message).toBe('Tried to resolve proxy for "some-url", but no browser window was available');
+    });
+
+    it("logs error", () => {
+      expect(logErrorMock).toHaveBeenCalledWith("Error resolving proxy", error);
+    });
+  });
+});

src/main/utils/resolve-system-proxy/resolve-system-proxy.injectable.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { resolveSystemProxyInjectionToken } from "../../../common/utils/resolve-system-proxy/resolve-system-proxy-injection-token";
+import resolveSystemProxyFromElectronInjectable from "./resolve-system-proxy-from-electron.injectable";
+
+const resolveSystemProxyInjectable = getInjectable({
+  id: "resolve-system-proxy-for-main",
+
+  instantiate: (di) => {
+    const resolveSystemProxyFromElectron = di.inject(resolveSystemProxyFromElectronInjectable);
+
+    return (url) => resolveSystemProxyFromElectron(url);
+  },
+
+  injectionToken: resolveSystemProxyInjectionToken,
+});
+
+export default resolveSystemProxyInjectable;