Switch main's route handlers to be static functions (#2712)

src/main/routes/helm-route.ts

@@ -1,143 +1,141 @@
 import { LensApiRequest } from "../router";
 import { helmService } from "../helm/helm-service";
-import { LensApi } from "../lens-api";
+import { respondJson, respondText } from "../utils/http-responses";
 import logger from "../logger";
 
-class HelmApiRoute extends LensApi {
-  public async listCharts(request: LensApiRequest) {
+export class HelmApiRoute {
+  static async listCharts(request: LensApiRequest) {
     const { response } = request;
     const charts = await helmService.listCharts();
 
-    this.respondJson(response, charts);
+    respondJson(response, charts);
   }
 
-  public async getChart(request: LensApiRequest) {
+  static async getChart(request: LensApiRequest) {
     const { params, query, response } = request;
 
     try {
       const chart = await helmService.getChart(params.repo, params.chart, query.get("version"));
 
-      this.respondJson(response, chart);
+      respondJson(response, chart);
     } catch (error) {
-      this.respondText(response, error, 422);
+      respondText(response, error, 422);
     }
   }
 
-  public async getChartValues(request: LensApiRequest) {
+  static async getChartValues(request: LensApiRequest) {
     const { params, query, response } = request;
 
     try {
       const values = await helmService.getChartValues(params.repo, params.chart, query.get("version"));
 
-      this.respondJson(response, values);
+      respondJson(response, values);
     } catch (error) {
-      this.respondText(response, error, 422);
+      respondText(response, error, 422);
     }
   }
 
-  public async installChart(request: LensApiRequest) {
+  static async installChart(request: LensApiRequest) {
     const { payload, cluster, response } = request;
 
     try {
       const result = await helmService.installChart(cluster, payload);
 
-      this.respondJson(response, result, 201);
+      respondJson(response, result, 201);
     } catch (error) {
       logger.debug(error);
-      this.respondText(response, error, 422);
+      respondText(response, error, 422);
     }
   }
 
-  public async updateRelease(request: LensApiRequest) {
+  static async updateRelease(request: LensApiRequest) {
     const { cluster, params, payload, response } = request;
 
     try {
       const result = await helmService.updateRelease(cluster, params.release, params.namespace, payload );
 
-      this.respondJson(response, result);
+      respondJson(response, result);
     } catch (error) {
       logger.debug(error);
-      this.respondText(response, error, 422);
+      respondText(response, error, 422);
     }
   }
 
-  public async rollbackRelease(request: LensApiRequest) {
+  static async rollbackRelease(request: LensApiRequest) {
     const { cluster, params, payload, response } = request;
 
     try {
       const result = await helmService.rollback(cluster, params.release, params.namespace, payload.revision);
 
-      this.respondJson(response, result);
+      respondJson(response, result);
     } catch (error) {
       logger.debug(error);
-      this.respondText(response, error, 422);
+      respondText(response, error, 422);
     }
   }
 
-  public async listReleases(request: LensApiRequest) {
+  static async listReleases(request: LensApiRequest) {
     const { cluster, params, response } = request;
 
     try {
       const result = await helmService.listReleases(cluster, params.namespace);
 
-      this.respondJson(response, result);
+      respondJson(response, result);
     } catch(error) {
       logger.debug(error);
-      this.respondText(response, error, 422);
+      respondText(response, error, 422);
     }
   }
 
-  public async getRelease(request: LensApiRequest) {
+  static async getRelease(request: LensApiRequest) {
     const { cluster, params, response } = request;
 
     try {
       const result = await helmService.getRelease(cluster, params.release, params.namespace);
 
-      this.respondJson(response, result);
+      respondJson(response, result);
     } catch (error) {
       logger.debug(error);
-      this.respondText(response, error, 422);
+      respondText(response, error, 422);
     }
   }
 
-  public async getReleaseValues(request: LensApiRequest) {
+  static async getReleaseValues(request: LensApiRequest) {
     const { cluster, params, response, query } = request;
 
     try {
       const result = await helmService.getReleaseValues(cluster, params.release, params.namespace, query.has("all"));
 
-      this.respondText(response, result);
+      respondText(response, result);
     } catch (error) {
       logger.debug(error);
-      this.respondText(response, error, 422);
+      respondText(response, error, 422);
     }
   }
 
-  public async getReleaseHistory(request: LensApiRequest) {
+  static async getReleaseHistory(request: LensApiRequest) {
     const { cluster, params, response } = request;
 
     try {
       const result = await helmService.getReleaseHistory(cluster, params.release, params.namespace);
 
-      this.respondJson(response, result);
+      respondJson(response, result);
     } catch (error) {
       logger.debug(error);
-      this.respondText(response, error, 422);
+      respondText(response, error, 422);
     }
   }
 
-  public async deleteRelease(request: LensApiRequest) {
+  static async deleteRelease(request: LensApiRequest) {
     const { cluster, params, response } = request;
 
     try {
       const result = await helmService.deleteRelease(cluster, params.release, params.namespace);
 
-      this.respondJson(response, result);
+      respondJson(response, result);
     } catch (error) {
       logger.debug(error);
-      this.respondText(response, error, 422);
+      respondText(response, error, 422);
     }
   }
 }
-
-export const helmRoute = new HelmApiRoute();

src/main/routes/kubeconfig-route.ts

@@ -1,5 +1,5 @@
 import { LensApiRequest } from "../router";
-import { LensApi } from "../lens-api";
+import { respondJson } from "../utils/http-responses";
 import { Cluster } from "../cluster";
 import { CoreV1Api, V1Secret } from "@kubernetes/client-node";
 
@@ -40,9 +40,8 @@ function generateKubeConfig(username: string, secret: V1Secret, cluster: Cluster
   };
 }
 
-class KubeconfigRoute extends LensApi {
-
-  public async routeServiceAccountRoute(request: LensApiRequest) {
+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);
@@ -53,8 +52,6 @@ class KubeconfigRoute extends LensApi {
     });
     const data = generateKubeConfig(params.account, secret, cluster);
 
-    this.respondJson(response, data);
+    respondJson(response, data);
   }
 }
-
-export const kubeconfigRoute = new KubeconfigRoute();

src/main/routes/metrics-route.ts

@@ -1,6 +1,6 @@
 import _ from "lodash";
 import { LensApiRequest } from "../router";
-import { LensApi } from "../lens-api";
+import { respondJson } from "../utils/http-responses";
 import { Cluster, ClusterMetadataKey } from "../cluster";
 import { ClusterPrometheusMetadata } from "../../common/cluster-store";
 import logger from "../logger";
@@ -41,8 +41,8 @@ async function loadMetrics(promQueries: string[], cluster: Cluster, prometheusPa
   return Promise.all(queries.map(loadMetric));
 }
 
-class MetricsRoute extends LensApi {
-  async routeMetrics({ response, cluster, payload, query }: LensApiRequest) {
+export class MetricsRoute {
+  static async routeMetrics({ response, cluster, payload, query }: LensApiRequest) {
     const queryParams: IMetricsQuery = Object.fromEntries(query.entries());
     const prometheusMetadata: ClusterPrometheusMetadata = {};
 
@@ -57,20 +57,19 @@ class MetricsRoute extends LensApi {
 
       if (!prometheusPath) {
         prometheusMetadata.success = false;
-        this.respondJson(response, {});
 
-        return;
+        return respondJson(response, {});
       }
 
       // return data in same structure as query
       if (typeof payload === "string") {
         const [data] = await loadMetrics([payload], cluster, prometheusPath, queryParams);
 
-        this.respondJson(response, data);
+        respondJson(response, data);
       } else if (Array.isArray(payload)) {
         const data = await loadMetrics(payload, cluster, prometheusPath, queryParams);
 
-        this.respondJson(response, data);
+        respondJson(response, data);
       } else {
         const queries = Object.entries(payload).map(([queryName, queryOpts]) => (
           (prometheusProvider.getQueries(queryOpts) as Record<string, string>)[queryName]
@@ -78,16 +77,14 @@ class MetricsRoute extends LensApi {
         const result = await loadMetrics(queries, cluster, prometheusPath, queryParams);
         const data = Object.fromEntries(Object.keys(payload).map((metricName, i) => [metricName, result[i]]));
 
-        this.respondJson(response, data);
+        respondJson(response, data);
       }
       prometheusMetadata.success = true;
     } catch {
       prometheusMetadata.success = false;
-      this.respondJson(response, {});
+      respondJson(response, {});
     } finally {
       cluster.metadata[ClusterMetadataKey.PROMETHEUS] = prometheusMetadata;
     }
   }
 }
-
-export const metricsRoute = new MetricsRoute();

src/main/routes/port-forward-route.ts

@@ -1,11 +1,11 @@
 import { LensApiRequest } from "../router";
-import { LensApi } from "../lens-api";
 import { spawn, ChildProcessWithoutNullStreams } from "child_process";
 import { Kubectl } from "../kubectl";
 import { shell } from "electron";
 import * as tcpPortUsed from "tcp-port-used";
 import logger from "../logger";
 import { getPortFrom } from "../utils/get-port";
+import { respondJson } from "../utils/http-responses";
 
 interface PortForwardArgs {
   clusterId: string;
@@ -95,9 +95,8 @@ class PortForward {
   }
 }
 
-class PortForwardRoute extends LensApi {
-
-  public async routePortForward(request: LensApiRequest) {
+export class PortForwardRoute {
+  static async routePortForward(request: LensApiRequest) {
     const { params, response, cluster} = request;
     const { namespace, port, resourceType, resourceName } = params;
     let portForward = PortForward.getPortforward({
@@ -117,18 +116,14 @@ class PortForwardRoute extends LensApi {
       const started = await portForward.start();
 
       if (!started) {
-        this.respondJson(response, {
+        return respondJson(response, {
           message: "Failed to open port-forward"
         }, 400);
-
-        return;
       }
     }
 
     portForward.open();
 
-    this.respondJson(response, {});
+    respondJson(response, {});
   }
 }
-
-export const portForwardRoute = new PortForwardRoute();

src/main/routes/resource-applier-route.ts

@@ -1,19 +1,17 @@
 import { LensApiRequest } from "../router";
-import { LensApi } from "../lens-api";
+import { respondJson, respondText } from "../utils/http-responses";
 import { ResourceApplier } from "../resource-applier";
 
-class ResourceApplierApiRoute extends LensApi {
-  public async applyResource(request: LensApiRequest) {
+export class ResourceApplierApiRoute {
+  static async applyResource(request: LensApiRequest) {
     const { response, cluster, payload } = request;
 
     try {
       const resource = await new ResourceApplier(cluster).apply(payload);
 
-      this.respondJson(response, [resource], 200);
+      respondJson(response, [resource], 200);
     } catch (error) {
-      this.respondText(response, error, 422);
+      respondText(response, error, 422);
     }
   }
 }
-
-export const resourceApplierRoute = new ResourceApplierApiRoute();

src/main/routes/version-route.ts

@@ -1,13 +1,11 @@
 import { LensApiRequest } from "../router";
-import { LensApi } from "../lens-api";
+import { respondJson } from "../utils/http-responses";
 import { getAppVersion } from "../../common/utils";
 
-class VersionRoute extends LensApi {
-  public async getVersion(request: LensApiRequest) {
+export class VersionRoute {
+  static async getVersion(request: LensApiRequest) {
     const { response } = request;
 
-    this.respondJson(response, { version: getAppVersion()}, 200);
+    respondJson(response, { version: getAppVersion()}, 200);
   }
 }
-
-export const versionRoute = new VersionRoute();