Add winston formatting support for error causes (#6576)

* Add winston formatting support for error causes

Signed-off-by: Sebastian Malton <sebastian@malton.name>

* Fix failing to run built version

- Finally make logger fully injectable
- Simplify startMainApplication to only have runMany(Sync) invocations
  to fix time of use bugs related to logger

Signed-off-by: Sebastian Malton <sebastian@malton.name>

* Remove legacy type enforced ipc to fix tests

Signed-off-by: Sebastian Malton <sebastian@malton.name>

* Fix type error

Signed-off-by: Sebastian Malton <sebastian@malton.name>

Signed-off-by: Sebastian Malton <sebastian@malton.name>

src/main/start-main-application/runnable-tokens/phases.ts

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+import { getInjectionToken } from "@ogre-tools/injectable";
+import type { Runnable } from "../../../common/runnable/run-many-for";
+import type { RunnableSync } from "../../../common/runnable/run-many-sync-for";
+
+/**
+ * These tokens are here so that the importing of their respective dependencies
+ * can be delayed until all of them are ready
+ */
+
+/**
+ * This runnable token should only have the app paths init so that it can be run by itself
+ */
+export const appPathsRunnablePhaseInjectionToken = getInjectionToken<RunnableSync>({
+  id: "app-paths-runnable-phase",
+});
+
+export const showLoadingRunnablePhaseInjectionToken = getInjectionToken<Runnable>({
+  id: "show-loading-runnable-phase",
+});
+
+export const showInitialWindowRunnablePhaseInjectionToken = getInjectionToken<Runnable>({
+  id: "show-initial-window-runnable-phase",
+});

src/main/start-main-application/runnables/show-initial-window.injectable.ts

@@ -0,0 +1,51 @@
+/**
+ * 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 shouldStartHiddenInjectable from "../../electron-app/features/should-start-hidden.injectable";
+import openDeepLinkInjectable from "../../protocol-handler/lens-protocol-router-main/open-deep-link-for-url/open-deep-link.injectable";
+import commandLineArgumentsInjectable from "../../utils/command-line-arguments.injectable";
+import createFirstApplicationWindowInjectable from "../lens-window/application-window/create-first-application-window.injectable";
+import splashWindowInjectable from "../lens-window/splash-window/splash-window.injectable";
+import { showInitialWindowRunnablePhaseInjectionToken } from "../runnable-tokens/phases";
+
+const getDeepLinkUrl = (commandLineArguments: string[]) => (
+  commandLineArguments
+    .map(arg => arg.toLowerCase())
+    .find(arg => arg.startsWith("lens://"))
+);
+
+const showInitialWindowInjectable = getInjectable({
+  id: "show-initial-window",
+  instantiate: (di) => {
+    const shouldStartHidden = di.inject(shouldStartHiddenInjectable);
+    const shouldStartWindow = !shouldStartHidden;
+    const createFirstApplicationWindow = di.inject(createFirstApplicationWindowInjectable);
+    const splashWindow = di.inject(splashWindowInjectable);
+    const openDeepLink = di.inject(openDeepLinkInjectable);
+    const commandLineArguments = di.inject(commandLineArgumentsInjectable);
+
+    return {
+      id: "show-initial-window",
+      run: async () => {
+        if (shouldStartWindow) {
+          const deepLinkUrl = getDeepLinkUrl(commandLineArguments);
+
+          if (deepLinkUrl) {
+            await openDeepLink(deepLinkUrl);
+          } else {
+            const applicationWindow = createFirstApplicationWindow();
+
+            await applicationWindow.start();
+          }
+
+          splashWindow.close();
+        }
+      },
+    };
+  },
+  injectionToken: showInitialWindowRunnablePhaseInjectionToken,
+});
+
+export default showInitialWindowInjectable;

src/main/start-main-application/runnables/show-loading.injectable.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 shouldStartHiddenInjectable from "../../electron-app/features/should-start-hidden.injectable";
+import splashWindowInjectable from "../lens-window/splash-window/splash-window.injectable";
+import { showLoadingRunnablePhaseInjectionToken } from "../runnable-tokens/phases";
+
+const showLoadingInjectable = getInjectable({
+  id: "show-loading",
+  instantiate: (di) => {
+    const shouldStartHidden = di.inject(shouldStartHiddenInjectable);
+    const shouldShowLoadingWindow = !shouldStartHidden;
+    const splashWindow = di.inject(splashWindowInjectable);
+
+    return {
+      id: "show-loading",
+      run: async () => {
+        if (shouldShowLoadingWindow) {
+          await splashWindow.start();
+        }
+      },
+    };
+  },
+  injectionToken: showLoadingRunnablePhaseInjectionToken,
+});
+
+export default showLoadingInjectable;

src/main/start-main-application/start-main-application.injectable.ts

@@ -10,13 +10,8 @@ import { beforeElectronIsReadyInjectionToken } from "./runnable-tokens/before-el
 import { beforeApplicationIsLoadingInjectionToken } from "./runnable-tokens/before-application-is-loading-injection-token";
 import { onLoadOfApplicationInjectionToken } from "./runnable-tokens/on-load-of-application-injection-token";
 import { afterApplicationIsLoadedInjectionToken } from "./runnable-tokens/after-application-is-loaded-injection-token";
-import splashWindowInjectable from "./lens-window/splash-window/splash-window.injectable";
-import openDeepLinkInjectable from "../protocol-handler/lens-protocol-router-main/open-deep-link-for-url/open-deep-link.injectable";
-import { pipeline } from "@ogre-tools/fp";
-import { find, map, startsWith, toLower } from "lodash/fp";
-import commandLineArgumentsInjectable from "../utils/command-line-arguments.injectable";
 import waitForElectronToBeReadyInjectable from "../electron-app/features/wait-for-electron-to-be-ready.injectable";
-import createFirstApplicationWindowInjectable from "./lens-window/application-window/create-first-application-window.injectable";
+import { appPathsRunnablePhaseInjectionToken, showInitialWindowRunnablePhaseInjectionToken, showLoadingRunnablePhaseInjectionToken } from "./runnable-tokens/phases";
 
 const startMainApplicationInjectable = getInjectable({
   id: "start-main-application",
@@ -25,53 +20,29 @@ const startMainApplicationInjectable = getInjectable({
     const runMany = runManyFor(di);
     const runManySync = runManySyncFor(di);
     const waitForElectronToBeReady = di.inject(waitForElectronToBeReadyInjectable);
-    const createFirstApplicationWindow = di.inject(createFirstApplicationWindowInjectable);
-    const splashWindow = di.inject(splashWindowInjectable);
-    const openDeepLink = di.inject(openDeepLinkInjectable);
-    const commandLineArguments = di.inject(commandLineArgumentsInjectable);
 
+    const appPathsRunnablePhase = runManySync(appPathsRunnablePhaseInjectionToken);
     const beforeElectronIsReady = runManySync(beforeElectronIsReadyInjectionToken);
     const beforeApplicationIsLoading = runMany(beforeApplicationIsLoadingInjectionToken);
+    const showLoadingRunnablePhase = runMany(showLoadingRunnablePhaseInjectionToken);
     const onLoadOfApplication = runMany(onLoadOfApplicationInjectionToken);
+    const showInitialWindowRunnablePhase = runMany(showInitialWindowRunnablePhaseInjectionToken);
     const afterApplicationIsLoaded = runMany(afterApplicationIsLoadedInjectionToken);
 
-    return (shouldStartWindow: boolean) => {
-      // Stuff happening before application is ready needs to be synchronous because of
-      // https://github.com/electron/electron/issues/21370
-      beforeElectronIsReady();
+    // Stuff happening before application is ready needs to be synchronous because of
+    // https://github.com/electron/electron/issues/21370
+    appPathsRunnablePhase();
+    beforeElectronIsReady();
 
-      return (async () => {
-        await waitForElectronToBeReady();
-
-        await beforeApplicationIsLoading();
-
-        if (shouldStartWindow) {
-          await splashWindow.start();
-        }
-
-        await onLoadOfApplication();
-
-        if (shouldStartWindow) {
-          const deepLinkUrl = getDeepLinkUrl(commandLineArguments);
-
-          if (deepLinkUrl) {
-            await openDeepLink(deepLinkUrl);
-          } else {
-            const applicationWindow = createFirstApplicationWindow();
-
-            await applicationWindow.start();
-          }
-
-          splashWindow.close();
-        }
-
-        await afterApplicationIsLoaded();
-      })();
-    };
+    return (async () => {
+      await waitForElectronToBeReady();
+      await beforeApplicationIsLoading();
+      await showLoadingRunnablePhase();
+      await onLoadOfApplication();
+      await showInitialWindowRunnablePhase();
+      await afterApplicationIsLoaded();
+    })();
   },
 });
 
-const getDeepLinkUrl = (commandLineArguments: string[]) =>
-  pipeline(commandLineArguments, map(toLower), find(startsWith("lens://")));
-
 export default startMainApplicationInjectable;