Convert all of Helm functions to be DI

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

src/common/k8s-api/endpoints/helm-charts.api.ts

@@ -3,72 +3,9 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 
-import { compile } from "path-to-regexp";
+import { autoBind, bifurcateArray } from "../../utils";
-import { apiBase } from "../index";
-import { stringify } from "querystring";
-import type { RequestInit } from "node-fetch";
-import { autoBind, bifurcateArray, isDefined } from "../../utils";
 import Joi from "joi";
 
-export type RepoHelmChartList = Record<string, RawHelmChart[]>;
-
-export interface IHelmChartDetails {
-  readme: string;
-  versions: HelmChart[];
-}
-
-const endpoint = compile(`/v2/charts/:repo?/:name?`) as (params?: {
-  repo?: string;
-  name?: string;
-}) => string;
-
-/**
- * Get a list of all helm charts from all saved helm repos
- */
-export async function listCharts(): Promise<HelmChart[]> {
-  const data = await apiBase.get<Record<string, RepoHelmChartList>>(endpoint());
-
-  return Object
-    .values(data)
-    .reduce((allCharts, repoCharts) => allCharts.concat(Object.values(repoCharts)), new Array<RawHelmChart[]>())
-    .map(([chart]) => HelmChart.create(chart, { onError: "log" }))
-    .filter(isDefined);
-}
-
-export interface GetChartDetailsOptions {
-  version?: string;
-  reqInit?: RequestInit;
-}
-
-/**
- * Get the readme and all versions of a chart
- * @param repo The repo to get from
- * @param name The name of the chart to request the data of
- * @param options.version The version of the chart's readme to get, default latest
- * @param options.reqInit A way for passing in an abort controller or other browser request options
- */
-export async function getChartDetails(repo: string, name: string, { version, reqInit }: GetChartDetailsOptions = {}): Promise<IHelmChartDetails> {
-  const path = endpoint({ repo, name });
-
-  const { readme, ...data } = await apiBase.get<IHelmChartDetails>(`${path}?${stringify({ version })}`, undefined, reqInit);
-  const versions = data.versions.map(version => HelmChart.create(version, { onError: "log" })).filter(isDefined);
-
-  return {
-    readme,
-    versions,
-  };
-}
-
-/**
- * Get chart values related to a specific repos' version of a chart
- * @param repo The repo to get from
- * @param name The name of the chart to request the data of
- * @param version The version to get the values from
- */
-export async function getChartValues(repo: string, name: string, version: string): Promise<string> {
-  return apiBase.get<string>(`/v2/charts/${repo}/${name}/values?${stringify({ version })}`);
-}
-
 export interface RawHelmChart {
   apiVersion: string;
   name: string;

src/common/k8s-api/endpoints/helm-charts.api/get-readme.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 { urlBuilderFor } from "../../../utils/buildUrl";
+import { apiBaseInjectionToken } from "../../api-base";
+
+const requestReadmeEndpoint = urlBuilderFor("/v2/charts/:repo/:name/readme");
+
+export type RequestHelmChartReadme = (repo: string, name: string, version?: string) => Promise<string>;
+
+const requestHelmChartReadmeInjectable = getInjectable({
+  id: "request-helm-chart-readme",
+  instantiate: (di): RequestHelmChartReadme => {
+    const apiBase = di.inject(apiBaseInjectionToken);
+
+    return (repo, name, version) => (
+      apiBase.get(requestReadmeEndpoint.compile({ name, repo }, { version }))
+    );
+  },
+});
+
+export default requestHelmChartReadmeInjectable;

src/common/k8s-api/endpoints/helm-charts.api/get-values.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 { urlBuilderFor } from "../../../utils/buildUrl";
+import { apiBaseInjectionToken } from "../../api-base";
+
+const requestValuesEndpoint = urlBuilderFor("/v2/charts/:repo/:name/values");
+
+export type RequestHelmChartValues = (repo: string, name: string, version: string) => Promise<string>;
+
+const requestHelmChartValuesInjectable = getInjectable({
+  id: "request-helm-chart-values",
+  instantiate: (di): RequestHelmChartValues => {
+    const apiBase = di.inject(apiBaseInjectionToken);
+
+    return (repo, name, version) => (
+      apiBase.get(requestValuesEndpoint.compile({ repo, name }, { version }))
+    );
+  },
+});
+
+export default requestHelmChartValuesInjectable;

src/common/k8s-api/endpoints/helm-charts.api/get-versions.injectable.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 { urlBuilderFor } from "../../../utils/buildUrl";
+import { apiBaseInjectionToken } from "../../api-base";
+import { HelmChart } from "../helm-charts.api";
+import type { RawHelmChart } from "../helm-charts.api";
+import { isDefined } from "../../../utils";
+
+const requestVersionsEndpoint = urlBuilderFor("/v2/charts/:repo/:name/versions");
+
+export type RequestHelmChartVersions = (repo: string, name: string) => Promise<HelmChart[]>;
+
+const requestHelmChartVersionsInjectable = getInjectable({
+  id: "request-helm-chart-versions",
+  instantiate: (di): RequestHelmChartVersions => {
+    const apiBase = di.inject(apiBaseInjectionToken);
+
+    return async (repo, name) => {
+      const rawVersions = await apiBase.get(requestVersionsEndpoint.compile({ name, repo })) as RawHelmChart[];
+
+      return rawVersions
+        .map(version => HelmChart.create(version, { onError: "log" }))
+        .filter(isDefined);
+    };
+  },
+});
+
+export default requestHelmChartVersionsInjectable;

src/common/k8s-api/endpoints/helm-charts.api/list.injectable.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 { apiBaseInjectionToken } from "../../api-base";
+import type { RawHelmChart } from "../helm-charts.api";
+import { HelmChart } from "../helm-charts.api";
+import { isDefined } from "../../../utils";
+
+export type RequestHelmCharts = () => Promise<HelmChart[]>;
+export type RepoHelmChartList = Record<string, RawHelmChart[]>;
+
+/**
+ * Get a list of all helm charts from all saved helm repos
+ */
+const requestHelmChartsInjectable = getInjectable({
+  id: "request-helm-charts",
+  instantiate: (di) => {
+    const apiBase = di.inject(apiBaseInjectionToken);
+
+    return async () => {
+      const data = await apiBase.get<Record<string, RepoHelmChartList>>("/v2/charts");
+
+      return Object
+        .values(data)
+        .reduce((allCharts, repoCharts) => allCharts.concat(Object.values(repoCharts)), new Array<RawHelmChart[]>())
+        .map(([chart]) => HelmChart.create(chart, { onError: "log" }))
+        .filter(isDefined);
+    };
+  },
+});
+
+export default requestHelmChartsInjectable;

src/common/k8s-api/endpoints/helm-releases.api.ts

@@ -3,65 +3,14 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 
-import { apiBase } from "../index";
 import type { ItemObject } from "../../item.store";
-import type { JsonApiData } from "../json-api";
+import type { HelmReleaseDetails } from "./helm-releases.api/get-details.injectable";
-import { buildURLPositional } from "../../utils/buildUrl";
-import type { HelmReleaseDetails } from "../../../renderer/components/+helm-releases/release-details/release-details-model/call-for-helm-release/call-for-helm-release-details/call-for-helm-release-details.injectable";
 
 export interface HelmReleaseUpdateDetails {
   log: string;
   release: HelmReleaseDetails;
 }
 
-export interface HelmReleaseRevision {
-  revision: number;
-  updated: string;
-  status: string;
-  chart: string;
-  app_version: string;
-  description: string;
-}
-
-type EndpointParams = {}
-  | { namespace: string }
-  | { namespace: string; name: string }
-  | { namespace: string; name: string; route: string };
-
-interface EndpointQuery {
-  all?: boolean;
-}
-
-export const endpoint = buildURLPositional<EndpointParams, EndpointQuery>("/v2/releases/:namespace?/:name?/:route?");
-
-export async function deleteRelease(name: string, namespace: string): Promise<JsonApiData> {
-  const path = endpoint({ name, namespace });
-
-  return apiBase.del(path);
-}
-
-export async function getReleaseValues(name: string, namespace: string, all?: boolean): Promise<string> {
-  const route = "values";
-  const path = endpoint({ name, namespace, route }, { all });
-
-  return apiBase.get<string>(path);
-}
-
-export async function getReleaseHistory(name: string, namespace: string): Promise<HelmReleaseRevision[]> {
-  const route = "history";
-  const path = endpoint({ name, namespace, route });
-
-  return apiBase.get(path);
-}
-
-export async function rollbackRelease(name: string, namespace: string, revision: number): Promise<JsonApiData> {
-  const route = "rollback";
-  const path = endpoint({ name, namespace, route });
-  const data = { revision };
-
-  return apiBase.put(path, { data });
-}
-
 export interface HelmReleaseDto {
   appVersion: string;
   name: string;

src/common/k8s-api/endpoints/helm-releases.api/create.injectable.ts

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import yaml from "js-yaml";
+import { getInjectable } from "@ogre-tools/injectable";
+import type { HelmReleaseUpdateDetails } from "../helm-releases.api";
+import { apiBaseInjectionToken } from "../../api-base";
+import { urlBuilderFor } from "../../../utils/buildUrl";
+
+interface HelmReleaseCreatePayload {
+  name?: string;
+  repo: string;
+  chart: string;
+  namespace: string;
+  version: string;
+  values: string;
+}
+
+export type RequestCreateHelmRelease = (payload: HelmReleaseCreatePayload) => Promise<HelmReleaseUpdateDetails>;
+
+const requestCreateEndpoint = urlBuilderFor("/v2/releases");
+
+const requestCreateHelmReleaseInjectable = getInjectable({
+  id: "request-create-helm-release",
+
+  instantiate: (di): RequestCreateHelmRelease => {
+    const apiBase = di.inject(apiBaseInjectionToken);
+
+    return ({ repo, chart, values, ...data }) => {
+      return apiBase.post(requestCreateEndpoint.compile({}), {
+        data: {
+          chart: `${repo}/${chart}`,
+          values: yaml.load(values),
+          ...data,
+        },
+      });
+    };
+  },
+});
+
+export default requestCreateHelmReleaseInjectable;

src/common/k8s-api/endpoints/helm-releases.api/delete.injectable.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 { urlBuilderFor } from "../../../utils/buildUrl";
+import { apiBaseInjectionToken } from "../../api-base";
+
+export type RequestDeleteHelmRelease = (name: string, namespace: string) => Promise<void>;
+
+const requestDeleteEndpoint = urlBuilderFor("/v2/releases/:namespace/:name");
+
+const requestDeleteHelmReleaseInjectable = getInjectable({
+  id: "request-delete-helm-release",
+  instantiate: (di): RequestDeleteHelmRelease => {
+    const apiBase = di.inject(apiBaseInjectionToken);
+
+    return (name, namespace) => apiBase.del(requestDeleteEndpoint.compile({ name, namespace }));
+  },
+});
+
+export default requestDeleteHelmReleaseInjectable;

src/common/k8s-api/endpoints/helm-releases.api/get-configuration.injectable.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 { urlBuilderFor } from "../../../utils/buildUrl";
+import { apiBaseInjectionToken } from "../../api-base";
+
+export type RequestHelmReleaseConfiguration = (
+  name: string,
+  namespace: string,
+  all: boolean
+) => Promise<string>;
+
+const requestConfigurationEnpoint = urlBuilderFor("/v2/releases/:namespace/:name/values");
+
+const requestHelmReleaseConfigurationInjectable = getInjectable({
+  id: "call-for-helm-release-configuration",
+
+  instantiate: (di): RequestHelmReleaseConfiguration => {
+    const apiBase = di.inject(apiBaseInjectionToken);
+
+    return (name, namespace, all: boolean) => (
+      apiBase.get(requestConfigurationEnpoint.compile({ name, namespace }, { all }))
+    );
+  },
+
+  causesSideEffects: true,
+});
+
+export default requestHelmReleaseConfigurationInjectable;

src/common/k8s-api/endpoints/helm-releases.api/get-details.injectable.ts

@@ -0,0 +1,41 @@
+/**
+ * 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 type { KubeJsonApiData } from "../../kube-json-api";
+import { apiBaseInjectionToken } from "../../api-base";
+import { urlBuilderFor } from "../../../utils/buildUrl";
+
+export interface HelmReleaseDetails {
+  resources: KubeJsonApiData[];
+  name: string;
+  namespace: string;
+  version: string;
+  config: string; // release values
+  manifest: string;
+  info: {
+    deleted: string;
+    description: string;
+    first_deployed: string;
+    last_deployed: string;
+    notes: string;
+    status: string;
+  };
+}
+
+export type CallForHelmReleaseDetails = (name: string, namespace: string) => Promise<HelmReleaseDetails>;
+
+const requestDetailsEnpoint = urlBuilderFor("/v2/releases/:namespace/:name");
+
+const requestHelmReleaseDetailsInjectable = getInjectable({
+  id: "call-for-helm-release-details",
+
+  instantiate: (di): CallForHelmReleaseDetails => {
+    const apiBase = di.inject(apiBaseInjectionToken);
+
+    return (name, namespace) => apiBase.get(requestDetailsEnpoint.compile({ name, namespace }));
+  },
+});
+
+export default requestHelmReleaseDetailsInjectable;

src/common/k8s-api/endpoints/helm-releases.api/get-history.injectable.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 { urlBuilderFor } from "../../../utils/buildUrl";
+import { apiBaseInjectionToken } from "../../api-base";
+
+export interface HelmReleaseRevision {
+  revision: number;
+  updated: string;
+  status: string;
+  chart: string;
+  app_version: string;
+  description: string;
+}
+
+export type RequestHelmReleaseHistory = (name: string, namespace: string) => Promise<HelmReleaseRevision[]>;
+
+const requestHistoryEnpoint = urlBuilderFor("/v2/releases/:namespace/:name/history");
+
+const requestHelmReleaseHistoryInjectable = getInjectable({
+  id: "request-helm-release-history",
+  instantiate: (di): RequestHelmReleaseHistory => {
+    const apiBase = di.inject(apiBaseInjectionToken);
+
+    return (name, namespace) => apiBase.get(requestHistoryEnpoint.compile({ name, namespace }));
+  },
+});
+
+export default requestHelmReleaseHistoryInjectable;

src/common/k8s-api/endpoints/helm-releases.api/get-values.injectable.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 { urlBuilderFor } from "../../../utils/buildUrl";
+import { apiBaseInjectionToken } from "../../api-base";
+
+export type RequestHelmReleaseValues = (name: string, namespace: string, all?: boolean) => Promise<string>;
+
+const requestValuesEndpoint = urlBuilderFor("/v2/release/:namespace/:name/values");
+
+const requestHelmReleaseValuesInjectable = getInjectable({
+  id: "request-helm-release-values",
+  instantiate: (di): RequestHelmReleaseValues => {
+    const apiBase = di.inject(apiBaseInjectionToken);
+
+    return (name, namespace, all) => apiBase.get(requestValuesEndpoint.compile({ name, namespace }, { all }));
+  },
+});
+
+export default requestHelmReleaseValuesInjectable;

src/common/k8s-api/endpoints/helm-releases.api/list.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 { urlBuilderFor } from "../../../utils/buildUrl";
+import { apiBaseInjectionToken } from "../../api-base";
+import type { HelmReleaseDto } from "../helm-releases.api";
+
+export type RequestHelmReleases = (namespace?: string) => Promise<HelmReleaseDto[]>;
+
+const requestHelmReleasesEndpoint = urlBuilderFor("/v2/releases/:namespace?");
+
+const requestHelmReleasesInjectable = getInjectable({
+  id: "request-helm-releases",
+
+  instantiate: (di): RequestHelmReleases => {
+    const apiBase = di.inject(apiBaseInjectionToken);
+
+    return (namespace) => apiBase.get(requestHelmReleasesEndpoint.compile({ namespace }));
+  },
+});
+
+export default requestHelmReleasesInjectable;

src/common/k8s-api/endpoints/helm-releases.api/rollback.injectable.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 { urlBuilderFor } from "../../../utils/buildUrl";
+import { apiBaseInjectionToken } from "../../api-base";
+
+export type RequestHelmReleaseRollback = (name: string, namespace: string, revision: number) => Promise<void>;
+
+const requestRollbackEndpoint = urlBuilderFor("/v2/releases/:namespace/:name");
+
+const requestHelmReleaseRollbackInjectable = getInjectable({
+  id: "request-helm-release-rollback",
+  instantiate: (di): RequestHelmReleaseRollback => {
+    const apiBase = di.inject(apiBaseInjectionToken);
+
+    return async (name, namespace, revision) => {
+      await apiBase.put(
+        requestRollbackEndpoint.compile({ name, namespace }),
+        { data: { revision }},
+      );
+    };
+  },
+});
+
+export default requestHelmReleaseRollbackInjectable;

src/common/k8s-api/endpoints/helm-releases.api/update.injectable.ts

@@ -0,0 +1,49 @@
+/**
+ * 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 yaml from "js-yaml";
+import { apiBaseInjectionToken } from "../../api-base";
+import { urlBuilderFor } from "../../../utils/buildUrl";
+
+interface HelmReleaseUpdatePayload {
+  repo: string;
+  chart: string;
+  version: string;
+  values: string;
+}
+
+export type RequestHelmReleaseUpdate = (
+  name: string,
+  namespace: string,
+  payload: HelmReleaseUpdatePayload
+) => Promise<{ updateWasSuccessful: true } | { updateWasSuccessful: false; error: unknown }>;
+
+const requestUpdateEndpoint = urlBuilderFor("/v2/releases/:namespace/:name");
+
+const requestHelmReleaseUpdateInjectable = getInjectable({
+  id: "request-helm-release-update",
+
+  instantiate: (di): RequestHelmReleaseUpdate => {
+    const apiBase = di.inject(apiBaseInjectionToken);
+
+    return async (name, namespace, { repo, chart, values, ...data }) => {
+      try {
+        await apiBase.put(requestUpdateEndpoint.compile({ name, namespace }), {
+          data: {
+            chart: `${repo}/${chart}`,
+            values: yaml.load(values),
+            ...data,
+          },
+        });
+      } catch (e) {
+        return { updateWasSuccessful: false, error: e };
+      }
+
+      return { updateWasSuccessful: true };
+    };
+  },
+});
+
+export default requestHelmReleaseUpdateInjectable;

src/common/utils/buildUrl.ts

@@ -35,3 +35,24 @@ export function buildURLPositional<P extends object = {}, Q extends object = {}>
     return buildURL(path, { params, query, fragment });
   };
 }
+
+export type UrlParamsFor<Pathname extends string> =
+  Pathname extends `${string}/:${infer A}?/${infer Tail}`
+    ? Partial<Record<A, string>> & UrlParamsFor<`/${Tail}`>
+    : Pathname extends `${string}/:${infer A}/${infer Tail}`
+      ? Record<A, string> & UrlParamsFor<`/${Tail}`>
+      : Pathname extends `${string}/:${infer A}?`
+        ? Partial<Record<A, string>>
+        : Pathname extends `${string}/:${infer A}`
+          ? Record<A, string>
+          : {};
+
+export interface UrlBuilder<Pathname extends string> {
+  compile(params: UrlParamsFor<Pathname>, query?: object, fragment?: string): string;
+}
+
+export function urlBuilderFor<Pathname extends string>(pathname: Pathname): UrlBuilder<Pathname> {
+  return {
+    compile: buildURLPositional(pathname),
+  };
+}

src/features/helm-charts/installing-chart/installing-helm-chart-from-previously-opened-tab.test.ts

@@ -9,23 +9,23 @@ import type { ApplicationBuilder } from "../../../renderer/components/test-utils
 import { getApplicationBuilder } from "../../../renderer/components/test-utils/get-application-builder";
 import { HelmChart } from "../../../common/k8s-api/endpoints/helm-charts.api";
 import getRandomInstallChartTabIdInjectable from "../../../renderer/components/dock/install-chart/get-random-install-chart-tab-id.injectable";
-import type { CallForHelmChartValues } from "../../../renderer/components/dock/install-chart/chart-data/call-for-helm-chart-values.injectable";
-import callForHelmChartValuesInjectable from "../../../renderer/components/dock/install-chart/chart-data/call-for-helm-chart-values.injectable";
 import namespaceStoreInjectable from "../../../renderer/components/+namespaces/store.injectable";
 import type { NamespaceStore } from "../../../renderer/components/+namespaces/store";
-import type { CallForHelmChartVersions } from "../../../renderer/components/+helm-charts/details/versions/call-for-helm-chart-versions.injectable";
-import callForHelmChartVersionsInjectable from "../../../renderer/components/+helm-charts/details/versions/call-for-helm-chart-versions.injectable";
 import writeJsonFileInjectable from "../../../common/fs/write-json-file.injectable";
 import directoryForLensLocalStorageInjectable from "../../../common/directory-for-lens-local-storage/directory-for-lens-local-storage.injectable";
 import hostedClusterIdInjectable from "../../../renderer/cluster-frame-context/hosted-cluster-id.injectable";
 import { TabKind } from "../../../renderer/components/dock/dock/store";
 import { controlWhenStoragesAreReady } from "../../../renderer/utils/create-storage/storages-are-ready";
-import callForCreateHelmReleaseInjectable from "../../../renderer/components/+helm-releases/create-release/call-for-create-helm-release.injectable";
+import requestCreateHelmReleaseInjectable from "../../../common/k8s-api/endpoints/helm-releases.api/create.injectable";
+import type { RequestHelmChartVersions } from "../../../common/k8s-api/endpoints/helm-charts.api/get-versions.injectable";
+import requestHelmChartVersionsInjectable from "../../../common/k8s-api/endpoints/helm-charts.api/get-versions.injectable";
+import type { RequestHelmChartValues } from "../../../common/k8s-api/endpoints/helm-charts.api/get-values.injectable";
+import requestHelmChartValuesInjectable from "../../../common/k8s-api/endpoints/helm-charts.api/get-values.injectable";
 
 describe("installing helm chart from previously opened tab", () => {
   let builder: ApplicationBuilder;
-  let callForHelmChartVersionsMock: AsyncFnMock<CallForHelmChartVersions>;
+  let requestHelmChartVersionsMock: AsyncFnMock<RequestHelmChartVersions>;
-  let callForHelmChartValuesMock: AsyncFnMock<CallForHelmChartValues>;
+  let requestHelmChartValuesMock: AsyncFnMock<RequestHelmChartValues>;
   let storagesAreReady: () => Promise<void>;
 
   beforeEach(() => {
@@ -33,38 +33,17 @@ describe("installing helm chart from previously opened tab", () => {
 
     builder.setEnvironmentToClusterFrame();
 
-    callForHelmChartVersionsMock = asyncFn();
+    requestHelmChartVersionsMock = asyncFn();
-    callForHelmChartValuesMock = asyncFn();
+    requestHelmChartValuesMock = asyncFn();
 
     builder.beforeWindowStart((windowDi) => {
-      windowDi.override(
-        directoryForLensLocalStorageInjectable,
-        () => "/some-directory-for-lens-local-storage",
-      );
-
-      windowDi.override(hostedClusterIdInjectable, () => "some-cluster-id");
-
       storagesAreReady = controlWhenStoragesAreReady(windowDi);
 
-      windowDi.override(
+      windowDi.override(directoryForLensLocalStorageInjectable, () => "/some-directory-for-lens-local-storage");
-        callForHelmChartVersionsInjectable,
+      windowDi.override(hostedClusterIdInjectable, () => "some-cluster-id");
-        () => callForHelmChartVersionsMock,
+      windowDi.override(requestHelmChartVersionsInjectable, () => requestHelmChartVersionsMock);
-      );
+      windowDi.override(requestHelmChartValuesInjectable, () => requestHelmChartValuesMock);
-
+      windowDi.override(requestCreateHelmReleaseInjectable, () => jest.fn());
-      windowDi.override(
-        callForHelmChartValuesInjectable,
-        () => callForHelmChartValuesMock,
-      );
-
-      windowDi.override(
-        callForHelmChartValuesInjectable,
-        () => callForHelmChartValuesMock,
-      );
-
-      windowDi.override(
-        callForCreateHelmReleaseInjectable,
-        () => jest.fn(),
-      );
 
       // TODO: Replace store mocking with mock for the actual side-effect (where the namespaces are coming from)
       windowDi.override(
@@ -154,7 +133,7 @@ describe("installing helm chart from previously opened tab", () => {
     });
 
     it("calls for default configuration of the chart", () => {
-      expect(callForHelmChartValuesMock).toHaveBeenCalledWith(
+      expect(requestHelmChartValuesMock).toHaveBeenCalledWith(
         "some-repository",
         "some-name",
         "some-other-version",
@@ -162,7 +141,7 @@ describe("installing helm chart from previously opened tab", () => {
     });
 
     it("calls for available versions", () => {
-      expect(callForHelmChartVersionsMock).toHaveBeenCalledWith(
+      expect(requestHelmChartVersionsMock).toHaveBeenCalledWith(
         "some-repository",
         "some-name",
       );
@@ -170,11 +149,11 @@ describe("installing helm chart from previously opened tab", () => {
 
     describe("when configuration and version resolves", () => {
       beforeEach(async () => {
-        await callForHelmChartValuesMock.resolve(
+        await requestHelmChartValuesMock.resolve(
           "some-default-configuration",
         );
 
-        await callForHelmChartVersionsMock.resolve([
+        await requestHelmChartVersionsMock.resolve([
           HelmChart.create({
             apiVersion: "some-api-version",
             name: "some-name",

src/features/helm-charts/installing-chart/opening-dock-tab-for-installing-helm-chart.test.ts

@@ -8,69 +8,44 @@ import type { RenderResult } from "@testing-library/react";
 import { fireEvent } from "@testing-library/react";
 import type { ApplicationBuilder } from "../../../renderer/components/test-utils/get-application-builder";
 import { getApplicationBuilder } from "../../../renderer/components/test-utils/get-application-builder";
-import type { CallForHelmCharts } from "../../../renderer/components/+helm-charts/helm-charts/call-for-helm-charts.injectable";
-import callForHelmChartsInjectable from "../../../renderer/components/+helm-charts/helm-charts/call-for-helm-charts.injectable";
 import { HelmChart } from "../../../common/k8s-api/endpoints/helm-charts.api";
 import getRandomInstallChartTabIdInjectable from "../../../renderer/components/dock/install-chart/get-random-install-chart-tab-id.injectable";
-import callForHelmChartValuesInjectable from "../../../renderer/components/dock/install-chart/chart-data/call-for-helm-chart-values.injectable";
+import requestCreateHelmReleaseInjectable from "../../../common/k8s-api/endpoints/helm-releases.api/create.injectable";
-import callForCreateHelmReleaseInjectable from "../../../renderer/components/+helm-releases/create-release/call-for-create-helm-release.injectable";
-import type { CallForHelmChartReadme } from "../../../renderer/components/+helm-charts/details/readme/call-for-helm-chart-readme.injectable";
-import callForHelmChartReadmeInjectable from "../../../renderer/components/+helm-charts/details/readme/call-for-helm-chart-readme.injectable";
-import type { CallForHelmChartVersions } from "../../../renderer/components/+helm-charts/details/versions/call-for-helm-chart-versions.injectable";
-import callForHelmChartVersionsInjectable from "../../../renderer/components/+helm-charts/details/versions/call-for-helm-chart-versions.injectable";
 import { flushPromises } from "../../../common/test-utils/flush-promises";
 import directoryForLensLocalStorageInjectable from "../../../common/directory-for-lens-local-storage/directory-for-lens-local-storage.injectable";
 import hostedClusterIdInjectable from "../../../renderer/cluster-frame-context/hosted-cluster-id.injectable";
 import dockStoreInjectable from "../../../renderer/components/dock/dock/store.injectable";
+import type { RequestHelmCharts } from "../../../common/k8s-api/endpoints/helm-charts.api/list.injectable";
+import type { RequestHelmChartVersions } from "../../../common/k8s-api/endpoints/helm-charts.api/get-versions.injectable";
+import type { RequestHelmChartReadme } from "../../../common/k8s-api/endpoints/helm-charts.api/get-readme.injectable";
+import requestHelmChartsInjectable from "../../../common/k8s-api/endpoints/helm-charts.api/list.injectable";
+import requestHelmChartVersionsInjectable from "../../../common/k8s-api/endpoints/helm-charts.api/get-versions.injectable";
+import requestHelmChartReadmeInjectable from "../../../common/k8s-api/endpoints/helm-charts.api/get-readme.injectable";
+import requestHelmChartValuesInjectable from "../../../common/k8s-api/endpoints/helm-charts.api/get-values.injectable";
 
 describe("opening dock tab for installing helm chart", () => {
   let builder: ApplicationBuilder;
-  let callForHelmChartsMock: AsyncFnMock<CallForHelmCharts>;
+  let requestHelmChartsMock: AsyncFnMock<RequestHelmCharts>;
-  let callForHelmChartVersionsMock: AsyncFnMock<CallForHelmChartVersions>;
+  let requestHelmChartVersionsMock: AsyncFnMock<RequestHelmChartVersions>;
-  let callForHelmChartReadmeMock: AsyncFnMock<CallForHelmChartReadme>;
+  let requestHelmChartReadmeMock: AsyncFnMock<RequestHelmChartReadme>;
-  let callForHelmChartValuesMock: jest.Mock;
+  let requestHelmChartValuesMock: jest.Mock;
 
   beforeEach(() => {
     builder = getApplicationBuilder();
 
-    callForHelmChartsMock = asyncFn();
+    requestHelmChartsMock = asyncFn();
-    callForHelmChartVersionsMock = asyncFn();
+    requestHelmChartVersionsMock = asyncFn();
-    callForHelmChartReadmeMock = asyncFn();
+    requestHelmChartReadmeMock = asyncFn();
-    callForHelmChartValuesMock = jest.fn();
+    requestHelmChartValuesMock = jest.fn();
 
     builder.beforeWindowStart((windowDi) => {
-      windowDi.override(
+      windowDi.override(directoryForLensLocalStorageInjectable, () => "/some-directory-for-lens-local-storage");
-        directoryForLensLocalStorageInjectable,
-        () => "/some-directory-for-lens-local-storage",
-      );
-
       windowDi.override(hostedClusterIdInjectable, () => "some-cluster-id");
-
+      windowDi.override(requestHelmChartsInjectable, () => requestHelmChartsMock);
-      windowDi.override(
+      windowDi.override(requestHelmChartVersionsInjectable, () => requestHelmChartVersionsMock);
-        callForHelmChartsInjectable,
+      windowDi.override(requestHelmChartReadmeInjectable, () => requestHelmChartReadmeMock);
-        () => callForHelmChartsMock,
+      windowDi.override(requestHelmChartValuesInjectable, () => requestHelmChartValuesMock);
-      );
+      windowDi.override(requestCreateHelmReleaseInjectable, () => jest.fn());
-
-      windowDi.override(
-        callForHelmChartVersionsInjectable,
-        () => callForHelmChartVersionsMock,
-      );
-
-      windowDi.override(
-        callForHelmChartReadmeInjectable,
-        () => callForHelmChartReadmeMock,
-      );
-
-      windowDi.override(
-        callForHelmChartValuesInjectable,
-        () => callForHelmChartValuesMock,
-      );
-
-      windowDi.override(
-        callForCreateHelmReleaseInjectable,
-        () => jest.fn(),
-      );
-
       windowDi.override(getRandomInstallChartTabIdInjectable, () =>
         jest
           .fn(() => "some-irrelevant-tab-id")
@@ -102,12 +77,12 @@ describe("opening dock tab for installing helm chart", () => {
     });
 
     it("calls for charts", () => {
-      expect(callForHelmChartsMock).toHaveBeenCalled();
+      expect(requestHelmChartsMock).toHaveBeenCalled();
     });
 
     describe("when charts resolve", () => {
       beforeEach(async () => {
-        await callForHelmChartsMock.resolve([
+        await requestHelmChartsMock.resolve([
           HelmChart.create({
             apiVersion: "some-api-version",
             name: "some-name",
@@ -160,7 +135,7 @@ describe("opening dock tab for installing helm chart", () => {
         });
 
         it("calls for chart versions", () => {
-          expect(callForHelmChartVersionsMock).toHaveBeenCalledWith(
+          expect(requestHelmChartVersionsMock).toHaveBeenCalledWith(
             "some-repository",
             "some-name",
           );
@@ -174,7 +149,7 @@ describe("opening dock tab for installing helm chart", () => {
 
         describe("when chart versions resolve", () => {
           beforeEach(async () => {
-            await callForHelmChartVersionsMock.resolve([
+            await requestHelmChartVersionsMock.resolve([
               HelmChart.create({
                 apiVersion: "some-api-version",
                 name: "some-name",
@@ -210,7 +185,7 @@ describe("opening dock tab for installing helm chart", () => {
           });
 
           it("calls for chart readme for the version", () => {
-            expect(callForHelmChartReadmeMock).toHaveBeenCalledWith(
+            expect(requestHelmChartReadmeMock).toHaveBeenCalledWith(
               "some-repository",
               "some-name",
               "some-version",
@@ -243,7 +218,7 @@ describe("opening dock tab for installing helm chart", () => {
 
           describe("when readme resolves", () => {
             beforeEach(async () => {
-              await callForHelmChartReadmeMock.resolve("some-readme");
+              await requestHelmChartReadmeMock.resolve("some-readme");
             });
 
             it("renders", () => {
@@ -258,7 +233,7 @@ describe("opening dock tab for installing helm chart", () => {
 
             describe("when selecting different version", () => {
               beforeEach(() => {
-                callForHelmChartReadmeMock.mockClear();
+                requestHelmChartReadmeMock.mockClear();
 
                 builder.select
                   .openMenu(
@@ -280,7 +255,7 @@ describe("opening dock tab for installing helm chart", () => {
               });
 
               it("calls for chart readme for the version", () => {
-                expect(callForHelmChartReadmeMock).toHaveBeenCalledWith(
+                expect(requestHelmChartReadmeMock).toHaveBeenCalledWith(
                   "some-repository",
                   "some-name",
                   "some-other-version",
@@ -289,7 +264,7 @@ describe("opening dock tab for installing helm chart", () => {
 
               describe("when readme resolves", () => {
                 beforeEach(async () => {
-                  await callForHelmChartReadmeMock.resolve("some-readme");
+                  await requestHelmChartReadmeMock.resolve("some-readme");
                 });
 
                 it("renders", () => {
@@ -305,7 +280,7 @@ describe("opening dock tab for installing helm chart", () => {
 
                   await flushPromises();
 
-                  expect(callForHelmChartValuesMock).toHaveBeenCalledWith(
+                  expect(requestHelmChartValuesMock).toHaveBeenCalledWith(
                     "some-repository",
                     "some-name",
                     "some-other-version",
@@ -316,7 +291,7 @@ describe("opening dock tab for installing helm chart", () => {
 
             describe("when selecting to install the chart", () => {
               beforeEach(() => {
-                callForHelmChartVersionsMock.mockClear();
+                requestHelmChartVersionsMock.mockClear();
 
                 const installButton = rendered.getByTestId(
                   "install-chart-for-some-repository-some-name",

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

@@ -9,27 +9,27 @@ import type { RenderResult } from "@testing-library/react";
 import { fireEvent } from "@testing-library/react";
 import type { AsyncFnMock } from "@async-fn/jest";
 import asyncFn from "@async-fn/jest";
-import type { CallForHelmReleases } from "../../renderer/components/+helm-releases/call-for-helm-releases/call-for-helm-releases.injectable";
+import type { RequestHelmReleases } from "../../common/k8s-api/endpoints/helm-releases.api/list.injectable";
-import callForHelmReleasesInjectable from "../../renderer/components/+helm-releases/call-for-helm-releases/call-for-helm-releases.injectable";
+import requestHelmReleasesInjectable from "../../common/k8s-api/endpoints/helm-releases.api/list.injectable";
 import namespaceStoreInjectable from "../../renderer/components/+namespaces/store.injectable";
 import type { NamespaceStore } from "../../renderer/components/+namespaces/store";
-import type { CallForHelmReleaseConfiguration } from "../../renderer/components/+helm-releases/release-details/release-details-model/call-for-helm-release-configuration/call-for-helm-release-configuration.injectable";
+import type { RequestHelmReleaseConfiguration } from "../../common/k8s-api/endpoints/helm-releases.api/get-configuration.injectable";
-import callForHelmReleaseConfigurationInjectable from "../../renderer/components/+helm-releases/release-details/release-details-model/call-for-helm-release-configuration/call-for-helm-release-configuration.injectable";
+import requestHelmReleaseConfigurationInjectable from "../../common/k8s-api/endpoints/helm-releases.api/get-configuration.injectable";
-import type { CallForHelmReleaseUpdate } from "../../renderer/components/+helm-releases/update-release/call-for-helm-release-update/call-for-helm-release-update.injectable";
+import type { RequestHelmReleaseUpdate } from "../../common/k8s-api/endpoints/helm-releases.api/update.injectable";
-import callForHelmReleaseUpdateInjectable from "../../renderer/components/+helm-releases/update-release/call-for-helm-release-update/call-for-helm-release-update.injectable";
+import requestHelmReleaseUpdateInjectable from "../../common/k8s-api/endpoints/helm-releases.api/update.injectable";
 import { useFakeTime } from "../../common/test-utils/use-fake-time";
-import type { CallForHelmRelease, DetailedHelmRelease } from "../../renderer/components/+helm-releases/release-details/release-details-model/call-for-helm-release/call-for-helm-release.injectable";
+import type { RequestHelmRelease, DetailedHelmRelease } from "../../renderer/components/+helm-releases/release-details/release-details-model/request-helm-release.injectable";
-import callForHelmReleaseInjectable from "../../renderer/components/+helm-releases/release-details/release-details-model/call-for-helm-release/call-for-helm-release.injectable";
+import requestHelmReleaseInjectable from "../../renderer/components/+helm-releases/release-details/release-details-model/request-helm-release.injectable";
 import showSuccessNotificationInjectable from "../../renderer/components/notifications/show-success-notification.injectable";
 import showCheckedErrorInjectable from "../../renderer/components/notifications/show-checked-error.injectable";
 import getRandomUpgradeChartTabIdInjectable from "../../renderer/components/dock/upgrade-chart/get-random-upgrade-chart-tab-id.injectable";
 
 describe("showing details for helm release", () => {
   let builder: ApplicationBuilder;
-  let callForHelmReleasesMock: AsyncFnMock<CallForHelmReleases>;
+  let requestHelmReleasesMock: AsyncFnMock<RequestHelmReleases>;
-  let callForHelmReleaseMock: AsyncFnMock<CallForHelmRelease>;
+  let requestHelmReleaseMock: AsyncFnMock<RequestHelmRelease>;
-  let callForHelmReleaseConfigurationMock: AsyncFnMock<CallForHelmReleaseConfiguration>;
+  let requestHelmReleaseConfigurationMock: AsyncFnMock<RequestHelmReleaseConfiguration>;
-  let callForHelmReleaseUpdateMock: AsyncFnMock<CallForHelmReleaseUpdate>;
+  let requestHelmReleaseUpdateMock: AsyncFnMock<RequestHelmReleaseUpdate>;
   let showSuccessNotificationMock: jest.Mock;
   let showCheckedErrorNotificationMock: jest.Mock;
 
@@ -40,50 +40,22 @@ describe("showing details for helm release", () => {
 
     builder.setEnvironmentToClusterFrame();
 
-    callForHelmReleasesMock = asyncFn();
+    requestHelmReleasesMock = asyncFn();
-    callForHelmReleaseMock = asyncFn();
+    requestHelmReleaseMock = asyncFn();
-    callForHelmReleaseConfigurationMock = asyncFn();
+    requestHelmReleaseConfigurationMock = asyncFn();
-    callForHelmReleaseUpdateMock = asyncFn();
+    requestHelmReleaseUpdateMock = asyncFn();
 
     showSuccessNotificationMock = jest.fn();
     showCheckedErrorNotificationMock = jest.fn();
 
     builder.beforeWindowStart((windowDi) => {
-      windowDi.override(
+      windowDi.override(getRandomUpgradeChartTabIdInjectable, () => () => "some-tab-id");
-        getRandomUpgradeChartTabIdInjectable,
+      windowDi.override(showSuccessNotificationInjectable, () => showSuccessNotificationMock);
-        () => () => "some-tab-id",
+      windowDi.override(showCheckedErrorInjectable, () => showCheckedErrorNotificationMock);
-      );
+      windowDi.override(requestHelmReleasesInjectable, () => requestHelmReleasesMock);
-
+      windowDi.override(requestHelmReleaseInjectable, () => requestHelmReleaseMock);
-      windowDi.override(
+      windowDi.override(requestHelmReleaseConfigurationInjectable, () => requestHelmReleaseConfigurationMock);
-        showSuccessNotificationInjectable,
+      windowDi.override(requestHelmReleaseUpdateInjectable, () => requestHelmReleaseUpdateMock);
-        () => showSuccessNotificationMock,
-      );
-
-      windowDi.override(
-        showCheckedErrorInjectable,
-        () => showCheckedErrorNotificationMock,
-      );
-
-      windowDi.override(
-        callForHelmReleasesInjectable,
-        () => callForHelmReleasesMock,
-      );
-
-      windowDi.override(
-        callForHelmReleaseInjectable,
-        () => callForHelmReleaseMock,
-      );
-
-      windowDi.override(
-        callForHelmReleaseConfigurationInjectable,
-        () => callForHelmReleaseConfigurationMock,
-      );
-
-      windowDi.override(
-        callForHelmReleaseUpdateInjectable,
-        () => callForHelmReleaseUpdateMock,
-      );
-
       windowDi.override(
         namespaceStoreInjectable,
         () =>
@@ -119,7 +91,7 @@ describe("showing details for helm release", () => {
       });
 
       it("calls for releases for each selected namespace", () => {
-        expect(callForHelmReleasesMock.mock.calls).toEqual([
+        expect(requestHelmReleasesMock.mock.calls).toEqual([
           ["some-namespace"],
           ["some-other-namespace"],
         ]);
@@ -132,15 +104,15 @@ describe("showing details for helm release", () => {
       });
 
       it("when releases resolve but there is none, renders", async () => {
-        await callForHelmReleasesMock.resolve([]);
+        await requestHelmReleasesMock.resolve([]);
-        await callForHelmReleasesMock.resolve([]);
+        await requestHelmReleasesMock.resolve([]);
 
         expect(rendered.baseElement).toMatchSnapshot();
       });
 
       describe("when releases resolve", () => {
         beforeEach(async () => {
-          await callForHelmReleasesMock.resolveSpecific(
+          await requestHelmReleasesMock.resolveSpecific(
             ([namespace]) => namespace === "some-namespace",
             [
               {
@@ -155,7 +127,7 @@ describe("showing details for helm release", () => {
             ],
           );
 
-          await callForHelmReleasesMock.resolveSpecific(
+          await requestHelmReleasesMock.resolveSpecific(
             ([namespace]) => namespace === "some-other-namespace",
             [
               {
@@ -201,7 +173,7 @@ describe("showing details for helm release", () => {
           });
 
           it("calls for release", () => {
-            expect(callForHelmReleaseMock).toHaveBeenCalledWith(
+            expect(requestHelmReleaseMock).toHaveBeenCalledWith(
               "some-name",
               "some-namespace",
             );
@@ -215,7 +187,7 @@ describe("showing details for helm release", () => {
 
           describe("when opening details for second release", () => {
             beforeEach(() => {
-              callForHelmReleaseMock.mockClear();
+              requestHelmReleaseMock.mockClear();
 
               const row = rendered.getByTestId(
                 "helm-release-row-for-some-other-namespace/some-other-name",
@@ -229,7 +201,7 @@ describe("showing details for helm release", () => {
             });
 
             it("calls for another release", () => {
-              expect(callForHelmReleaseMock).toHaveBeenCalledWith(
+              expect(requestHelmReleaseMock).toHaveBeenCalledWith(
                 "some-other-name",
                 "some-other-namespace",
               );
@@ -269,7 +241,7 @@ describe("showing details for helm release", () => {
 
             describe("when opening details for same release", () => {
               beforeEach(() => {
-                callForHelmReleaseMock.mockClear();
+                requestHelmReleaseMock.mockClear();
 
                 const row = rendered.getByTestId(
                   "helm-release-row-for-some-namespace/some-name",
@@ -283,7 +255,7 @@ describe("showing details for helm release", () => {
               });
 
               it("does not reload", () => {
-                expect(callForHelmReleaseMock).not.toHaveBeenCalled();
+                expect(requestHelmReleaseMock).not.toHaveBeenCalled();
               });
             });
           });
@@ -291,7 +263,7 @@ describe("showing details for helm release", () => {
 
           describe("when call for release resolves with error", () => {
             beforeEach(async () => {
-              await callForHelmReleaseMock.resolve({
+              await requestHelmReleaseMock.resolve({
                 callWasSuccessful: false,
                 error: "some-error",
               });
@@ -314,13 +286,13 @@ describe("showing details for helm release", () => {
             });
 
             it("does not call for release configuration", () => {
-              expect(callForHelmReleaseConfigurationMock).not.toHaveBeenCalled();
+              expect(requestHelmReleaseConfigurationMock).not.toHaveBeenCalled();
             });
           });
 
           describe("when call for release resolve with release", () => {
             beforeEach(async () => {
-              await callForHelmReleaseMock.resolve({
+              await requestHelmReleaseMock.resolve({
                 callWasSuccessful: true,
                 response: detailedReleaseFake,
               });
@@ -331,7 +303,7 @@ describe("showing details for helm release", () => {
             });
 
             it("calls for release configuration", () => {
-              expect(callForHelmReleaseConfigurationMock).toHaveBeenCalledWith(
+              expect(requestHelmReleaseConfigurationMock).toHaveBeenCalledWith(
                 "some-name",
                 "some-namespace",
                 true,
@@ -340,7 +312,7 @@ describe("showing details for helm release", () => {
 
             describe("when configuration resolves", () => {
               beforeEach(async () => {
-                await callForHelmReleaseConfigurationMock.resolve(
+                await requestHelmReleaseConfigurationMock.resolve(
                   "some-configuration",
                 );
               });
@@ -405,12 +377,12 @@ describe("showing details for helm release", () => {
                 });
 
                 it("does not save changes yet", () => {
-                  expect(callForHelmReleaseUpdateMock).not.toHaveBeenCalled();
+                  expect(requestHelmReleaseUpdateMock).not.toHaveBeenCalled();
                 });
 
                 describe("when toggling to see only user defined values", () => {
                   beforeEach(() => {
-                    callForHelmReleaseConfigurationMock.mockClear();
+                    requestHelmReleaseConfigurationMock.mockClear();
 
                     const toggle = rendered.getByTestId(
                       "user-supplied-values-only-checkbox",
@@ -420,7 +392,7 @@ describe("showing details for helm release", () => {
                   });
 
                   it("calls for only user defined configuration", () => {
-                    expect(callForHelmReleaseConfigurationMock).toHaveBeenCalledWith(
+                    expect(requestHelmReleaseConfigurationMock).toHaveBeenCalledWith(
                       "some-name",
                       "some-namespace",
                       false,
@@ -429,7 +401,7 @@ describe("showing details for helm release", () => {
 
                   describe("when configuration resolves", () => {
                     beforeEach(async () => {
-                      await callForHelmReleaseConfigurationMock.resolve(
+                      await requestHelmReleaseConfigurationMock.resolve(
                         "some-other-configuration",
                       );
                     });
@@ -447,7 +419,7 @@ describe("showing details for helm release", () => {
                     });
 
                     it("when toggling again, calls for all configuration", () => {
-                      callForHelmReleaseConfigurationMock.mockClear();
+                      requestHelmReleaseConfigurationMock.mockClear();
 
                       const toggle = rendered.getByTestId(
                         "user-supplied-values-only-checkbox",
@@ -455,7 +427,7 @@ describe("showing details for helm release", () => {
 
                       fireEvent.click(toggle);
 
-                      expect(callForHelmReleaseConfigurationMock).toHaveBeenCalledWith(
+                      expect(requestHelmReleaseConfigurationMock).toHaveBeenCalledWith(
                         "some-name",
                         "some-namespace",
                         true,
@@ -478,7 +450,7 @@ describe("showing details for helm release", () => {
                   });
 
                   it("calls for update", () => {
-                    expect(callForHelmReleaseUpdateMock).toHaveBeenCalledWith(
+                    expect(requestHelmReleaseUpdateMock).toHaveBeenCalledWith(
                       "some-name",
                       "some-namespace",
 
@@ -501,10 +473,10 @@ describe("showing details for helm release", () => {
 
                   describe("when update resolves with success", () => {
                     beforeEach(async () => {
-                      callForHelmReleasesMock.mockClear();
+                      requestHelmReleasesMock.mockClear();
-                      callForHelmReleaseConfigurationMock.mockClear();
+                      requestHelmReleaseConfigurationMock.mockClear();
 
-                      await callForHelmReleaseUpdateMock.resolve({
+                      await requestHelmReleaseUpdateMock.resolve({
                         updateWasSuccessful: true,
                       });
                     });
@@ -522,7 +494,7 @@ describe("showing details for helm release", () => {
                     });
 
                     it("reloads the configuration", () => {
-                      expect(callForHelmReleaseConfigurationMock).toHaveBeenCalledWith(
+                      expect(requestHelmReleaseConfigurationMock).toHaveBeenCalledWith(
                         "some-name",
                         "some-namespace",
                         true,
@@ -540,10 +512,10 @@ describe("showing details for helm release", () => {
 
                   describe("when update resolves with failure", () => {
                     beforeEach(async () => {
-                      callForHelmReleasesMock.mockClear();
+                      requestHelmReleasesMock.mockClear();
-                      callForHelmReleaseConfigurationMock.mockClear();
+                      requestHelmReleaseConfigurationMock.mockClear();
 
-                      await callForHelmReleaseUpdateMock.resolve({
+                      await requestHelmReleaseUpdateMock.resolve({
                         updateWasSuccessful: false,
                         error: "some-error",
                       });
@@ -562,7 +534,7 @@ describe("showing details for helm release", () => {
                     });
 
                     it("does not reload the configuration", () => {
-                      expect(callForHelmReleaseConfigurationMock).not.toHaveBeenCalled();
+                      expect(requestHelmReleaseConfigurationMock).not.toHaveBeenCalled();
                     });
 
                     it("does not show success notification", () => {

src/main/getDiForUnitTesting.ts

@@ -74,7 +74,7 @@ import getRandomIdInjectable from "../common/utils/get-random-id.injectable";
 import periodicalCheckForUpdatesInjectable from "./application-update/periodical-check-for-updates/periodical-check-for-updates.injectable";
 import execFileInjectable from "../common/fs/exec-file.injectable";
 import normalizedPlatformArchitectureInjectable from "../common/vars/normalized-platform-architecture.injectable";
-import getHelmChartInjectable from "./helm/helm-service/get-helm-chart.injectable";
+import getHelmChartVersionsInjectable from "./helm/helm-service/get-helm-chart-versions.injectable";
 import getHelmChartValuesInjectable from "./helm/helm-service/get-helm-chart-values.injectable";
 import listHelmChartsInjectable from "./helm/helm-service/list-helm-charts.injectable";
 import deleteHelmReleaseInjectable from "./helm/helm-service/delete-helm-release.injectable";
@@ -161,7 +161,7 @@ export function getDiForUnitTesting(opts: { doGeneralOverrides?: boolean } = {})
     di.override(periodicalCheckForUpdatesInjectable, () => ({ start: () => {}, stop: () => {}, started: false }));
 
     overrideFunctionalInjectables(di, [
-      getHelmChartInjectable,
+      getHelmChartVersionsInjectable,
       getHelmChartValuesInjectable,
       listHelmChartsInjectable,
       deleteHelmReleaseInjectable,

src/main/helm/helm-service/get-helm-chart-readme.injectable.ts

@@ -7,8 +7,8 @@ import getActiveHelmRepositoryInjectable from "../repositories/get-active-helm-r
 import type { HelmRepo } from "../../../common/helm/helm-repo";
 import helmChartManagerInjectable from "../helm-chart-manager.injectable";
 
-const getHelmChartInjectable = getInjectable({
+const getHelmChartReadmeInjectable = getInjectable({
-  id: "get-helm-chart",
+  id: "get-helm-chart-readme",
 
   instantiate: (di) => {
     const getActiveHelmRepository = di.inject(getActiveHelmRepositoryInjectable);
@@ -21,16 +21,11 @@ const getHelmChartInjectable = getInjectable({
         return undefined;
       }
 
-      const chartManager = getChartManager(repo);
+      return getChartManager(repo).getReadme(chartName, version);
-
-      return {
-        readme: await chartManager.getReadme(chartName, version),
-        versions: await chartManager.chartVersions(chartName),
-      };
     };
   },
 
   causesSideEffects: true,
 });
 
-export default getHelmChartInjectable;
+export default getHelmChartReadmeInjectable;

src/main/helm/helm-service/get-helm-chart-versions.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 { HelmChartManager } from "../helm-chart-manager";
+import getActiveHelmRepositoryInjectable from "../repositories/get-active-helm-repository.injectable";
+
+const getHelmChartVersionsInjectable = getInjectable({
+  id: "get-helm-chart-versions",
+
+  instantiate: (di) => {
+    const getActiveHelmRepository = di.inject(getActiveHelmRepositoryInjectable);
+
+    return async (repoName: string, chartName: string) => {
+      const repo = await getActiveHelmRepository(repoName);
+
+      if (!repo) {
+        return undefined;
+      }
+
+      return HelmChartManager.forRepo(repo).chartVersions(chartName);
+    };
+  },
+
+  causesSideEffects: true,
+});
+
+export default getHelmChartVersionsInjectable;

src/main/routes/helm/charts/get-readme-route.injectable.ts

@@ -5,22 +5,22 @@
 import { getRouteInjectable } from "../../../router/router.injectable";
 import { apiPrefix } from "../../../../common/vars";
 import { route } from "../../../router/route";
-import getHelmChartInjectable from "../../../helm/helm-service/get-helm-chart.injectable";
+import getHelmChartReadmeInjectable from "../../../helm/helm-service/get-helm-chart-readme.injectable";
 
-const getChartRouteInjectable = getRouteInjectable({
+const getHelmChartReadmeRouteInjectable = getRouteInjectable({
-  id: "get-chart-route",
+  id: "get-helm-chart-readme-route",
 
   instantiate: (di) => {
-    const getHelmChart = di.inject(getHelmChartInjectable);
+    const getHelmChartReadme = di.inject(getHelmChartReadmeInjectable);
 
     return route({
       method: "get",
-      path: `${apiPrefix}/v2/charts/{repo}/{chart}`,
+      path: `${apiPrefix}/v2/charts/{repo}/{chart}/readme`,
     })(async ({ params, query }) => {
       const { repo, chart } = params;
 
       return {
-        response: await getHelmChart(
+        response: await getHelmChartReadme(
           repo,
           chart,
           query.get("version") ?? undefined,
@@ -30,4 +30,4 @@ const getChartRouteInjectable = getRouteInjectable({
   },
 });
 
-export default getChartRouteInjectable;
+export default getHelmChartReadmeRouteInjectable;

src/main/routes/helm/charts/get-values-route.injectable.ts

@@ -7,8 +7,8 @@ import { apiPrefix } from "../../../../common/vars";
 import { route } from "../../../router/route";
 import getHelmChartValuesInjectable from "../../../helm/helm-service/get-helm-chart-values.injectable";
 
-const getChartRouteValuesInjectable = getRouteInjectable({
+const getHelmChartRouteValuesInjectable = getRouteInjectable({
-  id: "get-chart-route-values",
+  id: "get-helm-chart-values-route",
 
   instantiate: (di) => {
     const getHelmChartValues = di.inject(getHelmChartValuesInjectable);
@@ -26,4 +26,4 @@ const getChartRouteValuesInjectable = getRouteInjectable({
   },
 });
 
-export default getChartRouteValuesInjectable;
+export default getHelmChartRouteValuesInjectable;

src/main/routes/helm/charts/get-versions-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getRouteInjectable } from "../../../router/router.injectable";
+import { apiPrefix } from "../../../../common/vars";
+import { route } from "../../../router/route";
+import getHelmChartVersionsInjectable from "../../../helm/helm-service/get-helm-chart-versions.injectable";
+
+const getHelmChartVersionsRouteInjectable = getRouteInjectable({
+  id: "get-helm-chart-versions-route",
+
+  instantiate: (di) => {
+    const getHelmChartVersions = di.inject(getHelmChartVersionsInjectable);
+
+    return route({
+      method: "get",
+      path: `${apiPrefix}/v2/charts/{repo}/{chart}/versions`,
+    })(async ({ params: { repo, chart }}) => ({
+      response: await getHelmChartVersions(repo, chart),
+    }));
+  },
+});
+
+export default getHelmChartVersionsRouteInjectable;

src/main/routes/helm/charts/list-route.injectable.ts

@@ -7,8 +7,8 @@ import { apiPrefix } from "../../../../common/vars";
 import { route } from "../../../router/route";
 import listHelmChartsInjectable from "../../../helm/helm-service/list-helm-charts.injectable";
 
-const listChartsRouteInjectable = getRouteInjectable({
+const listHelmChartsRouteInjectable = getRouteInjectable({
-  id: "list-charts-route",
+  id: "list-helm-charts-route",
 
   instantiate: (di) => {
     const listHelmCharts = di.inject(listHelmChartsInjectable);
@@ -22,4 +22,4 @@ const listChartsRouteInjectable = getRouteInjectable({
   },
 });
 
-export default listChartsRouteInjectable;
+export default listHelmChartsRouteInjectable;

src/renderer/components/+helm-charts/details/readme-of-selected-helm-chart.injectable.ts

@@ -4,16 +4,16 @@
  */
 import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
 import { asyncComputed } from "@ogre-tools/injectable-react";
-import callForHelmChartReadmeInjectable from "./readme/call-for-helm-chart-readme.injectable";
 import helmChartDetailsVersionSelectionInjectable from "./versions/helm-chart-details-version-selection.injectable";
 import type { HelmChart } from "../../../../common/k8s-api/endpoints/helm-charts.api";
+import requestHelmChartReadmeInjectable from "../../../../common/k8s-api/endpoints/helm-charts.api/get-readme.injectable";
 
 const readmeOfSelectedHelmChartInjectable = getInjectable({
   id: "readme-of-selected-helm-chart",
 
   instantiate: (di, chart: HelmChart) => {
     const selection = di.inject(helmChartDetailsVersionSelectionInjectable, chart);
-    const callForHelmChartReadme = di.inject(callForHelmChartReadmeInjectable);
+    const requestHelmChartReadme = di.inject(requestHelmChartReadmeInjectable);
 
     return asyncComputed(async () => {
       const chartVersion = selection.value.get();
@@ -22,7 +22,7 @@ const readmeOfSelectedHelmChartInjectable = getInjectable({
         return "";
       }
 
-      return await callForHelmChartReadme(
+      return await requestHelmChartReadme(
         chartVersion.getRepository(),
         chartVersion.getName(),
         chartVersion.getVersion(),

src/renderer/components/+helm-charts/details/readme/call-for-helm-chart-readme.injectable.ts

@@ -1,29 +0,0 @@
-/**
- * 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 { getChartDetails } from "../../../../../common/k8s-api/endpoints/helm-charts.api";
-
-export type CallForHelmChartReadme = (
-  repo: string,
-  name: string,
-  version: string,
-) => Promise<string>;
-
-const callForHelmChartReadmeInjectable = getInjectable({
-  id: "call-for-helm-chart-readme",
-
-  instantiate:
-    (): CallForHelmChartReadme =>
-      async (repository: string, name: string, version: string) => {
-        // TODO: Dismantle wrong abstraction
-        const details = await getChartDetails(repository, name, { version });
-
-        return details.readme;
-      },
-
-  causesSideEffects: true,
-});
-
-export default callForHelmChartReadmeInjectable;

src/renderer/components/+helm-charts/details/versions-of-selected-helm-chart.injectable.ts

@@ -4,18 +4,18 @@
  */
 import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
 import { asyncComputed } from "@ogre-tools/injectable-react";
-import callForHelmChartVersionsInjectable from "./versions/call-for-helm-chart-versions.injectable";
 import type { HelmChart } from "../../../../common/k8s-api/endpoints/helm-charts.api";
+import requestHelmChartVersionsInjectable from "../../../../common/k8s-api/endpoints/helm-charts.api/get-versions.injectable";
 
 const versionsOfSelectedHelmChartInjectable = getInjectable({
   id: "versions-of-selected-helm-chart",
 
   instantiate: (di, chart: HelmChart) => {
-    const callForHelmChartVersions = di.inject(callForHelmChartVersionsInjectable);
+    const requestHelmChartVersions = di.inject(requestHelmChartVersionsInjectable);
 
     return asyncComputed(
       async () =>
-        await callForHelmChartVersions(chart.getRepository(), chart.getName()),
+        await requestHelmChartVersions(chart.getRepository(), chart.getName()),
       [],
     );
   },

src/renderer/components/+helm-charts/details/versions/call-for-helm-chart-versions.injectable.ts

@@ -1,28 +0,0 @@
-/**
- * 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 type { HelmChart } from "../../../../../common/k8s-api/endpoints/helm-charts.api";
-import { getChartDetails } from "../../../../../common/k8s-api/endpoints/helm-charts.api";
-
-export type CallForHelmChartVersions = (
-  repo: string,
-  name: string
-) => Promise<HelmChart[]>;
-
-const callForHelmChartVersionsInjectable = getInjectable({
-  id: "call-for-helm-chart-versions",
-
-  instantiate:
-    (): CallForHelmChartVersions => async (repository: string, name: string) => {
-    // TODO: Dismantle wrong abstraction
-      const details = await getChartDetails(repository, name);
-
-      return details.versions;
-    },
-
-  causesSideEffects: true,
-});
-
-export default callForHelmChartVersionsInjectable;

src/renderer/components/+helm-charts/get-char-details.injectable.ts

@@ -1,17 +0,0 @@
-/**
- * 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 type { GetChartDetailsOptions, IHelmChartDetails } from "../../../common/k8s-api/endpoints/helm-charts.api";
-import { getChartDetails } from "../../../common/k8s-api/endpoints/helm-charts.api";
-
-export type GetChartDetails = (repo: string, name: string, opts?: GetChartDetailsOptions) => Promise<IHelmChartDetails>;
-
-const getChartDetailsInjectable = getInjectable({
-  id: "get-chart-details",
-  instantiate: (): GetChartDetails => getChartDetails,
-  causesSideEffects: true,
-});
-
-export default getChartDetailsInjectable;

src/renderer/components/+helm-charts/helm-chart-store.injectable.ts

@@ -1,13 +0,0 @@
-/**
- * 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 { HelmChartStore } from "./helm-chart.store";
-
-const helmChartStoreInjectable = getInjectable({
-  id: "helm-chart-store",
-  instantiate: () => new HelmChartStore(),
-});
-
-export default helmChartStoreInjectable;

src/renderer/components/+helm-charts/helm-charts.tsx

@@ -7,7 +7,6 @@ import "./helm-charts.scss";
 
 import React, { Component } from "react";
 import { observer } from "mobx-react";
-import { helmChartStore } from "./helm-chart.store";
 import type { HelmChart } from "../../../common/k8s-api/endpoints/helm-charts.api";
 import { HelmChartDetails } from "./helm-chart-details";
 import { ItemListLayout } from "../item-object-list/list-layout";
@@ -21,6 +20,8 @@ import navigateToHelmChartsInjectable from "../../../common/front-end-routing/ro
 import { HelmChartIcon } from "./icon";
 import helmChartsInjectable from "./helm-charts/helm-charts.injectable";
 import selectedHelmChartInjectable from "./helm-charts/selected-helm-chart.injectable";
+import type { HelmChartStore } from "./store";
+import helmChartStoreInjectable from "./store.injectable";
 
 enum columnId {
   name = "name",
@@ -35,11 +36,10 @@ interface Dependencies {
     chartName: IComputedValue<string>;
     repo: IComputedValue<string>;
   };
-
   navigateToHelmCharts: NavigateToHelmCharts;
-
   charts: IAsyncComputed<HelmChart[]>;
   selectedChart: IComputedValue<HelmChart | undefined>;
+  helmChartStore: HelmChartStore;
 }
 
 @observer
@@ -79,7 +79,7 @@ class NonInjectedHelmCharts extends Component<Dependencies> {
           isConfigurable
           tableId="helm_charts"
           className="HelmCharts"
-          store={helmChartStore}
+          store={this.props.helmChartStore}
           getItems={() => this.props.charts.value.get()}
           isSelectable={false}
           sortingCallbacks={{
@@ -132,16 +132,14 @@ class NonInjectedHelmCharts extends Component<Dependencies> {
   }
 }
 
-export const HelmCharts = withInjectables<Dependencies>(
+export const HelmCharts = withInjectables<Dependencies>(NonInjectedHelmCharts, {
-  NonInjectedHelmCharts,
+  getProps: (di) => ({
-
+    routeParameters: di.inject(helmChartsRouteParametersInjectable),
-  {
+    navigateToHelmCharts: di.inject(navigateToHelmChartsInjectable),
-    getProps: (di) => ({
+    charts: di.inject(helmChartsInjectable),
-      routeParameters: di.inject(helmChartsRouteParametersInjectable),
+    selectedChart: di.inject(selectedHelmChartInjectable),
-      navigateToHelmCharts: di.inject(navigateToHelmChartsInjectable),
+    helmChartStore: di.inject(helmChartStoreInjectable),
-      charts: di.inject(helmChartsInjectable),
+  }),
-      selectedChart: di.inject(selectedHelmChartInjectable),
+},
-    }),
-  },
 );
 

src/renderer/components/+helm-charts/helm-charts/call-for-helm-charts.injectable.ts

@@ -1,17 +0,0 @@
-/**
- * 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 type { HelmChart } from "../../../../common/k8s-api/endpoints/helm-charts.api";
-import { listCharts } from "../../../../common/k8s-api/endpoints/helm-charts.api";
-
-export type CallForHelmCharts = () => Promise<HelmChart[]>;
-
-const callForHelmChartsInjectable = getInjectable({
-  id: "call-for-helm-charts",
-  instantiate: (): CallForHelmCharts => async () => await listCharts(),
-  causesSideEffects: true,
-});
-
-export default callForHelmChartsInjectable;

src/renderer/components/+helm-charts/helm-charts/helm-charts.injectable.ts

@@ -4,15 +4,15 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import { asyncComputed } from "@ogre-tools/injectable-react";
-import callForHelmChartsInjectable from "./call-for-helm-charts.injectable";
+import requestHelmChartsInjectable from "../../../../common/k8s-api/endpoints/helm-charts.api/list.injectable";
 
 const helmChartsInjectable = getInjectable({
   id: "helm-charts",
 
   instantiate: (di) => {
-    const callForHelmCharts = di.inject(callForHelmChartsInjectable);
+    const requestHelmCharts = di.inject(requestHelmChartsInjectable);
 
-    return asyncComputed(async () => await callForHelmCharts(), []);
+    return asyncComputed(async () => await requestHelmCharts(), []);
   },
 });
 

src/renderer/components/+helm-charts/store.injectable.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 requestHelmChartVersionsInjectable from "../../../common/k8s-api/endpoints/helm-charts.api/get-versions.injectable";
+import requestHelmChartsInjectable from "../../../common/k8s-api/endpoints/helm-charts.api/list.injectable";
+import { HelmChartStore } from "./store";
+
+const helmChartStoreInjectable = getInjectable({
+  id: "helm-chart-store",
+  instantiate: (di) => new HelmChartStore({
+    requestHelmCharts: di.inject(requestHelmChartsInjectable),
+    requestHelmChartVersions: di.inject(requestHelmChartVersionsInjectable),
+  }),
+});
+
+export default helmChartStoreInjectable;

src/renderer/components/+helm-charts/store.ts

@@ -7,19 +7,25 @@ import semver from "semver";
 import { observable, makeObservable } from "mobx";
 import { autoBind, sortCompareChartVersions } from "../../utils";
 import type { HelmChart } from "../../../common/k8s-api/endpoints/helm-charts.api";
-import { getChartDetails, listCharts } from "../../../common/k8s-api/endpoints/helm-charts.api";
 import { ItemStore } from "../../../common/item.store";
 import flatten from "lodash/flatten";
+import type { RequestHelmCharts } from "../../../common/k8s-api/endpoints/helm-charts.api/list.injectable";
+import type { RequestHelmChartVersions } from "../../../common/k8s-api/endpoints/helm-charts.api/get-versions.injectable";
 
 export interface ChartVersion {
   repo: string;
   version: string;
 }
 
+interface Dependencies {
+  requestHelmCharts: RequestHelmCharts;
+  requestHelmChartVersions: RequestHelmChartVersions;
+}
+
 export class HelmChartStore extends ItemStore<HelmChart> {
   @observable versions = observable.map<string, ChartVersion[]>();
 
-  constructor() {
+  constructor(protected readonly dependencies: Dependencies) {
     super();
 
     makeObservable(this);
@@ -28,7 +34,7 @@ export class HelmChartStore extends ItemStore<HelmChart> {
 
   async loadAll() {
     try {
-      const res = await this.loadItems(() => listCharts());
+      const res = await this.loadItems(() => this.dependencies.requestHelmCharts());
 
       this.failedLoading = false;
 
@@ -68,7 +74,7 @@ export class HelmChartStore extends ItemStore<HelmChart> {
     }
 
     const loadVersions = async (repo: string) => {
-      const { versions } = await getChartDetails(repo, chartName);
+      const versions = await this.dependencies.requestHelmChartVersions(repo, chartName);
 
       return versions.map(chart => ({
         repo,
@@ -104,5 +110,3 @@ export class HelmChartStore extends ItemStore<HelmChart> {
     throw new Error("removeItems is not supported");
   }
 }
-
-export const helmChartStore = new HelmChartStore();

src/renderer/components/+helm-releases/call-for-helm-releases/call-for-helm-releases.global-override-for-injectable.ts

@@ -1,15 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import callForHelmReleasesInjectable from "./call-for-helm-releases.injectable";
-import { getGlobalOverride } from "../../../../common/test-utils/get-global-override";
-
-export default getGlobalOverride(
-  callForHelmReleasesInjectable,
-  () => () => {
-    throw new Error(
-      "Tried to call for helm releases without explicit override.",
-    );
-  },
-);

src/renderer/components/+helm-releases/call-for-helm-releases/call-for-helm-releases.injectable.ts

@@ -1,24 +0,0 @@
-/**
- * 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 type { HelmReleaseDto } from "../../../../common/k8s-api/endpoints/helm-releases.api";
-
-import { apiBase } from "../../../../common/k8s-api";
-import { endpoint } from "../../../../common/k8s-api/endpoints/helm-releases.api";
-
-export type CallForHelmReleases = (
-  namespace?: string
-) => Promise<HelmReleaseDto[]>;
-
-const callForHelmReleasesInjectable = getInjectable({
-  id: "call-for-helm-releases",
-
-  instantiate: (): CallForHelmReleases => async (namespace) =>
-    await apiBase.get<HelmReleaseDto[]>(endpoint({ namespace })),
-
-  causesSideEffects: true,
-});
-
-export default callForHelmReleasesInjectable;

src/renderer/components/+helm-releases/create-release/call-for-create-helm-release.injectable.ts

@@ -1,44 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import yaml from "js-yaml";
-import { getInjectable } from "@ogre-tools/injectable";
-import type { HelmReleaseUpdateDetails } from "../../../../common/k8s-api/endpoints/helm-releases.api";
-import { endpoint } from "../../../../common/k8s-api/endpoints/helm-releases.api";
-import { apiBase } from "../../../../common/k8s-api";
-
-interface HelmReleaseCreatePayload {
-  name?: string;
-  repo: string;
-  chart: string;
-  namespace: string;
-  version: string;
-  values: string;
-}
-
-export type CallForCreateHelmRelease = (
-  payload: HelmReleaseCreatePayload
-) => Promise<HelmReleaseUpdateDetails>;
-
-const callForCreateHelmReleaseInjectable = getInjectable({
-  id: "call-for-create-helm-release",
-
-  instantiate: (): CallForCreateHelmRelease => (payload) => {
-    const { repo, chart: rawChart, values: rawValues, ...data } = payload;
-    const chart = `${repo}/${rawChart}`;
-    const values = yaml.load(rawValues);
-
-    return apiBase.post(endpoint(), {
-      data: {
-        chart,
-        values,
-        ...data,
-      },
-    });
-  },
-
-  causesSideEffects: true,
-});
-
-export default callForCreateHelmReleaseInjectable;

src/renderer/components/+helm-releases/create-release/create-release.injectable.ts

@@ -5,15 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 
 import releasesInjectable from "../releases.injectable";
-import type { CallForCreateHelmRelease } from "./call-for-create-helm-release.injectable";
+import type { RequestCreateHelmRelease } from "../../../../common/k8s-api/endpoints/helm-releases.api/create.injectable";
-import callForCreateHelmReleaseInjectable from "./call-for-create-helm-release.injectable";
+import requestCreateHelmReleaseInjectable from "../../../../common/k8s-api/endpoints/helm-releases.api/create.injectable";
 
 const createReleaseInjectable = getInjectable({
   id: "create-release",
 
-  instantiate: (di): CallForCreateHelmRelease => {
+  instantiate: (di): RequestCreateHelmRelease => {
     const releases = di.inject(releasesInjectable);
-    const callForCreateRelease = di.inject(callForCreateHelmReleaseInjectable);
+    const callForCreateRelease = di.inject(requestCreateHelmReleaseInjectable);
 
     return async (payload) => {
       const release = await callForCreateRelease(payload);

src/renderer/components/+helm-releases/delete-release/delete-release.injectable.ts

@@ -3,11 +3,8 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import type {
+import type { HelmRelease } from "../../../../common/k8s-api/endpoints/helm-releases.api";
-  HelmRelease } from "../../../../common/k8s-api/endpoints/helm-releases.api";
+import requestDeleteHelmReleaseInjectable from "../../../../common/k8s-api/endpoints/helm-releases.api/delete.injectable";
-import {
-  deleteRelease,
-} from "../../../../common/k8s-api/endpoints/helm-releases.api";
 import releasesInjectable from "../releases.injectable";
 
 const deleteReleaseInjectable = getInjectable({
@@ -15,9 +12,10 @@ const deleteReleaseInjectable = getInjectable({
 
   instantiate: (di) => {
     const releases = di.inject(releasesInjectable);
+    const requestDeleteHelmRelease = di.inject(requestDeleteHelmReleaseInjectable);
 
     return async (release: HelmRelease) => {
-      await deleteRelease(release.getName(), release.getNs());
+      await requestDeleteHelmRelease(release.getName(), release.getNs());
 
       releases.invalidate();
     };

src/renderer/components/+helm-releases/dialog/dialog.tsx

@@ -13,20 +13,23 @@ import type { DialogProps } from "../../dialog";
 import { Dialog } from "../../dialog";
 import { Wizard, WizardStep } from "../../wizard";
 import type { HelmRelease } from "../../../../common/k8s-api/endpoints/helm-releases.api";
-import { getReleaseHistory, type HelmReleaseRevision } from "../../../../common/k8s-api/endpoints/helm-releases.api";
 import { Select } from "../../select";
 import { Notifications } from "../../notifications";
 import orderBy from "lodash/orderBy";
 import { withInjectables } from "@ogre-tools/injectable-react";
 import releaseRollbackDialogStateInjectable from "./state.injectable";
+import type { RollbackRelease } from "../rollback-release/rollback-release.injectable";
 import rollbackReleaseInjectable from "../rollback-release/rollback-release.injectable";
+import type { HelmReleaseRevision, RequestHelmReleaseHistory } from "../../../../common/k8s-api/endpoints/helm-releases.api/get-history.injectable";
+import requestHelmReleaseHistoryInjectable from "../../../../common/k8s-api/endpoints/helm-releases.api/get-history.injectable";
 
 export interface ReleaseRollbackDialogProps extends DialogProps {
 }
 
 interface Dependencies {
-  rollbackRelease: (releaseName: string, namespace: string, revisionNumber: number) => Promise<void>;
+  rollbackRelease: RollbackRelease;
   state: IObservableValue<HelmRelease | undefined>;
+  requestHelmReleaseHistory: RequestHelmReleaseHistory;
 }
 
 @observer
@@ -48,7 +51,7 @@ class NonInjectedReleaseRollbackDialog extends React.Component<ReleaseRollbackDi
   onOpen = async (release: HelmRelease) => {
     this.isLoading.set(true);
 
-    const releases = await getReleaseHistory(release.getName(), release.getNs());
+    const releases = await this.props.requestHelmReleaseHistory(release.getName(), release.getNs());
 
     runInAction(() => {
       this.revisions.replace(orderBy(releases, "revision", "desc"));
@@ -134,14 +137,11 @@ class NonInjectedReleaseRollbackDialog extends React.Component<ReleaseRollbackDi
   }
 }
 
-export const ReleaseRollbackDialog = withInjectables<Dependencies, ReleaseRollbackDialogProps>(
+export const ReleaseRollbackDialog = withInjectables<Dependencies, ReleaseRollbackDialogProps>(NonInjectedReleaseRollbackDialog, {
-  NonInjectedReleaseRollbackDialog,
+  getProps: (di, props) => ({
-
+    ...props,
-  {
+    rollbackRelease: di.inject(rollbackReleaseInjectable),
-    getProps: (di, props) => ({
+    state: di.inject(releaseRollbackDialogStateInjectable),
-      rollbackRelease: di.inject(rollbackReleaseInjectable),
+    requestHelmReleaseHistory: di.inject(requestHelmReleaseHistoryInjectable),
-      state: di.inject(releaseRollbackDialogStateInjectable),
+  }),
-      ...props,
+});
-    }),
-  },
-);

src/renderer/components/+helm-releases/release-details/release-details-model/call-for-helm-release-configuration/call-for-helm-release-configuration.global-override-for-injectable.ts

@@ -1,15 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getGlobalOverride } from "../../../../../../common/test-utils/get-global-override";
-import callForHelmReleaseConfigurationInjectable from "./call-for-helm-release-configuration.injectable";
-
-export default getGlobalOverride(
-  callForHelmReleaseConfigurationInjectable,
-  () => () => {
-    throw new Error(
-      "Tried to call for helm release configuration without explicit override.",
-    );
-  },
-);

src/renderer/components/+helm-releases/release-details/release-details-model/call-for-helm-release-configuration/call-for-helm-release-configuration.injectable.ts

@@ -1,29 +0,0 @@
-/**
- * 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 { apiBase } from "../../../../../../common/k8s-api";
-import { endpoint } from "../../../../../../common/k8s-api/endpoints/helm-releases.api";
-
-export type CallForHelmReleaseConfiguration = (
-  name: string,
-  namespace: string,
-  all: boolean
-) => Promise<string>;
-
-const callForHelmReleaseConfigurationInjectable = getInjectable({
-  id: "call-for-helm-release-configuration",
-
-  instantiate:
-    (): CallForHelmReleaseConfiguration => async (name, namespace, all: boolean) => {
-      const route = "values";
-      const path = endpoint({ name, namespace, route }, { all });
-
-      return apiBase.get<string>(path);
-    },
-
-  causesSideEffects: true,
-});
-
-export default callForHelmReleaseConfigurationInjectable;

src/renderer/components/+helm-releases/release-details/release-details-model/call-for-helm-release/call-for-helm-release-details/call-for-helm-release-details.global-override-for-injectable.ts

@@ -1,15 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getGlobalOverride } from "../../../../../../../common/test-utils/get-global-override";
-import callForHelmReleaseDetailsInjectable from "./call-for-helm-release-details.injectable";
-
-export default getGlobalOverride(
-  callForHelmReleaseDetailsInjectable,
-  () => () => {
-    throw new Error(
-      "Tried to call for helm release details without explicit override.",
-    );
-  },
-);

src/renderer/components/+helm-releases/release-details/release-details-model/call-for-helm-release/call-for-helm-release-details/call-for-helm-release-details.injectable.ts

@@ -1,45 +0,0 @@
-/**
- * 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 { apiBase } from "../../../../../../../common/k8s-api";
-import { endpoint } from "../../../../../../../common/k8s-api/endpoints/helm-releases.api";
-import type { KubeJsonApiData } from "../../../../../../../common/k8s-api/kube-json-api";
-
-export interface HelmReleaseDetails {
-  resources: KubeJsonApiData[];
-  name: string;
-  namespace: string;
-  version: string;
-  config: string; // release values
-  manifest: string;
-
-  info: {
-    deleted: string;
-    description: string;
-    first_deployed: string;
-    last_deployed: string;
-    notes: string;
-    status: string;
-  };
-}
-
-export type CallForHelmReleaseDetails = (
-  name: string,
-  namespace: string
-) => Promise<HelmReleaseDetails>;
-
-const callForHelmReleaseDetailsInjectable = getInjectable({
-  id: "call-for-helm-release-details",
-
-  instantiate: (): CallForHelmReleaseDetails => async (name, namespace) => {
-    const path = endpoint({ name, namespace });
-
-    return apiBase.get<HelmReleaseDetails>(path);
-  },
-
-  causesSideEffects: true,
-});
-
-export default callForHelmReleaseDetailsInjectable;

src/renderer/components/+helm-releases/release-details/release-details-model/call-for-helm-release/call-for-helm-release.injectable.ts

@@ -1,51 +0,0 @@
-/**
- * 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 type { HelmReleaseDto } from "../../../../../../common/k8s-api/endpoints/helm-releases.api";
-import callForHelmReleasesInjectable from "../../../call-for-helm-releases/call-for-helm-releases.injectable";
-import type { HelmReleaseDetails } from "./call-for-helm-release-details/call-for-helm-release-details.injectable";
-import callForHelmReleaseDetailsInjectable from "./call-for-helm-release-details/call-for-helm-release-details.injectable";
-import type { AsyncResult } from "../../../../../../common/utils/async-result";
-
-export interface DetailedHelmRelease {
-  release: HelmReleaseDto;
-  details: HelmReleaseDetails;
-}
-
-export type CallForHelmRelease = (
-  name: string,
-  namespace: string
-) => Promise<AsyncResult<DetailedHelmRelease | undefined>>;
-
-const callForHelmReleaseInjectable = getInjectable({
-  id: "call-for-helm-release",
-
-  instantiate: (di): CallForHelmRelease => {
-    const callForHelmReleases = di.inject(callForHelmReleasesInjectable);
-    const callForHelmReleaseDetails = di.inject(callForHelmReleaseDetailsInjectable);
-
-    return async (name, namespace) => {
-      const [releases, details] = await Promise.all([
-        callForHelmReleases(namespace),
-        callForHelmReleaseDetails(name, namespace),
-      ]);
-
-      const release = releases.find(
-        (rel) => rel.name === name && rel.namespace === namespace,
-      );
-
-      if (!release) {
-        return {
-          callWasSuccessful: false,
-          error: `Release ${name} didn't exist in ${namespace} namespace.`,
-        };
-      }
-
-      return { callWasSuccessful: true, response: { release, details }};
-    };
-  },
-});
-
-export default callForHelmReleaseInjectable;

src/renderer/components/+helm-releases/release-details/release-details-model/release-details-model.injectable.tsx

@@ -6,18 +6,17 @@ import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
 import type { IComputedValue, IObservableValue } from "mobx";
 import { runInAction, action, observable, computed } from "mobx";
 import type { TargetHelmRelease } from "../target-helm-release.injectable";
-import type { CallForHelmRelease, DetailedHelmRelease } from "./call-for-helm-release/call-for-helm-release.injectable";
+import type { RequestHelmRelease, DetailedHelmRelease } from "./request-helm-release.injectable";
-import callForHelmReleaseInjectable from "./call-for-helm-release/call-for-helm-release.injectable";
+import requestHelmReleaseInjectable from "./request-helm-release.injectable";
 import type { LensTheme } from "../../../../themes/store";
-import type { CallForHelmReleaseConfiguration } from "./call-for-helm-release-configuration/call-for-helm-release-configuration.injectable";
+import type { RequestHelmReleaseConfiguration } from "../../../../../common/k8s-api/endpoints/helm-releases.api/get-configuration.injectable";
-import callForHelmReleaseConfigurationInjectable from "./call-for-helm-release-configuration/call-for-helm-release-configuration.injectable";
+import requestHelmReleaseConfigurationInjectable from "../../../../../common/k8s-api/endpoints/helm-releases.api/get-configuration.injectable";
-import { toHelmRelease } from "../../releases.injectable";
 import { pipeline } from "@ogre-tools/fp";
 import { groupBy, map } from "lodash/fp";
 import type { KubeJsonApiData } from "../../../../../common/k8s-api/kube-json-api";
 import type { GetResourceDetailsUrl } from "./get-resource-details-url.injectable";
 import getResourceDetailsUrlInjectable from "./get-resource-details-url.injectable";
-import type { CallForHelmReleaseUpdate } from "../../update-release/call-for-helm-release-update/call-for-helm-release-update.injectable";
+import type { RequestHelmReleaseUpdate } from "../../../../../common/k8s-api/endpoints/helm-releases.api/update.injectable";
 import updateReleaseInjectable from "../../update-release/update-release.injectable";
 import type { ShowCheckedErrorNotification } from "../../../notifications/show-checked-error.injectable";
 import showCheckedErrorNotificationInjectable from "../../../notifications/show-checked-error.injectable";
@@ -26,35 +25,29 @@ import showSuccessNotificationInjectable from "../../../notifications/show-succe
 import React from "react";
 import createUpgradeChartTabInjectable from "../../../dock/upgrade-chart/create-upgrade-chart-tab.injectable";
 import type { HelmRelease } from "../../../../../common/k8s-api/endpoints/helm-releases.api";
+import type { NavigateToHelmReleases } from "../../../../../common/front-end-routing/routes/cluster/helm/releases/navigate-to-helm-releases.injectable";
 import navigateToHelmReleasesInjectable from "../../../../../common/front-end-routing/routes/cluster/helm/releases/navigate-to-helm-releases.injectable";
 import assert from "assert";
 import activeThemeInjectable from "../../../../themes/active.injectable";
+import type { ToHelmRelease } from "../../to-helm-release.injectable";
+import toHelmReleaseInjectable from "../../to-helm-release.injectable";
 
 const releaseDetailsModelInjectable = getInjectable({
   id: "release-details-model",
 
   instantiate: async (di, targetRelease: TargetHelmRelease) => {
-    const callForHelmRelease = di.inject(callForHelmReleaseInjectable);
-    const callForHelmReleaseConfiguration = di.inject(callForHelmReleaseConfigurationInjectable);
-    const activeTheme = di.inject(activeThemeInjectable);
-    const getResourceDetailsUrl = di.inject(getResourceDetailsUrlInjectable);
-    const updateRelease = di.inject(updateReleaseInjectable);
-    const showCheckedErrorNotification = di.inject(showCheckedErrorNotificationInjectable);
-    const showSuccessNotification = di.inject(showSuccessNotificationInjectable);
-    const createUpgradeChartTab = di.inject(createUpgradeChartTabInjectable);
-    const navigateToHelmReleases = di.inject(navigateToHelmReleasesInjectable);
-
     const model = new ReleaseDetailsModel({
-      callForHelmRelease,
+      requestHelmRelease: di.inject(requestHelmReleaseInjectable),
       targetRelease,
-      activeTheme,
+      activeTheme: di.inject(activeThemeInjectable),
-      callForHelmReleaseConfiguration,
+      requestHelmReleaseConfiguration: di.inject(requestHelmReleaseConfigurationInjectable),
-      getResourceDetailsUrl,
+      getResourceDetailsUrl: di.inject(getResourceDetailsUrlInjectable),
-      updateRelease,
+      updateRelease: di.inject(updateReleaseInjectable),
-      showCheckedErrorNotification,
+      showCheckedErrorNotification: di.inject(showCheckedErrorNotificationInjectable),
-      showSuccessNotification,
+      showSuccessNotification: di.inject(showSuccessNotificationInjectable),
-      createUpgradeChartTab,
+      createUpgradeChartTab: di.inject(createUpgradeChartTabInjectable),
-      navigateToHelmReleases,
+      navigateToHelmReleases: di.inject(navigateToHelmReleasesInjectable),
+      toHelmRelease: di.inject(toHelmReleaseInjectable),
     });
 
     await model.load();
@@ -85,20 +78,21 @@ export interface ConfigurationInput {
 interface Dependencies {
   readonly targetRelease: TargetHelmRelease;
   readonly activeTheme: IComputedValue<LensTheme>;
-  callForHelmRelease: CallForHelmRelease;
+  requestHelmRelease: RequestHelmRelease;
-  callForHelmReleaseConfiguration: CallForHelmReleaseConfiguration;
+  requestHelmReleaseConfiguration: RequestHelmReleaseConfiguration;
   getResourceDetailsUrl: GetResourceDetailsUrl;
-  updateRelease: CallForHelmReleaseUpdate;
+  updateRelease: RequestHelmReleaseUpdate;
   showCheckedErrorNotification: ShowCheckedErrorNotification;
   showSuccessNotification: ShowNotification;
   createUpgradeChartTab: (release: HelmRelease) => string;
-  navigateToHelmReleases: () => void;
+  navigateToHelmReleases: NavigateToHelmReleases;
+  toHelmRelease: ToHelmRelease;
 }
 
 export class ReleaseDetailsModel {
   readonly id = `${this.dependencies.targetRelease.namespace}/${this.dependencies.targetRelease.name}`;
 
-  constructor(private readonly dependencies: Dependencies) {}
+  constructor(protected readonly dependencies: Dependencies) {}
 
   private readonly detailedRelease = observable.box<DetailedHelmRelease | undefined>();
 
@@ -171,7 +165,7 @@ export class ReleaseDetailsModel {
   load = async () => {
     const { name, namespace } = this.dependencies.targetRelease;
 
-    const result = await this.dependencies.callForHelmRelease(
+    const result = await this.dependencies.requestHelmRelease(
       name,
       namespace,
     );
@@ -199,7 +193,7 @@ export class ReleaseDetailsModel {
     const { name, namespace } = this.release;
 
     const configuration =
-      await this.dependencies.callForHelmReleaseConfiguration(
+      await this.dependencies.requestHelmReleaseConfiguration(
         name,
         namespace,
         !this.onlyUserSuppliedValuesAreShown.value.get(),
@@ -216,7 +210,7 @@ export class ReleaseDetailsModel {
 
     assert(detailedRelease, "Tried to access release before load");
 
-    return toHelmRelease(detailedRelease.release);
+    return this.dependencies.toHelmRelease(detailedRelease.release);
   }
 
   @computed private get details() {

src/renderer/components/+helm-releases/release-details/release-details-model/request-helm-release.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 type { HelmReleaseDto } from "../../../../../common/k8s-api/endpoints/helm-releases.api";
+import requestHelmReleasesInjectable from "../../../../../common/k8s-api/endpoints/helm-releases.api/list.injectable";
+import type { HelmReleaseDetails } from "../../../../../common/k8s-api/endpoints/helm-releases.api/get-details.injectable";
+import requestHelmReleaseDetailsInjectable from "../../../../../common/k8s-api/endpoints/helm-releases.api/get-details.injectable";
+import type { AsyncResult } from "../../../../../common/utils/async-result";
+
+export interface DetailedHelmRelease {
+  release: HelmReleaseDto;
+  details: HelmReleaseDetails;
+}
+
+export type RequestHelmRelease = (
+  name: string,
+  namespace: string
+) => Promise<AsyncResult<DetailedHelmRelease>>;
+
+const requestHelmReleaseInjectable = getInjectable({
+  id: "call-for-helm-release",
+
+  instantiate: (di): RequestHelmRelease => {
+    const requestHelmReleases = di.inject(requestHelmReleasesInjectable);
+    const requestHelmReleaseDetails = di.inject(requestHelmReleaseDetailsInjectable);
+
+    return async (name, namespace) => {
+      const [releases, details] = await Promise.all([
+        requestHelmReleases(namespace),
+        requestHelmReleaseDetails(name, namespace),
+      ]);
+
+      const release = releases.find(
+        (rel) => rel.name === name && rel.namespace === namespace,
+      );
+
+      if (!release) {
+        return {
+          callWasSuccessful: false,
+          error: `Release ${name} didn't exist in ${namespace} namespace.`,
+        };
+      }
+
+      return { callWasSuccessful: true, response: { release, details }};
+    };
+  },
+});
+
+export default requestHelmReleaseInjectable;

src/renderer/components/+helm-releases/releases.injectable.ts

@@ -7,11 +7,8 @@ import { asyncComputed } from "@ogre-tools/injectable-react";
 import namespaceStoreInjectable from "../+namespaces/store.injectable";
 import clusterFrameContextInjectable from "../../cluster-frame-context/cluster-frame-context.injectable";
 import releaseSecretsInjectable from "./release-secrets.injectable";
-import callForHelmReleasesInjectable from "./call-for-helm-releases/call-for-helm-releases.injectable";
+import requestHelmReleasesInjectable from "../../../common/k8s-api/endpoints/helm-releases.api/list.injectable";
-import type { HelmRelease, HelmReleaseDto } from "../../../common/k8s-api/endpoints/helm-releases.api";
+import toHelmReleaseInjectable from "./to-helm-release.injectable";
-import { formatDuration } from "../../../common/utils";
-import { helmChartStore } from "../+helm-charts/helm-chart.store";
-import { capitalize } from "lodash/fp";
 
 const releasesInjectable = getInjectable({
   id: "releases",
@@ -20,7 +17,8 @@ const releasesInjectable = getInjectable({
     const clusterContext = di.inject(clusterFrameContextInjectable);
     const namespaceStore = di.inject(namespaceStoreInjectable);
     const releaseSecrets = di.inject(releaseSecretsInjectable);
-    const callForHelmReleases = di.inject(callForHelmReleasesInjectable);
+    const requestHelmReleases = di.inject(requestHelmReleasesInjectable);
+    const toHelmRelease = di.inject(toHelmReleaseInjectable);
 
     return asyncComputed(async () => {
       const contextNamespaces = namespaceStore.contextNamespaces || [];
@@ -34,9 +32,9 @@ const releasesInjectable = getInjectable({
           contextNamespaces.includes(namespace),
         );
 
-      const releaseArrays = await (isLoadingAll ? callForHelmReleases() : Promise.all(
+      const releaseArrays = await (isLoadingAll ? requestHelmReleases() : Promise.all(
         contextNamespaces.map((namespace) =>
-          callForHelmReleases(namespace),
+          requestHelmReleases(namespace),
         ),
       ));
 
@@ -45,72 +43,5 @@ const releasesInjectable = getInjectable({
   },
 });
 
-export const toHelmRelease = (release: HelmReleaseDto) : HelmRelease => ({
-  ...release,
-
-  getId() {
-    return `${this.namespace}/${this.name}`;
-  },
-
-  getName() {
-    return this.name;
-  },
-
-  getNs() {
-    return this.namespace;
-  },
-
-  getChart(withVersion = false) {
-    let chart = this.chart;
-
-    if (!withVersion && this.getVersion() != "") {
-      const search = new RegExp(`-${this.getVersion()}`);
-
-      chart = chart.replace(search, "");
-    }
-
-    return chart;
-  },
-
-  getRevision() {
-    return parseInt(this.revision, 10);
-  },
-
-  getStatus() {
-    return capitalize(this.status);
-  },
-
-  getVersion() {
-    const versions = this.chart.match(/(?<=-)(v?\d+)[^-].*$/);
-
-    return versions?.[0] ?? "";
-  },
-
-  getUpdated(humanize = true, compact = true) {
-    const updated = this.updated.replace(/\s\w*$/, ""); // 2019-11-26 10:58:09 +0300 MSK -> 2019-11-26 10:58:09 +0300 to pass into Date()
-    const updatedDate = new Date(updated).getTime();
-    const diff = Date.now() - updatedDate;
-
-    if (humanize) {
-      return formatDuration(diff, compact);
-    }
-
-    return diff;
-  },
-
-  // Helm does not store from what repository the release is installed,
-  // so we have to try to guess it by searching charts
-  async getRepo() {
-    const chartName = this.getChart();
-    const version = this.getVersion();
-    const versions = await helmChartStore.getVersions(chartName);
-    const chartVersion = versions.find(
-      (chartVersion) => chartVersion.version === version,
-    );
-
-    return chartVersion ? chartVersion.repo : "";
-  },
-});
-
 
 export default releasesInjectable;

src/renderer/components/+helm-releases/rollback-release/rollback-release.injectable.ts

@@ -3,17 +3,20 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { rollbackRelease } from "../../../../common/k8s-api/endpoints/helm-releases.api";
+import requestHelmReleaseRollbackInjectable from "../../../../common/k8s-api/endpoints/helm-releases.api/rollback.injectable";
 import releasesInjectable from "../releases.injectable";
 
+export type RollbackRelease = (name: string, namespace: string, revision: number) => Promise<void>;
+
 const rollbackReleaseInjectable = getInjectable({
   id: "rollback-release",
 
-  instantiate: (di) => {
+  instantiate: (di): RollbackRelease => {
     const releases = di.inject(releasesInjectable);
+    const requestHelmReleaseRollback = di.inject(requestHelmReleaseRollbackInjectable);
 
-    return async (name: string, namespace: string, revision: number) => {
+    return async (name, namespace, revision) => {
-      await rollbackRelease(name, namespace, revision);
+      await requestHelmReleaseRollback(name, namespace, revision);
 
       releases.invalidate();
     };

src/renderer/components/+helm-releases/to-helm-release.injectable.ts

@@ -0,0 +1,87 @@
+/**
+ * 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 { capitalize } from "lodash";
+import helmChartStoreInjectable from "../+helm-charts/store.injectable";
+import type { HelmRelease, HelmReleaseDto } from "../../../common/k8s-api/endpoints/helm-releases.api";
+import { formatDuration } from "../../utils";
+
+export type ToHelmRelease = (release: HelmReleaseDto) => HelmRelease;
+
+const toHelmReleaseInjectable = getInjectable({
+  id: "to-helm-release",
+  instantiate: (di): ToHelmRelease => {
+    const helmChartStore = di.inject(helmChartStoreInjectable);
+
+    return (release) => ({
+      ...release,
+
+      getId() {
+        return `${this.namespace}/${this.name}`;
+      },
+
+      getName() {
+        return this.name;
+      },
+
+      getNs() {
+        return this.namespace;
+      },
+
+      getChart(withVersion = false) {
+        let chart = this.chart;
+
+        if (!withVersion && this.getVersion() != "") {
+          const search = new RegExp(`-${this.getVersion()}`);
+
+          chart = chart.replace(search, "");
+        }
+
+        return chart;
+      },
+
+      getRevision() {
+        return parseInt(this.revision, 10);
+      },
+
+      getStatus() {
+        return capitalize(this.status);
+      },
+
+      getVersion() {
+        const versions = this.chart.match(/(?<=-)(v?\d+)[^-].*$/);
+
+        return versions?.[0] ?? "";
+      },
+
+      getUpdated(humanize = true, compact = true) {
+        const updated = this.updated.replace(/\s\w*$/, ""); // 2019-11-26 10:58:09 +0300 MSK -> 2019-11-26 10:58:09 +0300 to pass into Date()
+        const updatedDate = new Date(updated).getTime();
+        const diff = Date.now() - updatedDate;
+
+        if (humanize) {
+          return formatDuration(diff, compact);
+        }
+
+        return diff;
+      },
+
+      // Helm does not store from what repository the release is installed,
+      // so we have to try to guess it by searching charts
+      async getRepo() {
+        const chartName = this.getChart();
+        const version = this.getVersion();
+        const versions = await helmChartStore.getVersions(chartName);
+        const chartVersion = versions.find(
+          (chartVersion) => chartVersion.version === version,
+        );
+
+        return chartVersion ? chartVersion.repo : "";
+      },
+    });
+  },
+});
+
+export default toHelmReleaseInjectable;

src/renderer/components/+helm-releases/update-release/call-for-helm-release-update/call-for-helm-release-update.global-override-for-injectable.ts

@@ -1,15 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getGlobalOverride } from "../../../../../common/test-utils/get-global-override";
-import callForHelmReleaseUpdateInjectable from "./call-for-helm-release-update.injectable";
-
-export default getGlobalOverride(
-  callForHelmReleaseUpdateInjectable,
-  () => () => {
-    throw new Error(
-      "Tried to call for helm release update without explicit override.",
-    );
-  },
-);

src/renderer/components/+helm-releases/update-release/call-for-helm-release-update/call-for-helm-release-update.injectable.ts

@@ -1,50 +0,0 @@
-/**
- * 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 { apiBase } from "../../../../../common/k8s-api";
-import { endpoint } from "../../../../../common/k8s-api/endpoints/helm-releases.api";
-import yaml from "js-yaml";
-
-interface HelmReleaseUpdatePayload {
-  repo: string;
-  chart: string;
-  version: string;
-  values: string;
-}
-
-export type CallForHelmReleaseUpdate = (
-  name: string,
-  namespace: string,
-  payload: HelmReleaseUpdatePayload
-) => Promise<{ updateWasSuccessful: true } | { updateWasSuccessful: false; error: unknown }>;
-
-const callForHelmReleaseUpdateInjectable = getInjectable({
-  id: "call-for-helm-release-update",
-
-  instantiate:
-    (): CallForHelmReleaseUpdate => async (name, namespace, payload) => {
-      const { repo, chart: rawChart, values: rawValues, ...data } = payload;
-      const chart = `${repo}/${rawChart}`;
-      const values = yaml.load(rawValues);
-
-      try {
-        await apiBase.put(endpoint({ name, namespace }), {
-          data: {
-            chart,
-            values,
-            ...data,
-          },
-        });
-      } catch (e) {
-        return { updateWasSuccessful: false, error: e };
-      }
-
-      return { updateWasSuccessful: true };
-    },
-
-  causesSideEffects: true,
-});
-
-export default callForHelmReleaseUpdateInjectable;

src/renderer/components/+helm-releases/update-release/update-release.injectable.ts

@@ -4,15 +4,15 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import releasesInjectable from "../releases.injectable";
-import type { CallForHelmReleaseUpdate } from "./call-for-helm-release-update/call-for-helm-release-update.injectable";
+import type { RequestHelmReleaseUpdate } from "../../../../common/k8s-api/endpoints/helm-releases.api/update.injectable";
-import callForHelmReleaseUpdateInjectable from "./call-for-helm-release-update/call-for-helm-release-update.injectable";
+import requestHelmReleaseUpdateInjectable from "../../../../common/k8s-api/endpoints/helm-releases.api/update.injectable";
 
 const updateReleaseInjectable = getInjectable({
   id: "update-release",
 
-  instantiate: (di): CallForHelmReleaseUpdate => {
+  instantiate: (di): RequestHelmReleaseUpdate => {
     const releases = di.inject(releasesInjectable);
-    const callForHelmReleaseUpdate = di.inject(callForHelmReleaseUpdateInjectable);
+    const callForHelmReleaseUpdate = di.inject(requestHelmReleaseUpdateInjectable);
 
     return async (
       name,

src/renderer/components/dock/install-chart/chart-data/call-for-helm-chart-values.injectable.ts

@@ -1,20 +0,0 @@
-/**
- * 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 { getChartValues } from "../../../../../common/k8s-api/endpoints/helm-charts.api";
-
-export type CallForHelmChartValues = (
-  repo: string,
-  name: string,
-  version: string
-) => Promise<string>;
-
-const callForHelmChartValuesInjectable = getInjectable({
-  id: "call-for-helm-chart-values",
-  instantiate: (): CallForHelmChartValues => getChartValues,
-  causesSideEffects: true,
-});
-
-export default callForHelmChartValuesInjectable;

src/renderer/components/dock/install-chart/install-chart-model.injectable.tsx

@@ -5,36 +5,31 @@
 import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
 import installChartTabStoreInjectable from "./store.injectable";
 import { waitUntilDefined } from "../../../../common/utils";
-import type { CallForHelmChartValues } from "./chart-data/call-for-helm-chart-values.injectable";
-import callForHelmChartValuesInjectable from "./chart-data/call-for-helm-chart-values.injectable";
 import type { IChartInstallData, InstallChartTabStore } from "./store";
 import type { HelmChart } from "../../../../common/k8s-api/endpoints/helm-charts.api";
 import React from "react";
-import {
+import { action, computed, observable, runInAction } from "mobx";
-  action,
-  computed,
-  observable,
-  runInAction,
-} from "mobx";
 import assert from "assert";
-import type { CallForCreateHelmRelease } from "../../+helm-releases/create-release/call-for-create-helm-release.injectable";
+import type { RequestCreateHelmRelease } from "../../../../common/k8s-api/endpoints/helm-releases.api/create.injectable";
-import callForCreateHelmReleaseInjectable from "../../+helm-releases/create-release/call-for-create-helm-release.injectable";
+import requestCreateHelmReleaseInjectable from "../../../../common/k8s-api/endpoints/helm-releases.api/create.injectable";
 import type { HelmReleaseUpdateDetails } from "../../../../common/k8s-api/endpoints/helm-releases.api";
 import dockStoreInjectable from "../dock/store.injectable";
 import type { NavigateToHelmReleases } from "../../../../common/front-end-routing/routes/cluster/helm/releases/navigate-to-helm-releases.injectable";
 import navigateToHelmReleasesInjectable from "../../../../common/front-end-routing/routes/cluster/helm/releases/navigate-to-helm-releases.injectable";
 import type { SingleValue } from "react-select";
-import type { CallForHelmChartVersions } from "../../+helm-charts/details/versions/call-for-helm-chart-versions.injectable";
+import type { RequestHelmChartValues } from "../../../../common/k8s-api/endpoints/helm-charts.api/get-values.injectable";
-import callForHelmChartVersionsInjectable from "../../+helm-charts/details/versions/call-for-helm-chart-versions.injectable";
+import requestHelmChartValuesInjectable from "../../../../common/k8s-api/endpoints/helm-charts.api/get-values.injectable";
+import type { RequestHelmChartVersions } from "../../../../common/k8s-api/endpoints/helm-charts.api/get-versions.injectable";
+import requestHelmChartVersionsInjectable from "../../../../common/k8s-api/endpoints/helm-charts.api/get-versions.injectable";
 
 const installChartModelInjectable = getInjectable({
   id: "install-chart-model",
 
   instantiate: async (di, tabId: string) => {
     const store = di.inject(installChartTabStoreInjectable);
-    const callForHelmChartValues = di.inject(callForHelmChartValuesInjectable);
+    const requestHelmChartValues = di.inject(requestHelmChartValuesInjectable);
-    const callForHelmChartVersions = di.inject(callForHelmChartVersionsInjectable);
+    const requestHelmChartVersions = di.inject(requestHelmChartVersionsInjectable);
-    const callForCreateHelmRelease = di.inject(callForCreateHelmReleaseInjectable);
+    const callForCreateHelmRelease = di.inject(requestCreateHelmReleaseInjectable);
     const dockStore = di.inject(dockStoreInjectable);
     const navigateToHelmReleases = di.inject(navigateToHelmReleasesInjectable);
     const closeTab = () => dockStore.closeTab(tabId);
@@ -49,8 +44,8 @@ const installChartModelInjectable = getInjectable({
       callForCreateHelmRelease,
       closeTab,
       navigateToHelmReleases,
-      callForHelmChartValues,
+      requestHelmChartValues,
-      callForHelmChartVersions,
+      requestHelmChartVersions,
       store,
     });
 
@@ -71,9 +66,9 @@ interface Dependencies {
   closeTab: () => void;
   navigateToHelmReleases: NavigateToHelmReleases;
   waitForChart: () => Promise<void>;
-  callForCreateHelmRelease: CallForCreateHelmRelease;
+  callForCreateHelmRelease: RequestCreateHelmRelease;
-  callForHelmChartValues: CallForHelmChartValues;
+  requestHelmChartValues: RequestHelmChartValues;
-  callForHelmChartVersions: CallForHelmChartVersions;
+  requestHelmChartVersions: RequestHelmChartVersions;
   store: InstallChartTabStore;
 }
 
@@ -127,7 +122,7 @@ export class InstallChartModel {
         this.configuration.isLoading.set(true);
       });
 
-      const configuration = await this.dependencies.callForHelmChartValues(
+      const configuration = await this.dependencies.requestHelmChartValues(
         this.chart.repo,
         this.chart.name,
         version,
@@ -193,13 +188,13 @@ export class InstallChartModel {
     await this.dependencies.waitForChart();
 
     const [defaultConfiguration, versions] = await Promise.all([
-      this.dependencies.callForHelmChartValues(
+      this.dependencies.requestHelmChartValues(
         this.chart.repo,
         this.chart.name,
         this.chart.version,
       ),
 
-      this.dependencies.callForHelmChartVersions(
+      this.dependencies.requestHelmChartVersions(
         this.chart.repo,
         this.chart.name,
       ),

src/renderer/components/dock/upgrade-chart/store.injectable.ts

@@ -6,6 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
 import { UpgradeChartTabStore } from "./store";
 import createDockTabStoreInjectable from "../dock-tab-store/create-dock-tab-store.injectable";
 import createStorageInjectable from "../../../utils/create-storage/create-storage.injectable";
+import requestHelmReleaseConfigurationInjectable from "../../../../common/k8s-api/endpoints/helm-releases.api/get-configuration.injectable";
 
 const upgradeChartTabStoreInjectable = getInjectable({
   id: "upgrade-chart-tab-store",
@@ -16,6 +17,7 @@ const upgradeChartTabStoreInjectable = getInjectable({
     return new UpgradeChartTabStore({
       createStorage: di.inject(createStorageInjectable),
       valuesStore: createDockTabStore<string>(),
+      requestHelmReleaseConfiguration: di.inject(requestHelmReleaseConfigurationInjectable),
     });
   },
 });

src/renderer/components/dock/upgrade-chart/store.ts

@@ -7,8 +7,8 @@ import { action, computed, makeObservable } from "mobx";
 import type { TabId } from "../dock/store";
 import type { DockTabStoreDependencies } from "../dock-tab-store/dock-tab.store";
 import { DockTabStore } from "../dock-tab-store/dock-tab.store";
-import { getReleaseValues } from "../../../../common/k8s-api/endpoints/helm-releases.api";
 import assert from "assert";
+import type { RequestHelmReleaseConfiguration } from "../../../../common/k8s-api/endpoints/helm-releases.api/get-configuration.injectable";
 
 export interface IChartUpgradeData {
   releaseName: string;
@@ -17,6 +17,7 @@ export interface IChartUpgradeData {
 
 export interface UpgradeChartTabStoreDependencies extends DockTabStoreDependencies {
   valuesStore: DockTabStore<string>;
+  requestHelmReleaseConfiguration: RequestHelmReleaseConfiguration;
 }
 
 export class UpgradeChartTabStore extends DockTabStore<IChartUpgradeData> {
@@ -44,7 +45,7 @@ export class UpgradeChartTabStore extends DockTabStore<IChartUpgradeData> {
     assert(data, "cannot reload values if no data");
 
     const { releaseName, releaseNamespace } = data;
-    const values = await getReleaseValues(releaseName, releaseNamespace, true);
+    const values = await this.dependencies.requestHelmReleaseConfiguration(releaseName, releaseNamespace, true);
 
     this.values.setData(tabId, values);
   }

src/renderer/components/dock/upgrade-chart/view.tsx

@@ -15,7 +15,7 @@ import type { UpgradeChartTabStore } from "./store";
 import { Spinner } from "../../spinner";
 import { Badge } from "../../badge";
 import { EditorPanel } from "../editor-panel";
-import { helmChartStore, type ChartVersion } from "../../+helm-charts/helm-chart.store";
+import type { HelmChartStore, ChartVersion } from "../../+helm-charts/store";
 import type { HelmRelease } from "../../../../common/k8s-api/endpoints/helm-releases.api";
 import type { SelectOption } from "../../select";
 import { Select } from "../../select";
@@ -24,8 +24,9 @@ import { withInjectables } from "@ogre-tools/injectable-react";
 import upgradeChartTabStoreInjectable from "./store.injectable";
 import updateReleaseInjectable from "../../+helm-releases/update-release/update-release.injectable";
 import releasesInjectable from "../../+helm-releases/releases.injectable";
-import type { CallForHelmReleaseUpdate } from "../../+helm-releases/update-release/call-for-helm-release-update/call-for-helm-release-update.injectable";
+import type { RequestHelmReleaseUpdate } from "../../../../common/k8s-api/endpoints/helm-releases.api/update.injectable";
 import { first } from "lodash/fp";
+import helmChartStoreInjectable from "../../+helm-charts/store.injectable";
 
 export interface UpgradeChartProps {
   className?: string;
@@ -35,7 +36,8 @@ export interface UpgradeChartProps {
 interface Dependencies {
   releases: IAsyncComputed<HelmRelease[]>;
   upgradeChartTabStore: UpgradeChartTabStore;
-  updateRelease: CallForHelmReleaseUpdate;
+  updateRelease: RequestHelmReleaseUpdate;
+  helmChartStore: HelmChartStore;
 }
 
 @observer
@@ -95,7 +97,7 @@ export class NonInjectedUpgradeChart extends React.Component<UpgradeChartProps &
 
     this.version = undefined;
     this.versions.clear();
-    const versions = await helmChartStore.getVersions(release.getChart());
+    const versions = await this.props.helmChartStore.getVersions(release.getChart());
 
     this.versions.replace(versions);
     this.version = first(this.versions);
@@ -194,9 +196,10 @@ export class NonInjectedUpgradeChart extends React.Component<UpgradeChartProps &
 
 export const UpgradeChart = withInjectables<Dependencies, UpgradeChartProps>(NonInjectedUpgradeChart, {
   getProps: (di, props) => ({
+    ...props,
     releases: di.inject(releasesInjectable),
     updateRelease: di.inject(updateReleaseInjectable),
     upgradeChartTabStore: di.inject(upgradeChartTabStoreInjectable),
-    ...props,
+    helmChartStore: di.inject(helmChartStoreInjectable),
   }),
 });