Move registerStore calls to after injectMany

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

extensions/kube-object-event-status/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kube-object-event-status",
-  "version": "0.0.1",
+  "version": "5.5.0-alpha.0.1650655975317",
   "description": "Adds kube object status from events",
   "renderer": "dist/renderer.js",
   "lens": {

extensions/metrics-cluster-feature/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lens-metrics-cluster-feature",
-  "version": "0.0.1",
+  "version": "5.5.0-alpha.0.1650655975317",
   "description": "Lens metrics cluster feature",
   "renderer": "dist/renderer.js",
   "lens": {

extensions/node-menu/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lens-node-menu",
-  "version": "0.0.1",
+  "version": "5.5.0-alpha.0.1650655975317",
   "description": "Lens node menu",
   "renderer": "dist/renderer.js",
   "lens": {

extensions/pod-menu/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lens-pod-menu",
-  "version": "0.0.1",
+  "version": "5.5.0-alpha.0.1650655975317",
   "description": "Lens pod menu",
   "renderer": "dist/renderer.js",
   "lens": {

package.json

@@ -3,7 +3,7 @@
   "productName": "OpenLens",
   "description": "OpenLens - Open Source IDE for Kubernetes",
   "homepage": "https://github.com/lensapp/lens",
-  "version": "5.5.0-alpha.0",
+  "version": "5.5.0-alpha.0.1650655975317",
   "main": "static/build/main.js",
   "copyright": "© 2021 OpenLens Authors",
   "license": "MIT",

src/common/k8s-api/api-manager/legacy-global.ts

@@ -1,11 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import { ApiManager } from "./api-manager";
-
-/**
- * @deprecated use `di.inject(apiManagerInjectable)` instead
- */
-export const apiManager = new ApiManager();

src/common/k8s-api/api-manager/manager.injectable.ts

@@ -2,16 +2,25 @@
  * 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 { getInjectable, getInjectionToken } from "@ogre-tools/injectable";
-import { apiManager } from "./legacy-global";
+import type { KubeObjectStore } from "../kube-object.store";
+import { ApiManager } from "./api-manager";
+
+export const kubeObjectStoreInjectionToken = getInjectionToken<KubeObjectStore<any, any, any>>({
+  id: "kube-object-store-token",
+});
 
 const apiManagerInjectable = getInjectable({
   id: "api-manager",
-  instantiate: () => {
+  instantiate: (di) => {
-    const a = apiManager;
+    const apiManager = new ApiManager();
+    const stores = di.injectMany(kubeObjectStoreInjectionToken);
 
-    // NOTE: this is to remove the deprecation notice
+    for (const store of stores) {
-    return a;
+      apiManager.registerStore(store);
+    }
+
+    return apiManager;
   },
 });
 

src/renderer/components/+cluster/cluster-overview-store/cluster-overview-store.injectable.ts

@@ -3,15 +3,11 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import type {
+
-  ClusterOverviewStorageState } from "./cluster-overview-store";
+import type { ClusterOverviewStorageState } from "./cluster-overview-store";
-import {
+import { ClusterOverviewStore, MetricNodeRole, MetricType } from "./cluster-overview-store";
-  ClusterOverviewStore,
-  MetricNodeRole,
-  MetricType,
-} from "./cluster-overview-store";
 import createStorageInjectable from "../../../utils/create-storage/create-storage.injectable";
-import apiManagerInjectable from "../../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/manager.injectable";
 import clusterApiInjectable from "../../../../common/k8s-api/endpoints/cluster.api.injectable";
 import createStoresAndApisInjectable from "../../../create-stores-apis.injectable";
 import assert from "assert";
@@ -24,24 +20,19 @@ const clusterOverviewStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "clusterOverviewStore is only available in certain environments");
     const createStorage = di.inject(createStorageInjectable);
     const clusterApi = di.inject(clusterApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
 
-    const storage = createStorage<ClusterOverviewStorageState>(
+    return new ClusterOverviewStore({
+      storage: createStorage<ClusterOverviewStorageState>(
         "cluster_overview",
         {
           metricType: MetricType.CPU, // setup defaults
           metricNodeRole: MetricNodeRole.WORKER,
         },
-    );
+      ),
-    const store = new ClusterOverviewStore({
-      storage,
       nodeStore: di.inject(nodeStoreInjectable),
     }, clusterApi);
-
-    apiManager.registerStore(store);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default clusterOverviewStoreInjectable;

src/renderer/components/+config-autoscalers/store.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import horizontalPodAutoscalerApiInjectable from "../../../common/k8s-api/endpoints/horizontal-pod-autoscaler.api.injectable";
 import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
 import { HorizontalPodAutoscalerStore } from "./store";
@@ -15,13 +15,10 @@ const horizontalPodAutoscalerStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "horizontalPodAutoscalerStore is only available in certain environments");
 
     const api = di.inject(horizontalPodAutoscalerApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
-    const store = new HorizontalPodAutoscalerStore(api);
 
-    apiManager.registerStore(store);
+    return new HorizontalPodAutoscalerStore(api);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default horizontalPodAutoscalerStoreInjectable;

src/renderer/components/+config-limit-ranges/store.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import limitRangeApiInjectable from "../../../common/k8s-api/endpoints/limit-range.api.injectable";
 import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
 import { LimitRangeStore } from "./store";
@@ -15,13 +15,10 @@ const limitRangeStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "limitRangeStore is only available in certain environments");
 
     const api = di.inject(limitRangeApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
-    const store = new LimitRangeStore(api);
 
-    apiManager.registerStore(store);
+    return new LimitRangeStore(api);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default limitRangeStoreInjectable;

src/renderer/components/+config-maps/store.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import configMapApiInjectable from "../../../common/k8s-api/endpoints/config-map.api.injectable";
 import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
 import { ConfigMapStore } from "./store";
@@ -15,13 +15,10 @@ const configMapStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "configMapStore is only available in certain environments");
 
     const api = di.inject(configMapApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
-    const store = new ConfigMapStore(api);
 
-    apiManager.registerStore(store);
+    return new ConfigMapStore(api);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default configMapStoreInjectable;

src/renderer/components/+config-pod-disruption-budgets/store.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import podDisruptionBudgetApiInjectable from "../../../common/k8s-api/endpoints/pod-disruption-budget.api.injectable";
 import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
 import { PodDisruptionBudgetStore } from "./store";
@@ -15,13 +15,10 @@ const podDisruptionBudgetStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "podDisruptionBudgetStore is only available in certain environments");
 
     const api = di.inject(podDisruptionBudgetApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
-    const store = new PodDisruptionBudgetStore(api);
 
-    apiManager.registerStore(store);
+    return new PodDisruptionBudgetStore(api);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default podDisruptionBudgetStoreInjectable;

src/renderer/components/+config-resource-quotas/store.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import resourceQuotaApiInjectable from "../../../common/k8s-api/endpoints/resource-quota.api.injectable";
 import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
 import { ResourceQuotaStore } from "./store";
@@ -15,13 +15,10 @@ const resourceQuotaStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "resourceQuotaStore is only available in certain environments");
 
     const api = di.inject(resourceQuotaApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
-    const store = new ResourceQuotaStore(api);
 
-    apiManager.registerStore(store);
+    return new ResourceQuotaStore(api);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default resourceQuotaStoreInjectable;

src/renderer/components/+config-secrets/store.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import secretApiInjectable from "../../../common/k8s-api/endpoints/secret.api.injectable";
 import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
 import { SecretStore } from "./store";
@@ -15,13 +15,10 @@ const secretStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "secretStore is only available in certain environments");
 
     const api = di.inject(secretApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
-    const store = new SecretStore(api);
 
-    apiManager.registerStore(store);
+    return new SecretStore(api);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default secretStoreInjectable;

src/renderer/components/+custom-resources/definition.store.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import customResourceDefinitionApiInjectable from "../../../common/k8s-api/endpoints/custom-resource-definition.api.injectable";
 import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
 import { CustomResourceDefinitionStore } from "./definition.store";
@@ -16,15 +16,12 @@ const customResourceDefinitionStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "customResourceDefinitionStore is only available in certain environments");
 
     const api = di.inject(customResourceDefinitionApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
+
-    const store = new CustomResourceDefinitionStore({
+    return new CustomResourceDefinitionStore({
       initCustomResourceStore: di.inject(initCustomResourceStoreInjectable),
     }, api);
-
-    apiManager.registerStore(store);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default customResourceDefinitionStoreInjectable;

src/renderer/components/+events/store.injectable.ts

@@ -5,7 +5,7 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import getPodByIdInjectable from "../+workloads-pods/get-pod-by-id.injectable";
-import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import kubeEventApiInjectable from "../../../common/k8s-api/endpoints/events.api.injectable";
 import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
 import { EventStore } from "./store";
@@ -16,15 +16,12 @@ const eventStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "eventStore is only available in certain environments");
 
     const api = di.inject(kubeEventApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
+
-    const store = new EventStore({
+    return new EventStore({
       getPodById: di.inject(getPodByIdInjectable),
     }, api);
-
-    apiManager.registerStore(store);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default eventStoreInjectable;

src/renderer/components/+namespaces/store.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import { NamespaceStore } from "./store";
-import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import createStorageInjectable from "../../utils/create-storage/create-storage.injectable";
 import namespaceApiInjectable from "../../../common/k8s-api/endpoints/namespace.api.injectable";
 import assert from "assert";
@@ -15,22 +15,15 @@ const namespaceStoreInjectable = getInjectable({
 
   instantiate: (di) => {
     assert(di.inject(createStoresAndApisInjectable), "namespaceStore is only available in certain environments");
+
     const createStorage = di.inject(createStorageInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
     const api = di.inject(namespaceApiInjectable);
 
-    const storage = createStorage<string[] | undefined>(
+    return new NamespaceStore({
-      "selected_namespaces",
+      storage: createStorage<string[] | undefined>("selected_namespaces", undefined),
-      undefined,
-    );
-    const store = new NamespaceStore({
-      storage,
     }, api);
-
-    apiManager.registerStore(store);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default namespaceStoreInjectable;

src/renderer/components/+network-endpoints/store.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import endpointsApiInjectable from "../../../common/k8s-api/endpoints/endpoint.api.injectable";
 import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
 import { EndpointsStore } from "./store";
@@ -15,13 +15,10 @@ const endpointsStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "endpointsStore is only available in certain environments");
 
     const api = di.inject(endpointsApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
-    const store = new EndpointsStore(api);
 
-    apiManager.registerStore(store);
+    return new EndpointsStore(api);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default endpointsStoreInjectable;

src/renderer/components/+network-policies/store.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import networkPolicyApiInjectable from "../../../common/k8s-api/endpoints/network-policy.api.injectable";
 import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
 import { NetworkPolicyStore } from "./store";
@@ -15,13 +15,10 @@ const networkPolicyStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "networkPolicyStore is only available in certain environments");
 
     const api = di.inject(networkPolicyApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
-    const store = new NetworkPolicyStore(api);
 
-    apiManager.registerStore(store);
+    return new NetworkPolicyStore(api);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default networkPolicyStoreInjectable;

src/renderer/components/+network-services/store.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import serviceApiInjectable from "../../../common/k8s-api/endpoints/service.api.injectable";
 import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
 import { ServiceStore } from "./store";
@@ -15,13 +15,10 @@ const serviceStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "serviceStore is only available in certain environments");
 
     const api = di.inject(serviceApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
-    const store = new ServiceStore(api);
 
-    apiManager.registerStore(store);
+    return new ServiceStore(api);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default serviceStoreInjectable;

src/renderer/components/+nodes/store.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import nodeApiInjectable from "../../../common/k8s-api/endpoints/node.api.injectable";
 import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
 import { NodeStore } from "./store";
@@ -15,13 +15,10 @@ const nodeStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "nodeStore is only available in certain environments");
 
     const api = di.inject(nodeApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
-    const store = new NodeStore(api);
 
-    apiManager.registerStore(store);
+    return new NodeStore(api);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default nodeStoreInjectable;

src/renderer/components/+pod-security-policies/store.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import podSecurityPolicyApiInjectable from "../../../common/k8s-api/endpoints/pod-security-policy.api.injectable";
 import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
 import { PodSecurityPolicyStore } from "./store";
@@ -15,13 +15,10 @@ const podSecurityPolicyStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "podSecurityPolicyStore is only available in certain environments");
 
     const api = di.inject(podSecurityPolicyApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
-    const store = new PodSecurityPolicyStore(api);
 
-    apiManager.registerStore(store);
+    return new PodSecurityPolicyStore(api);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default podSecurityPolicyStoreInjectable;

src/renderer/components/+storage-classes/store.injectable.ts

@@ -5,7 +5,7 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import getPersistentVolumesByStorageClassInjectable from "../+storage-volumes/get-persisten-volumes-by-storage-class.injectable";
-import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import storageClassApiInjectable from "../../../common/k8s-api/endpoints/storage-class.api.injectable";
 import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
 import { StorageClassStore } from "./store";
@@ -16,15 +16,12 @@ const storageClassStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "storageClassStore is only available in certain environments");
 
     const api = di.inject(storageClassApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
+
-    const store = new StorageClassStore({
+    return new StorageClassStore({
       getPersistentVolumesByStorageClass: di.inject(getPersistentVolumesByStorageClassInjectable),
     }, api);
-
-    apiManager.registerStore(store);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default storageClassStoreInjectable;

src/renderer/components/+storage-volume-claims/store.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import persistentVolumeClaimApiInjectable from "../../../common/k8s-api/endpoints/persistent-volume-claim.api.injectable";
 import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
 import { PersistentVolumeClaimStore } from "./store";
@@ -15,13 +15,10 @@ const persistentVolumeClaimStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "persistentVolumeClaimStore is only available in certain environments");
 
     const api = di.inject(persistentVolumeClaimApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
-    const store = new PersistentVolumeClaimStore(api);
 
-    apiManager.registerStore(store);
+    return new PersistentVolumeClaimStore(api);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default persistentVolumeClaimStoreInjectable;

src/renderer/components/+storage-volumes/store.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import persistentVolumeApiInjectable from "../../../common/k8s-api/endpoints/persistent-volume.api.injectable";
 import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
 import { PersistentVolumeStore } from "./store";
@@ -15,13 +15,10 @@ const persistentVolumeStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "persistentVolumeStore is only available in certain environments");
 
     const api = di.inject(persistentVolumeApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
-    const store = new PersistentVolumeStore(api);
 
-    apiManager.registerStore(store);
+    return new PersistentVolumeStore(api);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default persistentVolumeStoreInjectable;

src/renderer/components/+user-management/+cluster-role-bindings/store.injectable.ts

@@ -6,7 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { createStoresAndApisInjectionToken } from "../../../../common/k8s-api/create-stores-apis.token";
 import clusterRoleBindingApiInjectable from "../../../../common/k8s-api/endpoints/cluster-role-binding.api.injectable";
-import apiManagerInjectable from "../../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/manager.injectable";
 import { ClusterRoleBindingStore } from "./store";
 
 const clusterRoleBindingStoreInjectable = getInjectable({
@@ -15,13 +15,10 @@ const clusterRoleBindingStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectionToken), "clusterRoleBindingStore is only accessible in certain environments");
 
     const api = di.inject(clusterRoleBindingApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
-    const store = new ClusterRoleBindingStore(api);
 
-    apiManager.registerStore(store);
+    return new ClusterRoleBindingStore(api);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default clusterRoleBindingStoreInjectable;

src/renderer/components/+user-management/+cluster-roles/store.injectable.ts

@@ -6,7 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { createStoresAndApisInjectionToken } from "../../../../common/k8s-api/create-stores-apis.token";
 import clusterRoleApiInjectable from "../../../../common/k8s-api/endpoints/cluster-role.api.injectable";
-import apiManagerInjectable from "../../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/manager.injectable";
 import { ClusterRolesStore } from "./store";
 
 const clusterRoleStoreInjectable = getInjectable({
@@ -15,13 +15,10 @@ const clusterRoleStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectionToken), "clusterRoleStore is only available in certain environments");
 
     const api = di.inject(clusterRoleApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
-    const store = new ClusterRolesStore(api);
 
-    apiManager.registerStore(store);
+    return new ClusterRolesStore(api);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default clusterRoleStoreInjectable;

src/renderer/components/+user-management/+role-bindings/store.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import apiManagerInjectable from "../../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/manager.injectable";
 import roleBindingApiInjectable from "../../../../common/k8s-api/endpoints/role-binding.api.injectable";
 import createStoresAndApisInjectable from "../../../create-stores-apis.injectable";
 import { RoleBindingStore } from "./store";
@@ -15,13 +15,10 @@ const roleBindingStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "roleBindingStore is only available in certain environments");
 
     const api = di.inject(roleBindingApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
-    const store = new RoleBindingStore(api);
 
-    apiManager.registerStore(store);
+    return new RoleBindingStore(api);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default roleBindingStoreInjectable;

src/renderer/components/+user-management/+roles/store.injectable.ts

@@ -6,7 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import roleApiInjectable from "../../../../common/k8s-api/endpoints/role.api.injectable";
 import createStoresAndApisInjectable from "../../../create-stores-apis.injectable";
-import apiManagerInjectable from "../../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/manager.injectable";
 import { RoleStore } from "./store";
 
 const roleStoreInjectable = getInjectable({
@@ -15,13 +15,10 @@ const roleStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "roleStore is only available in certain environments");
 
     const api = di.inject(roleApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
-    const store = new RoleStore(api);
 
-    apiManager.registerStore(store);
+    return new RoleStore(api);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default roleStoreInjectable;

src/renderer/components/+user-management/+service-accounts/store.injectable.ts

@@ -6,7 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import serviceAccountApiInjectable from "../../../../common/k8s-api/endpoints/service-account.api.injectable";
 import createStoresAndApisInjectable from "../../../create-stores-apis.injectable";
-import apiManagerInjectable from "../../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/manager.injectable";
 import { ServiceAccountStore } from "./store";
 
 const serviceAccountStoreInjectable = getInjectable({
@@ -15,13 +15,10 @@ const serviceAccountStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "serviceAccountStore is only available in certain environments");
 
     const api = di.inject(serviceAccountApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
-    const store = new ServiceAccountStore(api);
 
-    apiManager.registerStore(store);
+    return new ServiceAccountStore(api);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default serviceAccountStoreInjectable;

src/renderer/components/+workloads-cronjobs/store.injectable.ts

@@ -5,7 +5,7 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import getJobsByOwnerInjectable from "../+workloads-jobs/get-jobs-by-owner.injectable";
-import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import cronJobApiInjectable from "../../../common/k8s-api/endpoints/cron-job.api.injectable";
 import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
 import { CronJobStore } from "./store";
@@ -16,15 +16,12 @@ const cronJobStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "cronJobStore is only available in certain environments");
 
     const api = di.inject(cronJobApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
+
-    const store = new CronJobStore({
+    return new CronJobStore({
       getJobsByOwner: di.inject(getJobsByOwnerInjectable),
     }, api);
-
-    apiManager.registerStore(store);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default cronJobStoreInjectable;

src/renderer/components/+workloads-daemonsets/store.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import getPodsByOwnerIdInjectable from "../+workloads-pods/get-pods-by-owner-id.injectable";
 import daemonSetApiInjectable from "../../../common/k8s-api/endpoints/daemon-set.api.injectable";
 import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
-import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import { DaemonSetStore } from "./store";
 
 const daemonSetStoreInjectable = getInjectable({
@@ -16,15 +16,12 @@ const daemonSetStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "daemonSetStore is only available in certain environments");
 
     const api = di.inject(daemonSetApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
+
-    const store = new DaemonSetStore({
+    return new DaemonSetStore({
       getPodsByOwnerId: di.inject(getPodsByOwnerIdInjectable),
     }, api);
-
-    apiManager.registerStore(store);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default daemonSetStoreInjectable;

src/renderer/components/+workloads-deployments/store.injectable.ts

@@ -5,7 +5,7 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import podStoreInjectable from "../+workloads-pods/store.injectable";
-import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import { createStoresAndApisInjectionToken } from "../../../common/k8s-api/create-stores-apis.token";
 import deploymentApiInjectable from "../../../common/k8s-api/endpoints/deployment.api.injectable";
 import { DeploymentStore } from "./store";
@@ -16,15 +16,12 @@ const deploymentStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectionToken), "deploymentStore is only available in certain environments");
 
     const api = di.inject(deploymentApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
+
-    const store = new DeploymentStore({
+    return new DeploymentStore({
       podStore: di.inject(podStoreInjectable),
     }, api);
-
-    apiManager.registerStore(store);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default deploymentStoreInjectable;

src/renderer/components/+workloads-jobs/store.injectable.ts

@@ -5,7 +5,7 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import getPodsByOwnerIdInjectable from "../+workloads-pods/get-pods-by-owner-id.injectable";
-import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import jobApiInjectable from "../../../common/k8s-api/endpoints/job.api.injectable";
 import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
 import { JobStore } from "./store";
@@ -16,15 +16,12 @@ const jobStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "jobStore is only available in certain environments");
 
     const api = di.inject(jobApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
+
-    const store = new JobStore({
+    return new JobStore({
       getPodsByOwnerId: di.inject(getPodsByOwnerIdInjectable),
     }, api);
-
-    apiManager.registerStore(store);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default jobStoreInjectable;

src/renderer/components/+workloads-pods/store.injectable.ts

@@ -6,7 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import podApiInjectable from "../../../common/k8s-api/endpoints/pod.api.injectable";
 import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
-import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import { PodStore } from "./store";
 import podMetricsApiInjectable from "../../../common/k8s-api/endpoints/pod-metrics.api.injectable";
 
@@ -16,15 +16,12 @@ const podStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "podStore is only available in certain environements");
 
     const api = di.inject(podApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
+
-    const store = new PodStore({
+    return new PodStore({
       podMetricsApi: di.inject(podMetricsApiInjectable),
     }, api);
-
-    apiManager.registerStore(store);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default podStoreInjectable;

src/renderer/components/+workloads-replicasets/store.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import getPodsByOwnerIdInjectable from "../+workloads-pods/get-pods-by-owner-id.injectable";
 import replicaSetApiInjectable from "../../../common/k8s-api/endpoints/replica-set.api.injectable";
 import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
-import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import { ReplicaSetStore } from "./store";
 
 const replicaSetStoreInjectable = getInjectable({
@@ -16,15 +16,12 @@ const replicaSetStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "replicaSetStore is only available in certain environments");
 
     const api = di.inject(replicaSetApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
+
-    const store = new ReplicaSetStore({
+    return new ReplicaSetStore({
       getPodsByOwnerId: di.inject(getPodsByOwnerIdInjectable),
     }, api);
-
-    apiManager.registerStore(store);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default replicaSetStoreInjectable;

src/renderer/components/+workloads-statefulsets/store.injectable.ts

@@ -5,7 +5,7 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import getPodsByOwnerIdInjectable from "../+workloads-pods/get-pods-by-owner-id.injectable";
-import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
+import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import statefulSetApiInjectable from "../../../common/k8s-api/endpoints/stateful-set.api.injectable";
 import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
 import { StatefulSetStore } from "./store";
@@ -16,15 +16,12 @@ const statefulSetStoreInjectable = getInjectable({
     assert(di.inject(createStoresAndApisInjectable), "statefulSetStore is only available in certain environment");
 
     const api = di.inject(statefulSetApiInjectable);
-    const apiManager = di.inject(apiManagerInjectable);
+
-    const store = new StatefulSetStore({
+    return new StatefulSetStore({
       getPodsByOwnerId: di.inject(getPodsByOwnerIdInjectable),
     }, api);
-
-    apiManager.registerStore(store);
-
-    return store;
   },
+  injectionToken: kubeObjectStoreInjectionToken,
 });
 
 export default statefulSetStoreInjectable;

src/renderer/components/input/search-input-url.tsx

@@ -45,10 +45,7 @@ class NonInjectedSearchInputUrl extends React.Component<SearchInputUrlProps & De
 
   onChange = (val: string, evt: React.ChangeEvent<any>) => {
     this.setValue(val);
-
+    this.props.onChange?.(val, evt);
-    if (this.props.onChange) {
-      this.props.onChange(val, evt);
-    }
   };
 
   constructor(props: SearchInputUrlProps & Dependencies) {
@@ -57,14 +54,17 @@ class NonInjectedSearchInputUrl extends React.Component<SearchInputUrlProps & De
   }
 
   render() {
-    const { inputVal } = this;
+    const { searchUrlParam, ...searchInputProps } = this.props;
 
     return (
       <SearchInput
-        value={inputVal}
+        value={this.inputVal}
-        onChange={this.onChange}
+        onChange={(val, event) => {
+          this.setValue(val);
+          this.props.onChange?.(val, event);
+        }}
         onClear={this.clear}
-        {...this.props}
+        {...searchInputProps}
       />
     );
   }

src/renderer/components/resource-metrics/resource-metrics.tsx

@@ -36,7 +36,8 @@ export const ResourceMetricsContext = createContext<ResourceMetricsValue | null>
 export function ResourceMetrics({ object, loader = noop, interval = 60, tabs, children, className, metrics }: ResourceMetricsProps) {
   const [tab, setTab] = useState<MetricsTab>(tabs[0]);
 
-  useEffect(loader, [object]);
+  // This is done just incase `loader` is actually something like `() => Promise<void>`
+  useEffect(() => void loader(), [object]);
   useInterval(loader, interval * 1000);
 
   const renderContents = () => {

src/renderer/components/select/select.tsx

@@ -69,7 +69,7 @@ function isGroup<Option, Group extends GroupBase<Option>>(optionOrGroup: Option
 
 const defaultFilter = createFilter({
   stringify(option) {
-    if (typeof option.data === "symbol") {
+    if (typeof option.value === "symbol") {
       return option.label;
     }