chore: Extract specific KubeApi injectables to own package

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

packages/utility-features/kube-api-specifics/index.ts

@@ -1,2 +1,2 @@
-export * from "./src/token";
-export * from "./src/can-be-created-token";
+export * from "./src/specifics";
+export * from "./src/feature";

packages/utility-features/kube-api-specifics/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@k8slens/kube-api-specifics",
   "private": false,
-  "version": "1.0.0-alpha.1",
+  "version": "1.0.0",
   "description": "Kube api",
   "type": "commonjs",
   "publishConfig": {
@@ -32,8 +32,11 @@
     "lint:fix": "lens-lint --fix"
   },
   "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"
   },
   "devDependencies": {
     "@k8slens/eslint-config": "^6.5.0-alpha.2",

packages/utility-features/kube-api-specifics/src/feature.ts

@@ -0,0 +1,13 @@
+import { getFeature } from "@k8slens/feature-core";
+import { autoRegister } from "@ogre-tools/injectable-extension-for-auto-registration";
+
+export const kubeApiSpecificsFeature = getFeature({
+  id: "kube-api-specifics",
+  register: (di) => {
+    autoRegister({
+      di,
+      targetModule: module,
+      getRequireContexts: () => [require.context("./", true, /\.injectable\.(ts|tsx)$/)],
+    });
+  },
+});

packages/utility-features/kube-api-specifics/src/specifics/cluster-role-binding.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/cluster-role.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/cluster.api.injectable.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 "./can-be-created-token";
+import { ClusterApi } from "@k8slens/kube-api";
+import { kubeApiInjectionToken } from "./token";
+import { logErrorInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
+import { maybeKubeApiInjectable } from "./maybe-kube-api.injectable";
+
+export const clusterApiInjectable = getInjectable({
+  id: "cluster-api",
+  instantiate: (di) => {
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterApi is only available in certain environments");
+
+    return new ClusterApi({
+      logError: di.inject(logErrorInjectionToken),
+      logInfo: di.inject(logInfoInjectionToken),
+      logWarn: di.inject(logWarningInjectionToken),
+      maybeKubeApi: di.inject(maybeKubeApiInjectable),
+    });
+  },
+
+  injectionToken: kubeApiInjectionToken,
+});

packages/utility-features/kube-api-specifics/src/specifics/component-status.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/config-map.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/cron-job.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/custom-resource-definition.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/daemon-set.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/deployment.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/endpoint.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/event.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/horizontal-pod-autoscaler.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/index.ts

@@ -0,0 +1,45 @@
+export * from "./can-be-created-token";
+export * from "./cluster-role-binding.api.injectable";
+export * from "./cluster-role.api.injectable";
+export * from "./cluster.api.injectable";
+export * from "./component-status.api.injectable";
+export * from "./config-map.api.injectable";
+export * from "./cron-job.api.injectable";
+export * from "./custom-resource-definition.api.injectable";
+export * from "./daemon-set.api.injectable";
+export * from "./deployment.api.injectable";
+export * from "./endpoint.api.injectable";
+export * from "./event.api.injectable";
+export * from "./horizontal-pod-autoscaler.api.injectable";
+export * from "./ingress-class.api.injectable";
+export * from "./ingress.api.injectable";
+export * from "./job.api.injectable";
+export * from "./lease.api.injectable";
+export * from "./limit-range.api.injectable";
+export * from "./maybe-kube-api.injectable";
+export * from "./mutating-webhook-configuration-api.injectable";
+export * from "./namespace.api.injectable";
+export * from "./network-policy.api.injectable";
+export * from "./node.api.injectable";
+export * from "./persistent-volume-claim.api.injectable";
+export * from "./persistent-volume.api.injectable";
+export * from "./pod-disruption-budget.api.injectable";
+export * from "./pod-metrics.api.injectable";
+export * from "./pod-security-policy.api.injectable";
+export * from "./pod.api.injectable";
+export * from "./priority-class.api.injectable";
+export * from "./replica-set.api.injectable";
+export * from "./replication-controller.api.injectable";
+export * from "./resource-quota.api.injectable";
+export * from "./role-binding.api.injectable";
+export * from "./role.api.injectable";
+export * from "./runtime-class.api.injectable";
+export * from "./secret.api.injectable";
+export * from "./self-subject-rules-reviews.api.injectable";
+export * from "./service-account.api.injectable";
+export * from "./service.api.injectable";
+export * from "./stateful-set.api.injectable";
+export * from "./storage-class.api.injectable";
+export * from "./token";
+export * from "./validating-webhook-configuration-api.injectable";
+export * from "./vertical-pod-autoscaler.api.injectable";

packages/utility-features/kube-api-specifics/src/specifics/ingress-class.api.injectable.ts

@@ -0,0 +1,30 @@
+/**
+ * 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 { IngressClassApi } from "@k8slens/kube-api";
+import { kubeApiInjectionToken } from "./token";
+import { logErrorInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
+import { maybeKubeApiInjectable } from "./maybe-kube-api.injectable";
+import { storesAndApisCanBeCreatedInjectionToken } from "./can-be-created-token";
+
+export const ingressClassApiInjectable = getInjectable({
+  id: "ingress-class-api",
+  instantiate: (di) => {
+    assert(
+      di.inject(storesAndApisCanBeCreatedInjectionToken),
+      "horizontalPodAutoscalerApi is only available in certain environments",
+    );
+
+    return new IngressClassApi({
+      logError: di.inject(logErrorInjectionToken),
+      logInfo: di.inject(logInfoInjectionToken),
+      logWarn: di.inject(logWarningInjectionToken),
+      maybeKubeApi: di.inject(maybeKubeApiInjectable),
+    });
+  },
+
+  injectionToken: kubeApiInjectionToken,
+});

packages/utility-features/kube-api-specifics/src/specifics/ingress.api.injectable.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 "./can-be-created-token";
+import { IngressApi } from "@k8slens/kube-api";
+import { kubeApiInjectionToken } from "./token";
+import { logErrorInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
+import { maybeKubeApiInjectable } from "./maybe-kube-api.injectable";
+
+export const ingressApiInjectable = getInjectable({
+  id: "ingress-api",
+  instantiate: (di) => {
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "ingressApi is only available in certain environments");
+
+    return new IngressApi({
+      logError: di.inject(logErrorInjectionToken),
+      logInfo: di.inject(logInfoInjectionToken),
+      logWarn: di.inject(logWarningInjectionToken),
+      maybeKubeApi: di.inject(maybeKubeApiInjectable),
+    });
+  },
+
+  injectionToken: kubeApiInjectionToken,
+});

packages/utility-features/kube-api-specifics/src/specifics/job.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/lease.api.injectable.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 "./can-be-created-token";
+import { LeaseApi } from "@k8slens/kube-api";
+import { kubeApiInjectionToken } from "./token";
+import { logErrorInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
+import { maybeKubeApiInjectable } from "./maybe-kube-api.injectable";
+
+export const leaseApiInjectable = getInjectable({
+  id: "lease-api",
+  instantiate: (di) => {
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "leaseApi is only available in certain environments");
+
+    return new LeaseApi({
+      logError: di.inject(logErrorInjectionToken),
+      logInfo: di.inject(logInfoInjectionToken),
+      logWarn: di.inject(logWarningInjectionToken),
+      maybeKubeApi: di.inject(maybeKubeApiInjectable),
+    });
+  },
+
+  injectionToken: kubeApiInjectionToken,
+});

packages/utility-features/kube-api-specifics/src/specifics/limit-range.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/maybe-kube-api.injectable.ts

@@ -0,0 +1,17 @@
+/**
+ * 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 { apiKubeInjectionToken } from "@k8slens/kube-api";
+
+export const maybeKubeApiInjectable = getInjectable({
+  id: "maybe-kube-api",
+  instantiate: (di) => {
+    try {
+      return di.inject(apiKubeInjectionToken);
+    } catch {
+      return undefined;
+    }
+  },
+});

packages/utility-features/kube-api-specifics/src/specifics/mutating-webhook-configuration-api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/namespace.api.injectable.ts

@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import assert from "assert";
+import { storesAndApisCanBeCreatedInjectionToken } from "./can-be-created-token";
+import { NamespaceApi } from "@k8slens/kube-api";
+import { kubeApiInjectionToken } from "./token";
+import { logErrorInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
+import { maybeKubeApiInjectable } from "./maybe-kube-api.injectable";
+
+export const namespaceApiInjectable = getInjectable({
+  id: "namespace-api",
+
+  instantiate: (di) => {
+    assert(
+      di.inject(storesAndApisCanBeCreatedInjectionToken),
+      "namespaceApi is only available in certain environments",
+    );
+
+    return new NamespaceApi({
+      logError: di.inject(logErrorInjectionToken),
+      logInfo: di.inject(logInfoInjectionToken),
+      logWarn: di.inject(logWarningInjectionToken),
+      maybeKubeApi: di.inject(maybeKubeApiInjectable),
+    });
+  },
+
+  injectionToken: kubeApiInjectionToken,
+});

packages/utility-features/kube-api-specifics/src/specifics/network-policy.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/node.api.injectable.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 "./can-be-created-token";
+import { NodeApi } from "@k8slens/kube-api";
+import { kubeApiInjectionToken } from "./token";
+import { logErrorInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
+import { maybeKubeApiInjectable } from "./maybe-kube-api.injectable";
+
+export const nodeApiInjectable = getInjectable({
+  id: "node-api",
+  instantiate: (di) => {
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "nodeApi is only available in certain environments");
+
+    return new NodeApi({
+      logError: di.inject(logErrorInjectionToken),
+      logInfo: di.inject(logInfoInjectionToken),
+      logWarn: di.inject(logWarningInjectionToken),
+      maybeKubeApi: di.inject(maybeKubeApiInjectable),
+    });
+  },
+
+  injectionToken: kubeApiInjectionToken,
+});

packages/utility-features/kube-api-specifics/src/specifics/persistent-volume-claim.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/persistent-volume.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/pod-disruption-budget.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/pod-metrics.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/pod-security-policy.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/pod.api.injectable.ts

@@ -0,0 +1,28 @@
+/**
+ * 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 "./can-be-created-token";
+import { PodApi } from "@k8slens/kube-api";
+import { kubeApiInjectionToken } from "./token";
+import { logErrorInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
+import { maybeKubeApiInjectable } from "./maybe-kube-api.injectable";
+
+export const podApiInjectable = getInjectable({
+  id: "pod-api",
+
+  instantiate: (di) => {
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podApi is only available in certain environments");
+
+    return new PodApi({
+      logError: di.inject(logErrorInjectionToken),
+      logInfo: di.inject(logInfoInjectionToken),
+      logWarn: di.inject(logWarningInjectionToken),
+      maybeKubeApi: di.inject(maybeKubeApiInjectable),
+    });
+  },
+
+  injectionToken: kubeApiInjectionToken,
+});

packages/utility-features/kube-api-specifics/src/specifics/priority-class.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/replica-set.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/replication-controller.api.injectable.ts

@@ -0,0 +1,30 @@
+/**
+ * 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 { ReplicationControllerApi } from "@k8slens/kube-api";
+import { kubeApiInjectionToken } from "./token";
+import { logErrorInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
+import { maybeKubeApiInjectable } from "./maybe-kube-api.injectable";
+import { storesAndApisCanBeCreatedInjectionToken } from "./can-be-created-token";
+
+export const replicationControllerApiInjectable = getInjectable({
+  id: "replication-controller-api",
+  instantiate: (di) => {
+    assert(
+      di.inject(storesAndApisCanBeCreatedInjectionToken),
+      "replicationControllerApi is only available in certain environments",
+    );
+
+    return new ReplicationControllerApi({
+      logError: di.inject(logErrorInjectionToken),
+      logInfo: di.inject(logInfoInjectionToken),
+      logWarn: di.inject(logWarningInjectionToken),
+      maybeKubeApi: di.inject(maybeKubeApiInjectable),
+    });
+  },
+
+  injectionToken: kubeApiInjectionToken,
+});

packages/utility-features/kube-api-specifics/src/specifics/resource-quota.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/role-binding.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/role.api.injectable.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 "./can-be-created-token";
+import { RoleApi } from "@k8slens/kube-api";
+import { kubeApiInjectionToken } from "./token";
+import { logErrorInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
+import { maybeKubeApiInjectable } from "./maybe-kube-api.injectable";
+
+export const roleApiInjectable = getInjectable({
+  id: "role-api",
+  instantiate: (di) => {
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "roleApi is only available in certain environments");
+
+    return new RoleApi({
+      logError: di.inject(logErrorInjectionToken),
+      logInfo: di.inject(logInfoInjectionToken),
+      logWarn: di.inject(logWarningInjectionToken),
+      maybeKubeApi: di.inject(maybeKubeApiInjectable),
+    });
+  },
+
+  injectionToken: kubeApiInjectionToken,
+});

packages/utility-features/kube-api-specifics/src/specifics/runtime-class.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/secret.api.injectable.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 "./can-be-created-token";
+import { SecretApi } from "@k8slens/kube-api";
+import { kubeApiInjectionToken } from "./token";
+import { logErrorInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
+import { maybeKubeApiInjectable } from "./maybe-kube-api.injectable";
+
+export const secretApiInjectable = getInjectable({
+  id: "secret-api",
+  instantiate: (di) => {
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "secretApi is only available in certain environments");
+
+    return new SecretApi({
+      logError: di.inject(logErrorInjectionToken),
+      logInfo: di.inject(logInfoInjectionToken),
+      logWarn: di.inject(logWarningInjectionToken),
+      maybeKubeApi: di.inject(maybeKubeApiInjectable),
+    });
+  },
+
+  injectionToken: kubeApiInjectionToken,
+});

packages/utility-features/kube-api-specifics/src/specifics/self-subject-rules-reviews.api.injectable.ts

@@ -0,0 +1,30 @@
+/**
+ * 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 "./can-be-created-token";
+import { SelfSubjectRulesReviewApi } from "@k8slens/kube-api";
+import { kubeApiInjectionToken } from "./token";
+import { logErrorInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
+import { maybeKubeApiInjectable } from "./maybe-kube-api.injectable";
+
+export 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({
+      logError: di.inject(logErrorInjectionToken),
+      logInfo: di.inject(logInfoInjectionToken),
+      logWarn: di.inject(logWarningInjectionToken),
+      maybeKubeApi: di.inject(maybeKubeApiInjectable),
+    });
+  },
+
+  injectionToken: kubeApiInjectionToken,
+});

packages/utility-features/kube-api-specifics/src/specifics/service-account.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/service.api.injectable.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 "./can-be-created-token";
+import { ServiceApi } from "@k8slens/kube-api";
+import { kubeApiInjectionToken } from "./token";
+import { logErrorInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
+import { maybeKubeApiInjectable } from "./maybe-kube-api.injectable";
+
+export const serviceApiInjectable = getInjectable({
+  id: "service-api",
+  instantiate: (di) => {
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "serviceApi is only available in certain environments");
+
+    return new ServiceApi({
+      logError: di.inject(logErrorInjectionToken),
+      logInfo: di.inject(logInfoInjectionToken),
+      logWarn: di.inject(logWarningInjectionToken),
+      maybeKubeApi: di.inject(maybeKubeApiInjectable),
+    });
+  },
+
+  injectionToken: kubeApiInjectionToken,
+});

packages/utility-features/kube-api-specifics/src/specifics/stateful-set.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/storage-class.api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/validating-webhook-configuration-api.injectable.ts

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

packages/utility-features/kube-api-specifics/src/specifics/vertical-pod-autoscaler.api.injectable.ts

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