lensapp/lens
1
0
Fork 0
mirror of https://github.com/lensapp/lens.git synced 2024-08-16 04:40:24 +03:00
Code Issues Projects Releases Wiki Activity

chore: Extract specific KubeApi injectables to own package

Browse Source 
Signed-off-by: Sebastian Malton <sebastian@malton.name>
This commit is contained in:
Sebastian Malton 2023-05-26 13:51:53 -04:00
parent 84017b48db
commit a546ae1000
176 changed files with 1366 additions and 1244 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
package-lock.json generated
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ClusterRoleBindingApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const clusterRoleBindingApiInjectable = getInjectable({
id: "cluster-role-binding-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterRoleBindingApi is only accessible in certain environments");
return new ClusterRoleBindingApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default clusterRoleBindingApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ClusterRoleApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const clusterRoleApiInjectable = getInjectable({
id: "cluster-role-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterRoleApi is only available in certain environments");
return new ClusterRoleApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default clusterRoleApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ComponentStatusApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
import { loggerInjectionToken } from "@k8slens/logger";
const componentStatusApiInjectable = getInjectable({
id: "component-status-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "componentStatusApi is only available in certain environments");
return new ComponentStatusApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default componentStatusApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ConfigMapApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const configMapApiInjectable = getInjectable({
id: "config-map-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "configMapApi is only available in certain environments");
return new ConfigMapApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default configMapApiInjectable;

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

@ -1,29 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { CronJobApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const cronJobApiInjectable = getInjectable({
id: "cron-job-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "cronJobApi is only available in certain environments");
return new CronJobApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}, {
checkPreferredVersion: true,
});
},
injectionToken: kubeApiInjectionToken,
});
export default cronJobApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { CustomResourceDefinitionApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
import { loggerInjectionToken } from "@k8slens/logger";
const customResourceDefinitionApiInjectable = getInjectable({
id: "custom-resource-definition-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "customResourceDefinitionApi is only available in certain environments");
return new CustomResourceDefinitionApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default customResourceDefinitionApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { DaemonSetApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const daemonSetApiInjectable = getInjectable({
id: "daemon-set-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "daemonSetApi is only available in certain environments");
return new DaemonSetApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default daemonSetApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { DeploymentApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const deploymentApiInjectable = getInjectable({
id: "deployment-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "deploymentApi is only available in certain environments");
return new DeploymentApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default deploymentApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { EndpointsApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const endpointsApiInjectable = getInjectable({
id: "endpoints-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "endpointsApi is only available in certain environments");
return new EndpointsApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default endpointsApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { KubeEventApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const kubeEventApiInjectable = getInjectable({
id: "kube-event-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "kubeEventApi is only available in certain environments");
return new KubeEventApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default kubeEventApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { HorizontalPodAutoscalerApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const horizontalPodAutoscalerApiInjectable = getInjectable({
id: "horizontal-pod-autoscaler-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "horizontalPodAutoscalerApi is only available in certain environments");
return new HorizontalPodAutoscalerApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default horizontalPodAutoscalerApiInjectable;

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

@ -1,21 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import { IngressClassApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const ingressClassApiInjectable = getInjectable({
id: "ingress-class-api",
instantiate: (di) => new IngressClassApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}),
injectionToken: kubeApiInjectionToken,
});
export default ingressClassApiInjectable;

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

@ -1,29 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { JobApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const jobApiInjectable = getInjectable({
id: "job-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "jobApi is only available in certain environments");
return new JobApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}, {
checkPreferredVersion: true,
});
},
injectionToken: kubeApiInjectionToken,
});
export default jobApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { LimitRangeApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const limitRangeApiInjectable = getInjectable({
id: "limit-range-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "limitRangeApi is only available in certain environments");
return new LimitRangeApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default limitRangeApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { MutatingWebhookConfigurationApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const mutatingWebhookConfigurationApiInjectable = getInjectable({
id: "mutating-webhook-configuration",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "mutatingWebhookApi is only available in certain environments");
return new MutatingWebhookConfigurationApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default mutatingWebhookConfigurationApiInjectable;

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

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

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { NetworkPolicyApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const networkPolicyApiInjectable = getInjectable({
id: "network-policy-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "networkPolicyApi is only available in certain environments");
return new NetworkPolicyApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default networkPolicyApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PersistentVolumeClaimApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const persistentVolumeClaimApiInjectable = getInjectable({
id: "persistent-volume-claim-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "persistentVolumeClaimApi is only available in certain environments");
return new PersistentVolumeClaimApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default persistentVolumeClaimApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PersistentVolumeApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const persistentVolumeApiInjectable = getInjectable({
id: "persistent-volume-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "persistentVolumeApi is only available in certain environments");
return new PersistentVolumeApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default persistentVolumeApiInjectable;

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

@ -1,35 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PodDisruptionBudgetApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const podDisruptionBudgetApiInjectable = getInjectable({
id: "pod-disruption-budget-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podDisruptionBudgetApi is only available in certain environments");
return new PodDisruptionBudgetApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}, {
checkPreferredVersion: true,
allowedUsableVersions: {
policy: [
"v1",
"v1beta1",
],
},
});
},
injectionToken: kubeApiInjectionToken,
});
export default podDisruptionBudgetApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PodMetricsApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const podMetricsApiInjectable = getInjectable({
id: "pod-metrics-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podMetricsApi is only available in certain environments");
return new PodMetricsApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default podMetricsApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PodSecurityPolicyApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const podSecurityPolicyApiInjectable = getInjectable({
id: "pod-security-policy-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podSecurityPolicyApi is only available in certain environments");
return new PodSecurityPolicyApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default podSecurityPolicyApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PriorityClassApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const priorityClassApiInjectable = getInjectable({
id: "priority-class-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "PriorityClassApi is only available in certain environments");
return new PriorityClassApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default priorityClassApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ReplicaSetApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const replicaSetApiInjectable = getInjectable({
id: "replica-set-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "replicaSetApi is only available in certain environments");
return new ReplicaSetApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default replicaSetApiInjectable;

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

@ -1,23 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import { ReplicationControllerApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const replicationControllerApiInjectable = getInjectable({
id: "replication-controller-api",
instantiate: (di) => {
return new ReplicationControllerApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default replicationControllerApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ResourceQuotaApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const resourceQuotaApiInjectable = getInjectable({
id: "resource-quota-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "resourceQuotaApi is only available in certain environments");
return new ResourceQuotaApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default resourceQuotaApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { RoleBindingApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const roleBindingApiInjectable = getInjectable({
id: "role-binding-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "roleBindingApi is only available in certain environments");
return new RoleBindingApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default roleBindingApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { RuntimeClassApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const runtimeClassApiInjectable = getInjectable({
id: "runtime-class-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "RuntimeClassApi is only available in certain environments");
return new RuntimeClassApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default runtimeClassApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { SelfSubjectRulesReviewApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const selfSubjectRulesReviewApiInjectable = getInjectable({
id: "self-subject-rules-review-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "selfSubjectRulesReviewApi is only available in certain environments");
return new SelfSubjectRulesReviewApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default selfSubjectRulesReviewApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ServiceAccountApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const serviceAccountApiInjectable = getInjectable({
id: "service-account-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "serviceAccountApi is only available in certain environments");
return new ServiceAccountApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default serviceAccountApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { StatefulSetApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const statefulSetApiInjectable = getInjectable({
id: "stateful-set-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "statefulSetApi is only available in certain environments");
return new StatefulSetApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default statefulSetApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { StorageClassApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const storageClassApiInjectable = getInjectable({
id: "storage-class-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "storageClassApi is only available in certain environments");
return new StorageClassApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default storageClassApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ValidatingWebhookConfigurationApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const validatingWebhookConfigurationApiInjectable = getInjectable({
id: "validating-webhook-configuration",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "validatingWebhookApi is only available in certain environments");
return new ValidatingWebhookConfigurationApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default validatingWebhookConfigurationApiInjectable;

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

@ -1,27 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { VerticalPodAutoscalerApi } from "@k8slens/kube-api";
import { kubeApiInjectionToken } from "@k8slens/kube-api-specifics";
import { loggerInjectionToken } from "@k8slens/logger";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const verticalPodAutoscalerApiInjectable = getInjectable({
id: "vertical-pod-autoscaler-api",
instantiate: (di) => {
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "verticalPodAutoscalerApi is only available in certain environments");
return new VerticalPodAutoscalerApi({
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},
injectionToken: kubeApiInjectionToken,
});
export default verticalPodAutoscalerApiInjectable;

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

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

9
packages/core/src/extensions/common-api/k8s-api.ts
View File

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

94
packages/core/src/extensions/renderer-api/k8s-api.ts
View File

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

2
packages/core/src/features/cluster/workloads/pods.test.tsx
View File

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

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

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

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

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

5
packages/core/src/renderer/components/cluster/store.injectable.ts
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

5
packages/core/src/renderer/components/events/store.injectable.ts
View File

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

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

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

5
packages/core/src/renderer/components/namespaces/store.injectable.ts
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

5
packages/core/src/renderer/components/nodes/store.injectable.ts
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

3
packages/core/src/renderer/components/storage-volumes/volumes.tsx
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Some files were not shown because too many files have changed in this diff Show More