Improve name of guarding injectable for stores and apis

- New name better implies that it is just a guard state and does not do
  anything

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

src/common/k8s-api/__tests__/deployment.api.test.ts

@@ -4,7 +4,7 @@
  */
 
 import { getDiForUnitTesting } from "../../../renderer/getDiForUnitTesting";
-import createStoresAndApisInjectable from "../../../renderer/create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../../renderer/stores-apis-can-be-created.injectable";
 import apiKubeInjectable from "../../../renderer/k8s/api-kube.injectable";
 import type { DeploymentApi } from "../endpoints/deployment.api";
 import deploymentApiInjectable from "../endpoints/deployment.api.injectable";
@@ -17,7 +17,7 @@ describe("DeploymentApi", () => {
   beforeEach(() => {
     const di = getDiForUnitTesting({ doGeneralOverrides: true });
 
-    di.override(createStoresAndApisInjectable, () => true);
+    di.override(storesAndApisCanBeCreatedInjectable, () => true);
     kubeJsonApi = {
       getResponse: jest.fn(),
       get: jest.fn(),

src/common/k8s-api/__tests__/stateful-set.api.test.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 
-import createStoresAndApisInjectable from "../../../renderer/create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../../renderer/stores-apis-can-be-created.injectable";
 import { getDiForUnitTesting } from "../../../renderer/getDiForUnitTesting";
 import apiKubeInjectable from "../../../renderer/k8s/api-kube.injectable";
 import type { StatefulSetApi } from "../endpoints";
@@ -17,7 +17,7 @@ describe("StatefulSetApi", () => {
   beforeEach(() => {
     const di = getDiForUnitTesting({ doGeneralOverrides: true });
 
-    di.override(createStoresAndApisInjectable, () => true);
+    di.override(storesAndApisCanBeCreatedInjectable, () => true);
     kubeJsonApi = {
       getResponse: jest.fn(),
       get: jest.fn(),

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

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable, getInjectionToken } from "@ogre-tools/injectable";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import type { KubeObjectStore } from "../kube-object.store";
 import { ApiManager } from "./api-manager";
 
@@ -16,7 +16,7 @@ const apiManagerInjectable = getInjectable({
   instantiate: (di) => {
     const apiManager = new ApiManager();
 
-    if (di.inject(createStoresAndApisInjectionToken)) {
+    if (di.inject(storesAndApisCanBeCreatedInjectionToken)) {
       const stores = di.injectMany(kubeObjectStoreInjectionToken);
 
       for (const store of stores) {

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { ClusterRoleBindingApi } from "./cluster-role-binding.api";
 
 const clusterRoleBindingApiInjectable = getInjectable({
   id: "cluster-role-binding-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "clusterRoleBindingApi is only accessible in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterRoleBindingApi is only accessible in certain environments");
 
     return new ClusterRoleBindingApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { ClusterRoleApi } from "./cluster-role.api";
 
 const clusterRoleApiInjectable = getInjectable({
   id: "cluster-role-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "clusterRoleApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterRoleApi is only available in certain environments");
 
     return new ClusterRoleApi();
   },

src/common/k8s-api/endpoints/cluster.api.injectable.ts

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { ClusterApi } from "./cluster.api";
 
 const clusterApiInjectable = getInjectable({
   id: "cluster-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "clusterApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterApi is only available in certain environments");
 
     return new ClusterApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { ComponentStatusApi } from "./component-status.api";
 
 const componentStatusApiInjectable = getInjectable({
   id: "component-status-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "componentStatusApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "componentStatusApi is only available in certain environments");
 
     return new ComponentStatusApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { ConfigMapApi } from "./config-map.api";
 
 const configMapApiInjectable = getInjectable({
   id: "config-map-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "configMapApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "configMapApi is only available in certain environments");
 
     return new ConfigMapApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { CronJobApi } from "./cron-job.api";
 
 const cronJobApiInjectable = getInjectable({
   id: "cron-job-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "cronJobApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "cronJobApi is only available in certain environments");
 
     return new CronJobApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { CustomResourceDefinitionApi } from "./custom-resource-definition.api";
 
 const customResourceDefinitionApiInjectable = getInjectable({
   id: "custom-resource-definition-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "customResourceDefinitionApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "customResourceDefinitionApi is only available in certain environments");
 
     return new CustomResourceDefinitionApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { DaemonSetApi } from "./daemon-set.api";
 
 const daemonSetApiInjectable = getInjectable({
   id: "daemon-set-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "daemonSetApi is only available in certain environements");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "daemonSetApi is only available in certain environements");
 
     return new DaemonSetApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { DeploymentApi } from "./deployment.api";
 
 const deploymentApiInjectable = getInjectable({
   id: "deployment-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "deploymentApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "deploymentApi is only available in certain environments");
 
     return new DeploymentApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { EndpointsApi } from "./endpoint.api";
 
 const endpointsApiInjectable = getInjectable({
   id: "endpoints-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "endpointsApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "endpointsApi is only available in certain environments");
 
     return new EndpointsApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { KubeEventApi } from "./events.api";
 
 const kubeEventApiInjectable = getInjectable({
   id: "kube-event-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "kubeEventApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "kubeEventApi is only available in certain environments");
 
     return new KubeEventApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { HorizontalPodAutoscalerApi } from "./horizontal-pod-autoscaler.api";
 
 const horizontalPodAutoscalerApiInjectable = getInjectable({
   id: "horizontal-pod-autoscaler-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "horizontalPodAutoscalerApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "horizontalPodAutoscalerApi is only available in certain environments");
 
     return new HorizontalPodAutoscalerApi();
   },

src/common/k8s-api/endpoints/ingress.api.injectable.ts

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { IngressApi } from "./ingress.api";
 
 const ingressApiInjectable = getInjectable({
   id: "ingress-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "ingressApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "ingressApi is only available in certain environments");
 
     return new IngressApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { JobApi } from "./job.api";
 
 const jobApiInjectable = getInjectable({
   id: "job-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "jobApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "jobApi is only available in certain environments");
 
     return new JobApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { LimitRangeApi } from "./limit-range.api";
 
 const limitRangeApiInjectable = getInjectable({
   id: "limit-range-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "limitRangeApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "limitRangeApi is only available in certain environments");
 
     return new LimitRangeApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { NamespaceApi } from "./namespace.api";
 
 const namespaceApiInjectable = getInjectable({
   id: "namespace-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "namespaceApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "namespaceApi is only available in certain environments");
 
     return new NamespaceApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { NetworkPolicyApi } from "./network-policy.api";
 
 const networkPolicyApiInjectable = getInjectable({
   id: "network-policy-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "networkPolicyApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "networkPolicyApi is only available in certain environments");
 
     return new NetworkPolicyApi();
   },

src/common/k8s-api/endpoints/node.api.injectable.ts

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { NodeApi } from "./node.api";
 
 const nodeApiInjectable = getInjectable({
   id: "node-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "nodeApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "nodeApi is only available in certain environments");
 
     return new NodeApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { PersistentVolumeClaimApi } from "./persistent-volume-claim.api";
 
 const persistentVolumeClaimApiInjectable = getInjectable({
   id: "persistent-volume-claim-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "persistentVolumeClaimApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "persistentVolumeClaimApi is only available in certain environments");
 
     return new PersistentVolumeClaimApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { PersistentVolumeApi } from "./persistent-volume.api";
 
 const persistentVolumeApiInjectable = getInjectable({
   id: "persistent-volume-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "persistentVolumeApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "persistentVolumeApi is only available in certain environments");
 
     return new PersistentVolumeApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { PodDisruptionBudgetApi } from "./pod-disruption-budget.api";
 
 const podDisruptionBudgetApiInjectable = getInjectable({
   id: "pod-disruption-budget-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "podDisruptionBudgetApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podDisruptionBudgetApi is only available in certain environments");
 
     return new PodDisruptionBudgetApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { PodMetricsApi } from "./pod-metrics.api";
 
 const podMetricsApiInjectable = getInjectable({
   id: "pod-metrics-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "podMetricsApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podMetricsApi is only available in certain environments");
 
     return new PodMetricsApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { PodSecurityPolicyApi } from "./pod-security-policy.api";
 
 const podSecurityPolicyApiInjectable = getInjectable({
   id: "pod-security-policy-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "podSecurityPolicyApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podSecurityPolicyApi is only available in certain environments");
 
     return new PodSecurityPolicyApi();
   },

src/common/k8s-api/endpoints/pod.api.injectable.ts

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { PodApi } from "./pod.api";
 
 const podApiInjectable = getInjectable({
   id: "pod-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "podApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podApi is only available in certain environments");
 
     return new PodApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { ReplicaSetApi } from "./replica-set.api";
 
 const replicaSetApiInjectable = getInjectable({
   id: "replica-set-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "replicaSetApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "replicaSetApi is only available in certain environments");
 
     return new ReplicaSetApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { ResourceQuotaApi } from "./resource-quota.api";
 
 const resourceQuotaApiInjectable = getInjectable({
   id: "resource-quota-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "resourceQuotaApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "resourceQuotaApi is only available in certain environments");
 
     return new ResourceQuotaApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { RoleBindingApi } from "./role-binding.api";
 
 const roleBindingApiInjectable = getInjectable({
   id: "role-binding-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "roleBindingApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "roleBindingApi is only available in certain environments");
 
     return new RoleBindingApi();
   },

src/common/k8s-api/endpoints/role.api.injectable.ts

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { RoleApi } from "./role.api";
 
 const roleApiInjectable = getInjectable({
   id: "role-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "roleApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "roleApi is only available in certain environments");
 
     return new RoleApi();
   },

src/common/k8s-api/endpoints/secret.api.injectable.ts

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { SecretApi } from "./secret.api";
 
 const secretApiInjectable = getInjectable({
   id: "secret-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "secretApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "secretApi is only available in certain environments");
 
     return new SecretApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { SelfSubjectRulesReviewApi } from "./self-subject-rules-reviews.api";
 
 const selfSubjectRulesReviewApiInjectable = getInjectable({
   id: "self-subject-rules-review-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "selfSubjectRulesReviewApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "selfSubjectRulesReviewApi is only available in certain environments");
 
     return new SelfSubjectRulesReviewApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { ServiceAccountApi } from "./service-account.api";
 
 const serviceAccountApiInjectable = getInjectable({
   id: "service-account-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "serviceAccountApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "serviceAccountApi is only available in certain environments");
 
     return new ServiceAccountApi();
   },

src/common/k8s-api/endpoints/service.api.injectable.ts

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { ServiceApi } from "./service.api";
 
 const serviceApiInjectable = getInjectable({
   id: "service-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "serviceApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "serviceApi is only available in certain environments");
 
     return new ServiceApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { StatefulSetApi } from "./stateful-set.api";
 
 const statefulSetApiInjectable = getInjectable({
   id: "stateful-set-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "statefulSetApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "statefulSetApi is only available in certain environments");
 
     return new StatefulSetApi();
   },

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

@@ -4,13 +4,13 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { StorageClassApi } from "./storage-class.api";
 
 const storageClassApiInjectable = getInjectable({
   id: "storage-class-api",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "storageClassApi is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "storageClassApi is only available in certain environments");
 
     return new StorageClassApi();
   },

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

@@ -5,12 +5,12 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import { computed } from "mobx";
 import namespaceStoreInjectable from "../../renderer/components/+namespaces/store.injectable";
-import { createStoresAndApisInjectionToken } from "./create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "./stores-apis-can-be-created.token";
 
 const selectedFilterNamespacesInjectable = getInjectable({
   id: "selected-filter-namespaces",
   instantiate: (di) => {
-    if (!di.inject(createStoresAndApisInjectionToken)) {
+    if (!di.inject(storesAndApisCanBeCreatedInjectionToken)) {
       // Dummy value so that this works in all environments
       return computed(() => []);
     }

src/common/k8s-api/stores-apis-can-be-created.token.ts

@@ -5,6 +5,6 @@
 
 import { getInjectionToken } from "@ogre-tools/injectable";
 
-export const createStoresAndApisInjectionToken = getInjectionToken<boolean>({
+export const storesAndApisCanBeCreatedInjectionToken = getInjectionToken<boolean>({
-  id: "create-stores-and-apis-token",
+  id: "stores-and-apis-can-be-created-token",
 });

src/main/create-stores-api.injectable.ts

@@ -1,14 +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 { createStoresAndApisInjectionToken } from "../common/k8s-api/create-stores-apis.token";
-
-const createStoresAndApisInjectable = getInjectable({
-  id: "create-stores-and-apis",
-  instantiate: () => false,
-  injectionToken: createStoresAndApisInjectionToken,
-});
-
-export default createStoresAndApisInjectable;

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

@@ -0,0 +1,14 @@
+/**
+ * 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 { storesAndApisCanBeCreatedInjectionToken } from "../common/k8s-api/stores-apis-can-be-created.token";
+
+const storesAndApisCanBeCreatedInjectable = getInjectable({
+  id: "create-stores-and-apis",
+  instantiate: () => false,
+  injectionToken: storesAndApisCanBeCreatedInjectionToken,
+});
+
+export default storesAndApisCanBeCreatedInjectable;

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

@@ -9,7 +9,7 @@ import { ClusterOverviewStore, MetricNodeRole, MetricType } from "./cluster-over
 import createStorageInjectable from "../../../utils/create-storage/create-storage.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/manager.injectable";
 import clusterApiInjectable from "../../../../common/k8s-api/endpoints/cluster.api.injectable";
-import createStoresAndApisInjectable from "../../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
 import assert from "assert";
 import nodeStoreInjectable from "../../+nodes/store.injectable";
 
@@ -17,7 +17,7 @@ const clusterOverviewStoreInjectable = getInjectable({
   id: "cluster-overview-store",
 
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectable), "clusterOverviewStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "clusterOverviewStore is only available in certain environments");
     const createStorage = di.inject(createStorageInjectable);
     const clusterApi = di.inject(clusterApiInjectable);
 

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

@@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import horizontalPodAutoscalerApiInjectable from "../../../common/k8s-api/endpoints/horizontal-pod-autoscaler.api.injectable";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import 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(createStoresAndApisInjectable), "horizontalPodAutoscalerStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "horizontalPodAutoscalerStore is only available in certain environments");
 
     const api = di.inject(horizontalPodAutoscalerApiInjectable);
 

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

@@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import limitRangeApiInjectable from "../../../common/k8s-api/endpoints/limit-range.api.injectable";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { LimitRangeStore } from "./store";
 
 const limitRangeStoreInjectable = getInjectable({
   id: "limit-range-store",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectable), "limitRangeStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "limitRangeStore is only available in certain environments");
 
     const api = di.inject(limitRangeApiInjectable);
 

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

@@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import configMapApiInjectable from "../../../common/k8s-api/endpoints/config-map.api.injectable";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { ConfigMapStore } from "./store";
 
 const configMapStoreInjectable = getInjectable({
   id: "config-map-store",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectable), "configMapStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "configMapStore is only available in certain environments");
 
     const api = di.inject(configMapApiInjectable);
 

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

@@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import podDisruptionBudgetApiInjectable from "../../../common/k8s-api/endpoints/pod-disruption-budget.api.injectable";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import 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(createStoresAndApisInjectable), "podDisruptionBudgetStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "podDisruptionBudgetStore is only available in certain environments");
 
     const api = di.inject(podDisruptionBudgetApiInjectable);
 

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

@@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import resourceQuotaApiInjectable from "../../../common/k8s-api/endpoints/resource-quota.api.injectable";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { ResourceQuotaStore } from "./store";
 
 const resourceQuotaStoreInjectable = getInjectable({
   id: "resource-quota-store",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectable), "resourceQuotaStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "resourceQuotaStore is only available in certain environments");
 
     const api = di.inject(resourceQuotaApiInjectable);
 

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

@@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import secretApiInjectable from "../../../common/k8s-api/endpoints/secret.api.injectable";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { SecretStore } from "./store";
 
 const secretStoreInjectable = getInjectable({
   id: "secret-store",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectable), "secretStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "secretStore is only available in certain environments");
 
     const api = di.inject(secretApiInjectable);
 

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

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

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

@@ -7,13 +7,13 @@ import assert from "assert";
 import autoRegistrationEmitterInjectable from "../../../common/k8s-api/api-manager/auto-registration-emitter.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import customResourceDefinitionApiInjectable from "../../../common/k8s-api/endpoints/custom-resource-definition.api.injectable";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { CustomResourceDefinitionStore } from "./definition.store";
 
 const customResourceDefinitionStoreInjectable = getInjectable({
   id: "custom-resource-definition-store",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectable), "customResourceDefinitionStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "customResourceDefinitionStore is only available in certain environments");
 
     const api = di.inject(customResourceDefinitionApiInjectable);
 

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

@@ -7,13 +7,13 @@ import assert from "assert";
 import getPodByIdInjectable from "../+workloads-pods/get-pod-by-id.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import kubeEventApiInjectable from "../../../common/k8s-api/endpoints/events.api.injectable";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { EventStore } from "./store";
 
 const eventStoreInjectable = getInjectable({
   id: "event-store",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectable), "eventStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "eventStore is only available in certain environments");
 
     const api = di.inject(kubeEventApiInjectable);
 

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

@@ -8,13 +8,13 @@ import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manag
 import createStorageInjectable from "../../utils/create-storage/create-storage.injectable";
 import namespaceApiInjectable from "../../../common/k8s-api/endpoints/namespace.api.injectable";
 import assert from "assert";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 
 const namespaceStoreInjectable = getInjectable({
   id: "namespace-store",
 
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectable), "namespaceStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "namespaceStore is only available in certain environments");
 
     const createStorage = di.inject(createStorageInjectable);
     const api = di.inject(namespaceApiInjectable);

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

@@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import endpointsApiInjectable from "../../../common/k8s-api/endpoints/endpoint.api.injectable";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { EndpointsStore } from "./store";
 
 const endpointsStoreInjectable = getInjectable({
   id: "endpoints-store",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectable), "endpointsStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "endpointsStore is only available in certain environments");
 
     const api = di.inject(endpointsApiInjectable);
 

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

@@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import ingressApiInjectable from "../../../common/k8s-api/endpoints/ingress.api.injectable";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { IngressStore } from "./store";
 
 const ingressStoreInjectable = getInjectable({
   id: "ingress-store",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectable), "ingressStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "ingressStore is only available in certain environments");
 
     const api = di.inject(ingressApiInjectable);
 

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

@@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import networkPolicyApiInjectable from "../../../common/k8s-api/endpoints/network-policy.api.injectable";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { NetworkPolicyStore } from "./store";
 
 const networkPolicyStoreInjectable = getInjectable({
   id: "network-policy-store",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectable), "networkPolicyStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "networkPolicyStore is only available in certain environments");
 
     const api = di.inject(networkPolicyApiInjectable);
 

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

@@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import serviceApiInjectable from "../../../common/k8s-api/endpoints/service.api.injectable";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { ServiceStore } from "./store";
 
 const serviceStoreInjectable = getInjectable({
   id: "service-store",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectable), "serviceStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "serviceStore is only available in certain environments");
 
     const api = di.inject(serviceApiInjectable);
 

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

@@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import nodeApiInjectable from "../../../common/k8s-api/endpoints/node.api.injectable";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { NodeStore } from "./store";
 
 const nodeStoreInjectable = getInjectable({
   id: "node-store",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectable), "nodeStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "nodeStore is only available in certain environments");
 
     const api = di.inject(nodeApiInjectable);
 

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

@@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import podSecurityPolicyApiInjectable from "../../../common/k8s-api/endpoints/pod-security-policy.api.injectable";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import 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(createStoresAndApisInjectable), "podSecurityPolicyStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "podSecurityPolicyStore is only available in certain environments");
 
     const api = di.inject(podSecurityPolicyApiInjectable);
 

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

@@ -7,13 +7,13 @@ import assert from "assert";
 import getPersistentVolumesByStorageClassInjectable from "../+storage-volumes/get-persisten-volumes-by-storage-class.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import storageClassApiInjectable from "../../../common/k8s-api/endpoints/storage-class.api.injectable";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { StorageClassStore } from "./store";
 
 const storageClassStoreInjectable = getInjectable({
   id: "storage-class-store",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectable), "storageClassStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "storageClassStore is only available in certain environments");
 
     const api = di.inject(storageClassApiInjectable);
 

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

@@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import persistentVolumeClaimApiInjectable from "../../../common/k8s-api/endpoints/persistent-volume-claim.api.injectable";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import 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(createStoresAndApisInjectable), "persistentVolumeClaimStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "persistentVolumeClaimStore is only available in certain environments");
 
     const api = di.inject(persistentVolumeClaimApiInjectable);
 

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

@@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import persistentVolumeApiInjectable from "../../../common/k8s-api/endpoints/persistent-volume.api.injectable";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { PersistentVolumeStore } from "./store";
 
 const persistentVolumeStoreInjectable = getInjectable({
   id: "persistent-volume-store",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectable), "persistentVolumeStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "persistentVolumeStore is only available in certain environments");
 
     const api = di.inject(persistentVolumeApiInjectable);
 

src/renderer/components/+user-management/+cluster-role-bindings/__tests__/dialog.test.tsx

@@ -11,7 +11,7 @@ import { getDiForUnitTesting } from "../../../../getDiForUnitTesting";
 import type { DiRender } from "../../../test-utils/renderFor";
 import { renderFor } from "../../../test-utils/renderFor";
 import clusterRoleStoreInjectable from "../../+cluster-roles/store.injectable";
-import createStoresAndApisInjectable from "../../../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../../../stores-apis-can-be-created.injectable";
 import ipcRendererInjectable from "../../../../app-paths/get-value-from-registered-channel/ipc-renderer/ipc-renderer.injectable";
 
 describe("ClusterRoleBindingDialog tests", () => {
@@ -20,7 +20,7 @@ describe("ClusterRoleBindingDialog tests", () => {
   beforeEach(async () => {
     const di = getDiForUnitTesting({ doGeneralOverrides: true });
 
-    di.override(createStoresAndApisInjectable, () => true);
+    di.override(storesAndApisCanBeCreatedInjectable, () => true);
     di.override(ipcRendererInjectable, () => ({
       on: jest.fn(),
       invoke: jest.fn(), // TODO: replace with proper mocking via the IPC bridge

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

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../../../../common/k8s-api/create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../../../../common/k8s-api/stores-apis-can-be-created.token";
 import clusterRoleBindingApiInjectable from "../../../../common/k8s-api/endpoints/cluster-role-binding.api.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/manager.injectable";
 import { ClusterRoleBindingStore } from "./store";
@@ -12,7 +12,7 @@ import { ClusterRoleBindingStore } from "./store";
 const clusterRoleBindingStoreInjectable = getInjectable({
   id: "cluster-role-binding-store",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "clusterRoleBindingStore is only accessible in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterRoleBindingStore is only accessible in certain environments");
 
     const api = di.inject(clusterRoleBindingApiInjectable);
 

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

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { createStoresAndApisInjectionToken } from "../../../../common/k8s-api/create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../../../../common/k8s-api/stores-apis-can-be-created.token";
 import clusterRoleApiInjectable from "../../../../common/k8s-api/endpoints/cluster-role.api.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/manager.injectable";
 import { ClusterRolesStore } from "./store";
@@ -12,7 +12,7 @@ import { ClusterRolesStore } from "./store";
 const clusterRoleStoreInjectable = getInjectable({
   id: "cluster-role-store",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "clusterRoleStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterRoleStore is only available in certain environments");
 
     const api = di.inject(clusterRoleApiInjectable);
 

src/renderer/components/+user-management/+role-bindings/__tests__/dialog.test.tsx

@@ -12,7 +12,7 @@ import type { DiRender } from "../../../test-utils/renderFor";
 import { renderFor } from "../../../test-utils/renderFor";
 import directoryForUserDataInjectable from "../../../../../common/app-paths/directory-for-user-data/directory-for-user-data.injectable";
 import clusterRoleStoreInjectable from "../../+cluster-roles/store.injectable";
-import createStoresAndApisInjectable from "../../../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../../../stores-apis-can-be-created.injectable";
 import ipcRendererInjectable from "../../../../app-paths/get-value-from-registered-channel/ipc-renderer/ipc-renderer.injectable";
 
 describe("RoleBindingDialog tests", () => {
@@ -21,7 +21,7 @@ describe("RoleBindingDialog tests", () => {
   beforeEach(async () => {
     const di = getDiForUnitTesting({ doGeneralOverrides: true });
 
-    di.override(createStoresAndApisInjectable, () => true);
+    di.override(storesAndApisCanBeCreatedInjectable, () => true);
     di.override(directoryForUserDataInjectable, () => "some-directory-for-user-data");
     di.override(ipcRendererInjectable, () => ({
       on: jest.fn(),

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

@@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/manager.injectable";
 import roleBindingApiInjectable from "../../../../common/k8s-api/endpoints/role-binding.api.injectable";
-import createStoresAndApisInjectable from "../../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
 import { RoleBindingStore } from "./store";
 
 const roleBindingStoreInjectable = getInjectable({
   id: "role-binding-store",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectable), "roleBindingStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "roleBindingStore is only available in certain environments");
 
     const api = di.inject(roleBindingApiInjectable);
 

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

@@ -5,14 +5,14 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import roleApiInjectable from "../../../../common/k8s-api/endpoints/role.api.injectable";
-import createStoresAndApisInjectable from "../../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/manager.injectable";
 import { RoleStore } from "./store";
 
 const roleStoreInjectable = getInjectable({
   id: "role-store",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectable), "roleStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "roleStore is only available in certain environments");
 
     const api = di.inject(roleApiInjectable);
 

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

@@ -5,14 +5,14 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import serviceAccountApiInjectable from "../../../../common/k8s-api/endpoints/service-account.api.injectable";
-import createStoresAndApisInjectable from "../../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/manager.injectable";
 import { ServiceAccountStore } from "./store";
 
 const serviceAccountStoreInjectable = getInjectable({
   id: "service-account-store",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectable), "serviceAccountStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "serviceAccountStore is only available in certain environments");
 
     const api = di.inject(serviceAccountApiInjectable);
 

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

@@ -7,13 +7,13 @@ import assert from "assert";
 import getJobsByOwnerInjectable from "../+workloads-jobs/get-jobs-by-owner.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import cronJobApiInjectable from "../../../common/k8s-api/endpoints/cron-job.api.injectable";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { CronJobStore } from "./store";
 
 const cronJobStoreInjectable = getInjectable({
   id: "cron-job-store",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectable), "cronJobStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "cronJobStore is only available in certain environments");
 
     const api = di.inject(cronJobApiInjectable);
 

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

@@ -6,14 +6,14 @@ 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 createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import { DaemonSetStore } from "./store";
 
 const daemonSetStoreInjectable = getInjectable({
   id: "daemon-set-store",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectable), "daemonSetStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "daemonSetStore is only available in certain environments");
 
     const api = di.inject(daemonSetApiInjectable);
 

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

@@ -14,7 +14,7 @@ import { getDiForUnitTesting } from "../../../getDiForUnitTesting";
 import deploymentApiInjectable from "../../../../common/k8s-api/endpoints/deployment.api.injectable";
 import type { OpenDeploymentScaleDialog } from "./open.injectable";
 import openDeploymentScaleDialogInjectable from "./open.injectable";
-import createStoresAndApisInjectable from "../../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
 import type { DiRender } from "../../test-utils/renderFor";
 import { renderFor } from "../../test-utils/renderFor";
 
@@ -90,7 +90,7 @@ describe("<DeploymentScaleDialog />", () => {
   beforeEach(() => {
     const di = getDiForUnitTesting({ doGeneralOverrides: true });
 
-    di.override(createStoresAndApisInjectable, () => true);
+    di.override(storesAndApisCanBeCreatedInjectable, () => true);
 
     deploymentApi = di.inject(deploymentApiInjectable);
     openDeploymentScaleDialog = di.inject(openDeploymentScaleDialogInjectable);

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

@@ -6,14 +6,14 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import podStoreInjectable from "../+workloads-pods/store.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
-import { createStoresAndApisInjectionToken } from "../../../common/k8s-api/create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../../../common/k8s-api/stores-apis-can-be-created.token";
 import deploymentApiInjectable from "../../../common/k8s-api/endpoints/deployment.api.injectable";
 import { DeploymentStore } from "./store";
 
 const deploymentStoreInjectable = getInjectable({
   id: "deployment-store",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "deploymentStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "deploymentStore is only available in certain environments");
 
     const api = di.inject(deploymentApiInjectable);
 

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

@@ -7,13 +7,13 @@ import assert from "assert";
 import getPodsByOwnerIdInjectable from "../+workloads-pods/get-pods-by-owner-id.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import jobApiInjectable from "../../../common/k8s-api/endpoints/job.api.injectable";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { JobStore } from "./store";
 
 const jobStoreInjectable = getInjectable({
   id: "job-store",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectable), "jobStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "jobStore is only available in certain environments");
 
     const api = di.inject(jobApiInjectable);
 

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

@@ -5,7 +5,7 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import podApiInjectable from "../../../common/k8s-api/endpoints/pod.api.injectable";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import { PodStore } from "./store";
 import podMetricsApiInjectable from "../../../common/k8s-api/endpoints/pod-metrics.api.injectable";
@@ -13,7 +13,7 @@ import podMetricsApiInjectable from "../../../common/k8s-api/endpoints/pod-metri
 const podStoreInjectable = getInjectable({
   id: "pod-store",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectable), "podStore is only available in certain environements");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "podStore is only available in certain environements");
 
     const api = di.inject(podApiInjectable);
 

src/renderer/components/+workloads-replicasets/scale-dialog/dialog.test.tsx

@@ -12,7 +12,7 @@ import type { ReplicaSetApi } from "../../../../common/k8s-api/endpoints/replica
 import { ReplicaSet } from "../../../../common/k8s-api/endpoints/replica-set.api";
 import type { OpenReplicaSetScaleDialog } from "./open.injectable";
 import replicaSetApiInjectable from "../../../../common/k8s-api/endpoints/replica-set.api.injectable";
-import createStoresAndApisInjectable from "../../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
 import { getDiForUnitTesting } from "../../../getDiForUnitTesting";
 import { type DiRender, renderFor } from "../../test-utils/renderFor";
 import openReplicaSetScaleDialogInjectable from "./open.injectable";
@@ -83,7 +83,7 @@ describe("<ReplicaSetScaleDialog />", () => {
   beforeEach(() => {
     const di = getDiForUnitTesting({ doGeneralOverrides: true });
 
-    di.override(createStoresAndApisInjectable, () => true);
+    di.override(storesAndApisCanBeCreatedInjectable, () => true);
 
     render = renderFor(di);
     replicaSetApi = di.inject(replicaSetApiInjectable);

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

@@ -6,14 +6,14 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import getPodsByOwnerIdInjectable from "../+workloads-pods/get-pods-by-owner-id.injectable";
 import replicaSetApiInjectable from "../../../common/k8s-api/endpoints/replica-set.api.injectable";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import { ReplicaSetStore } from "./store";
 
 const replicaSetStoreInjectable = getInjectable({
   id: "replica-set-store",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectable), "replicaSetStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "replicaSetStore is only available in certain environments");
 
     const api = di.inject(replicaSetApiInjectable);
 

src/renderer/components/+workloads-statefulsets/scale/dialog.test.tsx

@@ -13,7 +13,7 @@ import React from "react";
 import type { OpenStatefulSetScaleDialog } from "./open-dialog.injectable";
 import { getDiForUnitTesting } from "../../../getDiForUnitTesting";
 import statefulSetApiInjectable from "../../../../common/k8s-api/endpoints/stateful-set.api.injectable";
-import createStoresAndApisInjectable from "../../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
 import openStatefulSetScaleDialogInjectable from "./open-dialog.injectable";
 import { type DiRender, renderFor } from "../../test-utils/renderFor";
 
@@ -94,7 +94,7 @@ describe("<StatefulSetScaleDialog />", () => {
   beforeEach(() => {
     const di = getDiForUnitTesting({ doGeneralOverrides: true });
 
-    di.override(createStoresAndApisInjectable, () => true);
+    di.override(storesAndApisCanBeCreatedInjectable, () => true);
 
     render = renderFor(di);
     statefulSetApi = di.inject(statefulSetApiInjectable);

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

@@ -7,13 +7,13 @@ import assert from "assert";
 import getPodsByOwnerIdInjectable from "../+workloads-pods/get-pods-by-owner-id.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
 import statefulSetApiInjectable from "../../../common/k8s-api/endpoints/stateful-set.api.injectable";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { StatefulSetStore } from "./store";
 
 const statefulSetStoreInjectable = getInjectable({
   id: "stateful-set-store",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectable), "statefulSetStore is only available in certain environment");
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "statefulSetStore is only available in certain environment");
 
     const api = di.inject(statefulSetApiInjectable);
 

src/renderer/components/__tests__/cronjob.store.test.ts

@@ -5,7 +5,7 @@
 import type { CronJobStore } from "../+workloads-cronjobs/store";
 import cronJobStoreInjectable from "../+workloads-cronjobs/store.injectable";
 import { CronJob } from "../../../common/k8s-api/endpoints";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { getDiForUnitTesting } from "../../getDiForUnitTesting";
 
 const scheduledCronJob = new CronJob({
@@ -119,7 +119,7 @@ describe("CronJob Store tests", () => {
   beforeEach(() => {
     const di = getDiForUnitTesting({ doGeneralOverrides: true });
 
-    di.override(createStoresAndApisInjectable, () => true);
+    di.override(storesAndApisCanBeCreatedInjectable, () => true);
 
     cronJobStore = di.inject(cronJobStoreInjectable);
   });

src/renderer/components/__tests__/daemonset.store.test.ts

@@ -8,7 +8,7 @@ import type { DaemonSetStore } from "../+workloads-daemonsets/store";
 import daemonSetStoreInjectable from "../+workloads-daemonsets/store.injectable";
 import podStoreInjectable from "../+workloads-pods/store.injectable";
 import { DaemonSet, Pod } from "../../../common/k8s-api/endpoints";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { getDiForUnitTesting } from "../../getDiForUnitTesting";
 
 const runningDaemonSet = new DaemonSet({
@@ -136,7 +136,7 @@ describe("DaemonSet Store tests", () => {
   beforeEach(() => {
     const di = getDiForUnitTesting({ doGeneralOverrides: true });
 
-    di.override(createStoresAndApisInjectable, () => true);
+    di.override(storesAndApisCanBeCreatedInjectable, () => true);
 
     const podStore = di.inject(podStoreInjectable);
 

src/renderer/components/__tests__/deployments.store.test.ts

@@ -9,7 +9,7 @@ import deploymentStoreInjectable from "../+workloads-deployments/store.injectabl
 import podStoreInjectable from "../+workloads-pods/store.injectable";
 import type { PodSpec } from "../../../common/k8s-api/endpoints";
 import { Deployment, Pod } from "../../../common/k8s-api/endpoints";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { getDiForUnitTesting } from "../../getDiForUnitTesting";
 
 const spec: PodSpec = {
@@ -208,7 +208,7 @@ describe("Deployment Store tests", () => {
   beforeEach(() => {
     const di = getDiForUnitTesting({ doGeneralOverrides: true });
 
-    di.override(createStoresAndApisInjectable, () => true);
+    di.override(storesAndApisCanBeCreatedInjectable, () => true);
 
     const podStore = di.inject(podStoreInjectable);
 

src/renderer/components/__tests__/job.store.test.ts

@@ -8,7 +8,7 @@ import type { JobStore } from "../+workloads-jobs/store";
 import jobStoreInjectable from "../+workloads-jobs/store.injectable";
 import podStoreInjectable from "../+workloads-pods/store.injectable";
 import { Job, Pod } from "../../../common/k8s-api/endpoints";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { getDiForUnitTesting } from "../../getDiForUnitTesting";
 
 const runningJob = new Job({
@@ -173,7 +173,7 @@ describe("Job Store tests", () => {
   beforeEach(() => {
     const di = getDiForUnitTesting({ doGeneralOverrides: true });
 
-    di.override(createStoresAndApisInjectable, () => true);
+    di.override(storesAndApisCanBeCreatedInjectable, () => true);
 
     jobStore = di.inject(jobStoreInjectable);
 

src/renderer/components/__tests__/pods.store.test.ts

@@ -6,7 +6,7 @@
 import { Pod } from "../../../common/k8s-api/endpoints";
 import type { PodStore } from "../+workloads-pods/store";
 import podStoreInjectable from "../+workloads-pods/store.injectable";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { getDiForUnitTesting } from "../../getDiForUnitTesting";
 
 const runningPod = new Pod({
@@ -119,7 +119,7 @@ describe("Pod Store tests", () => {
   beforeEach(() => {
     const di = getDiForUnitTesting({ doGeneralOverrides: true });
 
-    di.override(createStoresAndApisInjectable, () => true);
+    di.override(storesAndApisCanBeCreatedInjectable, () => true);
 
     podStore = di.inject(podStoreInjectable);
   });

src/renderer/components/__tests__/replicaset.store.test.ts

@@ -8,7 +8,7 @@ import podStoreInjectable from "../+workloads-pods/store.injectable";
 import replicasetsStoreInjectable from "../+workloads-replicasets/store.injectable";
 import type { ReplicaSetStore } from "../+workloads-replicasets/store";
 import { ReplicaSet, Pod } from "../../../common/k8s-api/endpoints";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { getDiForUnitTesting } from "../../getDiForUnitTesting";
 
 const runningReplicaSet = new ReplicaSet({
@@ -136,7 +136,7 @@ describe("ReplicaSet Store tests", () => {
   beforeEach(() => {
     const di = getDiForUnitTesting({ doGeneralOverrides: true });
 
-    di.override(createStoresAndApisInjectable, () => true);
+    di.override(storesAndApisCanBeCreatedInjectable, () => true);
 
     const podStore = di.inject(podStoreInjectable);
 

src/renderer/components/__tests__/statefulset.store.test.ts

@@ -8,7 +8,7 @@ import podStoreInjectable from "../+workloads-pods/store.injectable";
 import type { StatefulSetStore } from "../+workloads-statefulsets/store";
 import statefulSetStoreInjectable from "../+workloads-statefulsets/store.injectable";
 import { StatefulSet, Pod } from "../../../common/k8s-api/endpoints";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { getDiForUnitTesting } from "../../getDiForUnitTesting";
 
 const runningStatefulSet = new StatefulSet({
@@ -136,7 +136,7 @@ describe("StatefulSet Store tests", () => {
   beforeEach(() => {
     const di = getDiForUnitTesting({ doGeneralOverrides: true });
 
-    di.override(createStoresAndApisInjectable, () => true);
+    di.override(storesAndApisCanBeCreatedInjectable, () => true);
 
     statefulSetStore = di.inject(statefulSetStoreInjectable);
 

src/renderer/components/delete-cluster-dialog/__tests__/delete-cluster-dialog.test.tsx

@@ -18,7 +18,7 @@ import type { DiRender } from "../../test-utils/renderFor";
 import { renderFor } from "../../test-utils/renderFor";
 import type { OpenDeleteClusterDialog } from "../open.injectable";
 import openDeleteClusterDialogInjectable from "../open.injectable";
-import createStoresAndApisInjectable from "../../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
 import createKubeconfigManagerInjectable from "../../../../main/kubeconfig-manager/create-kubeconfig-manager.injectable";
 import ipcRendererInjectable from "../../../app-paths/get-value-from-registered-channel/ipc-renderer/ipc-renderer.injectable";
 
@@ -104,7 +104,7 @@ describe("<DeleteClusterDialog />", () => {
     mainDi.override(createKubeconfigManagerInjectable, () => () => undefined);
     mockFs();
 
-    rendererDi.override(createStoresAndApisInjectable, () => true);
+    rendererDi.override(storesAndApisCanBeCreatedInjectable, () => true);
     rendererDi.override(ipcRendererInjectable, () => ({
       on: jest.fn(),
       invoke: jest.fn(), // TODO: replace with proper mocking via the IPC bridge

src/renderer/components/hotbar/__tests__/hotbar-remove-command.test.tsx

@@ -18,7 +18,7 @@ import directoryForUserDataInjectable from "../../../../common/app-paths/directo
 import getConfigurationFileModelInjectable from "../../../../common/get-configuration-file-model/get-configuration-file-model.injectable";
 import appVersionInjectable from "../../../../common/get-configuration-file-model/app-version/app-version.injectable";
 import type { HotbarStore } from "../../../../common/hotbars/store";
-import createStoresAndApisInjectable from "../../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
 import ipcRendererInjectable from "../../../app-paths/get-value-from-registered-channel/ipc-renderer/ipc-renderer.injectable";
 
 const mockHotbars: Partial<Record<string, any>> = {
@@ -45,7 +45,7 @@ describe("<HotbarRemoveCommand />", () => {
 
     mockFs();
 
-    di.override(createStoresAndApisInjectable, () => true);
+    di.override(storesAndApisCanBeCreatedInjectable, () => true);
     di.override(directoryForUserDataInjectable, () => "some-directory-for-user-data");
     di.override(ipcRendererInjectable, () => ({
       on: jest.fn(),

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

@@ -33,7 +33,7 @@ import navigateToPreferencesInjectable from "../../../common/front-end-routing/r
 import type { MenuItemOpts } from "../../../main/menu/application-menu-items.injectable";
 import applicationMenuItemsInjectable from "../../../main/menu/application-menu-items.injectable";
 import type { MenuItem, MenuItemConstructorOptions } from "electron";
-import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 
 type Callback = (dis: DiContainers) => void | Promise<void>;
 
@@ -81,7 +81,7 @@ export const getApplicationBuilder = () => {
   } as unknown as ClusterStore;
 
   rendererDi.override(clusterStoreInjectable, () => clusterStoreStub);
-  rendererDi.override(createStoresAndApisInjectable, () => true);
+  rendererDi.override(storesAndApisCanBeCreatedInjectable, () => true);
   mainDi.override(clusterStoreInjectable, () => clusterStoreStub);
 
   const beforeSetupsCallbacks: Callback[] = [];

src/renderer/k8s/api-kube.injectable.ts

@@ -7,13 +7,13 @@ import assert from "assert";
 import { onApiError } from "../api/on-api-error";
 import { apiKubePrefix, isDevelopment } from "../../common/vars";
 import { apiKubeInjectionToken } from "../../common/k8s-api/api-kube";
-import { createStoresAndApisInjectionToken } from "../../common/k8s-api/create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../../common/k8s-api/stores-apis-can-be-created.token";
 import { KubeJsonApi } from "../../common/k8s-api/kube-json-api";
 
 const apiKubeInjectable = getInjectable({
   id: "api-kube",
   instantiate: (di) => {
-    assert(di.inject(createStoresAndApisInjectionToken), "apiKube is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "apiKube is only available in certain environments");
 
     const apiKube = new KubeJsonApi({
       serverAddress: `http://127.0.0.1:${window.location.port}`,

src/renderer/stores-apis-can-be-created.injectable.ts

@@ -3,13 +3,13 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { createStoresAndApisInjectionToken } from "../common/k8s-api/create-stores-apis.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "../common/k8s-api/stores-apis-can-be-created.token";
 import { getClusterIdFromHost } from "./utils";
 
-const createStoresAndApisInjectable = getInjectable({
+const storesAndApisCanBeCreatedInjectable = getInjectable({
   id: "create-stores-and-apis",
   instantiate: () => Boolean(getClusterIdFromHost(location.host)),
-  injectionToken: createStoresAndApisInjectionToken,
+  injectionToken: storesAndApisCanBeCreatedInjectionToken,
 });
 
-export default createStoresAndApisInjectable;
+export default storesAndApisCanBeCreatedInjectable;