chore: Fixup lint of @k8slens/core after rebase

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

packages/core/src/features/helm-charts/installing-chart/installing-helm-chart-from-new-tab.test.ts

@@ -71,7 +71,7 @@ describe("installing helm chart from new tab", () => {
       );
     });
 
-    builder.beforeApplicationStart(({ mainDi }) => {
+    await builder.beforeApplicationStart(({ mainDi }) => {
       listClusterHelmReleasesMock = asyncFn();
       mainDi.override(listClusterHelmReleasesInjectable, () => listClusterHelmReleasesMock);
     });
@@ -403,8 +403,8 @@ describe("installing helm chart from new tab", () => {
 
                   await flushPromises();
                   await listClusterHelmReleasesMock.resolve({
-                    callWasSuccessful: true,
+                    isOk: true,
-                    response: [],
+                    value: [],
                   });
                 });
 

packages/core/src/features/helm-charts/upgrade-chart/upgrade-chart-new-tab.test.ts

@@ -49,7 +49,7 @@ describe("New Upgrade Helm Chart Dock Tab", () => {
       navigateToHelmReleases = windowDi.inject(navigateToHelmReleasesInjectable);
     });
 
-    builder.beforeApplicationStart(({ mainDi }) => {
+    await builder.beforeApplicationStart(({ mainDi }) => {
       listClusterHelmReleasesMock = asyncFn();
       mainDi.override(listClusterHelmReleasesInjectable, () => listClusterHelmReleasesMock);
     });
@@ -88,8 +88,8 @@ describe("New Upgrade Helm Chart Dock Tab", () => {
       describe("when helm releases resolves", () => {
         beforeEach(async () => {
           await listClusterHelmReleasesMock.resolve({
-            callWasSuccessful: true,
+            isOk: true,
-            response: [
+            value: [
               {
                 app_version: "some-app-version",
                 name: "some-name",

packages/core/src/features/helm-releases/main/handle-get-helm-release.injectable.ts

@@ -3,6 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getRequestChannelListenerInjectable } from "@k8slens/messaging";
+import { result } from "@k8slens/utilities";
 import getHelmReleaseInjectable from "../../../main/helm/helm-service/get-helm-release.injectable";
 import getClusterByIdInjectable from "../../cluster/storage/common/get-by-id.injectable";
 import { getHelmReleaseChannel } from "../common/channels";
@@ -17,16 +18,19 @@ const handleGetHelmReleaseInjectable = getRequestChannelListenerInjectable({
       const cluster = getClusterById(clusterId);
 
       if (!cluster) {
-        return {
+        return result.error(`Cluster with id "${clusterId}" not found`);
-          callWasSuccessful: false,
-          error: `Cluster with id "${clusterId}" not found`,
-        };
       }
 
-      return getHelmRelease({
+      const helmResult = await getHelmRelease({
         cluster,
         ...args,
       });
+
+      if (helmResult.isOk) {
+        return helmResult;
+      }
+
+      return result.error(helmResult.error.message);
     };
   },
   id: "handle-get-helm-release",

packages/core/src/features/helm-releases/main/handle-list-helm-releases.injectable.ts

@@ -4,6 +4,7 @@
  */
 
 import { getRequestChannelListenerInjectable } from "@k8slens/messaging";
+import { result } from "@k8slens/utilities";
 import listClusterHelmReleasesInjectable from "../../../main/helm/helm-service/list-helm-releases.injectable";
 import getClusterByIdInjectable from "../../cluster/storage/common/get-by-id.injectable";
 import { listHelmReleasesChannel } from "../common/channels";
@@ -19,10 +20,7 @@ const handleListHelmReleasesInjectable = getRequestChannelListenerInjectable({
       const cluster = getClusterById(clusterId);
 
       if (!cluster) {
-        return {
+        return result.error(`Cluster with id "${clusterId}" not found`);
-          callWasSuccessful: false,
-          error: `Cluster with id "${clusterId}" not found`,
-        };
       }
 
       return listClusterHelmReleases(cluster, namespace);

packages/core/src/features/helm-releases/showing-details-for-helm-release.test.ts

@@ -77,7 +77,7 @@ describe("showing details for helm release", () => {
       windowDi.override(requestHelmChartValuesInjectable, () => requestHelmChartValuesMock);
     });
 
-    builder.beforeApplicationStart(({ mainDi }) => {
+    await builder.beforeApplicationStart(({ mainDi }) => {
       listClusterHelmReleasesMock = asyncFn();
       mainDi.override(listClusterHelmReleasesInjectable, () => listClusterHelmReleasesMock);
     });
@@ -128,12 +128,12 @@ describe("showing details for helm release", () => {
 
       it("when releases resolve but there is none, renders", async () => {
         await listClusterHelmReleasesMock.resolve({
-          callWasSuccessful: true,
+          isOk: true,
-          response: [],
+          value: [],
         });
         await listClusterHelmReleasesMock.resolve({
-          callWasSuccessful: true,
+          isOk: true,
-          response: [],
+          value: [],
         });
 
         expect(rendered.baseElement).toMatchSnapshot();
@@ -144,8 +144,8 @@ describe("showing details for helm release", () => {
           await listClusterHelmReleasesMock.resolveSpecific(
             ([, namespace]) => namespace === "some-namespace",
             {
-              callWasSuccessful: true,
+              isOk: true,
-              response: [
+              value: [
                 {
                   app_version: "some-app-version",
                   name: "some-name",
@@ -162,8 +162,8 @@ describe("showing details for helm release", () => {
           await listClusterHelmReleasesMock.resolveSpecific(
             ([, namespace]) => namespace === "some-other-namespace",
             {
-              callWasSuccessful: true,
+              isOk: true,
-              response: [
+              value: [
                 {
                   app_version: "some-other-app-version",
                   name: "some-other-name",

packages/core/src/main/helm/helm-service/get-helm-release-data.injectable.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import type { AsyncResult } from "@k8slens/utilities";
-import { isObject, json } from "@k8slens/utilities";
+import { result, isObject, json } from "@k8slens/utilities";
 import { getInjectable } from "@ogre-tools/injectable";
 import type { HelmReleaseData } from "../../../features/helm-releases/common/channels";
 import execHelmInjectable from "../exec-helm/exec-helm.injectable";
@@ -12,7 +12,7 @@ export type GetHelmReleaseData = (
   name: string,
   namespace: string,
   kubeconfigPath: string,
-) => AsyncResult<HelmReleaseData, string>;
+) => AsyncResult<HelmReleaseData, Error>;
 
 const getHelmReleaseDataInjectable = getInjectable({
   id: "get-helm-release-data",
@@ -20,7 +20,7 @@ const getHelmReleaseDataInjectable = getInjectable({
     const execHelm = di.inject(execHelmInjectable);
 
     return async (releaseName, namespace, proxyKubeconfigPath) => {
-      const result = await execHelm([
+      const helmResult = await execHelm([
         "status",
         releaseName,
         "--namespace",
@@ -31,35 +31,23 @@ const getHelmReleaseDataInjectable = getInjectable({
         "json",
       ]);
 
-      if (!result.callWasSuccessful) {
+      if (!helmResult.isOk) {
-        return {
+        return result.wrapError("Failed to execute 'helm status'", helmResult);
-          callWasSuccessful: false,
-          error: `Failed to execute helm: ${result.error}`,
-        };
       }
 
-      const parseResult = json.parse(result.response);
+      const parseResult = json.parse(helmResult.value);
 
-      if (!parseResult.callWasSuccessful) {
+      if (!parseResult.isOk) {
-        return {
+        return result.wrapError("Failed to parse result from 'helm status'", parseResult);
-          callWasSuccessful: false,
-          error: `Failed to parse helm response: ${parseResult.error}`,
-        };
       }
 
-      const release = parseResult.response;
+      const release = parseResult.value;
 
       if (!isObject(release) || Array.isArray(release)) {
-        return {
+        return result.error(new Error(`Result from 'helm status' is not an object: ${JSON.stringify(release)}`));
-          callWasSuccessful: false,
-          error: `Helm response is not an object: ${JSON.stringify(release)}`,
-        };
       }
 
-      return {
+      return result.ok(release as unknown as HelmReleaseData);
-        callWasSuccessful: true,
-        response: release as unknown as HelmReleaseData,
-      };
     };
   },
 });

packages/core/src/main/helm/helm-service/get-helm-release.injectable.ts

@@ -6,6 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
 import type { Cluster } from "../../../common/cluster/cluster";
 import kubeconfigManagerInjectable from "../../kubeconfig-manager/kubeconfig-manager.injectable";
 import type { AsyncResult } from "@k8slens/utilities";
+import { result } from "@k8slens/utilities";
 import getHelmReleaseResourcesInjectable from "./get-helm-release-resources/get-helm-release-resources.injectable";
 import type { HelmReleaseDataWithResources } from "../../../features/helm-releases/common/channels";
 import getHelmReleaseDataInjectable from "./get-helm-release-data.injectable";
@@ -16,7 +17,7 @@ export interface GetHelmReleaseArgs {
   namespace: string;
 }
 
-export type GetHelmRelease = (args: GetHelmReleaseArgs) => AsyncResult<HelmReleaseDataWithResources, string>;
+export type GetHelmRelease = (args: GetHelmReleaseArgs) => AsyncResult<HelmReleaseDataWithResources, Error>;
 
 const getHelmReleaseInjectable = getInjectable({
   id: "get-helm-release",
@@ -36,10 +37,7 @@ const getHelmReleaseInjectable = getInjectable({
       );
 
       if (!releaseResult.isOk) {
-        return {
+        return result.wrapError("Failed to get helm release data", releaseResult);
-          isOk: false,
-          error: `Failed to get helm release data: ${releaseResult.error}`,
-        };
       }
 
       const resourcesResult = await getHelmReleaseResources(
@@ -49,19 +47,13 @@ const getHelmReleaseInjectable = getInjectable({
       );
 
       if (!resourcesResult.isOk) {
-        return {
+        return result.wrapError("Failed to get helm release resources", resourcesResult);
-          isOk: false,
-          error: `Failed to get helm release resources: ${resourcesResult.error}`,
-        };
       }
 
-      return {
+      return result.ok({
-        isOk: true,
+        ...releaseResult.value,
-        value: {
+        resources: resourcesResult.value,
-          ...releaseResult.value,
+      });
-          resources: resourcesResult.value,
-        },
-      };
     };
   },
 

packages/core/src/main/helm/helm-service/update-helm-release.injectable.ts

@@ -55,7 +55,7 @@ const updateHelmReleaseInjectable = getInjectable({
         const releaseResult = await getHelmRelease({ cluster, releaseName, namespace });
 
         if (!releaseResult.isOk) {
-          throw releaseResult.error; // keep the same interface
+          throw releaseResult.error.message; // keep the same interface
         }
 
         return {

packages/core/src/main/helm/list-helm-releases.injectable.ts

@@ -5,10 +5,10 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import execHelmInjectable from "./exec-helm/exec-helm.injectable";
 import type { AsyncResult } from "@k8slens/utilities";
-import { isObject } from "@k8slens/utilities";
+import { json, result, isObject } from "@k8slens/utilities";
 import type { ListedHelmRelease } from "../../features/helm-releases/common/channels";
 
-export type ListHelmReleases = (pathToKubeconfig: string, namespace?: string) => AsyncResult<ListedHelmRelease[], string>;
+export type ListHelmReleases = (pathToKubeconfig: string, namespace?: string) => AsyncResult<ListedHelmRelease[], Error>;
 
 const listHelmReleasesInjectable = getInjectable({
   id: "list-helm-releases",
@@ -32,18 +32,20 @@ const listHelmReleasesInjectable = getInjectable({
 
       args.push("--kubeconfig", pathToKubeconfig);
 
-      const result = await execHelm(args);
+      const helmResult = await execHelm(args);
 
-      if (!result.isOk) {
+      if (!helmResult.isOk) {
-        return {
+        return result.wrapError("Failed to list helm releases", helmResult);
-          isOk: false,
-          error: `Failed to list helm releases: ${result.error}`,
-        };
       }
 
-      const rawOutput = JSON.parse(result.value);
+      const parseResult = json.parse(helmResult.value);
-      const output = Array.isArray(rawOutput)
+
-        ? rawOutput.filter(isObject)
+      if (!parseResult.isOk) {
+        return result.wrapError("Failed to parse response from 'helm ls --all'", parseResult);
+      }
+
+      const output = Array.isArray(parseResult.value)
+        ? parseResult.value.filter(isObject)
         : [];
 
       return {

packages/core/src/renderer/components/helm-releases/release-details/release-details-model/request-detailed-helm-release.injectable.ts

@@ -4,6 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import type { AsyncResult } from "@k8slens/utilities";
+import { result } from "@k8slens/utilities";
 import requestHelmReleaseInjectable from "../../../../../features/helm-releases/renderer/request–helm-release.injectable";
 import type { GetHelmReleaseArgs, HelmReleaseDataWithResources } from "../../../../../features/helm-releases/common/channels";
 import requestListHelmReleasesInjectable from "../../../../../features/helm-releases/renderer/request-list-helm-releases.injectable";
@@ -15,7 +16,7 @@ export interface DetailedHelmRelease {
   details: HelmReleaseDataWithResources;
 }
 
-export type RequestDetailedHelmRelease = (args: GetHelmReleaseArgs) => AsyncResult<DetailedHelmRelease>;
+export type RequestDetailedHelmRelease = (args: GetHelmReleaseArgs) => AsyncResult<DetailedHelmRelease, string>;
 
 const requestDetailedHelmReleaseInjectable = getInjectable({
   id: "request-detailed-helm-release",
@@ -26,34 +27,28 @@ const requestDetailedHelmReleaseInjectable = getInjectable({
 
     return async ({ clusterId, namespace, releaseName }) => {
       const listReleasesResult = await requestListHelmReleases({ clusterId, namespace });
-      const detailsResult = await requestHelmRelease({ clusterId, releaseName, namespace });
 
-      if (!listReleasesResult.callWasSuccessful) {
+      if (!listReleasesResult.isOk) {
         return listReleasesResult;
       }
 
-      const release = listReleasesResult.response.find(
+      const detailsResult = await requestHelmRelease({ clusterId, releaseName, namespace });
-        (rel) => rel.name === releaseName && rel.namespace === namespace,
-      );
-
-      if (!release) {
-        return {
-          isOk: false,
-          error: `Release ${releaseName} didn't exist in ${namespace} namespace.`,
-        };
-      }
 
       if (!detailsResult.isOk) {
         return detailsResult;
       }
 
-      return {
+      const release = listReleasesResult.value
-        isOk: true,
+        .find((rel) => rel.name === releaseName && rel.namespace === namespace);
-        value: {
+
-          release: toHelmRelease(release),
+      if (!release) {
-          details: detailsResult.value,
+        return result.error(`Release ${releaseName} didn't exist in ${namespace} namespace.`);
-        },
+      }
-      };
+
+      return result.ok({
+        release: toHelmRelease(release),
+        details: detailsResult.value,
+      });
     };
   },
 });

packages/core/src/renderer/components/helm-releases/releases.injectable.ts

@@ -37,8 +37,8 @@ const releasesInjectable = getInjectable({
 
         return iter.chain([releaseResults].flat().values())
           .filterMap((result) => {
-            if (result.callWasSuccessful) {
+            if (result.isOk) {
-              return result.response;
+              return result.value;
             }
 
             logger.warn("Failed to list helm releases", { error: result.error });