Make routes in back-end comply to Open Closed Principle (#4859)

* Make registration of back-end routes happen using injectable Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Switch to using injectable to setup route for list charts Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Switch to using injectable to setup route for get chart Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Switch to using injectable to setup route for get chart values Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Switch to using injectable to setup route for installing chart Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Switch to using injectable to setup route for updating release Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Switch to using injectable to setup route for rollbacking release Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Switch to using injectable to setup route for listing releases Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Switch to using injectable to setup route for getting release Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Switch to using injectable to setup route for getting release values Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Switch to using injectable to setup route for getting release history Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Switch to using injectable to setup route for deleting release Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Remove HelmRoute for not being used anymore Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Switch to using injectable to setup route for applying resource Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Switch to using injectable to setup route for patching resource Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Switch to using injectable to setup route for stopping current port forward Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Switch to using injectable to setup route for getting current port forward Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Consolidate start port forward route to use injection token for registering route Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Switch to using injectable to setup route for metrics Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Switch to using injectable to setup route for getting service account Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Switch to using injectable to setup route for getting version Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Add global override for reading file to make it not required where not interesting Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Switch to using injectable to setup route for serving static files Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Make adding routes private for router Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Make routes wait until all asynchronous stuff are done Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Introduce healthy abstraction between back-end routes and route handlers Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Make response of route typed Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Fix incorrect return value of updateRelease Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Make typing of routes support synchronous values Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Make code cleaner Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Rename test for accuracy Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Add test for throwing route handler Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Remove duplicate license header Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Make mechanism of creating HTTP response an implementation detail Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Remove not needed properties from test Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Fix code style Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Fix typing and codestyle Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Fix typing error Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Fix merge conflicts Signed-off-by: Janne Savolainen <janne.savolainen@live.fi> * Organize all router related files under directory Signed-off-by: Janne Savolainen <janne.savolainen@live.fi>
2025-05-20 05:10:56 +00:00 · 2022-03-11 12:20:00 +02:00
1 parent 772e879b81
commit 38af26efc9
@@ -1,148 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import type { LensApiRequest } from "../router";
-import { helmService } from "../helm/helm-service";
-import logger from "../logger";
-import { respondJson, respondText } from "../utils/http-responses";
-import { getBoolean } from "../utils/parse-query";
-
-export class HelmApiRoute {
-  static async listCharts(request: LensApiRequest) {
-    const { response } = request;
-    const charts = await helmService.listCharts();
-
-    respondJson(response, charts);
-  }
-
-  static async getChart(request: LensApiRequest) {
-    const { params, query, response } = request;
-
-    try {
-      const chart = await helmService.getChart(params.repo, params.chart, query.get("version"));
-
-      respondJson(response, chart);
-    } catch (error) {
-      respondText(response, error?.toString() || "Error getting chart", 422);
-    }
-  }
-
-  static async getChartValues(request: LensApiRequest) {
-    const { params, query, response } = request;
-
-    try {
-      const values = await helmService.getChartValues(params.repo, params.chart, query.get("version"));
-
-      respondJson(response, values);
-    } catch (error) {
-      respondText(response, error?.toString() || "Error getting chart values", 422);
-    }
-  }
-
-  static async installChart(request: LensApiRequest) {
-    const { payload, cluster, response } = request;
-
-    try {
-      const result = await helmService.installChart(cluster, payload);
-
-      respondJson(response, result, 201);
-    } catch (error) {
-      logger.debug(error);
-      respondText(response, error?.toString() || "Error installing chart", 422);
-    }
-  }
-
-  static async updateRelease(request: LensApiRequest) {
-    const { cluster, params, payload, response } = request;
-
-    try {
-      const result = await helmService.updateRelease(cluster, params.release, params.namespace, payload );
-
-      respondJson(response, result);
-    } catch (error) {
-      logger.debug(error);
-      respondText(response, error?.toString() || "Error updating chart", 422);
-    }
-  }
-
-  static async rollbackRelease(request: LensApiRequest) {
-    const { cluster, params, payload, response } = request;
-
-    try {
-      await helmService.rollback(cluster, params.release, params.namespace, payload.revision);
-
-      response.end();
-    } catch (error) {
-      logger.debug(error);
-      respondText(response, error?.toString() || "Error rolling back chart", 422);
-    }
-  }
-
-  static async listReleases(request: LensApiRequest) {
-    const { cluster, params, response } = request;
-
-    try {
-      const result = await helmService.listReleases(cluster, params.namespace);
-
-      respondJson(response, result);
-    } catch(error) {
-      logger.debug(error);
-      respondText(response, error?.toString() || "Error listing release", 422);
-    }
-  }
-
-  static async getRelease(request: LensApiRequest) {
-    const { cluster, params, response } = request;
-
-    try {
-      const result = await helmService.getRelease(cluster, params.release, params.namespace);
-
-      respondJson(response, result);
-    } catch (error) {
-      logger.debug(error);
-      respondText(response, error?.toString() || "Error getting release", 422);
-    }
-  }
-
-  static async getReleaseValues(request: LensApiRequest) {
-    const { cluster, params: { namespace, release }, response, query } = request;
-    const all = getBoolean(query, "all");
-
-    try {
-      const result = await helmService.getReleaseValues(release, { cluster, namespace, all });
-
-      respondText(response, result);
-    } catch (error) {
-      logger.debug(error);
-      respondText(response, error?.toString() || "Error getting release values", 422);
-    }
-  }
-
-  static async getReleaseHistory(request: LensApiRequest) {
-    const { cluster, params, response } = request;
-
-    try {
-      const result = await helmService.getReleaseHistory(cluster, params.release, params.namespace);
-
-      respondJson(response, result);
-    } catch (error) {
-      logger.debug(error);
-      respondText(response, error?.toString() || "Error getting release history", 422);
-    }
-  }
-
-  static async deleteRelease(request: LensApiRequest) {
-    const { cluster, params, response } = request;
-
-    try {
-      const result = await helmService.deleteRelease(cluster, params.release, params.namespace);
-
-      respondJson(response, result);
-    } catch (error) {
-      logger.debug(error);
-      respondText(response, error?.toString() || "Error deleting release", 422);
-    }
-  }
-}
@@ -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 { routeInjectionToken } from "../../../router/router.injectable";
+import type { Route } from "../../../router/router";
+import { helmService } from "../../../helm/helm-service";
+import { apiPrefix } from "../../../../common/vars";
+import type { RawHelmChart } from "../../../../common/k8s-api/endpoints/helm-charts.api";
+
+interface GetChartResponse {
+  readme: string;
+  versions: RawHelmChart[];
+}
+
+const getChartRouteInjectable = getInjectable({
+  id: "get-chart-route",
+
+  instantiate: (): Route<GetChartResponse> => ({
+    method: "get",
+    path: `${apiPrefix}/v2/charts/{repo}/{chart}`,
+
+    handler: async ({ params, query }) => ({
+      response: await helmService.getChart(
+        params.repo,
+        params.chart,
+        query.get("version"),
+      ),
+    }),
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default getChartRouteInjectable;
@@ -0,0 +1,33 @@
+/**
+ * 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 { routeInjectionToken } from "../../../router/router.injectable";
+import type { Route } from "../../../router/router";
+import { helmService } from "../../../helm/helm-service";
+import { apiPrefix } from "../../../../common/vars";
+
+const getChartRouteValuesInjectable = getInjectable({
+  id: "get-chart-route-values",
+
+  instantiate: (): Route<string> => ({
+    method: "get",
+    path: `${apiPrefix}/v2/charts/{repo}/{chart}/values`,
+
+    handler: async ({
+      params,
+      query,
+    }) => ({
+      response: await helmService.getChartValues(
+        params.repo,
+        params.chart,
+        query.get("version"),
+      ),
+    }),
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default getChartRouteValuesInjectable;
@@ -0,0 +1,26 @@
+/**
+ * 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 { routeInjectionToken } from "../../../router/router.injectable";
+import type { Route } from "../../../router/router";
+import { helmService } from "../../../helm/helm-service";
+import { apiPrefix } from "../../../../common/vars";
+
+const listChartsRouteInjectable = getInjectable({
+  id: "list-charts-route",
+
+  instantiate: (): Route<any> => ({
+    method: "get",
+    path: `${apiPrefix}/v2/charts`,
+
+    handler: async () => ({
+      response: await helmService.listCharts(),
+    }),
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default listChartsRouteInjectable;
@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { apiPrefix } from "../../../../common/vars";
+import type { Route } from "../../../router/router";
+import { helmService } from "../../../helm/helm-service";
+import { routeInjectionToken } from "../../../router/router.injectable";
+import { getInjectable } from "@ogre-tools/injectable";
+
+const deleteReleaseRouteInjectable = getInjectable({
+  id: "delete-release-route",
+
+  instantiate: (): Route<string> => ({
+    method: "delete",
+    path: `${apiPrefix}/v2/releases/{namespace}/{release}`,
+
+    handler: async (request) => {
+      const { cluster, params } = request;
+
+      return {
+        response: await helmService.deleteRelease(
+          cluster,
+          params.release,
+          params.namespace,
+        ),
+      };
+    },
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default deleteReleaseRouteInjectable;
@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { apiPrefix } from "../../../../common/vars";
+import type { Route } from "../../../router/router";
+import { helmService } from "../../../helm/helm-service";
+import { routeInjectionToken } from "../../../router/router.injectable";
+import { getInjectable } from "@ogre-tools/injectable";
+
+const getReleaseRouteHistoryInjectable = getInjectable({
+  id: "get-release-history-route",
+
+  instantiate: (): Route<any> => ({
+    method: "get",
+    path: `${apiPrefix}/v2/releases/{namespace}/{release}/history`,
+
+    handler: async (request) => {
+      const { cluster, params } = request;
+
+      return {
+        response: await helmService.getReleaseHistory(
+          cluster,
+          params.release,
+          params.namespace,
+        ),
+      };
+    },
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default getReleaseRouteHistoryInjectable;
@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { apiPrefix } from "../../../../common/vars";
+import type { Route } from "../../../router/router";
+import { helmService } from "../../../helm/helm-service";
+import { routeInjectionToken } from "../../../router/router.injectable";
+import { getInjectable } from "@ogre-tools/injectable";
+
+const getReleaseRouteInjectable = getInjectable({
+  id: "get-release-route",
+
+  instantiate: (): Route<any> => ({
+    method: "get",
+    path: `${apiPrefix}/v2/releases/{namespace}/{release}`,
+
+    handler: async (request) => {
+      const { cluster, params } = request;
+
+      return {
+        response: await helmService.getRelease(
+          cluster,
+          params.release,
+          params.namespace,
+        ),
+      };
+    },
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default getReleaseRouteInjectable;
@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { apiPrefix } from "../../../../common/vars";
+import type { Route } from "../../../router/router";
+import { helmService } from "../../../helm/helm-service";
+import { routeInjectionToken } from "../../../router/router.injectable";
+import { getInjectable } from "@ogre-tools/injectable";
+import { getBoolean } from "../../../utils/parse-query";
+import { contentTypes } from "../../../router/router-content-types";
+
+const getReleaseRouteValuesInjectable = getInjectable({
+  id: "get-release-values-route",
+
+  instantiate: (): Route<string> => ({
+    method: "get",
+    path: `${apiPrefix}/v2/releases/{namespace}/{release}/values`,
+
+    handler: async (request) => {
+      const { cluster, params: { namespace, release }, query } = request;
+      const all = getBoolean(query, "all");
+
+      return {
+        response: await helmService.getReleaseValues(release, {
+          cluster,
+          namespace,
+          all,
+        }),
+
+        contentType: contentTypes.txt,
+      };
+    },
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default getReleaseRouteValuesInjectable;
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { apiPrefix } from "../../../../common/vars";
+import type { Route } from "../../../router/router";
+import { helmService } from "../../../helm/helm-service";
+import { routeInjectionToken } from "../../../router/router.injectable";
+import { getInjectable } from "@ogre-tools/injectable";
+
+interface InstallChartResponse {
+  log: string;
+  release: { name: string; namespace: string };
+}
+
+const installChartRouteInjectable = getInjectable({
+  id: "install-chart-route",
+
+  instantiate: () : Route<InstallChartResponse> => ({
+    method: "post",
+    path: `${apiPrefix}/v2/releases`,
+
+    handler: async (request) => {
+      const { payload, cluster } = request;
+
+      return {
+        response: await helmService.installChart(cluster, payload),
+        statusCode: 201,
+      };
+    },
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default installChartRouteInjectable;
@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { apiPrefix } from "../../../../common/vars";
+import type { Route } from "../../../router/router";
+import { helmService } from "../../../helm/helm-service";
+import { routeInjectionToken } from "../../../router/router.injectable";
+import { getInjectable } from "@ogre-tools/injectable";
+
+const listReleasesRouteInjectable = getInjectable({
+  id: "list-releases-route",
+
+  instantiate: (): Route<Record<string, any>> => ({
+    method: "get",
+    path: `${apiPrefix}/v2/releases/{namespace?}`,
+
+    handler: async (request) => {
+      const { cluster, params } = request;
+
+      return {
+        response: await helmService.listReleases(cluster, params.namespace),
+      };
+    },
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default listReleasesRouteInjectable;
@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { apiPrefix } from "../../../../common/vars";
+import type { Route } from "../../../router/router";
+import { helmService } from "../../../helm/helm-service";
+import { routeInjectionToken } from "../../../router/router.injectable";
+import { getInjectable } from "@ogre-tools/injectable";
+
+const rollbackReleaseRouteInjectable = getInjectable({
+  id: "rollback-release-route",
+
+  instantiate: (): Route<void> => ({
+    method: "put",
+    path: `${apiPrefix}/v2/releases/{namespace}/{release}/rollback`,
+
+    handler: async (request) => {
+      const { cluster, params, payload } = request;
+
+      await helmService.rollback(cluster, params.release, params.namespace, payload.revision);
+    },
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default rollbackReleaseRouteInjectable;
@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { apiPrefix } from "../../../../common/vars";
+import type { Route } from "../../../router/router";
+import { helmService } from "../../../helm/helm-service";
+import { routeInjectionToken } from "../../../router/router.injectable";
+import { getInjectable } from "@ogre-tools/injectable";
+
+interface UpdateReleaseResponse {
+  log: string;
+  release: { name: string; namespace: string };
+}
+
+const updateReleaseRouteInjectable = getInjectable({
+  id: "update-release-route",
+
+  instantiate: (): Route<UpdateReleaseResponse> => ({
+    method: "put",
+    path: `${apiPrefix}/v2/releases/{namespace}/{release}`,
+
+    handler: async ({
+      cluster,
+      params,
+      payload,
+    }) => ({
+      response: await helmService.updateRelease(
+        cluster,
+        params.release,
+        params.namespace,
+        payload,
+      ),
+    }),
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default updateReleaseRouteInjectable;
@@ -1,11 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-export * from "./kubeconfig-route";
-export * from "./metrics-route";
-export * from "./port-forward-route";
-export * from "./helm-route";
-export * from "./resource-applier-route";
-export * from "./version-route";
@@ -1,62 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import type { LensApiRequest } from "../router";
-import { respondJson } from "../utils/http-responses";
-import type { Cluster } from "../../common/cluster/cluster";
-import { CoreV1Api, V1Secret } from "@kubernetes/client-node";
-
-function generateKubeConfig(username: string, secret: V1Secret, cluster: Cluster) {
-  const tokenData = Buffer.from(secret.data["token"], "base64");
-
-  return {
-    "apiVersion": "v1",
-    "kind": "Config",
-    "clusters": [
-      {
-        "name": cluster.contextName,
-        "cluster": {
-          "server": cluster.apiUrl,
-          "certificate-authority-data": secret.data["ca.crt"],
-        },
-      },
-    ],
-    "users": [
-      {
-        "name": username,
-        "user": {
-          "token": tokenData.toString("utf8"),
-        },
-      },
-    ],
-    "contexts": [
-      {
-        "name": cluster.contextName,
-        "context": {
-          "user": username,
-          "cluster": cluster.contextName,
-          "namespace": secret.metadata.namespace,
-        },
-      },
-    ],
-    "current-context": cluster.contextName,
-  };
-}
-
-export class KubeconfigRoute {
-  static async routeServiceAccountRoute(request: LensApiRequest) {
-    const { params, response, cluster } = request;
-    const client = (await cluster.getProxyKubeconfig()).makeApiClient(CoreV1Api);
-    const secretList = await client.listNamespacedSecret(params.namespace);
-    const secret = secretList.body.items.find(secret => {
-      const { annotations } = secret.metadata;
-
-      return annotations && annotations["kubernetes.io/service-account.name"] == params.account;
-    });
-    const data = generateKubeConfig(params.account, secret, cluster);
-
-    respondJson(response, data);
-  }
-}
@@ -0,0 +1,75 @@
+/**
+ * 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 { apiPrefix } from "../../../common/vars";
+import type { Route } from "../../router/router";
+import { routeInjectionToken } from "../../router/router.injectable";
+import type { Cluster } from "../../../common/cluster/cluster";
+import { CoreV1Api, V1Secret } from "@kubernetes/client-node";
+
+const getServiceAccountRouteInjectable = getInjectable({
+  id: "get-service-account-route",
+
+  instantiate: (): Route<ReturnType<typeof generateKubeConfig>> => ({
+    method: "get",
+    path: `${apiPrefix}/kubeconfig/service-account/{namespace}/{account}`,
+
+    handler: async (request) => {
+      const { params, cluster } = request;
+      const client = (await cluster.getProxyKubeconfig()).makeApiClient(CoreV1Api);
+      const secretList = await client.listNamespacedSecret(params.namespace);
+
+      const secret = secretList.body.items.find(secret => {
+        const { annotations } = secret.metadata;
+
+        return annotations && annotations["kubernetes.io/service-account.name"] == params.account;
+      });
+
+      return { response: generateKubeConfig(params.account, secret, cluster) };
+    },
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default getServiceAccountRouteInjectable;
+
+function generateKubeConfig(username: string, secret: V1Secret, cluster: Cluster) {
+  const tokenData = Buffer.from(secret.data["token"], "base64");
+
+  return {
+    "apiVersion": "v1",
+    "kind": "Config",
+    "clusters": [
+      {
+        "name": cluster.contextName,
+        "cluster": {
+          "server": cluster.apiUrl,
+          "certificate-authority-data": secret.data["ca.crt"],
+        },
+      },
+    ],
+    "users": [
+      {
+        "name": username,
+        "user": {
+          "token": tokenData.toString("utf8"),
+        },
+      },
+    ],
+    "contexts": [
+      {
+        "name": cluster.contextName,
+        "context": {
+          "user": username,
+          "cluster": cluster.contextName,
+          "namespace": secret.metadata.namespace,
+        },
+      },
+    ],
+    "current-context": cluster.contextName,
+  };
+}
@@ -1,109 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import type { LensApiRequest } from "../router";
-import { respondJson } from "../utils/http-responses";
-import type { Cluster } from "../../common/cluster/cluster";
-import { ClusterMetadataKey, ClusterPrometheusMetadata } from "../../common/cluster-types";
-import logger from "../logger";
-import { getMetrics } from "../k8s-request";
-import { PrometheusProviderRegistry } from "../prometheus";
-
-export type IMetricsQuery = string | string[] | {
-  [metricName: string]: string;
-};
-
-// This is used for backoff retry tracking.
-const ATTEMPTS = [false, false, false, false, true];
-
-// prometheus metrics loader
-async function loadMetrics(promQueries: string[], cluster: Cluster, prometheusPath: string, queryParams: Record<string, string>): Promise<any[]> {
-  const queries = promQueries.map(p => p.trim());
-  const loaders = new Map<string, Promise<any>>();
-
-  async function loadMetric(query: string): Promise<any> {
-    async function loadMetricHelper(): Promise<any> {
-      for (const [attempt, lastAttempt] of ATTEMPTS.entries()) { // retry
-        try {
-          return await getMetrics(cluster, prometheusPath, { query, ...queryParams });
-        } catch (error) {
-          if (lastAttempt || (error?.statusCode >= 400 && error?.statusCode < 500)) {
-            logger.error("[Metrics]: metrics not available", error?.response ? error.response?.body : error);
-            throw new Error("Metrics not available");
-          }
-
-          await new Promise(resolve => setTimeout(resolve, (attempt + 1) * 1000)); // add delay before repeating request
-        }
-      }
-    }
-
-    return loaders.get(query) ?? loaders.set(query, loadMetricHelper()).get(query);
-  }
-
-  return Promise.all(queries.map(loadMetric));
-}
-
-interface MetricProviderInfo {
-  name: string;
-  id: string;
-  isConfigurable: boolean;
-}
-
-export class MetricsRoute {
-  static async routeMetrics({ response, cluster, payload, query }: LensApiRequest) {
-    const queryParams: IMetricsQuery = Object.fromEntries(query.entries());
-    const prometheusMetadata: ClusterPrometheusMetadata = {};
-
-    try {
-      const { prometheusPath, provider } = await cluster.contextHandler.getPrometheusDetails();
-
-      prometheusMetadata.provider = provider?.id;
-      prometheusMetadata.autoDetected = !cluster.preferences.prometheusProvider?.type;
-
-      if (!prometheusPath) {
-        prometheusMetadata.success = false;
-
-        return respondJson(response, {});
-      }
-
-      // return data in same structure as query
-      if (typeof payload === "string") {
-        const [data] = await loadMetrics([payload], cluster, prometheusPath, queryParams);
-
-        respondJson(response, data);
-      } else if (Array.isArray(payload)) {
-        const data = await loadMetrics(payload, cluster, prometheusPath, queryParams);
-
-        respondJson(response, data);
-      } else {
-        const queries = Object.entries<Record<string, string>>(payload)
-          .map(([queryName, queryOpts]) => (
-            provider.getQuery(queryOpts, queryName)
-          ));
-        const result = await loadMetrics(queries, cluster, prometheusPath, queryParams);
-        const data = Object.fromEntries(Object.keys(payload).map((metricName, i) => [metricName, result[i]]));
-
-        respondJson(response, data);
-      }
-      prometheusMetadata.success = true;
-    } catch (error) {
-      prometheusMetadata.success = false;
-      respondJson(response, {});
-      logger.warn(`[METRICS-ROUTE]: failed to get metrics for clusterId=${cluster.id}:`, error);
-    } finally {
-      cluster.metadata[ClusterMetadataKey.PROMETHEUS] = prometheusMetadata;
-    }
-  }
-
-  static async routeMetricsProviders({ response }: LensApiRequest) {
-    const providers: MetricProviderInfo[] = [];
-
-    for (const { name, id, isConfigurable } of PrometheusProviderRegistry.getInstance().providers.values()) {
-      providers.push({ name, id, isConfigurable });
-    }
-
-    respondJson(response, providers);
-  }
-}
@@ -0,0 +1,108 @@
+/**
+ * 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 { apiPrefix } from "../../../common/vars";
+import type { LensApiRequest, Route } from "../../router/router";
+import { routeInjectionToken } from "../../router/router.injectable";
+import { ClusterMetadataKey, ClusterPrometheusMetadata } from "../../../common/cluster-types";
+import logger from "../../logger";
+import type { Cluster } from "../../../common/cluster/cluster";
+import { getMetrics } from "../../k8s-request";
+import type { IMetricsQuery } from "./metrics-query";
+
+// This is used for backoff retry tracking.
+const ATTEMPTS = [false, false, false, false, true];
+
+async function loadMetrics(promQueries: string[], cluster: Cluster, prometheusPath: string, queryParams: Record<string, string>): Promise<any[]> {
+  const queries = promQueries.map(p => p.trim());
+  const loaders = new Map<string, Promise<any>>();
+
+  async function loadMetric(query: string): Promise<any> {
+    async function loadMetricHelper(): Promise<any> {
+      for (const [attempt, lastAttempt] of ATTEMPTS.entries()) { // retry
+        try {
+          return await getMetrics(cluster, prometheusPath, { query, ...queryParams });
+        } catch (error) {
+          if (lastAttempt || (error?.statusCode >= 400 && error?.statusCode < 500)) {
+            logger.error("[Metrics]: metrics not available", error?.response ? error.response?.body : error);
+            throw new Error("Metrics not available");
+          }
+
+          await new Promise(resolve => setTimeout(resolve, (attempt + 1) * 1000)); // add delay before repeating request
+        }
+      }
+    }
+
+    return loaders.get(query) ?? loaders.set(query, loadMetricHelper()).get(query);
+  }
+
+  return Promise.all(queries.map(loadMetric));
+}
+
+const addMetricsRoute = async ({ cluster, payload, query }: LensApiRequest) => {
+  const queryParams: IMetricsQuery = Object.fromEntries(query.entries());
+  const prometheusMetadata: ClusterPrometheusMetadata = {};
+
+  try {
+    const { prometheusPath, provider } = await cluster.contextHandler.getPrometheusDetails();
+
+    prometheusMetadata.provider = provider?.id;
+    prometheusMetadata.autoDetected = !cluster.preferences.prometheusProvider?.type;
+
+    if (!prometheusPath) {
+      prometheusMetadata.success = false;
+
+      return { response: {}};
+    }
+
+    // return data in same structure as query
+    if (typeof payload === "string") {
+      const [data] = await loadMetrics([payload], cluster, prometheusPath, queryParams);
+
+      return { response: data };
+    }
+
+    if (Array.isArray(payload)) {
+      const data = await loadMetrics(payload, cluster, prometheusPath, queryParams);
+
+      return { response: data };
+    }
+
+    const queries = Object.entries<Record<string, string>>(payload)
+      .map(([queryName, queryOpts]) => (
+        provider.getQuery(queryOpts, queryName)
+      ));
+
+    const result = await loadMetrics(queries, cluster, prometheusPath, queryParams);
+    const data = Object.fromEntries(Object.keys(payload).map((metricName, i) => [metricName, result[i]]));
+
+    prometheusMetadata.success = true;
+
+    return { response: data };
+  } catch (error) {
+    prometheusMetadata.success = false;
+
+    logger.warn(`[METRICS-ROUTE]: failed to get metrics for clusterId=${cluster.id}:`, error);
+
+    return { response: {}};
+  } finally {
+    cluster.metadata[ClusterMetadataKey.PROMETHEUS] = prometheusMetadata;
+  }
+};
+
+const addMetricsRouteInjectable = getInjectable({
+  id: "add-metrics-route",
+
+  instantiate: (): Route<any> => ({
+    method: "post",
+    path: `${apiPrefix}/metrics`,
+    handler: addMetricsRoute,
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default addMetricsRouteInjectable;
@@ -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 { apiPrefix } from "../../../common/vars";
+import type { Route } from "../../router/router";
+import { routeInjectionToken } from "../../router/router.injectable";
+import { PrometheusProviderRegistry } from "../../prometheus";
+import type { MetricProviderInfo } from "../../../common/k8s-api/endpoints/metrics.api";
+
+const getMetricProvidersRouteInjectable = getInjectable({
+  id: "get-metric-providers-route",
+
+  instantiate: (): Route<MetricProviderInfo[]> => ({
+    method: "get",
+    path: `${apiPrefix}/metrics/providers`,
+
+    handler: () => {
+      const providers: MetricProviderInfo[] = [];
+
+      for (const { name, id, isConfigurable } of PrometheusProviderRegistry.getInstance().providers.values()) {
+        providers.push({ name, id, isConfigurable });
+      }
+
+      return { response: providers };
+    },
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default getMetricProvidersRouteInjectable;
@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+export type IMetricsQuery = string | string[] | {
+  [metricName: string]: string;
+};
@@ -1,48 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import type { LensApiRequest } from "../router";
-import logger from "../logger";
-import { respondJson } from "../utils/http-responses";
-import { PortForward } from "./port-forward/port-forward";
-
-export class PortForwardRoute {
-  static async routeCurrentPortForward(request: LensApiRequest) {
-    const { params, query, response, cluster } = request;
-    const { namespace, resourceType, resourceName } = params;
-    const port = Number(query.get("port"));
-    const forwardPort = Number(query.get("forwardPort"));
-
-    const portForward = PortForward.getPortforward({
-      clusterId: cluster.id, kind: resourceType, name: resourceName,
-      namespace, port, forwardPort,
-    });
-
-    respondJson(response, { port: portForward?.forwardPort ?? null });
-  }
-
-  static async routeCurrentPortForwardStop(request: LensApiRequest) {
-    const { params, query, response, cluster } = request;
-    const { namespace, resourceType, resourceName } = params;
-    const port = Number(query.get("port"));
-    const forwardPort = Number(query.get("forwardPort"));
-
-    const portForward = PortForward.getPortforward({
-      clusterId: cluster.id, kind: resourceType, name: resourceName,
-      namespace, port, forwardPort,
-    });
-
-    try {
-      await portForward.stop();
-      respondJson(response, { status: true });
-    } catch (error) {
-      logger.error("[PORT-FORWARD-ROUTE]: error stopping a port-forward", { namespace, port, forwardPort, resourceType, resourceName });
-
-      return respondJson(response, {
-        message: `error stopping a forward port ${port}`,
-      }, 400);
-    }
-  }
-}
@@ -4,7 +4,7 @@
 */
 import { getInjectable } from "@ogre-tools/injectable";
 import { PortForward, PortForwardArgs } from "./port-forward";
-import bundledKubectlInjectable from "../../kubectl/bundled-kubectl.injectable";
+import bundledKubectlInjectable from "../../../kubectl/bundled-kubectl.injectable";

 const createPortForwardInjectable = getInjectable({
  id: "create-port-forward",
@@ -2,8 +2,8 @@
 * Copyright (c) OpenLens Authors. All rights reserved.
 * Licensed under MIT License. See LICENSE in root directory for more information.
 */
-import logger from "../../logger";
-import { getPortFrom } from "../../utils/get-port";
+import logger from "../../../logger";
+import { getPortFrom } from "../../../utils/get-port";
 import { spawn, ChildProcessWithoutNullStreams } from "child_process";
 import * as tcpPortUsed from "tcp-port-used";

@@ -0,0 +1,37 @@
+/**
+ * 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 { routeInjectionToken } from "../../router/router.injectable";
+import type { LensApiRequest, Route } from "../../router/router";
+import { apiPrefix } from "../../../common/vars";
+import { PortForward } from "./functionality/port-forward";
+
+const getCurrentPortForward = async (request: LensApiRequest) => {
+  const { params, query, cluster } = request;
+  const { namespace, resourceType, resourceName } = params;
+  const port = Number(query.get("port"));
+  const forwardPort = Number(query.get("forwardPort"));
+
+  const portForward = PortForward.getPortforward({
+    clusterId: cluster.id, kind: resourceType, name: resourceName,
+    namespace, port, forwardPort,
+  });
+
+  return { response: { port: portForward?.forwardPort ?? null }};
+};
+
+const getCurrentPortForwardRouteInjectable = getInjectable({
+  id: "get-current-port-forward-route",
+
+  instantiate: (): Route<{ port: number }> => ({
+    method: "get",
+    path: `${apiPrefix}/pods/port-forward/{namespace}/{resourceType}/{resourceName}`,
+    handler: getCurrentPortForward,
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default getCurrentPortForwardRouteInjectable;
@@ -1,17 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { routePortForward } from "./route-port-forward";
-import { getInjectable } from "@ogre-tools/injectable";
-import createPortForwardInjectable from "../create-port-forward.injectable";
-
-const routePortForwardInjectable = getInjectable({
-  id: "route-port-forward",
-
-  instantiate: (di) => routePortForward({
-    createPortForward: di.inject(createPortForwardInjectable),
-  }),
-});
-
-export default routePortForwardInjectable;
@@ -1,86 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import type { LensApiRequest } from "../../../router";
-import logger from "../../../logger";
-import { respondJson } from "../../../utils/http-responses";
-import { PortForward, PortForwardArgs } from "../port-forward";
-
-interface Dependencies {
-  createPortForward: (pathToKubeConfig: string, args: PortForwardArgs) => PortForward;
-}
-
-export const routePortForward =
-  ({ createPortForward }: Dependencies) =>
-    async (request: LensApiRequest) => {
-      const { params, query, response, cluster } = request;
-      const { namespace, resourceType, resourceName } = params;
-      const port = Number(query.get("port"));
-      const forwardPort = Number(query.get("forwardPort"));
-
-      try {
-        let portForward = PortForward.getPortforward({
-          clusterId: cluster.id,
-          kind: resourceType,
-          name: resourceName,
-          namespace,
-          port,
-          forwardPort,
-        });
-
-        if (!portForward) {
-          logger.info(
-            `Creating a new port-forward ${namespace}/${resourceType}/${resourceName}:${port}`,
-          );
-
-          const thePort =
-          0 < forwardPort && forwardPort < 65536 ? forwardPort : 0;
-
-          portForward = createPortForward(await cluster.getProxyKubeconfigPath(), {
-            clusterId: cluster.id,
-            kind: resourceType,
-            namespace,
-            name: resourceName,
-            port,
-            forwardPort: thePort,
-          });
-
-          const started = await portForward.start();
-
-          if (!started) {
-            logger.error("[PORT-FORWARD-ROUTE]: failed to start a port-forward", {
-              namespace,
-              port,
-              resourceType,
-              resourceName,
-            });
-
-            return respondJson(
-              response,
-              {
-                message: `Failed to forward port ${port} to ${
-                  thePort ? forwardPort : "random port"
-                }`,
-              },
-              400,
-            );
-          }
-        }
-
-        respondJson(response, { port: portForward.forwardPort });
-      } catch (error) {
-        logger.error(
-          `[PORT-FORWARD-ROUTE]: failed to open a port-forward: ${error}`,
-          { namespace, port, resourceType, resourceName },
-        );
-
-        return respondJson(
-          response,
-          {
-            message: `Failed to forward port ${port}`,
-          },
-          400,
-        );
-      }
-    };
@@ -0,0 +1,97 @@
+/**
+ * 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 { routeInjectionToken } from "../../router/router.injectable";
+import type { LensApiRequest, Route } from "../../router/router";
+import { apiPrefix } from "../../../common/vars";
+import { PortForward, PortForwardArgs } from "./functionality/port-forward";
+import logger from "../../logger";
+import createPortForwardInjectable from "./functionality/create-port-forward.injectable";
+
+interface Dependencies {
+  createPortForward: (pathToKubeConfig: string, args: PortForwardArgs) => PortForward;
+}
+
+const startPortForward = ({ createPortForward }: Dependencies) => async (request: LensApiRequest) => {
+  const { params, query, cluster } = request;
+  const { namespace, resourceType, resourceName } = params;
+  const port = Number(query.get("port"));
+  const forwardPort = Number(query.get("forwardPort"));
+
+  try {
+    let portForward = PortForward.getPortforward({
+      clusterId: cluster.id,
+      kind: resourceType,
+      name: resourceName,
+      namespace,
+      port,
+      forwardPort,
+    });
+
+    if (!portForward) {
+      logger.info(
+        `Creating a new port-forward ${namespace}/${resourceType}/${resourceName}:${port}`,
+      );
+
+      const thePort =
+          0 < forwardPort && forwardPort < 65536 ? forwardPort : 0;
+
+      portForward = createPortForward(await cluster.getProxyKubeconfigPath(), {
+        clusterId: cluster.id,
+        kind: resourceType,
+        namespace,
+        name: resourceName,
+        port,
+        forwardPort: thePort,
+      });
+
+      const started = await portForward.start();
+
+      if (!started) {
+        logger.error("[PORT-FORWARD-ROUTE]: failed to start a port-forward", {
+          namespace,
+          port,
+          resourceType,
+          resourceName,
+        });
+
+        return {
+          error: {
+            message: `Failed to forward port ${port} to ${
+              thePort ? forwardPort : "random port"
+            }`,
+          },
+        };
+      }
+    }
+
+    return { response: { port: portForward.forwardPort }};
+  } catch (error) {
+    logger.error(
+      `[PORT-FORWARD-ROUTE]: failed to open a port-forward: ${error}`,
+      { namespace, port, resourceType, resourceName },
+    );
+
+    return {
+      error: {
+        message: `Failed to forward port ${port}`,
+      },
+    };
+  }
+};
+
+const startPortForwardRouteInjectable = getInjectable({
+  id: "start-current-port-forward-route",
+
+  instantiate: (di): Route<{ port: number }> => ({
+    method: "post",
+    path: `${apiPrefix}/pods/port-forward/{namespace}/{resourceType}/{resourceName}`,
+    handler: startPortForward({ createPortForward: di.inject(createPortForwardInjectable) }),
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default startPortForwardRouteInjectable;
@@ -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 { routeInjectionToken } from "../../router/router.injectable";
+import type { LensApiRequest, Route } from "../../router/router";
+import { apiPrefix } from "../../../common/vars";
+import { PortForward } from "./functionality/port-forward";
+import logger from "../../logger";
+
+const stopCurrentPortForward = async (request: LensApiRequest) => {
+  const { params, query, cluster } = request;
+  const { namespace, resourceType, resourceName } = params;
+  const port = Number(query.get("port"));
+  const forwardPort = Number(query.get("forwardPort"));
+
+  const portForward = PortForward.getPortforward({
+    clusterId: cluster.id, kind: resourceType, name: resourceName,
+    namespace, port, forwardPort,
+  });
+
+  try {
+    await portForward.stop();
+
+    return { response: { status: true }};
+  } catch (error) {
+    logger.error("[PORT-FORWARD-ROUTE]: error stopping a port-forward", { namespace, port, forwardPort, resourceType, resourceName });
+
+    return {
+      error: {
+        message: `error stopping a forward port ${port}`,
+      },
+    };
+
+  }
+};
+
+const stopCurrentPortForwardRouteInjectable = getInjectable({
+  id: "stop-current-port-forward-route",
+
+  instantiate: (): Route<{ status: boolean }> => ({
+    method: "delete",
+    path: `${apiPrefix}/pods/port-forward/{namespace}/{resourceType}/{resourceName}`,
+    handler: stopCurrentPortForward,
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default stopCurrentPortForwardRouteInjectable;
@@ -1,34 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import type { LensApiRequest } from "../router";
-import { respondJson, respondText } from "../utils/http-responses";
-import { ResourceApplier } from "../resource-applier";
-
-export class ResourceApplierApiRoute {
-  static async applyResource(request: LensApiRequest) {
-    const { response, cluster, payload } = request;
-
-    try {
-      const resource = await new ResourceApplier(cluster).apply(payload);
-
-      respondJson(response, resource, 200);
-    } catch (error) {
-      respondText(response, error, 422);
-    }
-  }
-
-  static async patchResource(request: LensApiRequest) {
-    const { response, cluster, payload } = request;
-
-    try {
-      const resource = await new ResourceApplier(cluster).patch(payload.name, payload.kind, payload.patch, payload.ns);
-
-      respondJson(response, resource, 200);
-    } catch (error) {
-      respondText(response, error, 422);
-    }
-  }
-}
@@ -0,0 +1,26 @@
+/**
+ * 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 { routeInjectionToken } from "../../router/router.injectable";
+import type { Route } from "../../router/router";
+import { apiPrefix } from "../../../common/vars";
+import { ResourceApplier } from "../../resource-applier";
+
+const applyResourceRouteInjectable = getInjectable({
+  id: "apply-resource-route",
+
+  instantiate: (): Route<string> => ({
+    method: "post",
+    path: `${apiPrefix}/stack`,
+
+    handler: async ({ cluster, payload }) => ({
+      response: await new ResourceApplier(cluster).apply(payload),
+    }),
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default applyResourceRouteInjectable;
@@ -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 { routeInjectionToken } from "../../router/router.injectable";
+import type { Route } from "../../router/router";
+import { apiPrefix } from "../../../common/vars";
+import { ResourceApplier } from "../../resource-applier";
+
+const patchResourceRouteInjectable = getInjectable({
+  id: "patch-resource-route",
+
+  instantiate: (): Route<string> => ({
+    method: "patch",
+    path: `${apiPrefix}/stack`,
+
+    handler: async ({ cluster, payload }) => ({
+      response: await new ResourceApplier(cluster).patch(
+        payload.name,
+        payload.kind,
+        payload.patch,
+        payload.ns,
+      ),
+    }),
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default patchResourceRouteInjectable;
@@ -0,0 +1,94 @@
+/**
+ * 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 { LensApiRequest, Route } from "../router/router";
+import { contentTypes, SupportedFileExtension } from "../router/router-content-types";
+import logger from "../logger";
+import { routeInjectionToken } from "../router/router.injectable";
+import { appName, publicPath } from "../../common/vars";
+import path from "path";
+import readFileInjectable from "../../common/fs/read-file.injectable";
+import isDevelopmentInjectable from "../../common/vars/is-development.injectable";
+import httpProxy from "http-proxy";
+
+interface ProductionDependencies {
+  readFile: (path: string) => Promise<Buffer>;
+}
+
+const handleStaticFileInProduction =
+  ({ readFile }: ProductionDependencies) =>
+    async ({ params }: LensApiRequest) => {
+      const staticPath = path.resolve(__static);
+      let filePath = params.path;
+
+      for (let retryCount = 0; retryCount < 5; retryCount += 1) {
+        const asset = path.join(staticPath, filePath);
+        const normalizedFilePath = path.resolve(asset);
+
+        if (!normalizedFilePath.startsWith(staticPath)) {
+          return { statusCode: 404 };
+        }
+
+        try {
+          const fileExtension = path
+            .extname(asset)
+            .slice(1) as SupportedFileExtension;
+
+          const contentType = contentTypes[fileExtension] || contentTypes.txt;
+
+          return { response: await readFile(asset), contentType };
+        } catch (err) {
+          if (retryCount > 5) {
+            logger.error("handleStaticFile:", err.toString());
+
+            return { statusCode: 404 };
+          }
+
+          filePath = `${publicPath}/${appName}.html`;
+        }
+      }
+
+      return { statusCode: 404 };
+    };
+
+interface DevelopmentDependencies {
+  proxy: httpProxy;
+}
+
+const handleStaticFileInDevelopment =
+  ({ proxy }: DevelopmentDependencies) =>
+    (apiReq: LensApiRequest) => {
+      const { req, res } = apiReq.raw;
+
+      if (req.url === "/" || !req.url.startsWith("/build/")) {
+        req.url = `${publicPath}/${appName}.html`;
+      }
+
+      proxy.web(req, res, {
+        target: "http://127.0.0.1:8080",
+      });
+
+      return { proxy };
+    };
+
+const staticFileRouteInjectable = getInjectable({
+  id: "static-file-route",
+
+  instantiate: (di): Route<Buffer> => {
+    const isDevelopment = di.inject(isDevelopmentInjectable);
+
+    return {
+      method: "get",
+      path: `/{path*}`,
+      handler: isDevelopment
+        ? handleStaticFileInDevelopment({ proxy: httpProxy.createProxy() })
+        : handleStaticFileInProduction({ readFile: di.inject(readFileInjectable) }),
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default staticFileRouteInjectable;
@@ -1,16 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import type { LensApiRequest } from "../router";
-import { respondJson } from "../utils/http-responses";
-import { getAppVersion } from "../../common/utils";
-
-export class VersionRoute {
-  static async getVersion(request: LensApiRequest) {
-    const { response } = request;
-
-    respondJson(response, { version: getAppVersion() }, 200);
-  }
-}
@@ -0,0 +1,23 @@
+/**
+ * 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 { Route } from "../../router/router";
+import { routeInjectionToken } from "../../router/router.injectable";
+import { getAppVersion } from "../../../common/utils";
+
+const getVersionRouteInjectable = getInjectable({
+  id: "get-version-route",
+
+  instantiate: (): Route<{ version: string }> => ({
+    method: "get",
+    path: `/version`,
+
+    handler: () => ({ response: { version: getAppVersion() }}),
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default getVersionRouteInjectable;