hendrik/lens
1
0
Fork 0
mirror of https://github.com/lensapp/lens.git synced 2025-05-20 05:10:56 +00:00
Code Issues Projects Releases Wiki Activity

Export tokens instead of injectables

Browse Source 
Signed-off-by: Sami Tiilikainen <97873007+samitiilikainen@users.noreply.github.com>
This commit is contained in:
Sami Tiilikainen 2023-04-26 11:16:08 +03:00
parent 1bd54336ef
commit aa536791f2
263 changed files with 556 additions and 533 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
packages/core/src/common/cluster/create-can-i.injectable.ts
View File

@ -5,7 +5,7 @@
import type { AuthorizationV1Api, V1ResourceAttributes } from "@kubernetes/client-node";
import { getInjectable } from "@ogre-tools/injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
/**
* Requests the permissions for actions on the kube cluster
@ -19,7 +19,7 @@ export type CreateCanI = (api: AuthorizationV1Api) => CanI;
const createCanIInjectable = getInjectable({
id: "create-can-i",
instantiate: (di): CreateCanI => {
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return (api) => async (resourceAttributes: V1ResourceAttributes): Promise<boolean> => {
try {

4
packages/core/src/common/cluster/create-request-namespace-list-permissions.injectable.ts
View File

@ -5,7 +5,7 @@
import type { AuthorizationV1Api } from "@kubernetes/client-node";
import { getInjectable } from "@ogre-tools/injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import type { KubeApiResource } from "../rbac";
export type CanListResource = (resource: KubeApiResource) => boolean;
@ -21,7 +21,7 @@ export type CreateRequestNamespaceListPermissions = (api: AuthorizationV1Api) =>
const createRequestNamespaceListPermissionsInjectable = getInjectable({
id: "create-request-namespace-list-permissions",
instantiate: (di): CreateRequestNamespaceListPermissions => {
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return (api) => async (namespace) => {
try {

4
packages/core/src/common/ipc/ipc.ts
View File

@ -12,7 +12,7 @@ import { toJS } from "../utils/toJS";
import type { Disposer } from "@k8slens/utilities";
import { getLegacyGlobalDiForExtensionApi } from "../../extensions/as-legacy-globals-for-extension-api/legacy-global-di-for-extension-api";
import ipcRendererInjectable from "../../renderer/utils/channel/ipc-renderer.injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import ipcMainInjectionToken from "./ipc-main-injection-token";
import clusterFramesInjectable from "../cluster-frames.injectable";
@ -38,7 +38,7 @@ export async function broadcastMessage(channel: string, ...args: any[]): Promise
}
const di = getLegacyGlobalDiForExtensionApi();
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
const clusterFrames = di.inject(clusterFramesInjectable);
ipcMain.listeners(channel).forEach((func) => func({

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

@ -11,7 +11,7 @@ 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 { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import type { ApiManager } from "../api-manager";
import apiManagerInjectable from "../api-manager/manager.injectable";
import { KubeApi } from "../kube-api";
@ -61,7 +61,7 @@ describe("ApiManager", () => {
const apiBase = "apis/v1/foo";
const fallbackApiBase = "/apis/extensions/v1beta1/foo";
const kubeApi = new TestApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}, {
objectConstructor: KubeObject,
@ -72,7 +72,7 @@ describe("ApiManager", () => {
});
const kubeStore = new TestStore({
context: di.inject(clusterFrameContextForNamespacedResourcesInjectable),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
}, kubeApi);
apiManager.registerApi(kubeApi);
@ -136,7 +136,7 @@ describe("ApiManager", () => {
return Object.assign(
new KubeApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}, { objectConstructor }),
{
@ -189,7 +189,7 @@ describe("ApiManager", () => {
apiManager.registerStore(Object.assign(
new KubeObjectStore({
context: di.inject(clusterFrameContextForNamespacedResourcesInjectable),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
}, api),
{
someField: 2,

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

@ -20,7 +20,7 @@ import directoryForKubeConfigsInjectable from "../../app-paths/directory-for-kub
import apiManagerInjectable from "../api-manager/manager.injectable";
import type { DiContainer } from "@ogre-tools/injectable";
import ingressApiInjectable from "../endpoints/ingress.api.injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
import { Cluster } from "../../cluster/cluster";
@ -709,7 +709,7 @@ describe("KubeApi", () => {
beforeEach(async () => {
horizontalPodAutoscalerApi = new HorizontalPodAutoscalerApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}, {
allowedUsableVersions: {

4
packages/core/src/common/k8s-api/api-manager/create-custom-resource-store.injectable.ts
View File

@ -4,7 +4,7 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import clusterFrameContextForNamespacedResourcesInjectable from "../../../renderer/cluster-frame-context/for-namespaced-resources.injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import type { KubeApi } from "../kube-api";
import type { KubeObject } from "../kube-object";
import type { KubeObjectStoreDependencies } from "../kube-object.store";
@ -17,7 +17,7 @@ const createCustomResourceStoreInjectable = getInjectable({
instantiate: (di): CreateCustomResourceStore => {
const deps: KubeObjectStoreDependencies = {
context: di.inject(clusterFrameContextForNamespacedResourcesInjectable),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
};
return (api) => new CustomResourceStore(deps, api);

4
packages/core/src/common/k8s-api/create-json-api.injectable.ts
View File

@ -7,7 +7,7 @@ import { Agent } from "https";
import type { RequestInit } from "@k8slens/node-fetch";
import lensProxyCertificateInjectable from "../certificate/lens-proxy-certificate.injectable";
import fetchInjectable from "../fetch/fetch.injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import type { JsonApiConfig, JsonApiData, JsonApiDependencies, JsonApiParams } from "./json-api";
import { JsonApi } from "./json-api";
@ -18,7 +18,7 @@ const createJsonApiInjectable = getInjectable({
instantiate: (di): CreateJsonApi => {
const deps: JsonApiDependencies = {
fetch: di.inject(fetchInjectable),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
};
const lensProxyCert = di.inject(lensProxyCertificateInjectable);

4
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 { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import { apiKubePrefix } from "../vars";
import isDevelopmentInjectable from "../vars/is-development.injectable";
import apiBaseInjectable from "./api-base.injectable";
@ -37,7 +37,7 @@ const createKubeApiForClusterInjectable = getInjectable({
const apiBase = di.inject(apiBaseInjectable);
const isDevelopment = di.inject(isDevelopmentInjectable);
const createKubeJsonApi = di.inject(createKubeJsonApiInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return (
cluster: CreateKubeApiForLocalClusterConfig,

4
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 { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import isDevelopmentInjectable from "../vars/is-development.injectable";
import createKubeJsonApiInjectable from "./create-kube-json-api.injectable";
import type { KubeApiOptions } from "./kube-api";
@ -53,7 +53,7 @@ const createKubeApiForRemoteClusterInjectable = getInjectable({
instantiate: (di): CreateKubeApiForRemoteCluster => {
const isDevelopment = di.inject(isDevelopmentInjectable);
const createKubeJsonApi = di.inject(createKubeJsonApiInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return (
config: CreateKubeApiForRemoteClusterConfig,

4
packages/core/src/common/k8s-api/create-kube-api.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 { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import type { DerivedKubeApiOptions, KubeApiDependencies } from "./kube-api";
import maybeKubeApiInjectable from "./maybe-kube-api.injectable";
@ -15,7 +15,7 @@ const createKubeApiInjectable = getInjectable({
id: "create-kube-api",
instantiate: (di): CreateKubeApi => {
const deps: KubeApiDependencies = {
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
};

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

@ -7,7 +7,7 @@ import { Agent } from "https";
import type { RequestInit } from "@k8slens/node-fetch";
import lensProxyCertificateInjectable from "../certificate/lens-proxy-certificate.injectable";
import fetchInjectable from "../fetch/fetch.injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import type { JsonApiConfig, JsonApiDependencies } from "./json-api";
import { KubeJsonApi } from "./kube-json-api";
@ -18,7 +18,7 @@ const createKubeJsonApiInjectable = getInjectable({
instantiate: (di): CreateKubeJsonApi => {
const dependencies: JsonApiDependencies = {
fetch: di.inject(fetchInjectable),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
};
const lensProxyCert = di.inject(lensProxyCertificateInjectable);

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ClusterRoleBindingApi } from "./cluster-role-binding.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const clusterRoleBindingApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const clusterRoleBindingApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterRoleBindingApi is only accessible in certain environments");
return new ClusterRoleBindingApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ClusterRoleApi } from "./cluster-role.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const clusterRoleApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const clusterRoleApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterRoleApi is only available in certain environments");
return new ClusterRoleApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ClusterApi } from "./cluster.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const clusterApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const clusterApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterApi is only available in certain environments");
return new ClusterApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -8,7 +8,7 @@ import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-c
import { ComponentStatusApi } from "./component-status.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
const componentStatusApiInjectable = getInjectable({
id: "component-status-api",
@ -16,7 +16,7 @@ const componentStatusApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "componentStatusApi is only available in certain environments");
return new ComponentStatusApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ConfigMapApi } from "./config-map.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const configMapApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const configMapApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "configMapApi is only available in certain environments");
return new ConfigMapApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { CronJobApi } from "./cron-job.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const cronJobApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const cronJobApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "cronJobApi is only available in certain environments");
return new CronJobApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}, {
checkPreferredVersion: true,

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

@ -8,7 +8,7 @@ import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-c
import { CustomResourceDefinitionApi } from "./custom-resource-definition.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
const customResourceDefinitionApiInjectable = getInjectable({
id: "custom-resource-definition-api",
@ -16,7 +16,7 @@ const customResourceDefinitionApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "customResourceDefinitionApi is only available in certain environments");
return new CustomResourceDefinitionApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { DaemonSetApi } from "./daemon-set.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const daemonSetApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const daemonSetApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "daemonSetApi is only available in certain environements");
return new DaemonSetApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { DeploymentApi } from "./deployment.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const deploymentApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const deploymentApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "deploymentApi is only available in certain environments");
return new DeploymentApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { EndpointsApi } from "./endpoint.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const endpointsApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const endpointsApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "endpointsApi is only available in certain environments");
return new EndpointsApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { KubeEventApi } from "./events.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const kubeEventApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const kubeEventApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "kubeEventApi is only available in certain environments");
return new KubeEventApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { HorizontalPodAutoscalerApi } from "./horizontal-pod-autoscaler.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const horizontalPodAutoscalerApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const horizontalPodAutoscalerApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "horizontalPodAutoscalerApi is only available in certain environments");
return new HorizontalPodAutoscalerApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -5,13 +5,13 @@
import { getInjectable } from "@ogre-tools/injectable";
import { IngressClassApi } from "./ingress-class.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const ingressClassApiInjectable = getInjectable({
id: "ingress-class-api",
instantiate: (di) => new IngressClassApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}),

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { IngressApi } from "./ingress.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const ingressApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const ingressApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "ingressApi is only available in certain environments");
return new IngressApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { JobApi } from "./job.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const jobApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const jobApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "jobApi is only available in certain environments");
return new JobApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}, {
checkPreferredVersion: true,

4
packages/core/src/common/k8s-api/endpoints/lease.api.injectable.ts
View File

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { LeaseApi } from "./lease.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const leaseApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const leaseApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "leaseApi is only available in certain environments");
return new LeaseApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { LimitRangeApi } from "./limit-range.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const limitRangeApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const limitRangeApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "limitRangeApi is only available in certain environments");
return new LimitRangeApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -6,7 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
import { MutatingWebhookConfigurationApi } from "./mutating-webhook-configuration.api";
@ -16,7 +16,7 @@ const mutatingWebhookConfigurationApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "mutatingWebhookApi is only available in certain environments");
return new MutatingWebhookConfigurationApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { NamespaceApi } from "./namespace.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const namespaceApiInjectable = getInjectable({
@ -17,7 +17,7 @@ const namespaceApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "namespaceApi is only available in certain environments");
return new NamespaceApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { NetworkPolicyApi } from "./network-policy.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const networkPolicyApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const networkPolicyApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "networkPolicyApi is only available in certain environments");
return new NetworkPolicyApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

4
packages/core/src/common/k8s-api/endpoints/node.api.injectable.ts
View File

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { NodeApi } from "./node.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const nodeApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const nodeApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "nodeApi is only available in certain environments");
return new NodeApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PersistentVolumeClaimApi } from "./persistent-volume-claim.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const persistentVolumeClaimApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const persistentVolumeClaimApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "persistentVolumeClaimApi is only available in certain environments");
return new PersistentVolumeClaimApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PersistentVolumeApi } from "./persistent-volume.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const persistentVolumeApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const persistentVolumeApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "persistentVolumeApi is only available in certain environments");
return new PersistentVolumeApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PodDisruptionBudgetApi } from "./pod-disruption-budget.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const podDisruptionBudgetApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const podDisruptionBudgetApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podDisruptionBudgetApi is only available in certain environments");
return new PodDisruptionBudgetApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
}, {
checkPreferredVersion: true,

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PodMetricsApi } from "./pod-metrics.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const podMetricsApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const podMetricsApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podMetricsApi is only available in certain environments");
return new PodMetricsApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PodSecurityPolicyApi } from "./pod-security-policy.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const podSecurityPolicyApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const podSecurityPolicyApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podSecurityPolicyApi is only available in certain environments");
return new PodSecurityPolicyApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PodApi } from "./pod.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const podApiInjectable = getInjectable({
@ -17,7 +17,7 @@ const podApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podApi is only available in certain environments");
return new PodApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PriorityClassApi } from "./priority-class.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const priorityClassApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const priorityClassApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "PriorityClassApi is only available in certain environments");
return new PriorityClassApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ReplicaSetApi } from "./replica-set.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const replicaSetApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const replicaSetApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "replicaSetApi is only available in certain environments");
return new ReplicaSetApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -4,7 +4,7 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
import { ReplicationControllerApi } from "./replication-controller.api";
@ -12,7 +12,7 @@ const replicationControllerApiInjectable = getInjectable({
id: "replication-controller-api",
instantiate: (di) => {
return new ReplicationControllerApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ResourceQuotaApi } from "./resource-quota.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const resourceQuotaApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const resourceQuotaApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "resourceQuotaApi is only available in certain environments");
return new ResourceQuotaApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { RoleBindingApi } from "./role-binding.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const roleBindingApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const roleBindingApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "roleBindingApi is only available in certain environments");
return new RoleBindingApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { RoleApi } from "./role.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const roleApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const roleApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "roleApi is only available in certain environments");
return new RoleApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { RuntimeClassApi } from "./runtime-class.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const runtimeClassApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const runtimeClassApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "RuntimeClassApi is only available in certain environments");
return new RuntimeClassApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

4
packages/core/src/common/k8s-api/endpoints/secret.api.injectable.ts
View File

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { SecretApi } from "./secret.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const secretApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const secretApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "secretApi is only available in certain environments");
return new SecretApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { SelfSubjectRulesReviewApi } from "./self-subject-rules-reviews.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const selfSubjectRulesReviewApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const selfSubjectRulesReviewApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "selfSubjectRulesReviewApi is only available in certain environments");
return new SelfSubjectRulesReviewApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ServiceAccountApi } from "./service-account.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const serviceAccountApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const serviceAccountApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "serviceAccountApi is only available in certain environments");
return new ServiceAccountApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ServiceApi } from "./service.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const serviceApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const serviceApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "serviceApi is only available in certain environments");
return new ServiceApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { StatefulSetApi } from "./stateful-set.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const statefulSetApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const statefulSetApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "statefulSetApi is only available in certain environments");
return new StatefulSetApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { StorageClassApi } from "./storage-class.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const storageClassApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const storageClassApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "storageClassApi is only available in certain environments");
return new StorageClassApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -6,7 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
import { ValidatingWebhookConfigurationApi } from "./validating-webhook-configuration.api";
@ -16,7 +16,7 @@ const validatingWebhookConfigurationApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "validatingWebhookApi is only available in certain environments");
return new ValidatingWebhookConfigurationApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

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

@ -7,7 +7,7 @@ import assert from "assert";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { VerticalPodAutoscalerApi } from "./vertical-pod-autoscaler.api";
import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
const verticalPodAutoscalerApiInjectable = getInjectable({
@ -16,7 +16,7 @@ const verticalPodAutoscalerApiInjectable = getInjectable({
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "verticalPodAutoscalerApi is only available in certain environments");
return new VerticalPodAutoscalerApi({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
});
},

4
packages/core/src/common/k8s/create-resource-stack.injectable.ts
View File

@ -7,7 +7,7 @@ import type { KubernetesCluster } from "../catalog-entities";
import readDirectoryInjectable from "../fs/read-directory.injectable";
import readFileInjectable from "../fs/read-file.injectable";
import { kubectlApplyAllInjectionToken, kubectlDeleteAllInjectionToken } from "../kube-helpers/channels";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import joinPathsInjectable from "../path/join-paths.injectable";
import type { ResourceApplyingStack, ResourceStackDependencies } from "./resource-stack";
import { ResourceStack } from "./resource-stack";
@ -21,7 +21,7 @@ const createResourceStackInjectable = getInjectable({
joinPaths: di.inject(joinPathsInjectable),
kubectlApplyAll: di.inject(kubectlApplyAllInjectionToken),
kubectlDeleteAll: di.inject(kubectlDeleteAllInjectionToken),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
readDirectory: di.inject(readDirectoryInjectable),
readFile: di.inject(readFileInjectable),
};

4
packages/core/src/common/persistent-storage/create.injectable.ts
View File

@ -10,7 +10,7 @@ import type { IEqualsComparer } from "mobx";
import { reaction } from "mobx";
import directoryForUserDataInjectable from "../app-paths/directory-for-user-data/directory-for-user-data.injectable";
import getConfigurationFileModelInjectable from "../get-configuration-file-model/get-configuration-file-model.injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import getBasenameOfPathInjectable from "../path/get-basename.injectable";
import { enlistMessageChannelListenerInjectionToken, sendMessageToChannelInjectionToken } from "@k8slens/messaging";
import type { MessageChannel } from "@k8slens/messaging";
@ -63,7 +63,7 @@ const createPersistentStorageInjectable = getInjectable({
instantiate: (di): CreatePersistentStorage => {
const directoryForUserData = di.inject(directoryForUserDataInjectable);
const getConfigurationFileModel = di.inject(getConfigurationFileModelInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
const getBasenameOfPath = di.inject(getBasenameOfPathInjectable);
const ipcChannelPrefixes = di.inject(persistentStorageIpcChannelPrefixesInjectionToken);
const persistStateToConfig = di.inject(persistStateToConfigInjectionToken);

4
packages/core/src/common/persistent-storage/migrations.injectable.ts
View File

@ -4,7 +4,7 @@
*/
import type { InjectionToken } from "@ogre-tools/injectable";
import { lifecycleEnum, getInjectable } from "@ogre-tools/injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import { getOrInsert, iter, object } from "@k8slens/utilities";
export type AllowedSetValue<T> = T extends (...args: any[]) => any
@ -32,7 +32,7 @@ export interface MigrationDeclaration {
const persistentStorageMigrationsInjectable = getInjectable({
id: "persistent-storage-migrations",
instantiate: (di, token) => {
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
const declarations = di.injectMany(token);
const migrations = new Map<string, MigrationDeclaration["run"][]>();

4
packages/core/src/common/utils/with-error-logging/with-error-logging.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 { logErrorInjectable } from "@k8slens/logging";
import { logErrorInjectionToken } from "@k8slens/logging";
export type WithErrorLoggingFor = (
getErrorMessage: (error: unknown) => string
@ -15,7 +15,7 @@ const withErrorLoggingInjectable = getInjectable({
id: "with-error-logging",
instantiate: (di): WithErrorLoggingFor => {
const logError = di.inject(logErrorInjectable);
const logError = di.inject(logErrorInjectionToken);
return (getErrorMessage) =>
(toBeDecorated) =>

6
packages/core/src/common/utils/with-error-logging/with-error-logging.test.ts
View File

@ -9,7 +9,7 @@ import { pipeline } from "@ogre-tools/fp";
import type { AsyncFnMock } from "@async-fn/jest";
import asyncFn from "@async-fn/jest";
import { getPromiseStatus } from "@k8slens/test-utils";
import { logErrorInjectable } from "@k8slens/logging";
import { logErrorInjectionToken } from "@k8slens/logging";
describe("with-error-logging", () => {
describe("given decorated sync function", () => {
@ -22,7 +22,7 @@ describe("with-error-logging", () => {
logErrorMock = jest.fn();
di.override(logErrorInjectable, () => logErrorMock);
di.override(logErrorInjectionToken, () => logErrorMock);
const withErrorLoggingFor = di.inject(withErrorLoggingInjectable);
@ -120,7 +120,7 @@ describe("with-error-logging", () => {
logErrorMock = jest.fn();
di.override(logErrorInjectable, () => logErrorMock);
di.override(logErrorInjectionToken, () => logErrorMock);
const withErrorLoggingFor = di.inject(withErrorLoggingInjectable);

4
packages/core/src/common/utils/with-orphan-promise/with-orphan-promise.test.ts
View File

@ -6,7 +6,7 @@ import type { AsyncFnMock } from "@async-fn/jest";
import asyncFn from "@async-fn/jest";
import { getDiForUnitTesting } from "../../../main/getDiForUnitTesting";
import withOrphanPromiseInjectable from "./with-orphan-promise.injectable";
import { logErrorInjectable } from "@k8slens/logging";
import { logErrorInjectionToken } from "@k8slens/logging";
describe("with orphan promise, when called", () => {
let toBeDecorated: AsyncFnMock<(arg1: string, arg2: string) => Promise<string>>;
@ -18,7 +18,7 @@ describe("with orphan promise, when called", () => {
logErrorMock = jest.fn();
di.override(logErrorInjectable, () => logErrorMock);
di.override(logErrorInjectionToken, () => logErrorMock);
const withOrphanPromise = di.inject(withOrphanPromiseInjectable);

4
packages/core/src/extensions/as-legacy-globals-for-extension-api/as-legacy-global-singleton-object-for-extension-api.ts
View File

@ -5,7 +5,7 @@
import type { Injectable } from "@ogre-tools/injectable";
import { asLegacyGlobalForExtensionApi } from "./as-legacy-global-object-for-extension-api";
import { getLegacyGlobalDiForExtensionApi } from "./legacy-global-di-for-extension-api";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
export interface LegacySingleton<T> {
createInstance(): T;
@ -32,7 +32,7 @@ export function asLegacyGlobalSingletonForExtensionApi<Instance, InstantiationPa
resetInstance: () => {
const di = getLegacyGlobalDiForExtensionApi();
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
logger.warn(
`resetInstance() for a legacy global singleton of "${injectable.id}" does nothing.`,

4
packages/core/src/extensions/common-api/index.ts
View File

@ -3,7 +3,7 @@
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import { asLegacyGlobalForExtensionApi } from "../as-legacy-globals-for-extension-api/as-legacy-global-object-for-extension-api";
// APIs
@ -20,4 +20,4 @@ export type { LensExtension } from "../lens-extension";
export type { PackageJson } from "type-fest";
export type { LensExtensionManifest, InstalledExtension } from "@k8slens/legacy-extensions";
export const logger = asLegacyGlobalForExtensionApi(loggerInjectable);
export const logger = asLegacyGlobalForExtensionApi(loggerInjectionToken);

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

@ -22,7 +22,7 @@ import type { DerivedKubeApiOptions, KubeApiDependencies, KubeApiOptions } from
import { KubeApi as InternalKubeApi } from "../../common/k8s-api/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 { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import { getLegacyGlobalDiForExtensionApi } from "../as-legacy-globals-for-extension-api/legacy-global-di-for-extension-api";
import maybeKubeApiInjectable from "../../common/k8s-api/maybe-kube-api.injectable";
import { DeploymentApi as InternalDeploymentApi, IngressApi as InternalIngressApi, NodeApi, PersistentVolumeClaimApi, PodApi } from "../../common/k8s-api/endpoints";
@ -44,7 +44,7 @@ const getKubeApiDeps = (): KubeApiDependencies => {
const di = getLegacyGlobalDiForExtensionApi();
return {
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
maybeKubeApi: di.inject(maybeKubeApiInjectable),
};
};
@ -185,7 +185,7 @@ export abstract class KubeObjectStore<
super(
{
context: di.inject(clusterFrameContextForNamespacedResourcesInjectable),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
},
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
api!,

4
packages/core/src/extensions/extension-discovery/extension-discovery.injectable.ts
View File

@ -10,7 +10,7 @@ import extensionInstallationStateStoreInjectable from "../extension-installation
import installExtensionInjectable from "../install-extension/install-extension.injectable";
import extensionPackageRootDirectoryInjectable from "../install-extension/extension-package-root-directory.injectable";
import readJsonFileInjectable from "../../common/fs/read-json-file.injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import pathExistsInjectable from "../../common/fs/path-exists.injectable";
import watchInjectable from "../../common/fs/watch/watch.injectable";
import accessPathInjectable from "../../common/fs/access-path.injectable";
@ -43,7 +43,7 @@ const extensionDiscoveryInjectable = getInjectable({
readJsonFile: di.inject(readJsonFileInjectable),
pathExists: di.inject(pathExistsInjectable),
watch: di.inject(watchInjectable),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
accessPath: di.inject(accessPathInjectable),
copy: di.inject(copyInjectable),
removePath: di.inject(removePathInjectable),

4
packages/core/src/extensions/extension-installation-state-store/extension-installation-state-store.injectable.ts
View File

@ -3,13 +3,13 @@
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import { ExtensionInstallationStateStore } from "./extension-installation-state-store";
const extensionInstallationStateStoreInjectable = getInjectable({
id: "extension-installation-state-store",
instantiate: (di) => new ExtensionInstallationStateStore({
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
}),
});

4
packages/core/src/extensions/extension-loader/extension-loader.injectable.ts
View File

@ -6,7 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
import { ExtensionLoader } from "./extension-loader";
import extensionInstancesInjectable from "./extension-instances.injectable";
import extensionInjectable from "./extension/extension.injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import joinPathsInjectable from "../../common/path/join-paths.injectable";
import getDirnameOfPathInjectable from "../../common/path/get-dirname.injectable";
import { bundledExtensionInjectionToken } from "@k8slens/legacy-extensions";
@ -22,7 +22,7 @@ const extensionLoaderInjectable = getInjectable({
getExtension: (instance) => di.inject(extensionInjectable, instance),
bundledExtensions: di.injectMany(bundledExtensionInjectionToken),
extensionEntryPointName: di.inject(extensionEntryPointNameInjectionToken),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
joinPaths: di.inject(joinPathsInjectable),
getDirnameOfPath: di.inject(getDirnameOfPathInjectable),
}),

4
packages/core/src/extensions/install-extension/install-extension.injectable.ts
View File

@ -7,7 +7,7 @@ import { fork } from "child_process";
import AwaitLock from "await-lock";
import pathToNpmCliInjectable from "../../common/app-paths/path-to-npm-cli.injectable";
import extensionPackageRootDirectoryInjectable from "./extension-package-root-directory.injectable";
import { prefixedLoggerInjectable } from "@k8slens/logging";
import { prefixedLoggerInjectionToken } from "@k8slens/logging";
import readJsonFileInjectable from "../../common/fs/read-json-file.injectable";
import joinPathsInjectable from "../../common/path/join-paths.injectable";
import type { PackageJson } from "../common-api";
@ -36,7 +36,7 @@ const installExtensionInjectable = getInjectable({
const readJsonFile = di.inject(readJsonFileInjectable);
const writeJsonFile = di.inject(writeJsonFileInjectable);
const joinPaths = di.inject(joinPathsInjectable);
const logger = di.inject(prefixedLoggerInjectable, "EXTENSION-INSTALLER");
const logger = di.inject(prefixedLoggerInjectionToken, "EXTENSION-INSTALLER");
const forkNpm = (...args: string[]) => new Promise<void>((resolve, reject) => {
const child = fork(pathToNpmCli, args, {

4
packages/core/src/extensions/ipc/ipc-main.ts
View File

@ -11,7 +11,7 @@ import { once } from "lodash";
import { ipcMainHandle } from "../../common/ipc";
import type { Logger } from "../common-api";
import { getEnvironmentSpecificLegacyGlobalDiForExtensionApi } from "../as-legacy-globals-for-extension-api/legacy-global-di-for-extension-api";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
interface Dependencies {
readonly logger: Logger;
@ -26,7 +26,7 @@ export abstract class IpcMain extends IpcRegistrar {
const di = getEnvironmentSpecificLegacyGlobalDiForExtensionApi("main");
this.dependencies = {
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
};
// Call the static method on the bottom child class.

4
packages/core/src/extensions/lens-main-extension.ts
View File

@ -16,7 +16,7 @@ import type { InstalledExtension } from "./common-api";
import type { CatalogEntityRegistry } from "../main/catalog";
import type { NavigateForExtension } from "../main/start-main-application/lens-window/navigate-for-extension.injectable";
import catalogEntityRegistryInjectable from "../main/catalog/entity-registry.injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import navigateForExtensionInjectable from "../main/start-main-application/lens-window/navigate-for-extension.injectable";
import ensureHashedDirectoryForExtensionInjectable from "./extension-loader/file-system-provisioner-store/ensure-hashed-directory-for-extension.injectable";
@ -40,7 +40,7 @@ export class LensMainExtension extends LensExtension {
ensureHashedDirectoryForExtension: di.inject(ensureHashedDirectoryForExtensionInjectable),
navigate: di.inject(navigateForExtensionInjectable),
entityRegistry: di.inject(catalogEntityRegistryInjectable),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
};
super(deps, extension);

4
packages/core/src/extensions/lens-renderer-extension.ts
View File

@ -39,7 +39,7 @@ import type { InstalledExtension } from "./common-api";
import { getEnvironmentSpecificLegacyGlobalDiForExtensionApi } from "./as-legacy-globals-for-extension-api/legacy-global-di-for-extension-api";
import catalogCategoryRegistryInjectable from "../common/catalog/category-registry.injectable";
import catalogEntityRegistryInjectable from "../renderer/api/catalog/entity/registry.injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import getExtensionPageParametersInjectable from "../renderer/routes/get-extension-page-parameters.injectable";
import navigateToRouteInjectable from "../renderer/routes/navigate-to-route.injectable";
import routesInjectable from "../renderer/routes/routes.injectable";
@ -89,7 +89,7 @@ export class LensRendererExtension extends LensExtension {
categoryRegistry: di.inject(catalogCategoryRegistryInjectable),
entityRegistry: di.inject(catalogEntityRegistryInjectable),
routes: di.inject(routesInjectable),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
};
super(deps, extension);

4
packages/core/src/features/application-menu/application-menu-in-legacy-extension-api.test.ts
View File

@ -9,7 +9,7 @@ import type { ApplicationBuilder } from "../../renderer/components/test-utils/ge
import { getApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
import type { FakeExtensionOptions } from "../../renderer/components/test-utils/get-extension-fake";
import applicationMenuItemInjectionToken from "./main/menu-items/application-menu-item-injection-token";
import { logErrorInjectable } from "@k8slens/logging";
import { logErrorInjectionToken } from "@k8slens/logging";
describe("application-menu-in-legacy-extension-api", () => {
let builder: ApplicationBuilder;
@ -28,7 +28,7 @@ describe("application-menu-in-legacy-extension-api", () => {
logErrorMock = jest.fn();
mainDi.override(logErrorInjectable, () => logErrorMock);
mainDi.override(logErrorInjectionToken, () => logErrorMock);
});
await builder.startHidden();

4
packages/core/src/features/application-menu/handling-of-orphan-application-menu-items.test.ts
View File

@ -10,7 +10,7 @@ import { getCompositePaths } from "../../common/utils/composite/get-composite-pa
import { getInjectable } from "@ogre-tools/injectable";
import applicationMenuItemInjectionToken from "./main/menu-items/application-menu-item-injection-token";
import { runInAction } from "mobx";
import { logErrorInjectable } from "@k8slens/logging";
import { logErrorInjectionToken } from "@k8slens/logging";
describe("handling-of-orphan-application-menu-items, given orphan menu item", () => {
let builder: ApplicationBuilder;
@ -44,7 +44,7 @@ describe("handling-of-orphan-application-menu-items, given orphan menu item", ()
mainDi.register(someOrphanMenuItemInjectable);
});
mainDi.override(logErrorInjectable, () => logErrorMock);
mainDi.override(logErrorInjectionToken, () => logErrorMock);
mainDi.override(
populateApplicationMenuInjectable,

4
packages/core/src/features/application-menu/main/application-menu-item-composite.injectable.ts
View File

@ -12,7 +12,7 @@ import type { ApplicationMenuItemTypes } from "./menu-items/application-menu-ite
import type { RootComposite } from "../../../common/utils/composite/interfaces";
import type { Discriminable } from "../../../common/utils/composable-responsibilities/discriminable/discriminable";
import { orderByOrderNumber } from "../../../common/utils/composable-responsibilities/orderable/orderable";
import { logErrorInjectable } from "@k8slens/logging";
import { logErrorInjectionToken } from "@k8slens/logging";
import { isShown } from "../../../common/utils/composable-responsibilities/showable/showable";
export type MenuItemRoot = Discriminable<"root"> & RootComposite<"root">;
@ -22,7 +22,7 @@ const applicationMenuItemCompositeInjectable = getInjectable({
instantiate: (di) => {
const menuItems = di.inject(applicationMenuItemsInjectable);
const logError = di.inject(logErrorInjectable);
const logError = di.inject(logErrorInjectionToken);
return computed((): Composite<ApplicationMenuItemTypes | MenuItemRoot> => {
const items = menuItems.get();

4
packages/core/src/features/application-menu/main/application-menu-item-registrator.injectable.ts
View File

@ -15,13 +15,13 @@ import type {
} from "./menu-items/application-menu-item-injection-token";
import applicationMenuItemInjectionToken from "./menu-items/application-menu-item-injection-token";
import type { MenuRegistration } from "./menu-registration";
import { logErrorInjectable } from "@k8slens/logging";
import { logErrorInjectionToken } from "@k8slens/logging";
const applicationMenuItemRegistratorInjectable = getInjectable({
id: "application-menu-item-registrator",
instantiate: (di) => {
const logError = di.inject(logErrorInjectable);
const logError = di.inject(logErrorInjectionToken);
const toRecursedInjectables = toRecursedInjectablesFor(logError);
return (ext) => {

4
packages/core/src/features/application-menu/main/menu-items/help/open-documentation/open-documentation-menu-item.injectable.ts
View File

@ -6,14 +6,14 @@ import { getInjectable } from "@ogre-tools/injectable";
import applicationMenuItemInjectionToken from "../../application-menu-item-injection-token";
import { docsUrl } from "../../../../../../common/vars";
import openLinkInBrowserInjectable from "../../../../../../common/utils/open-link-in-browser.injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
const openDocumentationMenuItemInjectable = getInjectable({
id: "open-documentation-menu-item",
instantiate: (di) => {
const openLinkInBrowser = di.inject(openLinkInBrowserInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return {
kind: "clickable-menu-item" as const,

4
packages/core/src/features/application-menu/main/menu-items/help/open-support/open-support-item.injectable.ts
View File

@ -6,14 +6,14 @@ import { getInjectable } from "@ogre-tools/injectable";
import applicationMenuItemInjectionToken from "../../application-menu-item-injection-token";
import { supportUrl } from "../../../../../../common/vars";
import openLinkInBrowserInjectable from "../../../../../../common/utils/open-link-in-browser.injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
const openSupportItemInjectable = getInjectable({
id: "open-support-menu-item",
instantiate: (di) => {
const openLinkInBrowser = di.inject(openLinkInBrowserInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return {
kind: "clickable-menu-item" as const,

4
packages/core/src/features/application-update/main/check-for-updates/check-for-platform-updates/check-for-platform-updates.injectable.ts
View File

@ -5,7 +5,7 @@
import { getInjectable } from "@ogre-tools/injectable";
import electronUpdaterInjectable from "../../../../../main/electron-app/features/electron-updater.injectable";
import type { UpdateChannel } from "../../../common/update-channels";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import type { UpdateCheckResult } from "electron-updater";
export type CheckForUpdatesResult = {
@ -22,7 +22,7 @@ const checkForPlatformUpdatesInjectable = getInjectable({
instantiate: (di): CheckForPlatformUpdates => {
const electronUpdater = di.inject(electronUpdaterInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return async (updateChannel, { allowDowngrade }) => {
electronUpdater.channel = updateChannel.id;

4
packages/core/src/features/application-update/main/check-for-updates/check-for-platform-updates/check-for-platform-updates.test.ts
View File

@ -11,7 +11,7 @@ import type { CheckForPlatformUpdates } from "./check-for-platform-updates.injec
import checkForPlatformUpdatesInjectable from "./check-for-platform-updates.injectable";
import type { UpdateChannel, ReleaseChannel } from "../../../common/update-channels";
import { getPromiseStatus } from "@k8slens/test-utils";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import { noop } from "@k8slens/utilities";
describe("check-for-platform-updates", () => {
@ -39,7 +39,7 @@ describe("check-for-platform-updates", () => {
logErrorMock = jest.fn();
di.override(loggerInjectable, () => ({
di.override(loggerInjectionToken, () => ({
error: logErrorMock,
debug: noop,
info: noop,

4
packages/core/src/features/application-update/main/download-update/download-platform-update/download-platform-update.injectable.ts
View File

@ -4,7 +4,7 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import electronUpdaterInjectable from "../../../../../main/electron-app/features/electron-updater.injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import type { ProgressInfo } from "electron-updater";
import type { ProgressOfDownload } from "../../../common/progress-of-update-download/progress-of-update-download.injectable";
@ -17,7 +17,7 @@ const downloadPlatformUpdateInjectable = getInjectable({
instantiate: (di): DownloadPlatformUpdate => {
const electronUpdater = di.inject(electronUpdaterInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return async (onDownloadProgress) => {
onDownloadProgress({ percentage: 0 });

4
packages/core/src/features/application-update/main/download-update/download-platform-update/download-platform-update.test.ts
View File

@ -11,7 +11,7 @@ import type { AsyncFnMock } from "@async-fn/jest";
import asyncFn from "@async-fn/jest";
import { getPromiseStatus } from "@k8slens/test-utils";
import type { DiContainer } from "@ogre-tools/injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import { noop } from "@k8slens/utilities";
describe("download-platform-update", () => {
@ -45,7 +45,7 @@ describe("download-platform-update", () => {
di.override(electronUpdaterInjectable, () => electronUpdaterFake);
logErrorMock = jest.fn();
di.override(loggerInjectable, () => ({
di.override(loggerInjectionToken, () => ({
error: logErrorMock,
debug: noop,
info: noop,

4
packages/core/src/features/certificate-authorities/main/darwin-request-system-cas.injectable.ts
View File

@ -4,7 +4,7 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import execFileInjectable from "../../../common/fs/exec-file.injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import type { AsyncResult } from "@k8slens/utilities";
import { platformSpecificRequestSystemCAsInjectionToken } from "../common/request-system-cas-token";
@ -17,7 +17,7 @@ const darwinRequestSystemCAsInjectable = getInjectable({
platform: "darwin" as const,
instantiate: () => {
const execFile = di.inject(execFileInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
const execSecurity = async (...args: string[]): AsyncResult<string[]> => {
const result = await execFile("/usr/bin/security", args);

4
packages/core/src/features/certificate-authorities/main/win32-request-system-cas.injectable.ts
View File

@ -4,7 +4,7 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import execFileInjectable from "../../../common/fs/exec-file.injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import { platformSpecificRequestSystemCAsInjectionToken } from "../common/request-system-cas-token";
const pemEncoding = (hexEncodedCert: String) => {
@ -27,7 +27,7 @@ const win32RequestSystemCAsInjectable = getInjectable({
instantiate: () => {
const winCARootsExePath: string = __non_webpack_require__.resolve("win-ca/lib/roots.exe");
const execFile = di.inject(execFileInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return async () => {
/**

4
packages/core/src/features/cluster/storage/common/storage.injectable.ts
View File

@ -8,7 +8,7 @@ import { comparer, action } from "mobx";
import { clusterStoreMigrationInjectionToken } from "./migration-token";
import type { ClusterId, ClusterModel } from "../../../../common/cluster-types";
import { Cluster } from "../../../../common/cluster/cluster";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import createPersistentStorageInjectable from "../../../../common/persistent-storage/create.injectable";
import persistentStorageMigrationsInjectable from "../../../../common/persistent-storage/migrations.injectable";
import storeMigrationVersionInjectable from "../../../../common/vars/store-migration-version.injectable";
@ -23,7 +23,7 @@ const clustersPersistentStorageInjectable = getInjectable({
instantiate: (di) => {
const createPersistentStorage = di.inject(createPersistentStorageInjectable);
const clustersState = di.inject(clustersStateInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return createPersistentStorage<ClusterStoreModel>({
configName: "lens-cluster-store",

4
packages/core/src/features/helm-charts/child-features/preferences/renderer/adding-of-public-helm-repository/public-helm-repositories/request-public-helm-repositories.injectable.ts
View File

@ -7,7 +7,7 @@ import { sortBy } from "lodash/fp";
import proxyDownloadJsonInjectable from "../../../../../../../common/fetch/download-json/proxy.injectable";
import { withTimeout } from "../../../../../../../common/fetch/timeout-controller";
import type { HelmRepo } from "../../../../../../../common/helm/helm-repo";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
const publicHelmReposUrl = "https://github.com/lensapp/artifact-hub-repositories/releases/download/latest/repositories.json";
@ -16,7 +16,7 @@ const requestPublicHelmRepositoriesInjectable = getInjectable({
instantiate: (di) => {
const downloadJson = di.inject(proxyDownloadJsonInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return async (): Promise<HelmRepo[]> => {
const controller = withTimeout(10_000);

4
packages/core/src/features/helm-charts/listing-active-helm-repositories-in-preferences.test.ts
View File

@ -12,7 +12,7 @@ import asyncFn from "@async-fn/jest";
import type { HelmRepositoriesFromYaml } from "../../main/helm/repositories/get-active-helm-repositories/get-active-helm-repositories.injectable";
import execFileInjectable, { type ExecFile } from "../../common/fs/exec-file.injectable";
import helmBinaryPathInjectable from "../../main/helm/helm-binary-path.injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import type { Logger } from "@k8slens/logging";
import requestPublicHelmRepositoriesInjectable from "./child-features/preferences/renderer/adding-of-public-helm-repository/public-helm-repositories/request-public-helm-repositories.injectable";
import showErrorNotificationInjectable from "../../renderer/components/notifications/show-error-notification.injectable";
@ -45,7 +45,7 @@ describe("listing active helm repositories in preferences", () => {
mainDi.override(readYamlFileInjectable, () => readYamlFileMock);
mainDi.override(execFileInjectable, () => execFileMock);
mainDi.override(helmBinaryPathInjectable, () => "some-helm-binary-path");
mainDi.override(loggerInjectable, () => loggerStub);
mainDi.override(loggerInjectionToken, () => loggerStub);
});
builder.beforeWindowStart(({ windowDi }) => {

4
packages/core/src/features/hotbar/storage/common/create-hotbar.injectable.ts
View File

@ -4,7 +4,7 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import type { CreateHotbarData } from "./types";
import { prefixedLoggerInjectable } from "@k8slens/logging";
import { prefixedLoggerInjectionToken } from "@k8slens/logging";
import type { HotbarDependencies } from "./hotbar";
import { Hotbar } from "./hotbar";
@ -14,7 +14,7 @@ const createHotbarInjectable = getInjectable({
id: "create-hotbar",
instantiate: (di): CreateHotbar => {
const deps: HotbarDependencies = {
logger: di.inject(prefixedLoggerInjectable, "HOTBAR"),
logger: di.inject(prefixedLoggerInjectionToken, "HOTBAR"),
};
return (data) => new Hotbar(deps, data);

4
packages/core/src/features/hotbar/storage/main/5.0.0-beta.10.injectable.ts
View File

@ -11,7 +11,7 @@ import joinPathsInjectable from "../../../../common/path/join-paths.injectable";
import { getInjectable } from "@ogre-tools/injectable";
import { hotbarStoreMigrationInjectionToken } from "../common/migrations-token";
import readJsonSyncInjectable from "../../../../common/fs/read-json-sync.injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import { generateNewIdFor } from "../../../../common/utils/generate-new-id-for";
import type { ClusterModel } from "../../../../common/cluster-types";
import { defaultHotbarCells } from "../common/types";
@ -43,7 +43,7 @@ const v500Beta10HotbarStoreMigrationInjectable = getInjectable({
const joinPaths = di.inject(joinPathsInjectable);
const readJsonSync = di.inject(readJsonSyncInjectable);
const catalogCatalogEntity = di.inject(catalogCatalogEntityInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
const createHotbar = di.inject(createHotbarInjectable);
const rawHotbars = store.get("hotbars");
const hotbars: HotbarData[] = Array.isArray(rawHotbars) ? rawHotbars.filter(h => h && typeof h === "object") : [];

4
packages/core/src/features/hotbar/storage/storage-technical.test.ts
View File

@ -12,7 +12,7 @@ import type { IComputedValue } from "mobx";
import { computed } from "mobx";
import hasCategoryForEntityInjectable from "../../../common/catalog/has-category-for-entity.injectable";
import catalogCatalogEntityInjectable from "../../../common/catalog-entities/general-catalog-entities/implementations/catalog-catalog-entity.injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import type { Logger } from "@k8slens/logging";
import directoryForUserDataInjectable from "../../../common/app-paths/directory-for-user-data/directory-for-user-data.injectable";
import storeMigrationVersionInjectable from "../../../common/vars/store-migration-version.injectable";
@ -109,7 +109,7 @@ describe("Hotbars technical tests", () => {
silly: jest.fn(),
};
di.override(loggerInjectable, () => loggerMock);
di.override(loggerInjectionToken, () => loggerMock);
di.override(directoryForUserDataInjectable, () => "/some-directory-for-user-data");

6
packages/core/src/features/population-of-logs-to-a-file/population-of-logs-to-a-file.test.ts
View File

@ -3,7 +3,7 @@
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import type { DiContainer } from "@ogre-tools/injectable";
import { winstonLoggerInjectable } from "@k8slens/logging";
import { winstonLoggerInjectionToken } from "@k8slens/logging";
import type { ApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
import { getApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
import type winston from "winston";
@ -52,7 +52,7 @@ describe("Population of logs to a file", () => {
});
builder.beforeWindowStart(({ windowDi }) => {
windowDi.unoverride(winstonLoggerInjectable);
windowDi.unoverride(winstonLoggerInjectionToken);
// Now that we have the actual winston logger in use, let's not be noisy and deregister console transport
runInAction(() => {
@ -69,7 +69,7 @@ describe("Population of logs to a file", () => {
await builder.render();
windowDi = builder.applicationWindow.only.di;
const winstonLogger = windowDi.inject(winstonLoggerInjectable);
const winstonLogger = windowDi.inject(winstonLoggerInjectionToken);
logWarningInRenderer = winstonLogger.warn;
}

4
packages/core/src/features/population-of-logs-to-a-file/renderer/close-renderer-log-file-id.test.ts
View File

@ -6,7 +6,7 @@ import type winston from "winston";
import type { SendMessageToChannel } from "@k8slens/messaging";
import { sendMessageToChannelInjectionToken } from "@k8slens/messaging";
import type { DiContainer } from "@ogre-tools/injectable";
import { winstonLoggerInjectable } from "@k8slens/logging";
import { winstonLoggerInjectionToken } from "@k8slens/logging";
import { getDiForUnitTesting } from "../../../renderer/getDiForUnitTesting";
import closeRendererLogFileInjectable from "./close-renderer-log-file.injectable";
import rendererLogFileIdInjectable from "./renderer-log-file-id.injectable";
@ -27,7 +27,7 @@ describe("close renderer file logging", () => {
} as any as winston.Logger;
ipcTransportMock = { name: "ipc-renderer-transport" } as IpcLogTransport;
di.override(winstonLoggerInjectable, () => winstonMock);
di.override(winstonLoggerInjectionToken, () => winstonMock);
di.override(sendMessageToChannelInjectionToken, () => sendIpcMock);
di.override(rendererLogFileIdInjectable, () => "some-log-id");
di.override(ipcLogTransportInjectable, () => ipcTransportMock);

4
packages/core/src/features/population-of-logs-to-a-file/renderer/close-renderer-log-file.injectable.ts
View File

@ -4,7 +4,7 @@
*/
import { sendMessageToChannelInjectionToken } from "@k8slens/messaging";
import { getInjectable } from "@ogre-tools/injectable";
import { winstonLoggerInjectable } from "@k8slens/logging";
import { winstonLoggerInjectionToken } from "@k8slens/logging";
import { closeIpcFileLoggerChannel } from "../common/ipc-file-logger-channel";
import rendererLogFileIdInjectable from "./renderer-log-file-id.injectable";
import ipcLogTransportInjectable from "./ipc-transport.injectable";
@ -12,7 +12,7 @@ import ipcLogTransportInjectable from "./ipc-transport.injectable";
const closeRendererLogFileInjectable = getInjectable({
id: "close-renderer-log-file",
instantiate: (di) => {
const winstonLogger = di.inject(winstonLoggerInjectable);
const winstonLogger = di.inject(winstonLoggerInjectionToken);
const ipcLogTransport = di.inject(ipcLogTransportInjectable);
const messageToChannel = di.inject(sendMessageToChannelInjectionToken);
const fileId = di.inject(rendererLogFileIdInjectable);

4
packages/core/src/features/preferences/navigation-to-extension-specific-preferences.test.tsx
View File

@ -10,7 +10,7 @@ import "@testing-library/jest-dom/extend-expect";
import type { FakeExtensionOptions } from "../../renderer/components/test-utils/get-extension-fake";
import type { Discover } from "@k8slens/react-testing-library-discovery";
import { discoverFor } from "@k8slens/react-testing-library-discovery";
import { logErrorInjectable } from "@k8slens/logging";
import { logErrorInjectionToken } from "@k8slens/logging";
describe("preferences - navigation to extension specific preferences", () => {
let builder: ApplicationBuilder;
@ -28,7 +28,7 @@ describe("preferences - navigation to extension specific preferences", () => {
logErrorMock = jest.fn();
builder.beforeWindowStart(({ windowDi }) => {
windowDi.override(logErrorInjectable, () => logErrorMock);
windowDi.override(logErrorInjectionToken, () => logErrorMock);
builder.preferences.navigate();
});

4
packages/core/src/features/preferences/renderer/preference-items/kubernetes/kubeconfig-sync/discover-sync-kind.injectable.ts
View File

@ -4,7 +4,7 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import statInjectable from "../../../../../../common/fs/stat.injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
export interface SyncKind {
type: "file" | "folder" | "unknown";
@ -16,7 +16,7 @@ const discoverKubeconfigSyncKindInjectable = getInjectable({
id: "discover-kubeconfig-sync-kind",
instantiate: (di): DiscoverKubeconfigSyncKind => {
const stat = di.inject(statInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
return async (path) => {
try {

4
packages/core/src/features/preferences/renderer/preference-items/kubernetes/kubeconfig-sync/kubeconfig-sync.tsx
View File

@ -13,7 +13,7 @@ import { PathPicker } from "../../../../../../renderer/components/path-picker/pa
import { Spinner } from "../../../../../../renderer/components/spinner";
import { RemovableItem } from "../../../removable-item/removable-item";
import isWindowsInjectable from "../../../../../../common/vars/is-windows.injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import type { Logger } from "@k8slens/logging";
import type { DiscoverAllKubeconfigSyncKinds } from "./discover-all-sync-kinds.injectable";
import type { DiscoverKubeconfigSyncKind, SyncKind } from "./discover-sync-kind.injectable";
@ -179,7 +179,7 @@ export const KubeconfigSync = withInjectables<Dependencies>(NonInjectedKubeconfi
getProps: (di) => ({
state: di.inject(userPreferencesStateInjectable),
isWindows: di.inject(isWindowsInjectable),
logger: di.inject(loggerInjectable),
logger: di.inject(loggerInjectionToken),
discoverAllKubeconfigSyncKinds: di.inject(discoverAllKubeconfigSyncKindsInjectable),
discoverKubeconfigSyncKind: di.inject(discoverKubeconfigSyncKindInjectable),
}),

4
packages/core/src/features/preferences/renderer/preference-items/preferences-composite.injectable.ts
View File

@ -10,7 +10,7 @@ import { preferenceItemInjectionToken } from "./preference-item-injection-token"
import { pipeline } from "@ogre-tools/fp";
import type { PreferenceTabsRoot } from "./preference-tab-root";
import { preferenceTabsRoot } from "./preference-tab-root";
import { logErrorInjectable } from "@k8slens/logging";
import { logErrorInjectionToken } from "@k8slens/logging";
import { isShown } from "../../../../common/utils/composable-responsibilities/showable/showable";
import { orderByOrderNumber } from "../../../../common/utils/composable-responsibilities/orderable/orderable";
import { getCompositeFor } from "../../../../common/utils/composite/get-composite/get-composite";
@ -21,7 +21,7 @@ const preferencesCompositeInjectable = getInjectable({
instantiate: (di) => {
const computedInjectMany = di.inject(computedInjectManyInjectable);
const preferenceItems = computedInjectMany(preferenceItemInjectionToken);
const logError = di.inject(logErrorInjectable);
const logError = di.inject(logErrorInjectionToken);
const getComposite = getCompositeFor<PreferenceItemTypes | PreferenceTabsRoot>({
getId: (x) => x.id,

4
packages/core/src/features/shell-sync/main/compute-unix-shell-environment.injectable.ts
View File

@ -7,7 +7,7 @@ import { getInjectable } from "@ogre-tools/injectable";
import getBasenameOfPathInjectable from "../../../common/path/get-basename.injectable";
import spawnInjectable from "../../../main/child-process/spawn.injectable";
import randomUUIDInjectable from "../../../main/crypto/random-uuid.injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import processExecPathInjectable from "./execPath.injectable";
import processEnvInjectable from "./env.injectable";
import { object } from "@k8slens/utilities";
@ -56,7 +56,7 @@ const computeUnixShellEnvironmentInjectable = getInjectable({
const getBasenameOfPath = di.inject(getBasenameOfPathInjectable);
const spawn = di.inject(spawnInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
const randomUUID = di.inject(randomUUIDInjectable);
const processExecPath = di.inject(processExecPathInjectable);
const processEnv = di.inject(processEnvInjectable);

4
packages/core/src/features/shell-sync/main/setup-shell.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 { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import { onLoadOfApplicationInjectionToken } from "@k8slens/application";
import isSnapPackageInjectable from "../../../common/vars/is-snap-package.injectable";
import electronAppInjectable from "../../../main/electron-app/electron-app.injectable";
@ -17,7 +17,7 @@ const setupShellInjectable = getInjectable({
instantiate: (di) => ({
run: async () => {
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
const isSnapPackage = di.inject(isSnapPackageInjectable);
const electronApp = di.inject(electronAppInjectable);
const resolvedUserShellSetting = di.inject(userShellSettingInjectable);

4
packages/core/src/features/telemetry/emit-telemetry-from-specific-function-calls.test.ts
View File

@ -8,7 +8,7 @@ import { getInjectable } from "@ogre-tools/injectable";
import { getDiForUnitTesting } from "../../renderer/getDiForUnitTesting";
import telemetryWhiteListForParameterlessFunctionsInjectable from "./renderer/telemetry-white-list-for-parameterless-functions.injectable";
import emitEventInjectable from "../../common/app-event-bus/emit-event.injectable";
import { logErrorInjectable } from "@k8slens/logging";
import { logErrorInjectionToken } from "@k8slens/logging";
import telemetryDecoratorInjectable from "./renderer/telemetry-decorator.injectable";
describe("emit-telemetry-from-specific-function-calls", () => {
@ -57,7 +57,7 @@ describe("emit-telemetry-from-specific-function-calls", () => {
);
});
di.override(logErrorInjectable, () => logErrorMock);
di.override(logErrorInjectionToken, () => logErrorMock);
whiteListedFunction = di.inject(whiteListedInjectable);
nonWhiteListedFunction = di.inject(nonWhiteListedInjectable);

4
packages/core/src/features/tray/clicking-tray-menu-item-originating-from-extension.test.ts
View File

@ -6,7 +6,7 @@ import type { ApplicationBuilder } from "../../renderer/components/test-utils/ge
import { getApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
import type { FakeExtensionOptions } from "../../renderer/components/test-utils/get-extension-fake";
import getRandomIdInjectable from "../../common/utils/get-random-id.injectable";
import { logErrorInjectable } from "@k8slens/logging";
import { logErrorInjectionToken } from "@k8slens/logging";
describe("clicking tray menu item originating from extension", () => {
let builder: ApplicationBuilder;
@ -18,7 +18,7 @@ describe("clicking tray menu item originating from extension", () => {
builder.beforeApplicationStart(({ mainDi }) => {
logErrorMock = jest.fn();
mainDi.override(logErrorInjectable, () => logErrorMock);
mainDi.override(logErrorInjectionToken, () => logErrorMock);
mainDi.override(getRandomIdInjectable, () => () => "some-random-id");
});

4
packages/core/src/features/user-preferences/common/storage.injectable.ts
View File

@ -4,7 +4,7 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import { action } from "mobx";
import { prefixedLoggerInjectable } from "@k8slens/logging";
import { prefixedLoggerInjectionToken } from "@k8slens/logging";
import createPersistentStorageInjectable from "../../../common/persistent-storage/create.injectable";
import persistentStorageMigrationsInjectable from "../../../common/persistent-storage/migrations.injectable";
import { userPreferencesMigrationInjectionToken } from "./migrations-token";
@ -24,7 +24,7 @@ const userPreferencesPersistentStorageInjectable = getInjectable({
id: "user-preferences-persistent-storage",
instantiate: (di) => {
const createPersistentStorage = di.inject(createPersistentStorageInjectable);
const logger = di.inject(prefixedLoggerInjectable, "USER-PREFERENCES");
const logger = di.inject(prefixedLoggerInjectionToken, "USER-PREFERENCES");
const descriptors = di.inject(userPreferenceDescriptorsInjectable);
const selectedUpdateChannel = di.inject(selectedUpdateChannelInjectable);
const state = di.inject(userPreferencesStateInjectable);

4
packages/core/src/features/user-preferences/main/5.0.3-beta.1.injectable.ts
View File

@ -13,7 +13,7 @@ import { getInjectable } from "@ogre-tools/injectable";
import { userPreferencesMigrationInjectionToken } from "../../../features/user-preferences/common/migrations-token";
import readJsonSyncInjectable from "../../../common/fs/read-json-sync.injectable";
import homeDirectoryPathInjectable from "../../../common/os/home-directory-path.injectable";
import { loggerInjectable } from "@k8slens/logging";
import { loggerInjectionToken } from "@k8slens/logging";
import pathExistsSyncInjectable from "../../../common/fs/path-exists-sync.injectable";
import type { ClusterStoreModel } from "../../../features/cluster/storage/common/storage.injectable";
import type { UserPreferencesModel, KubeconfigSyncEntry } from "../common/preferences-helpers";
@ -24,7 +24,7 @@ const v503Beta1UserPreferencesStorageMigrationInjectable = getInjectable({
const userDataPath = di.inject(directoryForUserDataInjectable);
const kubeConfigsPath = di.inject(directoryForKubeConfigsInjectable);
const joinPaths = di.inject(joinPathsInjectable);
const logger = di.inject(loggerInjectable);
const logger = di.inject(loggerInjectionToken);
const isLogicalChildPath = di.inject(isLogicalChildPathInjectable);
const getDirnameOfPath = di.inject(getDirnameOfPathInjectable);
const readJsonSync = di.inject(readJsonSyncInjectable);

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