Implement a lot of technical requirements for behavioural unit tests

Note: the crux of this was to make routing env-agnostic, and not based on URLs as magic strings, but instead something type-enforced.

Note: extension-based routes comply to same exact interface by "late-registering" their routes when installed. Routes are just injectables.

Note: another chunk of global shared state is no more.

Note: a lot of explicit side effects have been cornered to injectables.

Note: a lot of stuff has become reactive as part if this.

Co-authored-by: Mikko Aspiala <mikko.aspiala@gmail.com>

Signed-off-by: Janne Savolainen <janne.savolainen@live.fi>

package.json

@@ -202,8 +202,9 @@
     "@hapi/call": "^8.0.1",
     "@hapi/subtext": "^7.0.3",
     "@kubernetes/client-node": "^0.16.3",
-    "@ogre-tools/injectable": "5.1.2",
+    "@ogre-tools/injectable": "5.1.3",
-    "@ogre-tools/injectable-react": "5.1.2",
+    "@ogre-tools/injectable-react": "5.1.3",
+    "@ogre-tools/fp": "5.1.3",
     "@sentry/electron": "^2.5.4",
     "@sentry/integrations": "^6.19.2",
     "@types/circular-dependency-plugin": "5.0.5",

src/common/__tests__/base-store.test.ts

@@ -7,10 +7,10 @@ import mockFs from "mock-fs";
 import { BaseStore } from "../base-store";
 import { action, comparer, makeObservable, observable, toJS } from "mobx";
 import { readFileSync } from "fs";
-import { getDisForUnitTesting } from "../../test-utils/get-dis-for-unit-testing";
 
 import directoryForUserDataInjectable
   from "../app-paths/directory-for-user-data/directory-for-user-data.injectable";
+import { getDiForUnitTesting } from "../../main/getDiForUnitTesting";
 
 jest.mock("electron", () => ({
   ipcMain: {
@@ -78,11 +78,11 @@ describe("BaseStore", () => {
   let store: TestStore;
 
   beforeEach(async () => {
-    const dis = getDisForUnitTesting({ doGeneralOverrides: true });
+    const mainDi = getDiForUnitTesting({ doGeneralOverrides: true });
 
-    dis.mainDi.override(directoryForUserDataInjectable, () => "some-user-data-directory");
+    mainDi.override(directoryForUserDataInjectable, () => "some-user-data-directory");
 
-    await dis.runSetups();
+    await mainDi.runSetups();
 
     store = undefined;
     TestStore.resetInstance();
@@ -99,9 +99,9 @@ describe("BaseStore", () => {
   });
 
   afterEach(() => {
+    mockFs.restore();
     store.disableSync();
     TestStore.resetInstance();
-    mockFs.restore();
   });
 
   describe("persistence", () => {

src/common/__tests__/cluster-store.test.ts

@@ -19,11 +19,13 @@ import type {
 } from "@ogre-tools/injectable";
 
 
-import { getDisForUnitTesting } from "../../test-utils/get-dis-for-unit-testing";
 import { createClusterInjectionToken } from "../cluster/create-cluster-injection-token";
 
 import directoryForUserDataInjectable
   from "../app-paths/directory-for-user-data/directory-for-user-data.injectable";
+import kubeAuthProxyCaInjectable from "../../main/kube-auth-proxy/kube-auth-proxy-ca.injectable";
+import createKubeAuthProxyCertFilesInjectable from "../../main/kube-auth-proxy/create-kube-auth-proxy-cert-files.injectable";
+import { getDiForUnitTesting } from "../../main/getDiForUnitTesting";
 
 console = new Console(stdout, stderr);
 
@@ -80,15 +82,14 @@ describe("cluster-store", () => {
   let createCluster: (model: ClusterModel) => Cluster;
 
   beforeEach(async () => {
-    const dis = getDisForUnitTesting({ doGeneralOverrides: true });
+    mainDi = getDiForUnitTesting({ doGeneralOverrides: true });
 
     mockFs();
 
-    mainDi = dis.mainDi;
+    mainDi.override(clusterStoreInjectable, (di) => ClusterStore.createInstance({ createCluster: di.inject(createClusterInjectionToken) }));
-
     mainDi.override(directoryForUserDataInjectable, () => "some-directory-for-user-data");
 
-    await dis.runSetups();
+    await mainDi.runSetups();
 
     createCluster = mainDi.inject(createClusterInjectionToken);
   });

src/common/__tests__/hotbar-store.test.ts

@@ -11,6 +11,9 @@ import { HotbarStore } from "../hotbar-store";
 import { getDiForUnitTesting } from "../../main/getDiForUnitTesting";
 import directoryForUserDataInjectable from "../app-paths/directory-for-user-data/directory-for-user-data.injectable";
 import writeFileInjectable from "../fs/write-file.injectable";
+import hotbarStoreInjectable from "../hotbar-store.injectable";
+import catalogCatalogEntityInjectable
+  from "../catalog-entities/general-catalog-entities/implementations/catalog-catalog-entity.injectable";
 
 jest.mock("../../main/catalog/catalog-entity-registry", () => ({
   catalogEntityRegistry: {
@@ -119,7 +122,11 @@ describe("HotbarStore", () => {
     di.override(writeFileInjectable, () => () => undefined);
     di.override(directoryForUserDataInjectable, () => "some-directory-for-user-data");
 
-    await di.runSetups();
+    di.override(hotbarStoreInjectable, (di) =>
+      HotbarStore.createInstance({
+        catalogCatalogEntity: di.inject(catalogCatalogEntityInjectable),
+      }),
+    );
 
     mockFs({
       "some-directory-for-user-data": {
@@ -127,12 +134,14 @@ describe("HotbarStore", () => {
       },
     });
 
-    HotbarStore.createInstance();
+    await di.runSetups();
+
+    di.inject(hotbarStoreInjectable);
   });
 
   afterEach(() => {
-    HotbarStore.resetInstance();
     mockFs.restore();
+    HotbarStore.resetInstance();
   });
 
   describe("load", () => {
@@ -328,7 +337,6 @@ describe("HotbarStore", () => {
 
   describe("pre beta-5 migrations", () => {
     beforeEach(() => {
-      HotbarStore.resetInstance();
       const mockOpts = {
         "some-directory-for-user-data": {
           "lens-hotbar-store.json": JSON.stringify({
@@ -392,8 +400,6 @@ describe("HotbarStore", () => {
       };
 
       mockFs(mockOpts);
-
-      HotbarStore.createInstance();
     });
 
     afterEach(() => {

src/common/__tests__/user-store.test.ts

@@ -26,34 +26,34 @@ import { Console } from "console";
 import { SemVer } from "semver";
 import electron from "electron";
 import { stdout, stderr } from "process";
-import { getDisForUnitTesting } from "../../test-utils/get-dis-for-unit-testing";
 import userStoreInjectable from "../user-store/user-store.injectable";
 import type { DiContainer } from "@ogre-tools/injectable";
 import directoryForUserDataInjectable from "../app-paths/directory-for-user-data/directory-for-user-data.injectable";
 import type { ClusterStoreModel } from "../cluster-store/cluster-store";
 import { defaultTheme } from "../vars";
 import writeFileInjectable from "../fs/write-file.injectable";
+import { getDiForUnitTesting } from "../../main/getDiForUnitTesting";
 
 console = new Console(stdout, stderr);
 
 describe("user store tests", () => {
   let userStore: UserStore;
-  let mainDi: DiContainer;
+  let di: DiContainer;
 
   beforeEach(async () => {
-    const dis = getDisForUnitTesting({ doGeneralOverrides: true });
+    di = getDiForUnitTesting({ doGeneralOverrides: true });
 
     mockFs();
 
-    mainDi = dis.mainDi;
+    di.override(writeFileInjectable, () => () => undefined);
+    di.override(directoryForUserDataInjectable, () => "some-directory-for-user-data");
+    di.override(userStoreInjectable, () => UserStore.createInstance());
 
-    mainDi.override(writeFileInjectable, () => () => undefined);
+    await di.runSetups();
-    mainDi.override(directoryForUserDataInjectable, () => "some-directory-for-user-data");
-
-    await dis.runSetups();
   });
 
   afterEach(() => {
+    UserStore.resetInstance();
     mockFs.restore();
   });
 
@@ -61,12 +61,7 @@ describe("user store tests", () => {
     beforeEach(() => {
       mockFs({ "some-directory-for-user-data": { "config.json": "{}", "kube_config": "{}" }});
 
-      userStore = mainDi.inject(userStoreInjectable);
+      userStore = di.inject(userStoreInjectable);
-    });
-
-    afterEach(() => {
-      mockFs.restore();
-      UserStore.resetInstance();
     });
 
     it("allows setting and retrieving lastSeenAppVersion", () => {
@@ -128,12 +123,7 @@ describe("user store tests", () => {
         },
       });
 
-      userStore = mainDi.inject(userStoreInjectable);
+      userStore = di.inject(userStoreInjectable);
-    });
-
-    afterEach(() => {
-      UserStore.resetInstance();
-      mockFs.restore();
     });
 
     it("sets last seen app version to 0.0.0", () => {

src/common/catalog-entities/general-catalog-entities/general-catalog-entities.injectable.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { observable } from "mobx";
+import { generalCatalogEntityInjectionToken } from "./general-catalog-entity-injection-token";
+
+const generalCatalogEntitiesInjectable = getInjectable({
+  id: "general-catalog-entities",
+
+  instantiate: (di) =>
+    observable(di.injectMany(generalCatalogEntityInjectionToken)),
+});
+
+export default generalCatalogEntitiesInjectable;

src/common/catalog-entities/general-catalog-entities/general-catalog-entity-injection-token.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectionToken } from "@ogre-tools/injectable";
+import type { GeneralEntity } from "../index";
+
+export const generalCatalogEntityInjectionToken = getInjectionToken<GeneralEntity>({
+  id: "general-catalog-entity-injection-token",
+});

src/common/catalog-entities/general-catalog-entities/implementations/catalog-catalog-entity.injectable.ts

@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { generalCatalogEntityInjectionToken } from "../general-catalog-entity-injection-token";
+import { GeneralEntity } from "../../index";
+import { buildURL } from "../../../utils/buildUrl";
+import catalogRouteInjectable from "../../../front-end-routing/routes/catalog/catalog-route.injectable";
+
+const catalogCatalogEntityInjectable = getInjectable({
+  id: "general-catalog-entity-for-catalog",
+
+  instantiate: (di) => {
+    const route = di.inject(catalogRouteInjectable);
+    const url = buildURL(route.path);
+
+    return new GeneralEntity({
+      metadata: {
+        uid: "catalog-entity",
+        name: "Catalog",
+        source: "app",
+        labels: {},
+      },
+      spec: {
+        path: url,
+        icon: {
+          material: "view_list",
+          background: "#3d90ce",
+        },
+      },
+      status: {
+        phase: "active",
+      },
+    });
+  },
+
+  injectionToken: generalCatalogEntityInjectionToken,
+});
+
+export default catalogCatalogEntityInjectable;

src/common/catalog-entities/general-catalog-entities/implementations/preferences-catalog-entity.injectable.ts

@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { generalCatalogEntityInjectionToken } from "../general-catalog-entity-injection-token";
+import { GeneralEntity } from "../../index";
+import { buildURL } from "../../../utils/buildUrl";
+import appPreferencesRouteInjectable from "../../../front-end-routing/routes/preferences/app/app-preferences-route.injectable";
+
+const preferencesCatalogEntityInjectable = getInjectable({
+  id: "general-catalog-entity-for-preferences",
+
+  instantiate: (di) => {
+    const route = di.inject(appPreferencesRouteInjectable);
+    const url = buildURL(route.path);
+
+    return new GeneralEntity({
+      metadata: {
+        uid: "preferences-entity",
+        name: "Preferences",
+        source: "app",
+        labels: {},
+      },
+      spec: {
+        path: url,
+        icon: {
+          material: "settings",
+          background: "#3d90ce",
+        },
+      },
+      status: {
+        phase: "active",
+      },
+    });
+  },
+
+  injectionToken: generalCatalogEntityInjectionToken,
+});
+
+export default preferencesCatalogEntityInjectable;

src/common/catalog-entities/general-catalog-entities/implementations/welcome-catalog-entity.injectable.ts

@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { generalCatalogEntityInjectionToken } from "../general-catalog-entity-injection-token";
+import { GeneralEntity } from "../../index";
+import { buildURL } from "../../../utils/buildUrl";
+import welcomeRouteInjectable from "../../../front-end-routing/routes/welcome/welcome-route.injectable";
+
+const welcomeCatalogEntityInjectable = getInjectable({
+  id: "general-catalog-entity-for-welcome",
+
+  instantiate: (di) => {
+    const route = di.inject(welcomeRouteInjectable);
+    const url = buildURL(route.path);
+
+    return new GeneralEntity({
+      metadata: {
+        uid: "welcome-page-entity",
+        name: "Welcome Page",
+        source: "app",
+        labels: {},
+      },
+      spec: {
+        path: url,
+        icon: {
+          material: "meeting_room",
+          background: "#3d90ce",
+        },
+      },
+      status: {
+        phase: "active",
+      },
+    });
+  },
+
+  injectionToken: generalCatalogEntityInjectionToken,
+});
+
+export default welcomeCatalogEntityInjectable;

src/common/cluster-store/cluster-store.injectable.ts

@@ -13,6 +13,8 @@ const clusterStoreInjectable = getInjectable({
     ClusterStore.createInstance({
       createCluster: di.inject(createClusterInjectionToken),
     }),
+
+  causesSideEffects: true,
 });
 
 export default clusterStoreInjectable;

src/common/front-end-routing/navigate-to-front-page.injectable.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import navigateToCatalogInjectable from "./routes/catalog/navigate-to-catalog.injectable";
+
+const navigateToFrontPageInjectable = getInjectable({
+  id: "navigate-to-front-page",
+  instantiate: (di) => di.inject(navigateToCatalogInjectable),
+});
+
+export default navigateToFrontPageInjectable;

src/common/front-end-routing/navigate-to-route-injection-token.ts

@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectionToken } from "@ogre-tools/injectable";
+import type { Route } from "./route-injection-token";
+
+type InferParametersFrom<TRoute> = TRoute extends Route<infer TParameters>
+  ? TParameters
+  : never;
+
+type RequiredKeys<T> = Exclude<
+  {
+    [K in keyof T]: T extends Record<K, T[K]> ? K : never;
+  }[keyof T],
+  undefined
+>;
+
+type ObjectContainingNoRequired<T> = T extends void
+  ? never
+  : RequiredKeys<T> extends []
+  ? any
+  : never;
+
+type ObjectContainsNoRequired<T> = T extends ObjectContainingNoRequired<T>
+  ? true
+  : false;
+
+// TODO: Missing types for:
+// - Navigating to route without parameters, with parameters
+// - Navigating to route with required parameters, without parameters
+type Parameters<TParameters> = TParameters extends void
+  ? {}
+  : ObjectContainsNoRequired<TParameters> extends true
+  ? { parameters?: TParameters }
+  : { parameters: TParameters };
+
+export type NavigateToRouteOptions<TRoute> = Parameters<
+  InferParametersFrom<TRoute>
+> & {
+  query?: Record<string, string>;
+  fragment?: string;
+  withoutAffectingBackButton?: boolean;
+};
+
+export type NavigateToRoute = <TRoute extends Route<unknown>>(
+  route: TRoute,
+  options?: NavigateToRouteOptions<TRoute>) => void;
+
+export const navigateToRouteInjectionToken = getInjectionToken<NavigateToRoute>(
+  { id: "navigate-to-route-injection-token" },
+);

src/common/front-end-routing/navigate-to-url-injection-token.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectionToken } from "@ogre-tools/injectable";
+
+export interface NavigateToUrlOptions {
+  withoutAffectingBackButton?: boolean;
+  forceRootFrame?: boolean;
+}
+
+export type NavigateToUrl = (url: string, options?: NavigateToUrlOptions) => void;
+
+export const navigateToUrlInjectionToken = getInjectionToken<NavigateToUrl>(
+  { id: "navigate-to-url-injection-token" },
+);

src/common/front-end-routing/navigation-ipc-channel.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { createChannel } from "../ipc-channel/create-channel/create-channel";
+import { IpcRendererNavigationEvents } from "../../renderer/navigation/events";
+
+export const appNavigationIpcChannel = createChannel<string>(IpcRendererNavigationEvents.NAVIGATE_IN_APP);
+export const clusterFrameNavigationIpcChannel = createChannel<string>(IpcRendererNavigationEvents.NAVIGATE_IN_CLUSTER);

src/common/front-end-routing/route-injection-token.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectionToken } from "@ogre-tools/injectable";
+import type { IComputedValue } from "mobx";
+import type { LensRendererExtension } from "../../extensions/lens-renderer-extension";
+
+export const routeInjectionToken = getInjectionToken<Route<unknown>>({
+  id: "route-injection-token",
+});
+
+export interface Route<TParameter = void> {
+  path: string;
+  clusterFrame: boolean;
+  isEnabled: IComputedValue<boolean>;
+  extension?: LensRendererExtension;
+
+  readonly parameterSignature?: TParameter;
+}

src/common/front-end-routing/routes/add-cluster/add-cluster-route.injectable.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import { routeInjectionToken } from "../../route-injection-token";
+
+const addClusterRouteInjectable = getInjectable({
+  id: "add-cluster-route",
+
+  instantiate: () => ({
+    path: "/add-cluster",
+    clusterFrame: false,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default addClusterRouteInjectable;

src/common/front-end-routing/routes/add-cluster/navigate-to-add-cluster.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import addClusterRouteInjectable from "./add-cluster-route.injectable";
+import { navigateToRouteInjectionToken } from "../../navigate-to-route-injection-token";
+
+const navigateToAddClusterInjectable = getInjectable({
+  id: "navigate-to-add-cluster",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(addClusterRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToAddClusterInjectable;

src/common/front-end-routing/routes/catalog/catalog-route.injectable.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import { Route, routeInjectionToken } from "../../route-injection-token";
+
+export interface CatalogPathParameters {
+  group?: string;
+  kind?: string;
+}
+
+const catalogRouteInjectable = getInjectable({
+  id: "catalog-route",
+
+  instantiate: (): Route<CatalogPathParameters> => ({
+    path: "/catalog/:group?/:kind?",
+    clusterFrame: false,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default catalogRouteInjectable;

src/common/front-end-routing/routes/catalog/navigate-to-catalog.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import catalogRouteInjectable, { CatalogPathParameters } from "./catalog-route.injectable";
+import { navigateToRouteInjectionToken } from "../../navigate-to-route-injection-token";
+
+export type NavigateToCatalog = (parameters?: CatalogPathParameters) => void;
+
+const navigateToCatalogInjectable = getInjectable({
+  id: "navigate-to-catalog",
+
+  instantiate: (di): NavigateToCatalog => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const catalogRoute = di.inject(catalogRouteInjectable);
+
+    return (parameters) =>
+      navigateToRoute(catalogRoute, {
+        parameters,
+      });
+  },
+});
+
+export default navigateToCatalogInjectable;

src/common/front-end-routing/routes/cluster-view/cluster-view-route.injectable.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import { routeInjectionToken } from "../../route-injection-token";
+
+const clusterViewRouteInjectable = getInjectable({
+  id: "cluster-view-route",
+
+  instantiate: () => ({
+    path: "/cluster/:clusterId",
+    clusterFrame: false,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default clusterViewRouteInjectable;

src/common/front-end-routing/routes/cluster-view/navigate-to-cluster-view.injectable.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { navigateToRouteInjectionToken } from "../../navigate-to-route-injection-token";
+import clusterViewRouteInjectable from "./cluster-view-route.injectable";
+
+export type NavigateToClusterView = (clusterId: string) => void;
+
+const navigateToClusterViewInjectable = getInjectable({
+  id: "navigate-to-cluster-view",
+
+  instantiate: (di): NavigateToClusterView => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(clusterViewRouteInjectable);
+
+    return (clusterId) =>
+      navigateToRoute(route, { parameters: { clusterId }});
+  },
+});
+
+export default navigateToClusterViewInjectable;

src/common/front-end-routing/routes/cluster/config/config-maps/config-maps-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const configMapsRouteInjectable = getInjectable({
+  id: "config-maps-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "configmaps");
+
+    return {
+      path: "/configmaps",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default configMapsRouteInjectable;

src/common/front-end-routing/routes/cluster/config/config-maps/navigate-to-config-maps.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import configMapsRouteInjectable from "./config-maps-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToConfigMapsInjectable = getInjectable({
+  id: "navigate-to-config-maps",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(configMapsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToConfigMapsInjectable;

src/common/front-end-routing/routes/cluster/config/horizontal-pod-autoscalers/horizontal-pod-autoscalers-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const horizontalPodAutoscalersRouteInjectable = getInjectable({
+  id: "horizontal-pod-autoscalers-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "horizontalpodautoscalers");
+
+    return {
+      path: "/hpa",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default horizontalPodAutoscalersRouteInjectable;

src/common/front-end-routing/routes/cluster/config/horizontal-pod-autoscalers/navigate-to-horizontal-pod-autoscalers.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import horizontalPodAutoscalersRouteInjectable from "./horizontal-pod-autoscalers-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToHorizontalPodAutoscalersInjectable = getInjectable({
+  id: "navigate-to-horizontal-pod-autoscalers",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(horizontalPodAutoscalersRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToHorizontalPodAutoscalersInjectable;

src/common/front-end-routing/routes/cluster/config/limit-ranges/limit-ranges-route.injectable.ts

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const limitRangesRouteInjectable = getInjectable({
+  id: "limit-ranges-route",
+
+  instantiate: (di) => {
+    const limitRangesIsAllowed = di.inject(
+      isAllowedResourceInjectable,
+      "limitranges",
+    );
+
+    return {
+      path: "/limitranges",
+      clusterFrame: true,
+      isEnabled: limitRangesIsAllowed,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default limitRangesRouteInjectable;

src/common/front-end-routing/routes/cluster/config/limit-ranges/navigate-to-limit-ranges.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import limitRangesRouteInjectable from "./limit-ranges-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToLimitRangesInjectable = getInjectable({
+  id: "navigate-to-limit-ranges",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(limitRangesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToLimitRangesInjectable;

src/common/front-end-routing/routes/cluster/config/pod-disruption-budgets/navigate-to-pod-disruption-budgets.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import podDisruptionBudgetsRouteInjectable from "./pod-disruption-budgets-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToPodDisruptionBudgetsInjectable = getInjectable({
+  id: "navigate-to-pod-disruption-budgets",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(podDisruptionBudgetsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToPodDisruptionBudgetsInjectable;

src/common/front-end-routing/routes/cluster/config/pod-disruption-budgets/pod-disruption-budgets-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const podDisruptionBudgetsRouteInjectable = getInjectable({
+  id: "pod-disruption-budgets-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "poddisruptionbudgets");
+
+    return {
+      path: "/poddisruptionbudgets",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default podDisruptionBudgetsRouteInjectable;

src/common/front-end-routing/routes/cluster/config/resource-quotas/navigate-to-resource-quotas.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import resourceQuotasRouteInjectable from "./resource-quotas-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToResourceQuotasInjectable = getInjectable({
+  id: "navigate-to-resource-quotas",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(resourceQuotasRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToResourceQuotasInjectable;

src/common/front-end-routing/routes/cluster/config/resource-quotas/resource-quotas-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const resourceQuotasRouteInjectable = getInjectable({
+  id: "resource-quotas-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "resourcequotas");
+
+    return {
+      path: "/resourcequotas",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default resourceQuotasRouteInjectable;

src/common/front-end-routing/routes/cluster/config/secrets/navigate-to-secrets.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import secretsRouteInjectable from "./secrets-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToSecretsInjectable = getInjectable({
+  id: "navigate-to-secrets",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(secretsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToSecretsInjectable;

src/common/front-end-routing/routes/cluster/config/secrets/secrets-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const secretsRouteInjectable = getInjectable({
+  id: "secrets-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "secrets");
+
+    return {
+      path: "/secrets",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default secretsRouteInjectable;

src/common/front-end-routing/routes/cluster/custom-resources/crd-list/crd-list-route.injectable.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const crdListRouteInjectable = getInjectable({
+  id: "crd-list-route",
+
+  instantiate: () => ({
+    path: "/crd/definitions",
+    clusterFrame: true,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default crdListRouteInjectable;

src/common/front-end-routing/routes/cluster/custom-resources/crd-list/navigate-to-crd-list.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import crdListRouteInjectable from "./crd-list-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToCrdListInjectable = getInjectable({
+  id: "navigate-to-crd-list",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(crdListRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToCrdListInjectable;

src/common/front-end-routing/routes/cluster/custom-resources/custom-resources/custom-resources-route.injectable.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import { Route, routeInjectionToken } from "../../../../route-injection-token";
+
+export interface CustomResourcesPathParameters {
+  group?: string;
+  name?: string;
+}
+
+const customResourcesRouteInjectable = getInjectable({
+  id: "custom-resources-route",
+
+  instantiate: (): Route<CustomResourcesPathParameters> => ({
+    path: "/crd/:group?/:name?",
+    clusterFrame: true,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default customResourcesRouteInjectable;

src/common/front-end-routing/routes/cluster/custom-resources/custom-resources/navigate-to-custom-resources.injectable.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import customResourcesRouteInjectable, { CustomResourcesPathParameters } from "./custom-resources-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToCustomResourcesInjectable = getInjectable({
+  id: "navigate-to-custom-resources",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(customResourcesRouteInjectable);
+
+    return (parameters?: CustomResourcesPathParameters) =>
+      navigateToRoute(route, { parameters });
+  },
+});
+
+export default navigateToCustomResourcesInjectable;

src/common/front-end-routing/routes/cluster/events/events-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../route-injection-token";
+
+const eventsRouteInjectable = getInjectable({
+  id: "events-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "events");
+
+    return {
+      path: "/events",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default eventsRouteInjectable;

src/common/front-end-routing/routes/cluster/events/navigate-to-events.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import eventsRouteInjectable from "./events-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../navigate-to-route-injection-token";
+
+const navigateToEventsInjectable = getInjectable({
+  id: "navigate-to-events",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(eventsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToEventsInjectable;

src/common/front-end-routing/routes/cluster/helm/charts/helm-charts-route.injectable.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import { Route, routeInjectionToken } from "../../../../route-injection-token";
+
+export interface HelmChartsPathParameters {
+  repo?: string;
+  chartName?: string;
+}
+
+const helmChartsRouteInjectable = getInjectable({
+  id: "helm-charts-route",
+
+  instantiate: (): Route<HelmChartsPathParameters> => ({
+    path: "/helm/charts/:repo?/:chartName?",
+    clusterFrame: true,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default helmChartsRouteInjectable;

src/common/front-end-routing/routes/cluster/helm/charts/navigate-to-helm-charts.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import helmChartsRouteInjectable, { HelmChartsPathParameters } from "./helm-charts-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+export type NavigateToHelmCharts = (parameters?: HelmChartsPathParameters) => void;
+
+const navigateToHelmChartsInjectable = getInjectable({
+  id: "navigate-to-helm-charts",
+
+  instantiate: (di): NavigateToHelmCharts => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(helmChartsRouteInjectable);
+
+    return (parameters) =>
+      navigateToRoute(route, {
+        parameters,
+      });
+  },
+});
+
+export default navigateToHelmChartsInjectable;

src/common/front-end-routing/routes/cluster/helm/releases/helm-releases-route.injectable.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import { Route, routeInjectionToken } from "../../../../route-injection-token";
+
+export interface HelmReleasesPathParameters {
+  namespace?: string;
+  name?: string;
+}
+
+const helmReleasesRouteInjectable = getInjectable({
+  id: "helm-releases-route",
+
+  instantiate: (): Route<HelmReleasesPathParameters> => ({
+    path: "/helm/releases/:namespace?/:name?",
+    clusterFrame: true,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default helmReleasesRouteInjectable;

src/common/front-end-routing/routes/cluster/helm/releases/navigate-to-helm-releases.injectable.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import helmReleasesRouteInjectable, { HelmReleasesPathParameters } from "./helm-releases-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+export type NavigateToHelmReleases = (parameters?: HelmReleasesPathParameters) => void;
+
+const navigateToHelmReleasesInjectable = getInjectable({
+  id: "navigate-to-helm-releases",
+
+  instantiate: (di): NavigateToHelmReleases => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(helmReleasesRouteInjectable);
+
+    return (parameters) =>
+      navigateToRoute(route, { parameters });
+  },
+});
+
+export default navigateToHelmReleasesInjectable;

src/common/front-end-routing/routes/cluster/namespaces/namespaces-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../route-injection-token";
+
+const namespacesRouteInjectable = getInjectable({
+  id: "namespaces-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "namespaces");
+
+    return {
+      path: "/namespaces",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default namespacesRouteInjectable;

src/common/front-end-routing/routes/cluster/namespaces/navigate-to-namespaces.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import namespacesRouteInjectable from "./namespaces-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../navigate-to-route-injection-token";
+
+const navigateToNamespacesInjectable = getInjectable({
+  id: "navigate-to-namespaces",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(namespacesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToNamespacesInjectable;

src/common/front-end-routing/routes/cluster/network/endpoints/endpoints-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const endpointsRouteInjectable = getInjectable({
+  id: "endpoints-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "endpoints");
+
+    return {
+      path: "/endpoints",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default endpointsRouteInjectable;

src/common/front-end-routing/routes/cluster/network/endpoints/navigate-to-endpoints.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import endpointsRouteInjectable from "./endpoints-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToEndpointsInjectable = getInjectable({
+  id: "navigate-to-endpoints",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(endpointsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToEndpointsInjectable;

src/common/front-end-routing/routes/cluster/network/ingresses/ingresses-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const ingressesRouteInjectable = getInjectable({
+  id: "ingresses-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "ingresses");
+
+    return {
+      path: "/ingresses",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default ingressesRouteInjectable;

src/common/front-end-routing/routes/cluster/network/ingresses/navigate-to-ingresses.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import ingressesRouteInjectable from "./ingresses-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToIngressesInjectable = getInjectable({
+  id: "navigate-to-ingresses",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(ingressesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToIngressesInjectable;

src/common/front-end-routing/routes/cluster/network/network-policies/navigate-to-network-policies.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import networkPoliciesRouteInjectable from "./network-policies-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToNetworkPoliciesInjectable = getInjectable({
+  id: "navigate-to-network-policies",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(networkPoliciesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToNetworkPoliciesInjectable;

src/common/front-end-routing/routes/cluster/network/network-policies/network-policies-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const networkPoliciesRouteInjectable = getInjectable({
+  id: "network-policies-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "networkpolicies");
+
+    return {
+      path: "/network-policies",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default networkPoliciesRouteInjectable;

src/common/front-end-routing/routes/cluster/network/port-forwards/navigate-to-port-forwards.injectable.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import portForwardsRouteInjectable, { PortForwardsPathParameters } from "./port-forwards-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+export type NavigateToPortForwards = (parameters?: PortForwardsPathParameters) => void;
+
+const navigateToPortForwardsInjectable = getInjectable({
+  id: "navigate-to-port-forwards",
+
+  instantiate: (di): NavigateToPortForwards => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(portForwardsRouteInjectable);
+
+    return (parameters) =>
+      navigateToRoute(route, { parameters });
+  },
+});
+
+export default navigateToPortForwardsInjectable;

src/common/front-end-routing/routes/cluster/network/port-forwards/port-forwards-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import { Route, routeInjectionToken } from "../../../../route-injection-token";
+
+export interface PortForwardsPathParameters {
+  forwardport?: string;
+}
+
+const portForwardsRouteInjectable = getInjectable({
+  id: "port-forwards-route",
+
+  instantiate: (): Route<PortForwardsPathParameters> => ({
+    path: "/port-forwards/:forwardport?",
+    clusterFrame: true,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default portForwardsRouteInjectable;

src/common/front-end-routing/routes/cluster/network/services/navigate-to-services.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import servicesRouteInjectable from "./services-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToServicesInjectable = getInjectable({
+  id: "navigate-to-services",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(servicesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToServicesInjectable;

src/common/front-end-routing/routes/cluster/network/services/services-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const servicesRouteInjectable = getInjectable({
+  id: "services-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "services");
+
+    return {
+      path: "/services",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default servicesRouteInjectable;

src/common/front-end-routing/routes/cluster/nodes/navigate-to-nodes.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import nodesRouteInjectable from "./nodes-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../navigate-to-route-injection-token";
+
+const navigateToNodesInjectable = getInjectable({
+  id: "navigate-to-nodes",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(nodesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToNodesInjectable;

src/common/front-end-routing/routes/cluster/nodes/nodes-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../route-injection-token";
+
+const nodesRouteInjectable = getInjectable({
+  id: "nodes-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "nodes");
+
+    return {
+      path: "/nodes",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default nodesRouteInjectable;

src/common/front-end-routing/routes/cluster/overview/cluster-overview-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../route-injection-token";
+
+const clusterOverviewRouteInjectable = getInjectable({
+  id: "cluster-overview-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "nodes");
+
+    return {
+      path: "/overview",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default clusterOverviewRouteInjectable;

src/common/front-end-routing/routes/cluster/overview/navigate-to-cluster-overview.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import clusterOverviewRouteInjectable from "./cluster-overview-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../navigate-to-route-injection-token";
+
+const navigateToClusterOverviewInjectable = getInjectable({
+  id: "navigate-to-cluster-overview",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(clusterOverviewRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToClusterOverviewInjectable;

src/common/front-end-routing/routes/cluster/storage/persistent-volume-claims/navigate-to-persistent-volume-claims.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import persistentVolumeClaimsRouteInjectable from "./persistent-volume-claims-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToPersistentVolumeClaimsInjectable = getInjectable({
+  id: "navigate-to-persistent-volume-claims",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(persistentVolumeClaimsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToPersistentVolumeClaimsInjectable;

src/common/front-end-routing/routes/cluster/storage/persistent-volume-claims/persistent-volume-claims-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const persistentVolumeClaimsRouteInjectable = getInjectable({
+  id: "persistent-volume-claims-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "persistentvolumeclaims");
+
+    return {
+      path: "/persistent-volume-claims",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default persistentVolumeClaimsRouteInjectable;

src/common/front-end-routing/routes/cluster/storage/persistent-volumes/navigate-to-persistent-volumes.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import persistentVolumesRouteInjectable from "./persistent-volumes-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToPersistentVolumesInjectable = getInjectable({
+  id: "navigate-to-persistent-volumes",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(persistentVolumesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToPersistentVolumesInjectable;

src/common/front-end-routing/routes/cluster/storage/persistent-volumes/persistent-volumes-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const persistentVolumesRouteInjectable = getInjectable({
+  id: "persistent-volumes-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "persistentvolumes");
+
+    return {
+      path: "/persistent-volumes",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default persistentVolumesRouteInjectable;

src/common/front-end-routing/routes/cluster/storage/storage-classes/navigate-to-storage-classes.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import storageClassesRouteInjectable from "./storage-classes-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToStorageClassesInjectable = getInjectable({
+  id: "navigate-to-storage-classes",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(storageClassesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToStorageClassesInjectable;

src/common/front-end-routing/routes/cluster/storage/storage-classes/storage-classes-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const storageClassesRouteInjectable = getInjectable({
+  id: "storage-classes-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "storageclasses");
+
+    return {
+      path: "/storage-classes",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default storageClassesRouteInjectable;

src/common/front-end-routing/routes/cluster/user-management/cluster-role-bindings/cluster-role-bindings-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const clusterRoleBindingsRouteInjectable = getInjectable({
+  id: "cluster-role-bindings-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "clusterrolebindings");
+
+    return {
+      path: "/cluster-role-bindings",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default clusterRoleBindingsRouteInjectable;

src/common/front-end-routing/routes/cluster/user-management/cluster-role-bindings/navigate-to-cluster-role-bindings.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import clusterRoleBindingsRouteInjectable from "./cluster-role-bindings-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToClusterRoleBindingsInjectable = getInjectable({
+  id: "navigate-to-cluster-role-bindings",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(clusterRoleBindingsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToClusterRoleBindingsInjectable;

src/common/front-end-routing/routes/cluster/user-management/cluster-roles/cluster-roles-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const clusterRolesRouteInjectable = getInjectable({
+  id: "cluster-roles-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "clusterroles");
+
+    return {
+      path: "/cluster-roles",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default clusterRolesRouteInjectable;

src/common/front-end-routing/routes/cluster/user-management/cluster-roles/navigate-to-cluster-roles.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import clusterRolesRouteInjectable from "./cluster-roles-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToClusterRolesInjectable = getInjectable({
+  id: "navigate-to-cluster-roles",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(clusterRolesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToClusterRolesInjectable;

src/common/front-end-routing/routes/cluster/user-management/pod-security-policies/navigate-to-pod-security-policies.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import podSecurityPoliciesRouteInjectable from "./pod-security-policies-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToPodSecurityPoliciesInjectable = getInjectable({
+  id: "navigate-to-pod-security-policies",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(podSecurityPoliciesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToPodSecurityPoliciesInjectable;

src/common/front-end-routing/routes/cluster/user-management/pod-security-policies/pod-security-policies-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const podSecurityPoliciesRouteInjectable = getInjectable({
+  id: "pod-security-policies-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "podsecuritypolicies");
+
+    return {
+      path: "/pod-security-policies",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default podSecurityPoliciesRouteInjectable;

src/common/front-end-routing/routes/cluster/user-management/role-bindings/navigate-to-role-bindings.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import roleBindingsRouteInjectable from "./role-bindings-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToRoleBindingsInjectable = getInjectable({
+  id: "navigate-to-role-bindings",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(roleBindingsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToRoleBindingsInjectable;

src/common/front-end-routing/routes/cluster/user-management/role-bindings/role-bindings-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const roleBindingsRouteInjectable = getInjectable({
+  id: "role-bindings-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "rolebindings");
+
+    return {
+      path: "/role-bindings",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default roleBindingsRouteInjectable;

src/common/front-end-routing/routes/cluster/user-management/roles/navigate-to-roles.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import rolesRouteInjectable from "./roles-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToRolesInjectable = getInjectable({
+  id: "navigate-to-roles",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(rolesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToRolesInjectable;

src/common/front-end-routing/routes/cluster/user-management/roles/roles-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const rolesRouteInjectable = getInjectable({
+  id: "roles-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "roles");
+
+    return {
+      path: "/roles",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default rolesRouteInjectable;

src/common/front-end-routing/routes/cluster/user-management/service-accounts/navigate-to-service-accounts.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import serviceAccountsRouteInjectable from "./service-accounts-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToServiceAccountsInjectable = getInjectable({
+  id: "navigate-to-service-accounts",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(serviceAccountsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToServiceAccountsInjectable;

src/common/front-end-routing/routes/cluster/user-management/service-accounts/service-accounts-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const serviceAccountsRouteInjectable = getInjectable({
+  id: "service-accounts-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "serviceaccounts");
+
+    return {
+      path: "/service-accounts",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default serviceAccountsRouteInjectable;

src/common/front-end-routing/routes/cluster/workloads/cron-jobs/cron-jobs-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const cronJobsRouteInjectable = getInjectable({
+  id: "cron-jobs-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "cronjobs");
+
+    return {
+      path: "/cronjobs",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default cronJobsRouteInjectable;

src/common/front-end-routing/routes/cluster/workloads/cron-jobs/navigate-to-cron-jobs.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import cronJobsRouteInjectable from "./cron-jobs-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToCronJobsInjectable = getInjectable({
+  id: "navigate-to-cron-jobs",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(cronJobsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToCronJobsInjectable;

src/common/front-end-routing/routes/cluster/workloads/daemonsets/daemonsets-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const daemonsetsRouteInjectable = getInjectable({
+  id: "daemonsets-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "daemonsets");
+
+    return {
+      path: "/daemonsets",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default daemonsetsRouteInjectable;

src/common/front-end-routing/routes/cluster/workloads/daemonsets/navigate-to-daemonsets.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import daemonsetsRouteInjectable from "./daemonsets-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToDaemonsetsInjectable = getInjectable({
+  id: "navigate-to-daemonsets",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(daemonsetsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToDaemonsetsInjectable;

src/common/front-end-routing/routes/cluster/workloads/deployments/deployments-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const deploymentsRouteInjectable = getInjectable({
+  id: "deployments-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "deployments");
+
+    return {
+      path: "/deployments",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default deploymentsRouteInjectable;

src/common/front-end-routing/routes/cluster/workloads/deployments/navigate-to-deployments.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import deploymentsRouteInjectable from "./deployments-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToDeploymentsInjectable = getInjectable({
+  id: "navigate-to-deployments",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(deploymentsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToDeploymentsInjectable;

src/common/front-end-routing/routes/cluster/workloads/jobs/jobs-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const jobsRouteInjectable = getInjectable({
+  id: "jobs-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "jobs");
+
+    return {
+      path: "/jobs",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default jobsRouteInjectable;

src/common/front-end-routing/routes/cluster/workloads/jobs/navigate-to-jobs.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import jobsRouteInjectable from "./jobs-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToJobsInjectable = getInjectable({
+  id: "navigate-to-jobs",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(jobsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToJobsInjectable;

src/common/front-end-routing/routes/cluster/workloads/overview/navigate-to-workloads-overview.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import workloadsOverviewRouteInjectable from "./workloads-overview-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToWorkloadsOverviewInjectable = getInjectable({
+  id: "navigate-to-workloads-overview",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(workloadsOverviewRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToWorkloadsOverviewInjectable;

src/common/front-end-routing/routes/cluster/workloads/overview/workloads-overview-route.injectable.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const workloadsOverviewRouteInjectable = getInjectable({
+  id: "workloads-overview-route",
+
+  instantiate: () => ({
+    path: "/workloads",
+    clusterFrame: true,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default workloadsOverviewRouteInjectable;

src/common/front-end-routing/routes/cluster/workloads/pods/navigate-to-pods.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import podsRouteInjectable from "./pods-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToPodsInjectable = getInjectable({
+  id: "navigate-to-pods",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(podsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToPodsInjectable;

src/common/front-end-routing/routes/cluster/workloads/pods/pods-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const podsRouteInjectable = getInjectable({
+  id: "pods-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "pods");
+
+    return {
+      path: "/pods",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default podsRouteInjectable;

src/common/front-end-routing/routes/cluster/workloads/replicasets/navigate-to-replicasets.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import replicasetsRouteInjectable from "./replicasets-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToReplicasetsInjectable = getInjectable({
+  id: "navigate-to-replicasets",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(replicasetsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToReplicasetsInjectable;

src/common/front-end-routing/routes/cluster/workloads/replicasets/replicasets-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const replicasetsRouteInjectable = getInjectable({
+  id: "replicasets-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "replicasets");
+
+    return {
+      path: "/replicasets",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default replicasetsRouteInjectable;

src/common/front-end-routing/routes/cluster/workloads/statefulsets/navigate-to-statefulsets.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import statefulsetsRouteInjectable from "./statefulsets-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToStatefulsetsInjectable = getInjectable({
+  id: "navigate-to-statefulsets",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(statefulsetsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToStatefulsetsInjectable;

src/common/front-end-routing/routes/cluster/workloads/statefulsets/statefulsets-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import isAllowedResourceInjectable from "../../../../../utils/is-allowed-resource.injectable";
+import { routeInjectionToken } from "../../../../route-injection-token";
+
+const statefulsetsRouteInjectable = getInjectable({
+  id: "statefulsets-route",
+
+  instantiate: (di) => {
+    const isAllowedResource = di.inject(isAllowedResourceInjectable, "statefulsets");
+
+    return {
+      path: "/statefulsets",
+      clusterFrame: true,
+      isEnabled: isAllowedResource,
+    };
+  },
+
+  injectionToken: routeInjectionToken,
+});
+
+export default statefulsetsRouteInjectable;

src/common/front-end-routing/routes/entity-settings/entity-settings-route.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import { Route, routeInjectionToken } from "../../route-injection-token";
+
+export interface EntitySettingsPathParameters {
+  entityId: string;
+}
+
+const entitySettingsRouteInjectable = getInjectable({
+  id: "entity-settings-route",
+
+  instantiate: (): Route<EntitySettingsPathParameters> => ({
+    path: "/entity/:entityId/settings",
+    clusterFrame: false,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default entitySettingsRouteInjectable;

src/common/front-end-routing/routes/entity-settings/navigate-to-entity-settings.injectable.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import entitySettingsRouteInjectable from "./entity-settings-route.injectable";
+import { navigateToRouteInjectionToken } from "../../navigate-to-route-injection-token";
+
+export type NavigateToEntitySettings = (entityId: string, targetTabId?: string) => void;
+
+const navigateToEntitySettingsInjectable = getInjectable({
+  id: "navigate-to-entity-settings",
+
+  instantiate: (di): NavigateToEntitySettings => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(entitySettingsRouteInjectable);
+
+    return (entityId, targetTabId) =>
+      navigateToRoute(route, { parameters: { entityId }, fragment: targetTabId });
+  },
+});
+
+export default navigateToEntitySettingsInjectable;

src/common/front-end-routing/routes/extensions/extensions-route.injectable.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import { routeInjectionToken } from "../../route-injection-token";
+
+const extensionsRouteInjectable = getInjectable({
+  id: "extensions-route",
+
+  instantiate: () => ({
+    path: "/extensions",
+    clusterFrame: false,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default extensionsRouteInjectable;

src/common/front-end-routing/routes/extensions/navigate-to-extensions.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import extensionsRouteInjectable from "./extensions-route.injectable";
+import { navigateToRouteInjectionToken } from "../../navigate-to-route-injection-token";
+
+const navigateToExtensionsInjectable = getInjectable({
+  id: "navigate-to-extensions",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(extensionsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToExtensionsInjectable;

src/common/front-end-routing/routes/preferences/app/app-preferences-route.injectable.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import { routeInjectionToken } from "../../../route-injection-token";
+
+const appPreferencesRouteInjectable = getInjectable({
+  id: "app-preferences-route",
+
+  instantiate: () => ({
+    path: "/preferences/app",
+    clusterFrame: false,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: routeInjectionToken,
+});
+
+export default appPreferencesRouteInjectable;

src/common/front-end-routing/routes/preferences/app/navigate-to-app-preferences.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import appPreferencesRouteInjectable from "./app-preferences-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../navigate-to-route-injection-token";
+
+const navigateToAppPreferencesInjectable = getInjectable({
+  id: "navigate-to-app-preferences",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(appPreferencesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToAppPreferencesInjectable;