Simplify function signature to not solve quirks of caller

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

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

src/common/utils/is-allowed-resource.injectable.ts

@@ -3,35 +3,19 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
-import type { IComputedValue } from "mobx";
 import allowedResourcesInjectable from "../cluster-store/allowed-resources.injectable";
 import type { KubeResource } from "../rbac";
 
-export type IsAllowedResource = (...resources: KubeResource[]) => boolean;
+export type IsAllowedResource = (resource: KubeResource) => boolean;
-
-interface Dependencies {
-  allowedResources: IComputedValue<Set<string>>;
-}
-
-const isAllowedResource = ({ allowedResources }: Dependencies) => (
-  (...resource) => {
-    const resources = resource.flat(2);
-
-    if (resources.length === 0) {
-      // Fix for the fact that JS's Array.every method is not the same as ∀
-      return true;
-    }
-
-    const allowed = allowedResources.get();
-
-    return resources.every(resource => allowed.has(resource));
-  }
-) as IsAllowedResource;
 
+// TODO: This injectable obscures MobX de-referencing. Make it more apparent in usage.
 const isAllowedResourceInjectable = getInjectable({
-  instantiate: (di) => isAllowedResource({
+  instantiate: (di) => {
-    allowedResources: di.inject(allowedResourcesInjectable),
+    const allowedResources = di.inject(allowedResourcesInjectable);
-  }),
+
+    return (resource: KubeResource) => allowedResources.get().has(resource);
+  },
+
   lifecycle: lifecycleEnum.singleton,
 });
 

src/extensions/renderer-api/k8s-api.ts

@@ -5,11 +5,14 @@
 import type { KubeResource } from "../../common/rbac";
 import isAllowedResourceInjectable from "../../common/utils/is-allowed-resource.injectable";
 import { asLegacyGlobalFunctionForExtensionApi } from "../as-legacy-globals-for-extension-api/as-legacy-global-function-for-extension-api";
+import { castArray } from "lodash/fp";
 
 export function isAllowedResource(resource: KubeResource | KubeResource[]) {
   const _isAllowedResource = asLegacyGlobalFunctionForExtensionApi(isAllowedResourceInjectable);
 
-  return _isAllowedResource(...[resource].flat());
+  const resources = castArray(resource);
+
+  return resources.every(x => _isAllowedResource(x));
 }
 
 export { ResourceStack } from "../../common/k8s/resource-stack";

src/renderer/components/+workloads-overview/workloads.ts

@@ -9,10 +9,11 @@ import type { KubeObject } from "../../../common/k8s-api/kube-object";
 import { workloadURL } from "../../../common/routes";
 import { ResourceNames } from "../../utils/rbac";
 import type { NamespaceStore } from "../+namespaces/namespace-store/namespace.store";
+import type { IsAllowedResource } from "../../../common/utils/is-allowed-resource.injectable";
 
 interface Dependencies {
   workloadStores: Map<KubeResource, KubeObjectStore<KubeObject>>;
-  isAllowedResource: (resource: KubeResource) => boolean;
+  isAllowedResource: IsAllowedResource;
   namespaceStore: NamespaceStore;
 }
 

src/renderer/frames/cluster-frame/cluster-frame.tsx

@@ -50,6 +50,7 @@ import type { History } from "history";
 import type { IsAllowedResource } from "../../../common/utils/is-allowed-resource.injectable";
 import isAllowedResourceInjectable from "../../../common/utils/is-allowed-resource.injectable";
 import { HelmRoute } from "../../components/+helm/route";
+import type { KubeResource } from "../../../common/rbac";
 
 interface Dependencies {
   history: History;
@@ -78,7 +79,9 @@ class NonInjectedClusterFrame extends React.Component<Dependencies> {
   }
 
   @computed get startUrl() {
-    return this.props.isAllowedResource("events", "nodes", "pods")
+    const resources : KubeResource[] = ["events", "nodes", "pods"];
+
+    return resources.every(x => this.props.isAllowedResource(x))
       ? routes.clusterURL()
       : routes.workloadsURL();
   }