Extract responsibilities from god-class and switch to getting helm repositories using competition instead of another god class

Signed-off-by: Janne Savolainen <janne.savolainen@live.fi>

src/main/helm/__tests__/helm-service.test.ts

@@ -3,27 +3,39 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 
-import { helmService } from "../helm-service";
+import { getDiForUnitTesting } from "../../getDiForUnitTesting";
-import { HelmRepoManager } from "../helm-repo-manager";
+import listHelmChartsInjectable from "../helm-service/list-helm-charts.injectable";
-
+import getActiveHelmRepositoriesInjectable from "../repositories/get-active-helm-repositories/get-active-helm-repositories.injectable";
-const mockHelmRepoManager = jest.spyOn(HelmRepoManager, "getInstance").mockImplementation();
 
 jest.mock("../helm-chart-manager");
 
 describe("Helm Service tests", () => {
+  let listHelmCharts: () => Promise<any>;
+  let getActiveHelmRepositoriesMock: jest.Mock;
+
+  beforeEach(() => {
+    const di = getDiForUnitTesting({ doGeneralOverrides: true });
+
+    getActiveHelmRepositoriesMock = jest.fn();
+
+    di.override(getActiveHelmRepositoriesInjectable, () => getActiveHelmRepositoriesMock);
+
+    di.permitSideEffects(listHelmChartsInjectable);
+
+    listHelmCharts = di.inject(listHelmChartsInjectable);
+  });
+
   afterEach(() => {
     jest.resetAllMocks();
   });
 
   it("list charts with deprecated entries", async () => {
-    mockHelmRepoManager.mockReturnValue({
+    getActiveHelmRepositoriesMock.mockReturnValue([
-      repositories: jest.fn().mockImplementation(async () => [
       { name: "stable", url: "stableurl" },
       { name: "experiment", url: "experimenturl" },
-      ]),
+    ] as any);
-    } as any);
 
-    const charts = await helmService.listCharts();
+    const charts = await listHelmCharts();
 
     expect(charts).toEqual({
       stable: {
@@ -123,15 +135,11 @@ describe("Helm Service tests", () => {
   });
 
   it("list charts sorted by version in descending order", async () => {
-    mockHelmRepoManager.mockReturnValue({
+    getActiveHelmRepositoriesMock.mockReturnValue([
-      repositories: jest.fn().mockImplementation(async () => {
-        return [
       { name: "bitnami", url: "bitnamiurl" },
-        ];
+    ] as any);
-      }),
-    } as any);
 
-    const charts = await helmService.listCharts();
+    const charts = await listHelmCharts();
 
     expect(charts).toEqual({
       bitnami: {

src/main/helm/helm-service.ts

@@ -1,134 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import type { Cluster } from "../../common/cluster/cluster";
-import logger from "../logger";
-import { HelmRepoManager } from "./helm-repo-manager";
-import { HelmChartManager } from "./helm-chart-manager";
-import { deleteRelease, getHistory, getRelease, getValues, installChart, listReleases, rollback, upgradeRelease } from "./helm-release-manager";
-import type { JsonObject } from "type-fest";
-import { object } from "../../common/utils";
-
-interface GetReleaseValuesArgs {
-  cluster: Cluster;
-  namespace: string;
-  all: boolean;
-}
-
-export interface InstallChartArgs {
-  chart: string;
-  values: JsonObject;
-  name: string;
-  namespace: string;
-  version: string;
-}
-
-export interface UpdateChartArgs {
-  chart: string;
-  values: JsonObject;
-  version: string;
-}
-
-class HelmService {
-  public async installChart(cluster: Cluster, data: InstallChartArgs) {
-    const proxyKubeconfig = await cluster.getProxyKubeconfigPath();
-
-    return installChart(data.chart, data.values, data.name, data.namespace, data.version, proxyKubeconfig);
-  }
-
-  public async listCharts() {
-    const repositories = await HelmRepoManager.getInstance().repositories();
-
-    return object.fromEntries(
-      await Promise.all(repositories.map(async repo => [repo.name, await HelmChartManager.forRepo(repo).charts()] as const)),
-    );
-  }
-
-  public async getChart(repoName: string, chartName: string, version = "") {
-    const repo = await HelmRepoManager.getInstance().repo(repoName);
-
-    if (!repo) {
-      return undefined;
-    }
-
-    const chartManager = HelmChartManager.forRepo(repo);
-
-    return {
-      readme: await chartManager.getReadme(chartName, version),
-      versions: await chartManager.chartVersions(chartName),
-    };
-  }
-
-  public async getChartValues(repoName: string, chartName: string, version = "") {
-    const repo = await HelmRepoManager.getInstance().repo(repoName);
-
-    if (!repo) {
-      return undefined;
-    }
-
-    return HelmChartManager.forRepo(repo).getValues(chartName, version);
-  }
-
-  public async listReleases(cluster: Cluster, namespace?: string) {
-    const proxyKubeconfig = await cluster.getProxyKubeconfigPath();
-
-    logger.debug("list releases");
-
-    return listReleases(proxyKubeconfig, namespace);
-  }
-
-  public async getRelease(cluster: Cluster, releaseName: string, namespace: string) {
-    const kubeconfigPath = await cluster.getProxyKubeconfigPath();
-    const kubectl = await cluster.ensureKubectl();
-    const kubectlPath = await kubectl.getPath();
-
-    logger.debug("Fetch release");
-
-    return getRelease(releaseName, namespace, kubeconfigPath, kubectlPath);
-  }
-
-  public async getReleaseValues(releaseName: string, { cluster, namespace, all }: GetReleaseValuesArgs) {
-    const pathToKubeconfig = await cluster.getProxyKubeconfigPath();
-
-    logger.debug("Fetch release values");
-
-    return getValues(releaseName, { namespace, all, kubeconfigPath: pathToKubeconfig });
-  }
-
-  public async getReleaseHistory(cluster: Cluster, releaseName: string, namespace: string) {
-    const proxyKubeconfig = await cluster.getProxyKubeconfigPath();
-
-    logger.debug("Fetch release history");
-
-    return getHistory(releaseName, namespace, proxyKubeconfig);
-  }
-
-  public async deleteRelease(cluster: Cluster, releaseName: string, namespace: string) {
-    const proxyKubeconfig = await cluster.getProxyKubeconfigPath();
-
-    logger.debug("Delete release");
-
-    return deleteRelease(releaseName, namespace, proxyKubeconfig);
-  }
-
-  public async updateRelease(cluster: Cluster, releaseName: string, namespace: string, data: UpdateChartArgs) {
-    const proxyKubeconfig = await cluster.getProxyKubeconfigPath();
-    const kubectl = await cluster.ensureKubectl();
-    const kubectlPath = await kubectl.getPath();
-
-    logger.debug("Upgrade release");
-
-    return upgradeRelease(releaseName, data.chart, data.values, namespace, data.version, proxyKubeconfig, kubectlPath);
-  }
-
-  public async rollback(cluster: Cluster, releaseName: string, namespace: string, revision: number) {
-    const proxyKubeconfig = await cluster.getProxyKubeconfigPath();
-
-    logger.debug("Rollback release");
-    await rollback(releaseName, namespace, revision, proxyKubeconfig);
-  }
-}
-
-export const helmService = new HelmService();

src/main/helm/helm-service/delete-helm-release.injectable.ts

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import type { Cluster } from "../../../common/cluster/cluster";
+import { deleteRelease } from "../helm-release-manager";
+import loggerInjectable from "../../../common/logger.injectable";
+
+const deleteHelmReleaseInjectable = getInjectable({
+  id: "delete-helm-release",
+
+  instantiate: (di) => {
+    const logger = di.inject(loggerInjectable);
+
+    return async (cluster: Cluster, releaseName: string, namespace: string) => {
+      const proxyKubeconfig = await cluster.getProxyKubeconfigPath();
+
+      logger.debug("Delete release");
+
+      return deleteRelease(releaseName, namespace, proxyKubeconfig);
+    };
+  },
+
+  causesSideEffects: true,
+});
+
+export default deleteHelmReleaseInjectable;

src/main/helm/helm-service/get-helm-chart-values.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 getHelmChartValuesInjectable = getInjectable({
+  id: "get-helm-chart-values",
+
+  instantiate: (di) => {
+    const getActiveHelmRepository = di.inject(getActiveHelmRepositoryInjectable);
+
+    return async (repoName: string, chartName: string, version = "") => {
+      const repo = await getActiveHelmRepository(repoName);
+
+      if (!repo) {
+        return undefined;
+      }
+
+      return HelmChartManager.forRepo(repo).getValues(chartName, version);
+    };
+  },
+
+  causesSideEffects: true,
+});
+
+export default getHelmChartValuesInjectable;

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

src/main/helm/helm-service/get-helm-release-history.injectable.ts

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import type { Cluster } from "../../../common/cluster/cluster";
+import { getHistory } from "../helm-release-manager";
+import loggerInjectable from "../../../common/logger.injectable";
+
+const getHelmReleaseHistoryInjectable = getInjectable({
+  id: "get-helm-release-history",
+
+  instantiate: (di) => {
+    const logger = di.inject(loggerInjectable);
+
+    return async (cluster: Cluster, releaseName: string, namespace: string) => {
+      const proxyKubeconfig = await cluster.getProxyKubeconfigPath();
+
+      logger.debug("Fetch release history");
+
+      return getHistory(releaseName, namespace, proxyKubeconfig);
+    };
+  },
+
+  causesSideEffects: true,
+});
+
+export default getHelmReleaseHistoryInjectable;

src/main/helm/helm-service/get-helm-release-values.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 { getValues } from "../helm-release-manager";
+import loggerInjectable from "../../../common/logger.injectable";
+import type { Cluster } from "../../../common/cluster/cluster";
+
+interface GetReleaseValuesArgs {
+  cluster: Cluster;
+  namespace: string;
+  all: boolean;
+}
+
+const getHelmReleaseValuesInjectable = getInjectable({
+  id: "get-helm-release-values",
+
+  instantiate: (di) => {
+    const logger = di.inject(loggerInjectable);
+
+    return async (
+      releaseName: string,
+      { cluster, namespace, all }: GetReleaseValuesArgs,
+    ) => {
+      const pathToKubeconfig = await cluster.getProxyKubeconfigPath();
+
+      logger.debug("Fetch release values");
+
+      return getValues(releaseName, {
+        namespace,
+        all,
+        kubeconfigPath: pathToKubeconfig,
+      });
+    };
+  },
+
+  causesSideEffects: true,
+});
+
+export default getHelmReleaseValuesInjectable;

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

@@ -0,0 +1,30 @@
+/**
+ * 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 { Cluster } from "../../../common/cluster/cluster";
+import { getRelease } from "../helm-release-manager";
+import loggerInjectable from "../../../common/logger.injectable";
+
+const getHelmReleaseInjectable = getInjectable({
+  id: "get-helm-release",
+
+  instantiate: (di) => {
+    const logger = di.inject(loggerInjectable);
+
+    return async (cluster: Cluster, releaseName: string, namespace: string) => {
+      const kubeconfigPath = await cluster.getProxyKubeconfigPath();
+      const kubectl = await cluster.ensureKubectl();
+      const kubectlPath = await kubectl.getPath();
+
+      logger.debug("Fetch release");
+
+      return getRelease(releaseName, namespace, kubeconfigPath, kubectlPath);
+    };
+  },
+
+  causesSideEffects: true,
+});
+
+export default getHelmReleaseInjectable;

src/main/helm/helm-service/install-helm-chart.injectable.ts

@@ -0,0 +1,30 @@
+/**
+ * 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 { JsonObject } from "type-fest";
+import type { Cluster } from "../../../common/cluster/cluster";
+import { installChart } from "../helm-release-manager";
+
+export interface InstallChartArgs {
+  chart: string;
+  values: JsonObject;
+  name: string;
+  namespace: string;
+  version: string;
+}
+
+const installHelmChartInjectable = getInjectable({
+  id: "install-helm-chart",
+
+  instantiate: () => async (cluster: Cluster, data: InstallChartArgs) => {
+    const proxyKubeconfig = await cluster.getProxyKubeconfigPath();
+
+    return installChart(data.chart, data.values, data.name, data.namespace, data.version, proxyKubeconfig);
+  },
+
+  causesSideEffects: true,
+});
+
+export default installHelmChartInjectable;

src/main/helm/helm-service/list-helm-charts.injectable.ts

@@ -0,0 +1,36 @@
+/**
+ * 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 { object } from "../../../common/utils";
+import { HelmChartManager } from "../helm-chart-manager";
+import getActiveHelmRepositoriesInjectable from "../repositories/get-active-helm-repositories/get-active-helm-repositories.injectable";
+
+const listHelmChartsInjectable = getInjectable({
+  id: "list-helm-charts",
+
+  instantiate: (di) => {
+    const getActiveHelmRepositories = di.inject(getActiveHelmRepositoriesInjectable);
+
+    return async () => {
+      const repositories = await getActiveHelmRepositories();
+
+      return object.fromEntries(
+        await Promise.all(
+          repositories.map(
+            async (repo) =>
+              [
+                repo.name,
+                await HelmChartManager.forRepo(repo).charts(),
+              ] as const,
+          ),
+        ),
+      );
+    };
+  },
+
+  causesSideEffects: true,
+});
+
+export default listHelmChartsInjectable;

src/main/helm/helm-service/list-helm-releases.injectable.ts

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import type { Cluster } from "../../../common/cluster/cluster";
+import loggerInjectable from "../../../common/logger.injectable";
+import { listReleases } from "../helm-release-manager";
+
+const listHelmReleasesInjectable = getInjectable({
+  id: "list-helm-releases",
+
+  instantiate: (di) => {
+    const logger = di.inject(loggerInjectable);
+
+    return async (cluster: Cluster, namespace?: string) => {
+      const proxyKubeconfig = await cluster.getProxyKubeconfigPath();
+
+      logger.debug("list releases");
+
+      return listReleases(proxyKubeconfig, namespace);
+    };
+  },
+
+  causesSideEffects: true,
+});
+
+export default listHelmReleasesInjectable;

src/main/helm/helm-service/rollback-helm-release.injectable.ts

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import type { Cluster } from "../../../common/cluster/cluster";
+import loggerInjectable from "../../../common/logger.injectable";
+import { rollback } from "../helm-release-manager";
+
+const rollbackHelmReleaseInjectable = getInjectable({
+  id: "rollback-helm-release",
+
+  instantiate: (di) => {
+    const logger = di.inject(loggerInjectable);
+
+    return async (
+      cluster: Cluster,
+      releaseName: string,
+      namespace: string,
+      revision: number,
+    ) => {
+      const proxyKubeconfig = await cluster.getProxyKubeconfigPath();
+
+      logger.debug("Rollback release");
+      await rollback(releaseName, namespace, revision, proxyKubeconfig);
+    };
+  },
+
+  causesSideEffects: true,
+});
+
+export default rollbackHelmReleaseInjectable;

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

@@ -0,0 +1,45 @@
+/**
+ * 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 { Cluster } from "../../../common/cluster/cluster";
+import { upgradeRelease } from "../helm-release-manager";
+import loggerInjectable from "../../../common/logger.injectable";
+import type { JsonObject } from "type-fest";
+
+export interface UpdateChartArgs {
+  chart: string;
+  values: JsonObject;
+  version: string;
+}
+
+const updateHelmReleaseInjectable = getInjectable({
+  id: "update-helm-release",
+
+  instantiate: (di) => {
+    const logger = di.inject(loggerInjectable);
+
+    return async (cluster: Cluster, releaseName: string, namespace: string, data: UpdateChartArgs) => {
+      const proxyKubeconfig = await cluster.getProxyKubeconfigPath();
+      const kubectl = await cluster.ensureKubectl();
+      const kubectlPath = await kubectl.getPath();
+
+      logger.debug("Upgrade release");
+
+      return upgradeRelease(
+        releaseName,
+        data.chart,
+        data.values,
+        namespace,
+        data.version,
+        proxyKubeconfig,
+        kubectlPath,
+      );
+    };
+  },
+
+  causesSideEffects: true,
+});
+
+export default updateHelmReleaseInjectable;

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

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

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

@@ -3,23 +3,27 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getRouteInjectable } from "../../../router/router.injectable";
-import { helmService } from "../../../helm/helm-service";
 import { apiPrefix } from "../../../../common/vars";
 import { route } from "../../../router/route";
+import getHelmChartValuesInjectable from "../../../helm/helm-service/get-helm-chart-values.injectable";
 
 const getChartRouteValuesInjectable = getRouteInjectable({
   id: "get-chart-route-values",
 
-  instantiate: () => route({
+  instantiate: (di) => {
+    const getHelmChartValues = di.inject(getHelmChartValuesInjectable);
+
+    return route({
       method: "get",
       path: `${apiPrefix}/v2/charts/{repo}/{chart}/values`,
     })(async ({ params, query }) => ({
-    response: await helmService.getChartValues(
+      response: await getHelmChartValues(
         params.repo,
         params.chart,
         query.get("version") ?? undefined,
       ),
-  })),
+    }));
+  },
 });
 
 export default getChartRouteValuesInjectable;

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

@@ -3,19 +3,23 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getRouteInjectable } from "../../../router/router.injectable";
-import { helmService } from "../../../helm/helm-service";
 import { apiPrefix } from "../../../../common/vars";
 import { route } from "../../../router/route";
+import listHelmChartsInjectable from "../../../helm/helm-service/list-helm-charts.injectable";
 
 const listChartsRouteInjectable = getRouteInjectable({
   id: "list-charts-route",
 
-  instantiate: () => route({
+  instantiate: (di) => {
+    const listHelmCharts = di.inject(listHelmChartsInjectable);
+
+    return route({
       method: "get",
       path: `${apiPrefix}/v2/charts`,
     })(async () => ({
-    response: await helmService.listCharts(),
+      response: await listHelmCharts(),
-  })),
+    }));
+  },
 });
 
 export default listChartsRouteInjectable;

src/main/routes/helm/releases/delete-release-route.injectable.ts

@@ -3,23 +3,23 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { apiPrefix } from "../../../../common/vars";
-import { helmService } from "../../../helm/helm-service";
 import { getRouteInjectable } from "../../../router/router.injectable";
 import { clusterRoute } from "../../../router/route";
+import deleteHelmReleaseInjectable from "../../../helm/helm-service/delete-helm-release.injectable";
 
 const deleteReleaseRouteInjectable = getRouteInjectable({
   id: "delete-release-route",
 
-  instantiate: () => clusterRoute({
+  instantiate: (di) => {
+    const deleteHelmRelease = di.inject(deleteHelmReleaseInjectable);
+
+    return clusterRoute({
       method: "delete",
       path: `${apiPrefix}/v2/releases/{namespace}/{release}`,
     })(async ({ cluster, params: { release, namespace }}) => ({
-    response: await helmService.deleteRelease(
+      response: await deleteHelmRelease(cluster, release, namespace),
-      cluster,
+    }));
-      release,
+  },
-      namespace,
-    ),
-  })),
 });
 
 export default deleteReleaseRouteInjectable;

src/main/routes/helm/releases/get-release-history-route.injectable.ts

@@ -3,23 +3,27 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { apiPrefix } from "../../../../common/vars";
-import { helmService } from "../../../helm/helm-service";
 import { getRouteInjectable } from "../../../router/router.injectable";
 import { clusterRoute } from "../../../router/route";
+import getHelmReleaseHistoryInjectable from "../../../helm/helm-service/get-helm-release-history.injectable";
 
 const getReleaseRouteHistoryInjectable = getRouteInjectable({
   id: "get-release-history-route",
 
-  instantiate: () => clusterRoute({
+  instantiate: (di) => {
+    const getHelmReleaseHistory = di.inject(getHelmReleaseHistoryInjectable);
+
+    return clusterRoute({
       method: "get",
       path: `${apiPrefix}/v2/releases/{namespace}/{release}/history`,
     })(async ({ cluster, params }) => ({
-    response: await helmService.getReleaseHistory(
+      response: await getHelmReleaseHistory(
         cluster,
         params.release,
         params.namespace,
       ),
-  })),
+    }));
+  },
 });
 
 export default getReleaseRouteHistoryInjectable;

src/main/routes/helm/releases/get-release-route.injectable.ts

@@ -3,23 +3,27 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { apiPrefix } from "../../../../common/vars";
-import { helmService } from "../../../helm/helm-service";
 import { getRouteInjectable } from "../../../router/router.injectable";
 import { clusterRoute } from "../../../router/route";
+import getHelmReleaseInjectable from "../../../helm/helm-service/get-helm-release.injectable";
 
 const getReleaseRouteInjectable = getRouteInjectable({
   id: "get-release-route",
 
-  instantiate: () => clusterRoute({
+  instantiate: (di) => {
+    const getHelmRelease = di.inject(getHelmReleaseInjectable);
+
+    return clusterRoute({
       method: "get",
       path: `${apiPrefix}/v2/releases/{namespace}/{release}`,
     })(async ({ cluster, params }) => ({
-    response: await helmService.getRelease(
+      response: await getHelmRelease(
         cluster,
         params.release,
         params.namespace,
       ),
-  })),
+    }));
+  },
 });
 
 export default getReleaseRouteInjectable;

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

@@ -3,27 +3,31 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { apiPrefix } from "../../../../common/vars";
-import { helmService } from "../../../helm/helm-service";
 import { getRouteInjectable } from "../../../router/router.injectable";
 import { getBoolean } from "../../../utils/parse-query";
 import { contentTypes } from "../../../router/router-content-types";
 import { clusterRoute } from "../../../router/route";
+import getHelmReleaseValuesInjectable from "../../../helm/helm-service/get-helm-release-values.injectable";
 
 const getReleaseRouteValuesInjectable = getRouteInjectable({
   id: "get-release-values-route",
 
-  instantiate: () => clusterRoute({
+  instantiate: (di) => {
+    const getHelmReleaseValues = di.inject(getHelmReleaseValuesInjectable);
+
+    return clusterRoute({
       method: "get",
       path: `${apiPrefix}/v2/releases/{namespace}/{release}/values`,
     })(async ({ cluster, params: { namespace, release }, query }) => ({
-    response: await helmService.getReleaseValues(release, {
+      response: await getHelmReleaseValues(release, {
         cluster,
         namespace,
         all: getBoolean(query, "all"),
       }),
 
       contentType: contentTypes.txt,
-  })),
+    }));
+  },
 });
 
 export default getReleaseRouteValuesInjectable;

src/main/routes/helm/releases/install-chart-route.injectable.ts

@@ -3,11 +3,11 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { apiPrefix } from "../../../../common/vars";
-import type { InstallChartArgs } from "../../../helm/helm-service";
-import { helmService } from "../../../helm/helm-service";
 import { getRouteInjectable } from "../../../router/router.injectable";
 import Joi from "joi";
 import { payloadValidatedClusterRoute } from "../../../router/route";
+import type { InstallChartArgs } from "../../../helm/helm-service/install-helm-chart.injectable";
+import installHelmChartInjectable from "../../../helm/helm-service/install-helm-chart.injectable";
 
 const installChartArgsValidator = Joi.object<InstallChartArgs, true, InstallChartArgs>({
   chart: Joi
@@ -31,14 +31,18 @@ const installChartArgsValidator = Joi.object<InstallChartArgs, true, InstallChar
 const installChartRouteInjectable = getRouteInjectable({
   id: "install-chart-route",
 
-  instantiate: () => payloadValidatedClusterRoute({
+  instantiate: (di) => {
+    const installHelmChart = di.inject(installHelmChartInjectable);
+
+    return payloadValidatedClusterRoute({
       method: "post",
       path: `${apiPrefix}/v2/releases`,
       payloadValidator: installChartArgsValidator,
     })(async ({ payload, cluster }) => ({
-    response: await helmService.installChart(cluster, payload),
+      response: await installHelmChart(cluster, payload),
       statusCode: 201,
-  })),
+    }));
+  },
 });
 
 export default installChartRouteInjectable;

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

@@ -3,19 +3,23 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { apiPrefix } from "../../../../common/vars";
-import { helmService } from "../../../helm/helm-service";
 import { getRouteInjectable } from "../../../router/router.injectable";
 import { clusterRoute } from "../../../router/route";
+import listHelmReleasesInjectable from "../../../helm/helm-service/list-helm-releases.injectable";
 
 const listReleasesRouteInjectable = getRouteInjectable({
   id: "list-releases-route",
 
-  instantiate: () => clusterRoute({
+  instantiate: (di) => {
+    const listHelmReleases = di.inject(listHelmReleasesInjectable);
+
+    return clusterRoute({
       method: "get",
       path: `${apiPrefix}/v2/releases/{namespace?}`,
     })(async ({ cluster, params }) => ({
-    response: await helmService.listReleases(cluster, params.namespace),
+      response: await listHelmReleases(cluster, params.namespace),
-  })),
+    }));
+  },
 });
 
 export default listReleasesRouteInjectable;

src/main/routes/helm/releases/rollback-release-route.injectable.ts

@@ -3,10 +3,10 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { apiPrefix } from "../../../../common/vars";
-import { helmService } from "../../../helm/helm-service";
 import { getRouteInjectable } from "../../../router/router.injectable";
 import Joi from "joi";
 import { payloadValidatedClusterRoute } from "../../../router/route";
+import rollbackHelmReleaseInjectable from "../../../helm/helm-service/rollback-helm-release.injectable";
 
 interface RollbackReleasePayload {
   revision: number;
@@ -21,13 +21,17 @@ const rollbackReleasePayloadValidator = Joi.object<RollbackReleasePayload, true,
 const rollbackReleaseRouteInjectable = getRouteInjectable({
   id: "rollback-release-route",
 
-  instantiate: () => payloadValidatedClusterRoute({
+  instantiate: (di) => {
+    const rollbackRelease = di.inject(rollbackHelmReleaseInjectable);
+
+    return payloadValidatedClusterRoute({
       method: "put",
       path: `${apiPrefix}/v2/releases/{namespace}/{release}/rollback`,
       payloadValidator: rollbackReleasePayloadValidator,
     })(async ({ cluster, params: { release, namespace }, payload }) => {
-    await helmService.rollback(cluster, release, namespace, payload.revision);
+      await rollbackRelease(cluster, release, namespace, payload.revision);
-  }),
+    });
+  },
 });
 
 export default rollbackReleaseRouteInjectable;

src/main/routes/helm/releases/update-release-route.injectable.ts

@@ -3,11 +3,11 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { apiPrefix } from "../../../../common/vars";
-import type { UpdateChartArgs } from "../../../helm/helm-service";
-import { helmService } from "../../../helm/helm-service";
 import { getRouteInjectable } from "../../../router/router.injectable";
 import { payloadValidatedClusterRoute } from "../../../router/route";
 import Joi from "joi";
+import type { UpdateChartArgs } from "../../../helm/helm-service/update-helm-release.injectable";
+import updateHelmReleaseInjectable from "../../../helm/helm-service/update-helm-release.injectable";
 
 const updateChartArgsValidator = Joi.object<UpdateChartArgs, true, UpdateChartArgs>({
   chart: Joi
@@ -24,18 +24,22 @@ const updateChartArgsValidator = Joi.object<UpdateChartArgs, true, UpdateChartAr
 const updateReleaseRouteInjectable = getRouteInjectable({
   id: "update-release-route",
 
-  instantiate: () => payloadValidatedClusterRoute({
+  instantiate: (di) => {
+    const updateRelease = di.inject(updateHelmReleaseInjectable);
+
+    return payloadValidatedClusterRoute({
       method: "put",
       path: `${apiPrefix}/v2/releases/{namespace}/{release}`,
       payloadValidator: updateChartArgsValidator,
     })(async ({ cluster, params, payload }) => ({
-    response: await helmService.updateRelease(
+      response: await updateRelease(
         cluster,
         params.release,
         params.namespace,
         payload,
       ),
-  })),
+    }));
+  },
 });
 
 export default updateReleaseRouteInjectable;