Fix type errors after upgrade

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

src/common/base-store.ts

@@ -31,7 +31,7 @@ export interface BaseStoreParams<T> extends ConfOptions<T> {
 /**
  * Note: T should only contain base JSON serializable types.
  */
-export abstract class BaseStore<T> extends Singleton {
+export abstract class BaseStore<T extends object> extends Singleton {
   protected storeConfig?: Config<T>;
   protected syncDisposers: Disposer[] = [];
 

src/common/get-configuration-file-model/get-configuration-file-model.injectable.ts

@@ -8,7 +8,7 @@ import type { BaseStoreParams } from "../base-store";
 
 const getConfigurationFileModelInjectable = getInjectable({
   id: "get-configuration-file-model",
-  instantiate: () => <ConfigurationContent>(content: BaseStoreParams<ConfigurationContent>) => new Config(content),
+  instantiate: () => <T extends object>(content: BaseStoreParams<T>) => new Config(content),
   causesSideEffects: true,
 });
 

src/common/k8s-api/endpoints/metrics.api.ts

@@ -7,7 +7,6 @@
 
 import moment from "moment";
 import { apiBase } from "../index";
-import type { IMetricsQuery } from "../../../main/routes/metrics/metrics-query";
 
 export interface MetricData {
   status: string;
@@ -55,28 +54,33 @@ export interface IResourceMetrics<T extends MetricData> {
   networkTransmit: T;
 }
 
+async function getMetrics(query: string, reqParams?: IMetricsReqParams): Promise<MetricData>;
+async function getMetrics(query: string[], reqParams?: IMetricsReqParams): Promise<MetricData[]>;
+async function getMetrics<MetricNames extends string>(query: Record<MetricNames, Partial<Record<string, string>>>, reqParams?: IMetricsReqParams): Promise<Record<MetricNames, MetricData>>;
+
+async function getMetrics(query: string | string[] | Partial<Record<string, Partial<Record<string, string>>>>, reqParams: IMetricsReqParams = {}): Promise<MetricData | MetricData[] | Partial<Record<string, MetricData>>> {
+  const { range = 3600, step = 60, namespace } = reqParams;
+  let { start, end } = reqParams;
+
+  if (!start && !end) {
+    const timeNow = Date.now() / 1000;
+    const now = moment.unix(timeNow).startOf("minute").unix();  // round date to minutes
+
+    start = now - range;
+    end = now;
+  }
+
+  return apiBase.post("/metrics", {
+    data: query,
+    query: {
+      start, end, step,
+      "kubernetes_namespace": namespace,
+    },
+  });
+}
+
 export const metricsApi = {
-  async getMetrics<T = IMetricsQuery>(query: T, reqParams: IMetricsReqParams = {}): Promise<T extends object ? { [K in keyof T]: MetricData } : MetricData> {
-    const { range = 3600, step = 60, namespace } = reqParams;
-    let { start, end } = reqParams;
-
-    if (!start && !end) {
-      const timeNow = Date.now() / 1000;
-      const now = moment.unix(timeNow).startOf("minute").unix();  // round date to minutes
-
-      start = now - range;
-      end = now;
-    }
-
-    return apiBase.post("/metrics", {
-      data: query,
-      query: {
-        start, end, step,
-        "kubernetes_namespace": namespace,
-      },
-    });
-  },
-
+  getMetrics,
   async getMetricProviders(): Promise<MetricProviderInfo[]> {
     return apiBase.get("/metrics/providers");
   },

src/common/protocol-handler/router.ts

@@ -113,7 +113,17 @@ export abstract class LensProtocolRouter {
     }
 
     // if no exact match pick the one that is the most specific
-    return matches.sort(([a], [b]) => compareMatches(a, b))[0] ?? null;
+    return matches.sort(([a], [b]) => {
+      if (a.path === "/") {
+        return 1;
+      }
+
+      if (b.path === "/") {
+        return -1;
+      }
+
+      return countBy(b.path)["/"] - countBy(a.path)["/"];
+    })[0] ?? null;
   }
 
   /**
@@ -265,21 +275,3 @@ export abstract class LensProtocolRouter {
     this.internalRoutes.delete(urlSchema);
   }
 }
-
-/**
- * a comparison function for `array.sort(...)`. Sort order should be most path
- * parts to least path parts.
- * @param a the left side to compare
- * @param b the right side to compare
- */
-function compareMatches<T>(a: match<T>, b: match<T>): number {
-  if (a.path === "/") {
-    return 1;
-  }
-
-  if (b.path === "/") {
-    return -1;
-  }
-
-  return countBy(b.path)["/"] - countBy(a.path)["/"];
-}

src/common/utils/readableStream.ts

@@ -4,6 +4,7 @@
  */
 
 import { Readable } from "readable-stream";
+import type { ReadableStreamDefaultReadResult } from "stream/web";
 import type { TypedArray } from "type-fest";
 
 /**

src/common/utils/singleton.ts

@@ -27,7 +27,7 @@ export class Singleton {
    * @param args The constructor arguments for the child class
    * @returns An instance of the child class
    */
-  static createInstance<T, R extends any[]>(this: StaticThis<T, R>, ...args: R): T {
+  static createInstance<T extends Singleton, R extends any[]>(this: StaticThis<T, R>, ...args: R): T {
     if (!Singleton.instances.has(this)) {
       if (Singleton.creating.length > 0) {
         throw new TypeError(`Cannot create a second singleton (${this.name}) while creating a first (${Singleton.creating})`);

src/extensions/as-legacy-globals-for-extension-api/as-legacy-global-object-for-extension-api-with-modifications.ts

@@ -9,7 +9,7 @@ import type { Injectable } from "@ogre-tools/injectable";
  * @deprecated use asLegacyGlobalForExtensionApi instead, and use proper implementations instead of "modifications".
  */
 export const asLegacyGlobalObjectForExtensionApiWithModifications = <
-  InjectableInstance extends InjectionTokenInstance,
+  InjectableInstance extends InjectionTokenInstance & object,
   InjectionTokenInstance,
   ModificationObject extends object,
 >(

src/extensions/extension-store.ts

@@ -8,7 +8,7 @@ import * as path from "path";
 import type { LensExtension } from "./lens-extension";
 import assert from "assert";
 
-export abstract class ExtensionStore<T> extends BaseStore<T> {
+export abstract class ExtensionStore<T extends object> extends BaseStore<T> {
   readonly displayName = "ExtensionStore<T>";
   protected extension?: LensExtension;
 

src/main/routes/metrics/add-metrics-route.injectable.ts

@@ -9,7 +9,6 @@ import type { ClusterPrometheusMetadata } from "../../../common/cluster-types";
 import { ClusterMetadataKey } from "../../../common/cluster-types";
 import logger from "../../logger";
 import type { Cluster } from "../../../common/cluster/cluster";
-import type { IMetricsQuery } from "./metrics-query";
 import { clusterRoute } from "../../router/route";
 import { isObject } from "lodash";
 import { isRequestError } from "../../../common/utils";
@@ -60,7 +59,7 @@ const addMetricsRouteInjectable = getRouteInjectable({
     const getMetrics = di.inject(getMetricsInjectable);
     const loadMetrics = loadMetricsFor(getMetrics);
 
-    const queryParams: IMetricsQuery = Object.fromEntries(query.entries());
+    const queryParams = Object.fromEntries(query.entries());
     const prometheusMetadata: ClusterPrometheusMetadata = {};
 
     try {

src/main/routes/metrics/metrics-query.ts

@@ -1,7 +0,0 @@
-/**
- * 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;
-};

src/renderer/api/helpers/watch-for-general-entity-navigation.injectable.ts

@@ -4,6 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import { reaction, when } from "mobx";
+import type { GeneralEntity } from "../../../common/catalog-entities";
 import generalCategoryInjectable from "../../../common/catalog/categories/general.injectable";
 import isActiveRouteInjectable from "../../navigation/is-route-active.injectable";
 import observableHistoryInjectable from "../../navigation/observable-history.injectable";
@@ -30,7 +31,7 @@ const watchForGeneralEntityNavigationInjectable = getInjectable({
           dispose.push(reaction(
             () => observableHistory.location,
             () => {
-              const entities = entityRegistry.getItemsForCategory(generalCategory);
+              const entities = entityRegistry.getItemsForCategory(generalCategory) as GeneralEntity[];
               const activeEntity = entities.find(entity => isActiveRoute(entity.spec.path));
 
               if (activeEntity) {

src/renderer/navigation/index.ts

@@ -5,7 +5,6 @@
 
 import { asLegacyGlobalFunctionForExtensionApi } from "../../extensions/as-legacy-globals-for-extension-api/as-legacy-global-function-for-extension-api";
 import { asLegacyGlobalForExtensionApi } from "../../extensions/as-legacy-globals-for-extension-api/as-legacy-global-object-for-extension-api";
-import matchRouteInjectable from "./match-route.injectable";
 import navigateInjectable from "./navigate.injectable";
 import observableHistoryInjectable from "./observable-history.injectable";
 
@@ -21,9 +20,4 @@ export const navigation = asLegacyGlobalForExtensionApi(observableHistoryInjecta
  */
 export const navigate = asLegacyGlobalFunctionForExtensionApi(navigateInjectable);
 
-/**
- * @deprecated use `di.inject(matchRouteInjectable)` instead
- */
-export const matchRoute = asLegacyGlobalFunctionForExtensionApi(matchRouteInjectable);
-
 export * from "./page-param";

src/renderer/navigation/match-route.injectable.ts

@@ -7,7 +7,7 @@ import type { match, RouteProps } from "react-router";
 import { matchPath } from "react-router";
 import observableHistoryInjectable from "./observable-history.injectable";
 
-export type MatchRoute = <Params>(route: string | string[] | RouteProps) => match<Params> | null;
+export type MatchRoute = <Params extends { [K in keyof Params]?: string }>(route: string | string[] | RouteProps) => match<Params> | null;
 
 const matchRouteInjectable = getInjectable({
   id: "match-route",

src/renderer/utils/storageHelper.ts

@@ -9,6 +9,7 @@ import type { Draft } from "immer";
 import { produce, isDraft } from "immer";
 import { isEqual, isPlainObject } from "lodash";
 import logger from "../../main/logger";
+import assert from "assert";
 
 export interface StorageChange<T> {
   key: string;
@@ -154,8 +155,9 @@ export class StorageHelper<T> implements StorageLayer<T> {
   }
 
   @action
-  merge(value: Partial<T> | ((draft: Draft<T>) => Partial<T> | void)) {
+  merge(value: T extends object ? Partial<T> | ((draft: Draft<T>) => Partial<T> | void) : never) {
     const nextValue = produce<T>(toJS(this.get()), (draft) => {
+      assert(typeof draft === "object" && draft);
 
       if (typeof value == "function") {
         const newValue = value(draft);