@rancher/shell 0.3.4 → 0.3.5

package/store/index.js

@@ -55,89 +55,150 @@ export const plugins = [
   }),
 ];
 
-const getActiveNamespaces = (state, getters) => {
-  const out = {};
+/**
+ * Get all the namespaces categories
+ * @returns Record<string, true>
+ */
+const getActiveNamespacesCategories = (getters, namespaces, filters) => {
+  // Split namespaces by category
+  const includeAll = getters.isAllNamespaces;
+  const includeSystem = filters.includes(ALL_SYSTEM);
+  const includeUser = filters.includes(ALL_USER);
+  const includeOrphans = filters.includes(ALL_ORPHANS);
+
+  // Categories to pull in all the user, system, or orphaned namespaces
+  const hasCategory = includeAll || includeOrphans || includeSystem || includeUser;
+
+  return hasCategory ? Object.values(namespaces).reduce((acc, ns) => {
+    if (
+      includeAll ||
+      (includeOrphans && !ns.projectId) ||
+      (includeUser && !ns.isSystem) ||
+      (includeSystem && ns.isSystem)
+    ) {
+      acc[ns.id] = true;
+    }
+
+    return acc;
+  }, {}) : {};
+};
+
+/**
+ * Get handpicked namespaces from the filters
+ * @returns Record<string, true>
+ */
+const getActiveSingleNamespaces = (getters, filters) => {
+  const activeNamespaces = {};
+
+  // Individual cases for stacked project and/or namespace filters
+  if ( !getters.isAllNamespaces ) {
+    const clusterId = getters['currentCluster']?.id;
+
+    for ( const filter of filters ) {
+      const [type, id] = filter.split('://', 2);
+
+      if ( !type ) {
+        continue;
+      }
+
+      if ( type === 'ns' ) {
+        activeNamespaces[id] = true;
+      } else if (type === 'project') {
+        // Set all the namespaces contained in the project
+        const project = getters['management/byId'](MANAGEMENT.PROJECT, `${ clusterId }/${ id }`);
+
+        if ( project ) {
+          for ( const projectNamespace of project.namespaces ) {
+            activeNamespaces[projectNamespace.id] = true;
+          }
+        }
+      }
+    }
+  }
+
+  return activeNamespaces;
+};
+
+/**
+ * Get only namespaces for user with roles "Cluster Member" and "View All Projects"
+ * @returns Record<string, true>
+ */
+const getReadOnlyActiveNamespaces = (namespaces, activeNamespaces) => {
+  const readonlyNamespaces = Object
+    .values(namespaces)
+    .filter(ns => !!ns.links.update)
+    .map(({ id }) => id);
+
+  return Object.keys(activeNamespaces)
+    .filter(ns => readonlyNamespaces.includes(ns))
+    .reduce((acc, ns) => ({
+      ...acc,
+      [ns]: true
+    }), {});
+};
+
+/**
+ * Collect all the namespaces grouped by category, project or single pick
+ * @returns Record<string, true>
+ */
+const getActiveNamespaces = (state, getters, readonly = false) => {
   const product = getters['currentProduct'];
-  const workspace = state.workspace;
 
   if ( !product ) {
-    return out;
+    return {};
   }
 
+  // TODO: Add comment with logic for fleet
   if ( product.showWorkspaceSwitcher ) {
-    const fleetOut = { [workspace]: true };
+    const fleetOut = { [state.workspace]: true };
 
     updateActiveNamespaceCache(state, fleetOut);
 
     return fleetOut;
   }
 
+  // Reset cache if no cluster is found or is not in store
   const inStore = product?.inStore;
   const clusterId = getters['currentCluster']?.id;
 
   if ( !clusterId || !inStore ) {
-    updateActiveNamespaceCache(state, out);
+    updateActiveNamespaceCache(state, {});
 
-    return out;
+    return {};
   }
 
-  let namespaces = [];
+  // Use default "All Namespaces" category if no namespaces is found
+  const hasNamespaces = Array.isArray(state.allNamespaces) && state.allNamespaces.length > 0;
+  const allNamespaces = hasNamespaces ? state.allNamespaces : getters[`${ inStore }/all`](NAMESPACE);
 
-  if (Array.isArray(state.allNamespaces) && state.allNamespaces.length > 0) {
-    namespaces = state.allNamespaces;
-  } else {
-    namespaces = getters[`${ inStore }/all`](NAMESPACE);
-  }
+  const allowedNamespaces = allNamespaces
+    .filter(ns => state.prefs.data['all-namespaces'] ? true : !ns.isObscure) // Filter out Rancher system namespaces
+    .filter(ns => product.hideSystemResources ? !ns.isSystem : true); // Filter out Fleet system namespaces
 
-  const filters = state.namespaceFilters.filter(x => !!x && !`${ x }`.startsWith(NAMESPACED_PREFIX));
-  const includeAll = getters.isAllNamespaces;
-  const includeSystem = filters.includes(ALL_SYSTEM);
-  const includeUser = filters.includes(ALL_USER);
-  const includeOrphans = filters.includes(ALL_ORPHANS);
+  // Retrieve all the filters selected by the user
+  const filters = state.namespaceFilters.filter(
+    filters => !!filters && !`${ filters }`.startsWith(NAMESPACED_PREFIX)
+  );
 
-  // Special cases to pull in all the user, system, or orphaned namespaces
-  if ( includeAll || includeOrphans || includeSystem || includeUser ) {
-    for ( const ns of namespaces ) {
-      if (
-        includeAll ||
-        ( includeOrphans && !ns.projectId ) ||
-        ( includeUser && !ns.isSystem ) ||
-        ( includeSystem && ns.isSystem )
-      ) {
-        out[ns.id] = true;
-      }
-    }
-  }
-
-  // Individual requests for a specific project/namespace
-  if ( !includeAll ) {
-    for ( const filter of filters ) {
-      const [type, id] = filter.split('://', 2);
-
-      if ( !type ) {
-        continue;
-      }
+  const activeNamespaces = {
+    ...getActiveNamespacesCategories(getters, allowedNamespaces, filters),
+    ...getActiveSingleNamespaces(getters, filters),
+  };
 
-      if ( type === 'ns' ) {
-        out[id] = true;
-      } else if ( type === 'project' ) {
-        const project = getters['management/byId'](MANAGEMENT.PROJECT, `${ clusterId }/${ id }`);
+  // Create map that can be used to efficiently check if a resource should be displayed
+  updateActiveNamespaceCache(state, activeNamespaces);
 
-        if ( project ) {
-          for ( const ns of project.namespaces ) {
-            out[ns.id] = true;
-          }
-        }
-      }
-    }
+  // Exclude namespaces restricted to the user for writing
+  if (readonly) {
+    return getReadOnlyActiveNamespaces(allowedNamespaces, activeNamespaces);
   }
-  // Create map that can be used to efficiently check if a
-  // resource should be displayed
-  updateActiveNamespaceCache(state, out);
 
-  return out;
+  return activeNamespaces;
 };
 
+/**
+ * Caching side-effect while retrieving namespaces filters
+ */
 const updateActiveNamespaceCache = (state, activeNamespaceCache) => {
   // This is going to run a lot, so keep it optimised
   let cacheKey = '';
@@ -164,8 +225,8 @@ export const state = () => {
     namespaceFilters:        [],
     activeNamespaceCache:    {}, // Used to efficiently check if a resource should be displayed
     activeNamespaceCacheKey: '', // Fingerprint of activeNamespaceCache
-    allNamespaces:           null,
-    allWorkspaces:           null,
+    allNamespaces:           [],
+    allWorkspaces:           [],
     clusterId:               null,
     productId:               null,
     workspace:               null,
@@ -241,6 +302,12 @@ export const getters = {
     return out;
   },
 
+  getStoreNameByProductId(state) {
+    const products = state['type-map']?.products;
+
+    return (products.find(p => p.name === state.productId) || {})?.inStore || 'cluster';
+  },
+
   currentStore(state, getters) {
     return (type) => {
       const product = getters['currentProduct'];
@@ -404,6 +471,10 @@ export const getters = {
     return state.namespaceFilters;
   },
 
+  allNamespaces(state) {
+    return state.allNamespaces;
+  },
+
   namespaces(state, getters) {
     // Call this getter if you want to recompute the active namespaces
     // by looping over all namespaces in a cluster. Otherwise call activeNamespaceCache,
@@ -412,6 +483,14 @@ export const getters = {
     return () => getActiveNamespaces(state, getters);
   },
 
+  /**
+   * Return namespaces which the user can refer to create resources
+   * @returns Record<string, true>
+   */
+  allowedNamespaces(state, getters) {
+    return () => getActiveNamespaces(state, getters, true);
+  },
+
   defaultNamespace(state, getters, rootState, rootGetters) {
     const product = getters['currentProduct'];
 
@@ -529,6 +608,15 @@ export const mutations = {
     getActiveNamespaces(state, getters);
   },
 
+  changeAllNamespaces(state, namespace) {
+    // `allNamespaces/changeAllNamespaces` allow products to restrict the namespaces shown to the user in the NamespaceFilter and NameNsDescription components.
+    // You can configure the `notFilterNamespace` parameter for each resource page to define namespaces that do not need to be filtered,  and then change `allNamespaces` by calling `changeAllNamespaces`
+    // eg:
+    // const notFilterNamespaces = this.$store.getters[`type-map/optionsFor`](resource).notFilterNamespace || [];
+    // const allNamespaces = this.$store.getters[`${ this.currentProduct.inStore }/filterNamespace`](notFilterNamespaces);
+    state.allNamespaces = namespace;
+  },
+
   setNamespaceFilterMode(state, mode) {
     state.namespaceFilterMode = mode;
   },
@@ -552,7 +640,6 @@ export const mutations = {
     }
 
     state.workspace = value;
-
     getActiveNamespaces(state, getters);
   },
 

package/store/type-map.js

@@ -104,6 +104,8 @@
 //                               customRoute: undefined,
 //                               hasGraph: undefined   -- If true, render ForceDirectedTreeChart graph (ATTENTION: option graphConfig is needed also!!!)
 //                               graphConfig: undefined   -- Use this to pass along the graph configuration
+//                               notFilterNamespace:  undefined -- Define namespaces that do not need to be filtered
+//                               localOnly: False -- Hide this type from the nav/search bar on downstream clusters
 //                           }
 // )
 // ignoreGroup(group):        Never show group or any types in it
@@ -842,7 +844,7 @@ export const getters = {
 
   allTypes(state, getters, rootState, rootGetters) {
     return (product, mode = ALL) => {
-      const module = findBy(state.products, 'name', product).inStore;
+      const module = findBy(state.products, 'name', product)?.inStore;
       const schemas = rootGetters[`${ module }/all`](SCHEMA);
       const counts = rootGetters[`${ module }/all`](COUNT)?.[0]?.counts || {};
       const isDev = rootGetters['prefs/get'](VIEW_IN_API);
@@ -869,6 +871,8 @@ export const getters = {
           continue;
         } else if ( typeof typeOptions.ifRancherCluster !== 'undefined' && typeOptions.ifRancherCluster !== rootGetters.isRancher ) {
           continue;
+        } else if (typeOptions.localOnly && !rootGetters.currentCluster?.isLocal) {
+          continue;
         }
 
         out[schema.id] = {

package/tsconfig.default.json

@@ -0,0 +1,36 @@
+{
+  "compilerOptions": {
+    "target": "ES2018",
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "lib": [
+      "ESNext",
+      "ESNext.AsyncIterable",
+      "DOM"
+    ],
+    "esModuleInterop": true,
+    "allowJs": true,
+    "sourceMap": true,
+    "strict": true,
+    "noEmit": false,
+    "baseUrl": ".",
+    "rootDir": ".",
+    "paths": {
+      "~/*": [
+        "../*"
+      ],
+      "@/*": [
+        "../*"
+      ],
+      "@shell/*": [
+        "../shell/*"
+      ],
+      "@pkg/*": [
+        "../shell/pkg/*"
+      ]
+    },
+    "typeRoots": [
+      "./node_modules/@types"
+    ],
+  },
+}

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "extends": "./tsconfig.default.json",
+  "compilerOptions": {
+    "types": [
+      "@types/node",
+      "@types/jest",
+      "@nuxt/types"
+    ]
+  },
+  "exclude": [
+    "node_modules",
+    ".nuxt",
+    "dist",
+    "dist-pkg",
+    "cypress",
+    "shell/creators",
+    "shell/scripts",
+    "cypress",
+    "./cypress.config.ts",
+    "docusaurus",
+    "script/standalone",
+    "**/*.spec.ts"
+  ]
+}