chore: Extract specific KubeApi injectables to own package

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

package-lock.json

@@ -35793,8 +35793,11 @@
         "@k8slens/typescript": "^6.5.0-alpha.2"
       },
       "peerDependencies": {
+        "@k8slens/feature-core": "^6.5.0-alpha.8",
         "@k8slens/kube-api": "^1.0.0-alpha.1",
-        "@ogre-tools/injectable": "^17.2.0"
+        "@k8slens/logger": "^1.0.0",
+        "@ogre-tools/injectable": "^17.2.0",
+        "@ogre-tools/injectable-extension-for-auto-registration": "^17.2.0"
       }
     },
     "packages/utility-features/react-testing-library-discovery": {

packages/core/src/common/k8s-api/__tests__/api-manager.test.ts

@@ -11,13 +11,12 @@ import { getDiForUnitTesting } from "../../../renderer/getDiForUnitTesting";
 import storesAndApisCanBeCreatedInjectable from "../../../renderer/stores-apis-can-be-created.injectable";
 import directoryForKubeConfigsInjectable from "../../app-paths/directory-for-kube-configs/directory-for-kube-configs.injectable";
 import directoryForUserDataInjectable from "../../app-paths/directory-for-user-data/directory-for-user-data.injectable";
-import { loggerInjectionToken } from "@k8slens/logger";
+import { logErrorInjectionToken, loggerInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
 import type { ApiManager } from "../api-manager";
 import apiManagerInjectable from "../api-manager/manager.injectable";
 import { KubeApi } from "@k8slens/kube-api";
 import { KubeObject } from "@k8slens/kube-object";
 import { KubeObjectStore } from "../kube-object.store";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 // eslint-disable-next-line no-restricted-imports
 import { KubeApi as ExternalKubeApi } from "../../../extensions/common-api/k8s-api";
@@ -25,6 +24,7 @@ import { Cluster } from "../../cluster/cluster";
 import { runInAction } from "mobx";
 import { customResourceDefinitionApiInjectionToken } from "../api-manager/crd-api-token";
 import assert from "assert";
+import { maybeKubeApiInjectable } from "@k8slens/kube-api-specifics";
 
 class TestApi extends KubeApi<KubeObject> {
   protected checkPreferredVersion() {
@@ -61,7 +61,9 @@ describe("ApiManager", () => {
       const apiBase = "api/v1/foo";
       const fallbackApiBase = "/apis/extensions/v1beta1/foo";
       const kubeApi = new TestApi({
-        logger: di.inject(loggerInjectionToken),
+        logError: di.inject(logErrorInjectionToken),
+        logInfo: di.inject(logInfoInjectionToken),
+        logWarn: di.inject(logWarningInjectionToken),
         maybeKubeApi: di.inject(maybeKubeApiInjectable),
       }, {
         objectConstructor: KubeObject,
@@ -136,7 +138,9 @@ describe("ApiManager", () => {
 
             return Object.assign(
               new KubeApi({
-                logger: di.inject(loggerInjectionToken),
+                logError: di.inject(logErrorInjectionToken),
+                logInfo: di.inject(logInfoInjectionToken),
+                logWarn: di.inject(logWarningInjectionToken),
                 maybeKubeApi: di.inject(maybeKubeApiInjectable),
               }, { objectConstructor }),
               {

packages/core/src/common/k8s-api/__tests__/kube-api-version-detection.test.ts

@@ -20,9 +20,8 @@ import hostedClusterInjectable from "../../../renderer/cluster-frame-context/hos
 import directoryForKubeConfigsInjectable from "../../app-paths/directory-for-kube-configs/directory-for-kube-configs.injectable";
 import apiManagerInjectable from "../api-manager/manager.injectable";
 import type { DiContainer } from "@ogre-tools/injectable";
-import ingressApiInjectable from "../endpoints/ingress.api.injectable";
+import { ingressApiInjectable, maybeKubeApiInjectable } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
+import { logErrorInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 import { Cluster } from "../../cluster/cluster";
 
 describe("KubeApi", () => {
@@ -710,7 +709,9 @@ describe("KubeApi", () => {
 
     beforeEach(async () => {
       horizontalPodAutoscalerApi = new HorizontalPodAutoscalerApi({
-        logger: di.inject(loggerInjectionToken),
+        logError: di.inject(logErrorInjectionToken),
+        logInfo: di.inject(logInfoInjectionToken),
+        logWarn: di.inject(logWarningInjectionToken),
         maybeKubeApi: di.inject(maybeKubeApiInjectable),
       }, {
         allowedUsableVersions: {

packages/core/src/common/k8s-api/__tests__/kube-api.test.ts

@@ -22,7 +22,7 @@ import hostedClusterInjectable from "../../../renderer/cluster-frame-context/hos
 import directoryForKubeConfigsInjectable from "../../app-paths/directory-for-kube-configs/directory-for-kube-configs.injectable";
 import apiKubeInjectable from "../../../renderer/k8s/api-kube.injectable";
 import type { DiContainer } from "@ogre-tools/injectable";
-import podApiInjectable from "../endpoints/pod.api.injectable";
+import { podApiInjectable } from "@k8slens/kube-api-specifics";
 
 // NOTE: this is fine because we are testing something that only exported
 // eslint-disable-next-line no-restricted-imports

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

@@ -3,11 +3,10 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { ApiManager } from "./api-manager";
 import { computedInjectManyInjectable } from "@ogre-tools/injectable-extension-for-mobx";
 import { kubeObjectStoreInjectionToken } from "./kube-object-store-token";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
+import { kubeApiInjectionToken, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { computed } from "mobx";
 import { customResourceDefinitionApiInjectionToken } from "./crd-api-token";
 import createCustomResourceStoreInjectable from "./create-custom-resource-store.injectable";

packages/core/src/common/k8s-api/create-kube-api-for-cluster.injectable.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { loggerInjectionToken } from "@k8slens/logger";
+import { logErrorInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
 import { apiKubePrefix } from "../vars";
 import isDevelopmentInjectable from "../vars/is-development.injectable";
 import apiBaseInjectable from "./api-base.injectable";
@@ -37,7 +37,9 @@ const createKubeApiForClusterInjectable = getInjectable({
     const apiBase = di.inject(apiBaseInjectable);
     const isDevelopment = di.inject(isDevelopmentInjectable);
     const createKubeJsonApi = di.inject(createKubeJsonApiInjectable);
-    const logger = di.inject(loggerInjectionToken);
+    const logError = di.inject(logErrorInjectionToken);
+    const logInfo = di.inject(logInfoInjectionToken);
+    const logWarn = di.inject(logWarningInjectionToken);
 
     return (
       cluster: CreateKubeApiForLocalClusterConfig,
@@ -64,7 +66,9 @@ const createKubeApiForClusterInjectable = getInjectable({
 
       return new KubeApi(
         {
-          logger,
+          logError,
+          logInfo,
+          logWarn,
           maybeKubeApi: undefined,
         },
         {

packages/core/src/common/k8s-api/create-kube-api-for-remote-cluster.injectable.ts

@@ -6,7 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
 import type { AgentOptions } from "https";
 import { Agent } from "https";
 import type { RequestInit } from "@k8slens/node-fetch";
-import { loggerInjectionToken } from "@k8slens/logger";
+import { logErrorInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
 import isDevelopmentInjectable from "../vars/is-development.injectable";
 import createKubeJsonApiInjectable from "./create-kube-json-api.injectable";
 import type { KubeApiOptions } from "@k8slens/kube-api";
@@ -53,7 +53,9 @@ const createKubeApiForRemoteClusterInjectable = getInjectable({
   instantiate: (di): CreateKubeApiForRemoteCluster => {
     const isDevelopment = di.inject(isDevelopmentInjectable);
     const createKubeJsonApi = di.inject(createKubeJsonApiInjectable);
-    const logger = di.inject(loggerInjectionToken);
+    const logError = di.inject(logErrorInjectionToken);
+    const logInfo = di.inject(logInfoInjectionToken);
+    const logWarn = di.inject(logWarningInjectionToken);
 
     return (
       config: CreateKubeApiForRemoteClusterConfig,
@@ -110,7 +112,9 @@ const createKubeApiForRemoteClusterInjectable = getInjectable({
 
       return new KubeApi(
         {
-          logger,
+          logError,
+          logInfo,
+          logWarn,
           maybeKubeApi: undefined,
         },
         {

packages/core/src/common/k8s-api/create-kube-api.injectable.ts

@@ -3,9 +3,9 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { loggerInjectionToken } from "@k8slens/logger";
+import { logErrorInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
 import type { DerivedKubeApiOptions, KubeApiDependencies } from "@k8slens/kube-api";
-import maybeKubeApiInjectable from "./maybe-kube-api.injectable";
+import { maybeKubeApiInjectable } from "@k8slens/kube-api-specifics";
 
 export interface CreateKubeApi {
   <Api>(ctor: new (deps: KubeApiDependencies, opts: DerivedKubeApiOptions) => Api, opts?: DerivedKubeApiOptions): Api;
@@ -15,7 +15,9 @@ const createKubeApiInjectable = getInjectable({
   id: "create-kube-api",
   instantiate: (di): CreateKubeApi => {
     const deps: KubeApiDependencies = {
-      logger: di.inject(loggerInjectionToken),
+      logError: di.inject(logErrorInjectionToken),
+      logInfo: di.inject(logInfoInjectionToken),
+      logWarn: di.inject(logWarningInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     };
 

packages/core/src/common/k8s-api/endpoints/cluster-role-binding.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { ClusterRoleBindingApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const clusterRoleBindingApiInjectable = getInjectable({
-  id: "cluster-role-binding-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterRoleBindingApi is only accessible in certain environments");
-
-    return new ClusterRoleBindingApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default clusterRoleBindingApiInjectable;

packages/core/src/common/k8s-api/endpoints/cluster-role.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { ClusterRoleApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const clusterRoleApiInjectable = getInjectable({
-  id: "cluster-role-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterRoleApi is only available in certain environments");
-
-    return new ClusterRoleApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default clusterRoleApiInjectable;

packages/core/src/common/k8s-api/endpoints/component-status.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { ComponentStatusApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-import { loggerInjectionToken } from "@k8slens/logger";
-
-const componentStatusApiInjectable = getInjectable({
-  id: "component-status-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "componentStatusApi is only available in certain environments");
-
-    return new ComponentStatusApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default componentStatusApiInjectable;

packages/core/src/common/k8s-api/endpoints/config-map.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { ConfigMapApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const configMapApiInjectable = getInjectable({
-  id: "config-map-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "configMapApi is only available in certain environments");
-
-    return new ConfigMapApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default configMapApiInjectable;

packages/core/src/common/k8s-api/endpoints/cron-job.api.injectable.ts

@@ -1,29 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { CronJobApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const cronJobApiInjectable = getInjectable({
-  id: "cron-job-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "cronJobApi is only available in certain environments");
-
-    return new CronJobApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    }, {
-      checkPreferredVersion: true,
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default cronJobApiInjectable;

packages/core/src/common/k8s-api/endpoints/custom-resource-definition.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { CustomResourceDefinitionApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-import { loggerInjectionToken } from "@k8slens/logger";
-
-const customResourceDefinitionApiInjectable = getInjectable({
-  id: "custom-resource-definition-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "customResourceDefinitionApi is only available in certain environments");
-
-    return new CustomResourceDefinitionApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default customResourceDefinitionApiInjectable;

packages/core/src/common/k8s-api/endpoints/daemon-set.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { DaemonSetApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const daemonSetApiInjectable = getInjectable({
-  id: "daemon-set-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "daemonSetApi is only available in certain environments");
-
-    return new DaemonSetApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default daemonSetApiInjectable;

packages/core/src/common/k8s-api/endpoints/deployment.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { DeploymentApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const deploymentApiInjectable = getInjectable({
-  id: "deployment-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "deploymentApi is only available in certain environments");
-
-    return new DeploymentApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default deploymentApiInjectable;

packages/core/src/common/k8s-api/endpoints/endpoint.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { EndpointsApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const endpointsApiInjectable = getInjectable({
-  id: "endpoints-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "endpointsApi is only available in certain environments");
-
-    return new EndpointsApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default endpointsApiInjectable;

packages/core/src/common/k8s-api/endpoints/events.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { KubeEventApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const kubeEventApiInjectable = getInjectable({
-  id: "kube-event-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "kubeEventApi is only available in certain environments");
-
-    return new KubeEventApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default kubeEventApiInjectable;

packages/core/src/common/k8s-api/endpoints/horizontal-pod-autoscaler.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { HorizontalPodAutoscalerApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const horizontalPodAutoscalerApiInjectable = getInjectable({
-  id: "horizontal-pod-autoscaler-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "horizontalPodAutoscalerApi is only available in certain environments");
-
-    return new HorizontalPodAutoscalerApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default horizontalPodAutoscalerApiInjectable;

packages/core/src/common/k8s-api/endpoints/ingress-class.api.injectable.ts

@@ -1,21 +0,0 @@
-/**
- * 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 { IngressClassApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const ingressClassApiInjectable = getInjectable({
-  id: "ingress-class-api",
-  instantiate: (di) => new IngressClassApi({
-    logger: di.inject(loggerInjectionToken),
-    maybeKubeApi: di.inject(maybeKubeApiInjectable),
-  }),
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default ingressClassApiInjectable;

packages/core/src/common/k8s-api/endpoints/job.api.injectable.ts

@@ -1,29 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { JobApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const jobApiInjectable = getInjectable({
-  id: "job-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "jobApi is only available in certain environments");
-
-    return new JobApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    }, {
-      checkPreferredVersion: true,
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default jobApiInjectable;

packages/core/src/common/k8s-api/endpoints/limit-range.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { LimitRangeApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const limitRangeApiInjectable = getInjectable({
-  id: "limit-range-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "limitRangeApi is only available in certain environments");
-
-    return new LimitRangeApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default limitRangeApiInjectable;

packages/core/src/common/k8s-api/endpoints/mutating-webhook-configuration-api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { MutatingWebhookConfigurationApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const mutatingWebhookConfigurationApiInjectable = getInjectable({
-  id: "mutating-webhook-configuration",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "mutatingWebhookApi is only available in certain environments");
-
-    return new MutatingWebhookConfigurationApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default mutatingWebhookConfigurationApiInjectable;

packages/core/src/common/k8s-api/endpoints/namespace.api.injectable.ts

@@ -1,28 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { NamespaceApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const namespaceApiInjectable = getInjectable({
-  id: "namespace-api",
-
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "namespaceApi is only available in certain environments");
-
-    return new NamespaceApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default namespaceApiInjectable;

packages/core/src/common/k8s-api/endpoints/network-policy.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { NetworkPolicyApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const networkPolicyApiInjectable = getInjectable({
-  id: "network-policy-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "networkPolicyApi is only available in certain environments");
-
-    return new NetworkPolicyApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default networkPolicyApiInjectable;

packages/core/src/common/k8s-api/endpoints/persistent-volume-claim.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { PersistentVolumeClaimApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const persistentVolumeClaimApiInjectable = getInjectable({
-  id: "persistent-volume-claim-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "persistentVolumeClaimApi is only available in certain environments");
-
-    return new PersistentVolumeClaimApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default persistentVolumeClaimApiInjectable;

packages/core/src/common/k8s-api/endpoints/persistent-volume.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { PersistentVolumeApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const persistentVolumeApiInjectable = getInjectable({
-  id: "persistent-volume-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "persistentVolumeApi is only available in certain environments");
-
-    return new PersistentVolumeApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default persistentVolumeApiInjectable;

packages/core/src/common/k8s-api/endpoints/pod-disruption-budget.api.injectable.ts

@@ -1,35 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { PodDisruptionBudgetApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const podDisruptionBudgetApiInjectable = getInjectable({
-  id: "pod-disruption-budget-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podDisruptionBudgetApi is only available in certain environments");
-
-    return new PodDisruptionBudgetApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    }, {
-      checkPreferredVersion: true,
-      allowedUsableVersions: {
-        policy: [
-          "v1",
-          "v1beta1",
-        ],
-      },
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default podDisruptionBudgetApiInjectable;

packages/core/src/common/k8s-api/endpoints/pod-metrics.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { PodMetricsApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const podMetricsApiInjectable = getInjectable({
-  id: "pod-metrics-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podMetricsApi is only available in certain environments");
-
-    return new PodMetricsApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default podMetricsApiInjectable;

packages/core/src/common/k8s-api/endpoints/pod-security-policy.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { PodSecurityPolicyApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const podSecurityPolicyApiInjectable = getInjectable({
-  id: "pod-security-policy-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podSecurityPolicyApi is only available in certain environments");
-
-    return new PodSecurityPolicyApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default podSecurityPolicyApiInjectable;

packages/core/src/common/k8s-api/endpoints/priority-class.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { PriorityClassApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const priorityClassApiInjectable = getInjectable({
-  id: "priority-class-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "PriorityClassApi is only available in certain environments");
-
-    return new PriorityClassApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default priorityClassApiInjectable;

packages/core/src/common/k8s-api/endpoints/replica-set.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { ReplicaSetApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const replicaSetApiInjectable = getInjectable({
-  id: "replica-set-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "replicaSetApi is only available in certain environments");
-
-    return new ReplicaSetApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default replicaSetApiInjectable;

packages/core/src/common/k8s-api/endpoints/replication-controller.api.injectable.ts

@@ -1,23 +0,0 @@
-/**
- * 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 { ReplicationControllerApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const replicationControllerApiInjectable = getInjectable({
-  id: "replication-controller-api",
-  instantiate: (di) => {
-    return new ReplicationControllerApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default replicationControllerApiInjectable;

packages/core/src/common/k8s-api/endpoints/resource-quota.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { ResourceQuotaApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const resourceQuotaApiInjectable = getInjectable({
-  id: "resource-quota-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "resourceQuotaApi is only available in certain environments");
-
-    return new ResourceQuotaApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default resourceQuotaApiInjectable;

packages/core/src/common/k8s-api/endpoints/role-binding.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { RoleBindingApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const roleBindingApiInjectable = getInjectable({
-  id: "role-binding-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "roleBindingApi is only available in certain environments");
-
-    return new RoleBindingApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default roleBindingApiInjectable;

packages/core/src/common/k8s-api/endpoints/runtime-class.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { RuntimeClassApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const runtimeClassApiInjectable = getInjectable({
-  id: "runtime-class-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "RuntimeClassApi is only available in certain environments");
-
-    return new RuntimeClassApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default runtimeClassApiInjectable;

packages/core/src/common/k8s-api/endpoints/self-subject-rules-reviews.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { SelfSubjectRulesReviewApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const selfSubjectRulesReviewApiInjectable = getInjectable({
-  id: "self-subject-rules-review-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "selfSubjectRulesReviewApi is only available in certain environments");
-
-    return new SelfSubjectRulesReviewApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default selfSubjectRulesReviewApiInjectable;

packages/core/src/common/k8s-api/endpoints/service-account.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { ServiceAccountApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const serviceAccountApiInjectable = getInjectable({
-  id: "service-account-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "serviceAccountApi is only available in certain environments");
-
-    return new ServiceAccountApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default serviceAccountApiInjectable;

packages/core/src/common/k8s-api/endpoints/stateful-set.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { StatefulSetApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const statefulSetApiInjectable = getInjectable({
-  id: "stateful-set-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "statefulSetApi is only available in certain environments");
-
-    return new StatefulSetApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default statefulSetApiInjectable;

packages/core/src/common/k8s-api/endpoints/storage-class.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { StorageClassApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const storageClassApiInjectable = getInjectable({
-  id: "storage-class-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "storageClassApi is only available in certain environments");
-
-    return new StorageClassApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default storageClassApiInjectable;

packages/core/src/common/k8s-api/endpoints/validating-webhook-configuration-api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { ValidatingWebhookConfigurationApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const validatingWebhookConfigurationApiInjectable = getInjectable({
-  id: "validating-webhook-configuration",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "validatingWebhookApi is only available in certain environments");
-
-    return new ValidatingWebhookConfigurationApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default validatingWebhookConfigurationApiInjectable;

packages/core/src/common/k8s-api/endpoints/vertical-pod-autoscaler.api.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * 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 assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
-import { VerticalPodAutoscalerApi } from "@k8slens/kube-api";
-import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
-import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-
-const verticalPodAutoscalerApiInjectable = getInjectable({
-  id: "vertical-pod-autoscaler-api",
-  instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "verticalPodAutoscalerApi is only available in certain environments");
-
-    return new VerticalPodAutoscalerApi({
-      logger: di.inject(loggerInjectionToken),
-      maybeKubeApi: di.inject(maybeKubeApiInjectable),
-    });
-  },
-
-  injectionToken: kubeApiInjectionToken,
-});
-
-export default verticalPodAutoscalerApiInjectable;

packages/core/src/common/k8s-api/selected-filter-namespaces.injectable.ts

@@ -2,10 +2,10 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
+import { storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { getInjectable } from "@ogre-tools/injectable";
 import { computed } from "mobx";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../renderer/cluster-frame-context/for-namespaced-resources.injectable";
-import { storesAndApisCanBeCreatedInjectionToken } from "./stores-apis-can-be-created.token";
 
 const selectedFilterNamespacesInjectable = getInjectable({
   id: "selected-filter-namespaces",

packages/core/src/extensions/common-api/k8s-api.ts

@@ -20,10 +20,9 @@ import type { KubeJsonApiDataFor, KubeObject } from "@k8slens/kube-object";
 import type { DerivedKubeApiOptions, KubeApiDependencies, KubeApiOptions, KubeJsonApi as InternalKubeJsonApi } from "@k8slens/kube-api";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../renderer/cluster-frame-context/for-namespaced-resources.injectable";
 import type { ClusterContext } from "../../renderer/cluster-frame-context/cluster-frame-context";
-import { loggerInjectionToken } from "@k8slens/logger";
+import { logErrorInjectionToken, loggerInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../../common/k8s-api/maybe-kube-api.injectable";
+import { maybeKubeApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { DeploymentApi as InternalDeploymentApi, IngressApi as InternalIngressApi, NodeApi, PersistentVolumeClaimApi, PodApi, KubeApi as InternalKubeApi } from "@k8slens/kube-api";
-import { storesAndApisCanBeCreatedInjectionToken } from "../../common/k8s-api/stores-apis-can-be-created.token";
 import type { JsonApiConfig } from "@k8slens/json-api";
 import createKubeJsonApiInjectable from "../../common/k8s-api/create-kube-json-api.injectable";
 import type { RequestInit } from "@k8slens/node-fetch";
@@ -40,7 +39,9 @@ const getKubeApiDeps = (): KubeApiDependencies => {
   const di = getLegacyGlobalDiForExtensionApi();
 
   return {
-    logger: di.inject(loggerInjectionToken),
+    logError: di.inject(logErrorInjectionToken),
+    logInfo: di.inject(logInfoInjectionToken),
+    logWarn: di.inject(logWarningInjectionToken),
     maybeKubeApi: di.inject(maybeKubeApiInjectable),
   };
 };

packages/core/src/extensions/renderer-api/k8s-api.ts

@@ -5,37 +5,7 @@
 import type { KubeResource } from "../../common/rbac";
 import { apiResourceRecord } from "../../common/rbac";
 import { getLegacyGlobalDiForExtensionApi, asLegacyGlobalForExtensionApi, asLegacyGlobalFunctionForExtensionApi } from "@k8slens/legacy-global-di";
-import clusterRoleBindingApiInjectable from "../../common/k8s-api/endpoints/cluster-role-binding.api.injectable";
+import * as kubeApiSpecifics from "@k8slens/kube-api-specifics";
-import clusterRoleApiInjectable from "../../common/k8s-api/endpoints/cluster-role.api.injectable";
-import serviceAccountApiInjectable from "../../common/k8s-api/endpoints/service-account.api.injectable";
-import roleApiInjectable from "../../common/k8s-api/endpoints/role.api.injectable";
-import podApiInjectable from "../../common/k8s-api/endpoints/pod.api.injectable";
-import daemonSetApiInjectable from "../../common/k8s-api/endpoints/daemon-set.api.injectable";
-import replicaSetApiInjectable from "../../common/k8s-api/endpoints/replica-set.api.injectable";
-import statefulSetApiInjectable from "../../common/k8s-api/endpoints/stateful-set.api.injectable";
-import deploymentApiInjectable from "../../common/k8s-api/endpoints/deployment.api.injectable";
-import jobApiInjectable from "../../common/k8s-api/endpoints/job.api.injectable";
-import cronJobApiInjectable from "../../common/k8s-api/endpoints/cron-job.api.injectable";
-import nodeApiInjectable from "../../common/k8s-api/endpoints/node.api.injectable";
-import configMapApiInjectable from "../../common/k8s-api/endpoints/config-map.api.injectable";
-import secretApiInjectable from "../../common/k8s-api/endpoints/secret.api.injectable";
-import resourceQuotaApiInjectable from "../../common/k8s-api/endpoints/resource-quota.api.injectable";
-import limitRangeApiInjectable from "../../common/k8s-api/endpoints/limit-range.api.injectable";
-import horizontalPodAutoscalerApiInjectable from "../../common/k8s-api/endpoints/horizontal-pod-autoscaler.api.injectable";
-import verticalPodAutoscalerApiInjectable from "../../common/k8s-api/endpoints/vertical-pod-autoscaler.api.injectable";
-import podDisruptionBudgetApiInjectable from "../../common/k8s-api/endpoints/pod-disruption-budget.api.injectable";
-import priorityClassStoreApiInjectable from "../../common/k8s-api/endpoints/priority-class.api.injectable";
-import serviceApiInjectable from "../../common/k8s-api/endpoints/service.api.injectable";
-import endpointsApiInjectable from "../../common/k8s-api/endpoints/endpoint.api.injectable";
-import ingressApiInjectable from "../../common/k8s-api/endpoints/ingress.api.injectable";
-import networkPolicyApiInjectable from "../../common/k8s-api/endpoints/network-policy.api.injectable";
-import persistentVolumeApiInjectable from "../../common/k8s-api/endpoints/persistent-volume.api.injectable";
-import persistentVolumeClaimApiInjectable from "../../common/k8s-api/endpoints/persistent-volume-claim.api.injectable";
-import storageClassApiInjectable from "../../common/k8s-api/endpoints/storage-class.api.injectable";
-import namespaceApiInjectable from "../../common/k8s-api/endpoints/namespace.api.injectable";
-import kubeEventApiInjectable from "../../common/k8s-api/endpoints/events.api.injectable";
-import roleBindingApiInjectable from "../../common/k8s-api/endpoints/role-binding.api.injectable";
-import customResourceDefinitionApiInjectable from "../../common/k8s-api/endpoints/custom-resource-definition.api.injectable";
 import { shouldShowResourceInjectionToken } from "../../features/cluster/showing-kube-resources/common/allowed-resources-injection-token";
 import requestMetricsInjectable from "../../common/k8s-api/endpoints/metrics.api/request-metrics.injectable";
 
@@ -59,37 +29,37 @@ export function isAllowedResource(resources: KubeResource | KubeResource[]) {
   });
 }
 
-export const serviceAccountsApi = asLegacyGlobalForExtensionApi(serviceAccountApiInjectable);
+export const serviceAccountsApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.serviceAccountApiInjectable);
-export const clusterRoleApi = asLegacyGlobalForExtensionApi(clusterRoleApiInjectable);
+export const clusterRoleApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.clusterRoleApiInjectable);
-export const clusterRoleBindingApi = asLegacyGlobalForExtensionApi(clusterRoleBindingApiInjectable);
+export const clusterRoleBindingApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.clusterRoleBindingApiInjectable);
-export const roleApi = asLegacyGlobalForExtensionApi(roleApiInjectable);
+export const roleApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.roleApiInjectable);
-export const podsApi = asLegacyGlobalForExtensionApi(podApiInjectable);
+export const podsApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.podApiInjectable);
-export const daemonSetApi = asLegacyGlobalForExtensionApi(daemonSetApiInjectable);
+export const daemonSetApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.daemonSetApiInjectable);
-export const replicaSetApi = asLegacyGlobalForExtensionApi(replicaSetApiInjectable);
+export const replicaSetApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.replicaSetApiInjectable);
-export const statefulSetApi = asLegacyGlobalForExtensionApi(statefulSetApiInjectable);
+export const statefulSetApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.statefulSetApiInjectable);
-export const deploymentApi = asLegacyGlobalForExtensionApi(deploymentApiInjectable);
+export const deploymentApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.deploymentApiInjectable);
-export const jobApi = asLegacyGlobalForExtensionApi(jobApiInjectable);
+export const jobApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.jobApiInjectable);
-export const cronJobApi = asLegacyGlobalForExtensionApi(cronJobApiInjectable);
+export const cronJobApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.cronJobApiInjectable);
-export const nodesApi = asLegacyGlobalForExtensionApi(nodeApiInjectable);
+export const nodesApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.nodeApiInjectable);
-export const secretsApi = asLegacyGlobalForExtensionApi(secretApiInjectable);
+export const secretsApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.secretApiInjectable);
-export const configMapApi = asLegacyGlobalForExtensionApi(configMapApiInjectable);
+export const configMapApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.configMapApiInjectable);
-export const resourceQuotaApi = asLegacyGlobalForExtensionApi(resourceQuotaApiInjectable);
+export const resourceQuotaApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.resourceQuotaApiInjectable);
-export const limitRangeApi = asLegacyGlobalForExtensionApi(limitRangeApiInjectable);
+export const limitRangeApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.limitRangeApiInjectable);
-export const serviceApi = asLegacyGlobalForExtensionApi(serviceApiInjectable);
+export const serviceApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.serviceApiInjectable);
-export const hpaApi = asLegacyGlobalForExtensionApi(horizontalPodAutoscalerApiInjectable);
+export const hpaApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.horizontalPodAutoscalerApiInjectable);
-export const vpaApi = asLegacyGlobalForExtensionApi(verticalPodAutoscalerApiInjectable);
+export const vpaApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.verticalPodAutoscalerApiInjectable);
-export const pdbApi = asLegacyGlobalForExtensionApi(podDisruptionBudgetApiInjectable);
+export const pdbApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.podDisruptionBudgetApiInjectable);
-export const pcApi = asLegacyGlobalForExtensionApi(priorityClassStoreApiInjectable);
+export const pcApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.priorityClassApiInjectable);
-export const endpointApi = asLegacyGlobalForExtensionApi(endpointsApiInjectable);
+export const endpointApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.endpointsApiInjectable);
-export const ingressApi = asLegacyGlobalForExtensionApi(ingressApiInjectable);
+export const ingressApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.ingressApiInjectable);
-export const networkPolicyApi = asLegacyGlobalForExtensionApi(networkPolicyApiInjectable);
+export const networkPolicyApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.networkPolicyApiInjectable);
-export const persistentVolumeApi = asLegacyGlobalForExtensionApi(persistentVolumeApiInjectable);
+export const persistentVolumeApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.persistentVolumeApiInjectable);
-export const pvcApi = asLegacyGlobalForExtensionApi(persistentVolumeClaimApiInjectable);
+export const pvcApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.persistentVolumeClaimApiInjectable);
-export const storageClassApi = asLegacyGlobalForExtensionApi(storageClassApiInjectable);
+export const storageClassApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.storageClassApiInjectable);
-export const namespacesApi = asLegacyGlobalForExtensionApi(namespaceApiInjectable);
+export const namespacesApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.namespaceApiInjectable);
-export const eventApi = asLegacyGlobalForExtensionApi(kubeEventApiInjectable);
+export const eventApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.kubeEventApiInjectable);
-export const roleBindingApi = asLegacyGlobalForExtensionApi(roleBindingApiInjectable);
+export const roleBindingApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.roleBindingApiInjectable);
-export const crdApi = asLegacyGlobalForExtensionApi(customResourceDefinitionApiInjectable);
+export const crdApi = asLegacyGlobalForExtensionApi(kubeApiSpecifics.customResourceDefinitionApiInjectable);
 
 export * from "../common-api/k8s-api";
 

packages/core/src/features/cluster/workloads/pods.test.tsx

@@ -10,7 +10,7 @@ import podStoreInjectable from "../../../renderer/components/workloads-pods/stor
 import type { PodMetrics, PodStatus } from "@k8slens/kube-object";
 import { Pod } from "@k8slens/kube-object";
 import type { PodMetricsApi } from "@k8slens/kube-api";
-import podMetricsApiInjectable from "../../../common/k8s-api/endpoints/pod-metrics.api.injectable";
+import { podMetricsApiInjectable } from "@k8slens/kube-api-specifics";
 import type { RequestMetrics } from "../../../common/k8s-api/endpoints/metrics.api/request-metrics.injectable";
 import requestMetricsInjectable from "../../../common/k8s-api/endpoints/metrics.api/request-metrics.injectable";
 

packages/core/src/main/stores-apis-can-be-created.injectable.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { storesAndApisCanBeCreatedInjectionToken } from "../common/k8s-api/stores-apis-can-be-created.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 
 const storesAndApisCanBeCreatedInjectable = getInjectable({
   id: "create-stores-and-apis",

packages/core/src/renderer/before-frame-starts/runnables/setup-auto-crd-api-creations.injectable.ts

@@ -8,11 +8,11 @@ import { customResourceDefinitionApiInjectionToken } from "../../../common/k8s-a
 import type { CustomResourceDefinition } from "@k8slens/kube-object";
 import { KubeApi } from "@k8slens/kube-api";
 import { KubeObject } from "@k8slens/kube-object";
-import maybeKubeApiInjectable from "../../../common/k8s-api/maybe-kube-api.injectable";
+import { logErrorInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
-import { loggerInjectionToken } from "@k8slens/logger";
 import { injectableDifferencingRegistratorWith } from "../../../common/utils/registrator-helper";
 import customResourceDefinitionStoreInjectable from "../../components/custom-resource-definitions/store.injectable";
 import { beforeClusterFrameStartsSecondInjectionToken } from "../tokens";
+import { maybeKubeApiInjectable } from "@k8slens/kube-api-specifics";
 
 const setupAutoCrdApiCreationsInjectable = getInjectable({
   id: "setup-auto-crd-api-creations",
@@ -45,7 +45,9 @@ const toCrdApiInjectable = (crd: CustomResourceDefinition) => getInjectable({
     };
 
     return new KubeApi({
-      logger: di.inject(loggerInjectionToken),
+      logError: di.inject(logErrorInjectionToken),
+      logInfo: di.inject(logInfoInjectionToken),
+      logWarn: di.inject(logWarningInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     }, { objectConstructor });
   },

packages/core/src/renderer/components/cluster/store.injectable.ts

@@ -6,8 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
 
 import { ClusterStore } from "./store";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import clusterApiInjectable from "../../../common/k8s-api/endpoints/cluster.api.injectable";
+import { clusterApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import assert from "assert";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
 import { loggerInjectionToken } from "@k8slens/logger";
@@ -16,7 +15,7 @@ const clusterStoreInjectable = getInjectable({
   id: "cluster-store",
 
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "clusterStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterStore is only available in certain environments");
     const clusterApi = di.inject(clusterApiInjectable);
 
     return new ClusterStore({

packages/core/src/renderer/components/config-horizontal-pod-autoscalers/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import horizontalPodAutoscalerApiInjectable from "../../../common/k8s-api/endpoints/horizontal-pod-autoscaler.api.injectable";
+import { horizontalPodAutoscalerApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { HorizontalPodAutoscalerStore } from "./store";
 
 const horizontalPodAutoscalerStoreInjectable = getInjectable({
   id: "horizontal-pod-autoscaler-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "horizontalPodAutoscalerStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "horizontalPodAutoscalerStore is only available in certain environments");
 
     const api = di.inject(horizontalPodAutoscalerApiInjectable);
 

packages/core/src/renderer/components/config-leases/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import leaseApiInjectable from "../../../common/k8s-api/endpoints/lease.api.injectable";
+import { leaseApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { LeaseStore } from "./store";
 
 const leaseStoreInjectable = getInjectable({
   id: "lease-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "leaseStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "leaseStore is only available in certain environments");
 
     const api = di.inject(leaseApiInjectable);
 

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

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import limitRangeApiInjectable from "../../../common/k8s-api/endpoints/limit-range.api.injectable";
+import { limitRangeApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { LimitRangeStore } from "./store";
 
 const limitRangeStoreInjectable = getInjectable({
   id: "limit-range-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "limitRangeStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "limitRangeStore is only available in certain environments");
 
     const api = di.inject(limitRangeApiInjectable);
 

packages/core/src/renderer/components/config-maps/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import configMapApiInjectable from "../../../common/k8s-api/endpoints/config-map.api.injectable";
+import { configMapApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { ConfigMapStore } from "./store";
 
 const configMapStoreInjectable = getInjectable({
   id: "config-map-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "configMapStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "configMapStore is only available in certain environments");
 
     const api = di.inject(configMapApiInjectable);
 

packages/core/src/renderer/components/config-mutating-webhook-configurations/mutating-webhook-configuration-store.injectable.ts

@@ -7,12 +7,14 @@ import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manag
 import { MutatingWebhookConfigurationStore } from "./mutating-webhook-configuration-store";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
 import { loggerInjectionToken } from "@k8slens/logger";
-import mutatingWebhookConfigurationApiInjectable
+import { mutatingWebhookConfigurationApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
-  from "../../../common/k8s-api/endpoints/mutating-webhook-configuration-api.injectable";
+import assert from "assert";
 
 const mutatingWebhookConfigurationStoreInjectable = getInjectable({
   id: "mutating-webhook-configuration-store",
   instantiate: (di) => {
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "mutatingWebhookConfigurationStore is only available in certain environments");
+
     const api = di.inject(mutatingWebhookConfigurationApiInjectable);
 
     return new MutatingWebhookConfigurationStore({

packages/core/src/renderer/components/config-pod-disruption-budgets/__tests__/pod-distruption-budgets.test.tsx

@@ -11,13 +11,13 @@ import { PodDisruptionBudgets } from "../pod-disruption-budgets";
 import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
 import selectedNamespacesStorageInjectable from "../../../../features/namespace-filtering/renderer/storage.injectable";
 import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../../../../common/k8s-api/maybe-kube-api.injectable";
 import podDisruptionBudgetStoreInjectable from "../store.injectable";
 import siblingTabsInjectable from "../../../routes/sibling-tabs.injectable";
 import { Cluster } from "../../../../common/cluster/cluster";
 import hostedClusterInjectable from "../../../cluster-frame-context/hosted-cluster.injectable";
 import userPreferencesStateInjectable from "../../../../features/user-preferences/common/state.injectable";
 import type { DiContainer } from "@ogre-tools/injectable";
+import { maybeKubeApiInjectable } from "@k8slens/kube-api-specifics";
 
 describe("<PodDisruptionBudgets />", () => {
   let di: DiContainer;
@@ -60,7 +60,7 @@ describe("<PodDisruptionBudgets />", () => {
       get: () => ({}),
     }) as any);
     di.override(loggerInjectionToken, () => null);
-    di.override(maybeKubeApiInjectable, () => (() => null) as any);
+    di.override(maybeKubeApiInjectable, () => null);
     di.override(siblingTabsInjectable, () => ({ get: () => [] } as any));
     di.override(userPreferencesStateInjectable, () => ({
       hiddenTableColumns: {

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

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import podDisruptionBudgetApiInjectable from "../../../common/k8s-api/endpoints/pod-disruption-budget.api.injectable";
+import { podDisruptionBudgetApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { PodDisruptionBudgetStore } from "./store";
 
 const podDisruptionBudgetStoreInjectable = getInjectable({
   id: "pod-disruption-budget-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "podDisruptionBudgetStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podDisruptionBudgetStore is only available in certain environments");
 
     const api = di.inject(podDisruptionBudgetApiInjectable);
 

packages/core/src/renderer/components/config-priority-classes/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import priorityClassApiInjectable from "../../../common/k8s-api/endpoints/priority-class.api.injectable";
+import { priorityClassApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForClusterScopedResourcesInjectable from "../../cluster-frame-context/for-cluster-scoped-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { PriorityClassStore } from "./store";
 
 const priorityClassStoreInjectable = getInjectable({
   id: "priority-class-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "priorityClassStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "priorityClassStore is only available in certain environments");
 
     const api = di.inject(priorityClassApiInjectable);
 

packages/core/src/renderer/components/config-resource-quotas/add-dialog/view.tsx

@@ -24,7 +24,7 @@ import { SubTitle } from "../../layout/sub-title";
 import { withInjectables } from "@ogre-tools/injectable-react";
 import closeAddQuotaDialogInjectable from "./close.injectable";
 import isAddQuotaDialogOpenInjectable from "./is-open.injectable";
-import resourceQuotaApiInjectable from "../../../../common/k8s-api/endpoints/resource-quota.api.injectable";
+import { resourceQuotaApiInjectable } from "@k8slens/kube-api-specifics";
 import type { ShowCheckedErrorNotification } from "../../notifications/show-checked-error.injectable";
 import showCheckedErrorNotificationInjectable from "../../notifications/show-checked-error.injectable";
 

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

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import resourceQuotaApiInjectable from "../../../common/k8s-api/endpoints/resource-quota.api.injectable";
+import { resourceQuotaApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { ResourceQuotaStore } from "./store";
 
 const resourceQuotaStoreInjectable = getInjectable({
   id: "resource-quota-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "resourceQuotaStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "resourceQuotaStore is only available in certain environments");
 
     const api = di.inject(resourceQuotaApiInjectable);
 

packages/core/src/renderer/components/config-runtime-classes/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import runtimeClassApiInjectable from "../../../common/k8s-api/endpoints/runtime-class.api.injectable";
+import { runtimeClassApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForClusterScopedResourcesInjectable from "../../cluster-frame-context/for-cluster-scoped-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { RuntimeClassStore } from "./store";
 
 const runtimeClassStoreInjectable = getInjectable({
   id: "runtime-class-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "runtimeClassStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "runtimeClassStore is only available in certain environments");
 
     const api = di.inject(runtimeClassApiInjectable);
 

packages/core/src/renderer/components/config-secrets/add-dialog/view.tsx

@@ -25,7 +25,7 @@ import upperFirst from "lodash/upperFirst";
 import type { ShowDetails } from "../../kube-detail-params/show-details.injectable";
 import { withInjectables } from "@ogre-tools/injectable-react";
 import closeAddSecretDialogInjectable from "./close.injectable";
-import secretApiInjectable from "../../../../common/k8s-api/endpoints/secret.api.injectable";
+import { secretApiInjectable } from "@k8slens/kube-api-specifics";
 import showDetailsInjectable from "../../kube-detail-params/show-details.injectable";
 import isAddSecretDialogOpenInjectable from "./is-open.injectable";
 import type { ShowCheckedErrorNotification } from "../../notifications/show-checked-error.injectable";

packages/core/src/renderer/components/config-secrets/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import secretApiInjectable from "../../../common/k8s-api/endpoints/secret.api.injectable";
+import { secretApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { SecretStore } from "./store";
 
 const secretStoreInjectable = getInjectable({
   id: "secret-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "secretStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "secretStore is only available in certain environments");
 
     const api = di.inject(secretApiInjectable);
 

packages/core/src/renderer/components/config-validating-webhook-configurations/validating-webhook-configuration-store.injectable.ts

@@ -7,12 +7,14 @@ import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manag
 import { ValidatingWebhookConfigurationStore } from "./validating-webhook-configuration-store";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
 import { loggerInjectionToken } from "@k8slens/logger";
-import validatingWebhookConfigurationApiInjectable
+import { storesAndApisCanBeCreatedInjectionToken, validatingWebhookConfigurationApiInjectable } from "@k8slens/kube-api-specifics";
-  from "../../../common/k8s-api/endpoints/validating-webhook-configuration-api.injectable";
+import assert from "assert";
 
 const validatingWebhookConfigurationStoreInjectable = getInjectable({
   id: "validating-webhook-configuration-store",
   instantiate: (di) => {
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "validatingWebhookConfigurationStore is only available in certain environments");
+
     const api = di.inject(validatingWebhookConfigurationApiInjectable);
 
     return new ValidatingWebhookConfigurationStore({

packages/core/src/renderer/components/config-vertical-pod-autoscalers/store.injectable.ts

@@ -6,15 +6,14 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { loggerInjectionToken } from "@k8slens/logger";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import verticalPodAutoscalerApiInjectable from "../../../common/k8s-api/endpoints/vertical-pod-autoscaler.api.injectable";
+import { storesAndApisCanBeCreatedInjectionToken, verticalPodAutoscalerApiInjectable } from "@k8slens/kube-api-specifics";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { VerticalPodAutoscalerStore } from "./store";
 
 const verticalPodAutoscalerStoreInjectable = getInjectable({
   id: "vertical-pod-autoscaler-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "verticalPodAutoscalerStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "verticalPodAutoscalerStore is only available in certain environments");
 
     const api = di.inject(verticalPodAutoscalerApiInjectable);
 

packages/core/src/renderer/components/custom-resource-definitions/definitions.injectable.ts

@@ -5,15 +5,15 @@
 
 import { getInjectable } from "@ogre-tools/injectable";
 import { computed } from "mobx";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import subscribeStoresInjectable from "../../kube-watch-api/subscribe-stores.injectable";
 import customResourceDefinitionStoreInjectable from "./store.injectable";
+import { storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 
 const customResourceDefinitionsInjectable = getInjectable({
   id: "custom-resource-definitions",
 
   instantiate: (di) => {
-    const createStoresAndApis = di.inject(storesAndApisCanBeCreatedInjectable);
+    const createStoresAndApis = di.inject(storesAndApisCanBeCreatedInjectionToken);
 
     if (!createStoresAndApis) {
       return computed(() => []);

packages/core/src/renderer/components/custom-resource-definitions/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import customResourceDefinitionApiInjectable from "../../../common/k8s-api/endpoints/custom-resource-definition.api.injectable";
+import { customResourceDefinitionApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForClusterScopedResourcesInjectable from "../../cluster-frame-context/for-cluster-scoped-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { CustomResourceDefinitionStore } from "./store";
 
 const customResourceDefinitionStoreInjectable = getInjectable({
   id: "custom-resource-definition-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "customResourceDefinitionStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "customResourceDefinitionStore is only available in certain environments");
 
     const api = di.inject(customResourceDefinitionApiInjectable);
 

packages/core/src/renderer/components/dock/logs/call-for-logs.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import type { PodLogsQuery } from "@k8slens/kube-object";
-import podApiInjectable from "../../../../common/k8s-api/endpoints/pod.api.injectable";
+import { podApiInjectable } from "@k8slens/kube-api-specifics";
 import type { ResourceDescriptor } from "@k8slens/kube-api";
 
 export type CallForLogs = (params: ResourceDescriptor, query?: PodLogsQuery) => Promise<string>;

packages/core/src/renderer/components/events/store.injectable.ts

@@ -6,16 +6,15 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import getPodByIdInjectable from "../workloads-pods/get-pod-by-id.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import kubeEventApiInjectable from "../../../common/k8s-api/endpoints/events.api.injectable";
+import { kubeEventApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { EventStore } from "./store";
 
 const eventStoreInjectable = getInjectable({
   id: "event-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "eventStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "eventStore is only available in certain environments");
 
     const api = di.inject(kubeEventApiInjectable);
 

packages/core/src/renderer/components/kube-object-meta/kube-object-meta.tsx

@@ -20,7 +20,7 @@ import getDetailsUrlInjectable from "../kube-detail-params/get-details-url.injec
 import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
 import { loggerInjectionToken } from "@k8slens/logger";
 import type { NamespaceApi } from "@k8slens/kube-api";
-import namespaceApiInjectable from "../../../common/k8s-api/endpoints/namespace.api.injectable";
+import { namespaceApiInjectable } from "@k8slens/kube-api-specifics";
 
 export interface KubeObjectMetaProps {
   object: KubeObject;

packages/core/src/renderer/components/namespaces/store.injectable.ts

@@ -5,9 +5,8 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import { NamespaceStore } from "./store";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import namespaceApiInjectable from "../../../common/k8s-api/endpoints/namespace.api.injectable";
+import { namespaceApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import assert from "assert";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import clusterFrameContextForClusterScopedResourcesInjectable from "../../cluster-frame-context/for-cluster-scoped-resources.injectable";
 import clusterConfiguredAccessibleNamespacesInjectable from "../../cluster/accessible-namespaces.injectable";
 import { loggerInjectionToken } from "@k8slens/logger";
@@ -17,7 +16,7 @@ const namespaceStoreInjectable = getInjectable({
   id: "namespace-store",
 
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "namespaceStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "namespaceStore is only available in certain environments");
 
     const api = di.inject(namespaceApiInjectable);
 

packages/core/src/renderer/components/network-endpoints/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import endpointsApiInjectable from "../../../common/k8s-api/endpoints/endpoint.api.injectable";
+import { endpointsApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { EndpointsStore } from "./store";
 
 const endpointsStoreInjectable = getInjectable({
   id: "endpoints-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "endpointsStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "endpointsStore is only available in certain environments");
 
     const api = di.inject(endpointsApiInjectable);
 

packages/core/src/renderer/components/network-ingresses/ingress-class-set-default.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
 import type { IngressClass } from "@k8slens/kube-object";
-import ingressClassApiInjectable from "../../../common/k8s-api/endpoints/ingress-class.api.injectable";
+import { ingressClassApiInjectable } from "@k8slens/kube-api-specifics";
 import ingressClassStoreInjectable from "./ingress-class-store.injectable";
 
 export const ingressClassSetDefaultInjectable = getInjectable({

packages/core/src/renderer/components/network-ingresses/ingress-class-store.injectable.ts

@@ -5,9 +5,8 @@
 import assert from "assert";
 import { getInjectable } from "@ogre-tools/injectable";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import ingressClassApiInjectable from "../../../common/k8s-api/endpoints/ingress-class.api.injectable";
+import { ingressClassApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { IngressClassStore } from "./ingress-class-store";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import clusterFrameContextForClusterScopedResourcesInjectable from "../../cluster-frame-context/for-cluster-scoped-resources.injectable";
 import { loggerInjectionToken } from "@k8slens/logger";
 
@@ -15,7 +14,7 @@ const ingressClassStoreInjectable = getInjectable({
   id: "ingress-class-store",
 
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "ingressClassStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "ingressClassStore is only available in certain environments");
 
     const api = di.inject(ingressClassApiInjectable);
 

packages/core/src/renderer/components/network-ingresses/ingress-store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import ingressApiInjectable from "../../../common/k8s-api/endpoints/ingress.api.injectable";
+import { ingressApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { IngressStore } from "./ingress-store";
 
 const ingressStoreInjectable = getInjectable({
   id: "ingress-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "ingressStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "ingressStore is only available in certain environments");
 
     const api = di.inject(ingressApiInjectable);
 

packages/core/src/renderer/components/network-policies/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import networkPolicyApiInjectable from "../../../common/k8s-api/endpoints/network-policy.api.injectable";
+import { networkPolicyApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { NetworkPolicyStore } from "./store";
 
 const networkPolicyStoreInjectable = getInjectable({
   id: "network-policy-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "networkPolicyStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "networkPolicyStore is only available in certain environments");
 
     const api = di.inject(networkPolicyApiInjectable);
 

packages/core/src/renderer/components/network-port-forwards/port-forward-details.tsx

@@ -14,10 +14,9 @@ import { cssNames } from "@k8slens/utilities";
 import type { PodApi, ServiceApi } from "@k8slens/kube-api";
 import { PortForwardMenu } from "./port-forward-menu";
 import { withInjectables } from "@ogre-tools/injectable-react";
-import serviceApiInjectable from "../../../common/k8s-api/endpoints/service.api.injectable";
+import { serviceApiInjectable, podApiInjectable } from "@k8slens/kube-api-specifics";
 import type { GetDetailsUrl } from "../kube-detail-params/get-details-url.injectable";
 import getDetailsUrlInjectable from "../kube-detail-params/get-details-url.injectable";
-import podApiInjectable from "../../../common/k8s-api/endpoints/pod.api.injectable";
 
 export interface PortForwardDetailsProps {
   portForward: PortForwardItem;

packages/core/src/renderer/components/network-services/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import serviceApiInjectable from "../../../common/k8s-api/endpoints/service.api.injectable";
+import { serviceApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { ServiceStore } from "./store";
 
 const serviceStoreInjectable = getInjectable({
   id: "service-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "serviceStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "serviceStore is only available in certain environments");
 
     const api = di.inject(serviceApiInjectable);
 

packages/core/src/renderer/components/nodes/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import nodeApiInjectable from "../../../common/k8s-api/endpoints/node.api.injectable";
+import { nodeApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForClusterScopedResourcesInjectable from "../../cluster-frame-context/for-cluster-scoped-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { NodeStore } from "./store";
 
 const nodeStoreInjectable = getInjectable({
   id: "node-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "nodeStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "nodeStore is only available in certain environments");
 
     const api = di.inject(nodeApiInjectable);
 

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

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import podSecurityPolicyApiInjectable from "../../../common/k8s-api/endpoints/pod-security-policy.api.injectable";
+import { podSecurityPolicyApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForClusterScopedResourcesInjectable from "../../cluster-frame-context/for-cluster-scoped-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { PodSecurityPolicyStore } from "./store";
 
 const podSecurityPolicyStoreInjectable = getInjectable({
   id: "pod-security-policy-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "podSecurityPolicyStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podSecurityPolicyStore is only available in certain environments");
 
     const api = di.inject(podSecurityPolicyApiInjectable);
 

packages/core/src/renderer/components/storage-classes/store.injectable.ts

@@ -6,16 +6,15 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import getPersistentVolumesByStorageClassInjectable from "../storage-volumes/get-persistent-volumes-by-storage-class.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import storageClassApiInjectable from "../../../common/k8s-api/endpoints/storage-class.api.injectable";
+import { storageClassApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForClusterScopedResourcesInjectable from "../../cluster-frame-context/for-cluster-scoped-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { StorageClassStore } from "./store";
 
 const storageClassStoreInjectable = getInjectable({
   id: "storage-class-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "storageClassStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "storageClassStore is only available in certain environments");
 
     const api = di.inject(storageClassApiInjectable);
 

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

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import persistentVolumeClaimApiInjectable from "../../../common/k8s-api/endpoints/persistent-volume-claim.api.injectable";
+import { persistentVolumeClaimApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { PersistentVolumeClaimStore } from "./store";
 
 const persistentVolumeClaimStoreInjectable = getInjectable({
   id: "persistent-volume-claim-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "persistentVolumeClaimStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "persistentVolumeClaimStore is only available in certain environments");
 
     const api = di.inject(persistentVolumeClaimApiInjectable);
 

packages/core/src/renderer/components/storage-volume-claims/volume-claim-details.tsx

@@ -20,7 +20,7 @@ import type { PodStore } from "../workloads-pods/store";
 import getDetailsUrlInjectable from "../kube-detail-params/get-details-url.injectable";
 import podStoreInjectable from "../workloads-pods/store.injectable";
 import { stopPropagation } from "@k8slens/utilities";
-import storageClassApiInjectable from "../../../common/k8s-api/endpoints/storage-class.api.injectable";
+import { storageClassApiInjectable } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 
 export interface PersistentVolumeClaimDetailsProps extends KubeObjectDetailsProps<PersistentVolumeClaim> {

packages/core/src/renderer/components/storage-volume-claims/volume-claims.tsx

@@ -21,7 +21,7 @@ import { withInjectables } from "@ogre-tools/injectable-react";
 import getDetailsUrlInjectable from "../kube-detail-params/get-details-url.injectable";
 import persistentVolumeClaimStoreInjectable from "./store.injectable";
 import podStoreInjectable from "../workloads-pods/store.injectable";
-import storageClassApiInjectable from "../../../common/k8s-api/endpoints/storage-class.api.injectable";
+import { storageClassApiInjectable } from "@k8slens/kube-api-specifics";
 import { NamespaceSelectBadge } from "../namespaces/namespace-select-badge";
 
 enum columnId {

packages/core/src/renderer/components/storage-volumes/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import persistentVolumeApiInjectable from "../../../common/k8s-api/endpoints/persistent-volume.api.injectable";
+import { persistentVolumeApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForClusterScopedResourcesInjectable from "../../cluster-frame-context/for-cluster-scoped-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { PersistentVolumeStore } from "./store";
 
 const persistentVolumeStoreInjectable = getInjectable({
   id: "persistent-volume-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "persistentVolumeStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "persistentVolumeStore is only available in certain environments");
 
     const api = di.inject(persistentVolumeApiInjectable);
 

packages/core/src/renderer/components/storage-volumes/volume-details.tsx

@@ -20,8 +20,7 @@ import { withInjectables } from "@ogre-tools/injectable-react";
 import { loggerInjectionToken } from "@k8slens/logger";
 import type { GetDetailsUrl } from "../kube-detail-params/get-details-url.injectable";
 import getDetailsUrlInjectable from "../kube-detail-params/get-details-url.injectable";
-import persistentVolumeClaimApiInjectable from "../../../common/k8s-api/endpoints/persistent-volume-claim.api.injectable";
+import { persistentVolumeClaimApiInjectable, storageClassApiInjectable } from "@k8slens/kube-api-specifics";
-import storageClassApiInjectable from "../../../common/k8s-api/endpoints/storage-class.api.injectable";
 
 export interface PersistentVolumeDetailsProps extends KubeObjectDetailsProps<PersistentVolume> {
 }

packages/core/src/renderer/components/storage-volumes/volumes.tsx

@@ -18,9 +18,8 @@ import type { PersistentVolumeStore } from "./store";
 import type { GetDetailsUrl } from "../kube-detail-params/get-details-url.injectable";
 import { withInjectables } from "@ogre-tools/injectable-react";
 import getDetailsUrlInjectable from "../kube-detail-params/get-details-url.injectable";
-import persistentVolumeClaimApiInjectable from "../../../common/k8s-api/endpoints/persistent-volume-claim.api.injectable";
+import { persistentVolumeClaimApiInjectable, storageClassApiInjectable } from "@k8slens/kube-api-specifics";
 import persistentVolumeStoreInjectable from "./store.injectable";
-import storageClassApiInjectable from "../../../common/k8s-api/endpoints/storage-class.api.injectable";
 
 enum columnId {
   name = "name",

packages/core/src/renderer/components/test-utils/get-application-builder.tsx

@@ -52,7 +52,7 @@ import { applicationWindowInjectionToken } from "../../../main/start-main-applic
 import type { LensWindow } from "../../../main/start-main-application/lens-window/application-window/create-lens-window.injectable";
 import type { FakeExtensionOptions } from "./get-extension-fake";
 import { getExtensionFakeForMain, getExtensionFakeForRenderer } from "./get-extension-fake";
-import namespaceApiInjectable from "../../../common/k8s-api/endpoints/namespace.api.injectable";
+import { namespaceApiInjectable } from "@k8slens/kube-api-specifics";
 import { Namespace } from "@k8slens/kube-object";
 import { getOverrideFsWithFakes } from "../../../test-utils/override-fs-with-fakes";
 import applicationMenuItemCompositeInjectable from "../../../features/application-menu/main/application-menu-item-composite.injectable";

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

@@ -4,8 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../../../../common/k8s-api/stores-apis-can-be-created.token";
+import { storesAndApisCanBeCreatedInjectionToken, clusterRoleBindingApiInjectable } from "@k8slens/kube-api-specifics";
-import clusterRoleBindingApiInjectable from "../../../../common/k8s-api/endpoints/cluster-role-binding.api.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/kube-object-store-token";
 import { ClusterRoleBindingStore } from "./store";
 import clusterFrameContextForClusterScopedResourcesInjectable from "../../../cluster-frame-context/for-cluster-scoped-resources.injectable";

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

@@ -4,8 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../../../../common/k8s-api/stores-apis-can-be-created.token";
+import { storesAndApisCanBeCreatedInjectionToken, clusterRoleApiInjectable } from "@k8slens/kube-api-specifics";
-import clusterRoleApiInjectable from "../../../../common/k8s-api/endpoints/cluster-role.api.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/kube-object-store-token";
 import { ClusterRoleStore } from "./store";
 import clusterFrameContextForClusterScopedResourcesInjectable from "../../../cluster-frame-context/for-cluster-scoped-resources.injectable";

packages/core/src/renderer/components/user-management/role-bindings/dialog/view.tsx

@@ -35,7 +35,7 @@ import showDetailsInjectable from "../../../kube-detail-params/show-details.inje
 import clusterRoleStoreInjectable from "../../cluster-roles/store.injectable";
 import roleStoreInjectable from "../../roles/store.injectable";
 import serviceAccountStoreInjectable from "../../service-accounts/store.injectable";
-import roleApiInjectable from "../../../../../common/k8s-api/endpoints/role.api.injectable";
+import { roleApiInjectable } from "@k8slens/kube-api-specifics";
 import type { ShowCheckedErrorNotification } from "../../../notifications/show-checked-error.injectable";
 import showCheckedErrorNotificationInjectable from "../../../notifications/show-checked-error.injectable";
 import type { RoleApi } from "@k8slens/kube-api";

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

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/kube-object-store-token";
-import roleBindingApiInjectable from "../../../../common/k8s-api/endpoints/role-binding.api.injectable";
+import { roleBindingApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
 import { RoleBindingStore } from "./store";
 
 const roleBindingStoreInjectable = getInjectable({
   id: "role-binding-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "roleBindingStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "roleBindingStore is only available in certain environments");
 
     const api = di.inject(roleBindingApiInjectable);
 

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

@@ -4,8 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import roleApiInjectable from "../../../../common/k8s-api/endpoints/role.api.injectable";
+import { roleApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
-import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/kube-object-store-token";
 import { RoleStore } from "./store";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../../cluster-frame-context/for-namespaced-resources.injectable";
@@ -14,7 +13,7 @@ import { loggerInjectionToken } from "@k8slens/logger";
 const roleStoreInjectable = getInjectable({
   id: "role-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "roleStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "roleStore is only available in certain environments");
 
     const api = di.inject(roleApiInjectable);
 

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

@@ -4,8 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import serviceAccountApiInjectable from "../../../../common/k8s-api/endpoints/service-account.api.injectable";
+import { serviceAccountApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
-import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/kube-object-store-token";
 import { ServiceAccountStore } from "./store";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../../cluster-frame-context/for-namespaced-resources.injectable";
@@ -14,7 +13,7 @@ import { loggerInjectionToken } from "@k8slens/logger";
 const serviceAccountStoreInjectable = getInjectable({
   id: "service-account-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "serviceAccountStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "serviceAccountStore is only available in certain environments");
 
     const api = di.inject(serviceAccountApiInjectable);
 

packages/core/src/renderer/components/workloads-cronjobs/cron-job-menu.tsx

@@ -12,7 +12,7 @@ import { withInjectables } from "@ogre-tools/injectable-react";
 import openConfirmDialogInjectable from "../confirm-dialog/open.injectable";
 import type { OpenCronJobTriggerDialog } from "./trigger-dialog/open.injectable";
 import openCronJobTriggerDialogInjectable from "./trigger-dialog/open.injectable";
-import cronJobApiInjectable from "../../../common/k8s-api/endpoints/cron-job.api.injectable";
+import { cronJobApiInjectable } from "@k8slens/kube-api-specifics";
 import type { ShowCheckedErrorNotification } from "../notifications/show-checked-error.injectable";
 import showCheckedErrorNotificationInjectable from "../notifications/show-checked-error.injectable";
 import type { CronJobApi } from "@k8slens/kube-api";

packages/core/src/renderer/components/workloads-cronjobs/store.injectable.ts

@@ -6,16 +6,15 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import getJobsByOwnerInjectable from "../workloads-jobs/get-jobs-by-owner.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import cronJobApiInjectable from "../../../common/k8s-api/endpoints/cron-job.api.injectable";
+import { cronJobApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { CronJobStore } from "./store";
 
 const cronJobStoreInjectable = getInjectable({
   id: "cron-job-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "cronJobStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "cronJobStore is only available in certain environments");
 
     const api = di.inject(cronJobApiInjectable);
 

packages/core/src/renderer/components/workloads-cronjobs/trigger-dialog/view.tsx

@@ -19,7 +19,7 @@ import { Input } from "../../input";
 import { systemName, maxLength } from "../../input/input_validators";
 import { withInjectables } from "@ogre-tools/injectable-react";
 import closeCronJobTriggerDialogInjectable from "./close.injectable";
-import jobApiInjectable from "../../../../common/k8s-api/endpoints/job.api.injectable";
+import { jobApiInjectable } from "@k8slens/kube-api-specifics";
 import cronJobTriggerDialogStateInjectable from "./state.injectable";
 import type { ShowCheckedErrorNotification } from "../../notifications/show-checked-error.injectable";
 import showCheckedErrorNotificationInjectable from "../../notifications/show-checked-error.injectable";

packages/core/src/renderer/components/workloads-daemonsets/daemonset-menu.tsx

@@ -8,7 +8,7 @@ import type { DaemonSet } from "@k8slens/kube-object";
 import { MenuItem } from "../menu";
 import { Icon } from "@k8slens/icon";
 import { withInjectables } from "@ogre-tools/injectable-react";
-import daemonSetApiInjectable from "../../../common/k8s-api/endpoints/daemon-set.api.injectable";
+import { daemonSetApiInjectable } from "@k8slens/kube-api-specifics";
 import type { OpenConfirmDialog } from "../confirm-dialog/open.injectable";
 import openConfirmDialogInjectable from "../confirm-dialog/open.injectable";
 import type { ShowCheckedErrorNotification } from "../notifications/show-checked-error.injectable";

packages/core/src/renderer/components/workloads-daemonsets/store.injectable.ts

@@ -5,8 +5,7 @@
 import { getInjectable } from "@ogre-tools/injectable";
 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 { daemonSetApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
 import { DaemonSetStore } from "./store";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
@@ -15,7 +14,7 @@ import { loggerInjectionToken } from "@k8slens/logger";
 const daemonSetStoreInjectable = getInjectable({
   id: "daemon-set-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "daemonSetStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "daemonSetStore is only available in certain environments");
 
     const api = di.inject(daemonSetApiInjectable);
 

packages/core/src/renderer/components/workloads-deployments/deployment-menu.tsx

@@ -9,7 +9,7 @@ import { MenuItem } from "../menu";
 import { Icon } from "@k8slens/icon";
 import type { OpenDeploymentScaleDialog } from "./scale/open.injectable";
 import { withInjectables } from "@ogre-tools/injectable-react";
-import deploymentApiInjectable from "../../../common/k8s-api/endpoints/deployment.api.injectable";
+import { deploymentApiInjectable } from "@k8slens/kube-api-specifics";
 import openDeploymentScaleDialogInjectable from "./scale/open.injectable";
 import type { OpenConfirmDialog } from "../confirm-dialog/open.injectable";
 import openConfirmDialogInjectable from "../confirm-dialog/open.injectable";

packages/core/src/renderer/components/workloads-deployments/scale/dialog.test.tsx

@@ -9,7 +9,7 @@ import { DeploymentScaleDialog } from "./dialog";
 import type { DeploymentApi } from "@k8slens/kube-api";
 import { Deployment } from "@k8slens/kube-object";
 import { getDiForUnitTesting } from "../../../getDiForUnitTesting";
-import deploymentApiInjectable from "../../../../common/k8s-api/endpoints/deployment.api.injectable";
+import { deploymentApiInjectable } from "@k8slens/kube-api-specifics";
 import type { OpenDeploymentScaleDialog } from "./open.injectable";
 import openDeploymentScaleDialogInjectable from "./open.injectable";
 import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";