@rancher/shell 0.5.3 → 2.0.0

package/store/type-map.js

@@ -37,6 +37,7 @@
 //   ifHaveType,              -- Show this product only if the given type exists in the store [inStore], This can also be specified as an object { type: TYPE, store: 'management' } if the type isn't in the current [inStore]
 //   ifHaveVerb,              -- In combination with ifHaveTYpe, show it only if the type also has this collectionMethod
 //   inStore,                 -- Which store to look at for if* above and the left-nav, defaults to "cluster"
+//   rootProduct,             -- Optional root (parent) product - if set, used to optimize navigation when product changes stays within root product
 //   inExplorer,              -- Determines if the product is to be scoped to the explorer
 //   public,                  -- If true, show to all users.  If false, only show when the Developer Tools pref is on (default true)
 //   category,                -- Group to show the product in for the nav hamburger menu
@@ -133,7 +134,7 @@ import {
 } from '@shell/config/types';
 import { VIEW_IN_API, EXPANDED_GROUPS, FAVORITE_TYPES } from '@shell/store/prefs';
 import {
-  addObject, findBy, insertAt, isArray, removeObject, filterBy
+  addObject, findBy, isArray, removeObject, filterBy
 } from '@shell/utils/array';
 import { clone, get } from '@shell/utils/object';
 import {
@@ -148,8 +149,9 @@ import isObject from 'lodash/isObject';
 import { normalizeType } from '@shell/plugins/dashboard-store/normalize';
 import { sortBy } from '@shell/utils/sort';
 
-import { haveV1Monitoring, haveV2Monitoring } from '@shell/utils/monitoring';
+import { haveV2Monitoring } from '@shell/utils/monitoring';
 import { NEU_VECTOR_NAMESPACE } from '@shell/config/product/neuvector';
+import { createHeaders, rowValueGetter } from '@shell/store/type-map.utils';
 
 export const NAMESPACED = 'namespaced';
 export const CLUSTER_LEVEL = 'cluster';
@@ -206,10 +208,7 @@ export const SPOOFED_API_PREFIX = '__[[spoofedapi]]__';
 const instanceMethods = {};
 const graphConfigMap = {};
 
-const FIELD_REGEX = /^\$\.metadata\.fields\[([0-9]*)\]/;
-
 export const IF_HAVE = {
-  V1_MONITORING:            'v1-monitoring',
   V2_MONITORING:            'v2-monitoring',
   PROJECT:                  'project',
   NO_PROJECT:               'no-project',
@@ -239,9 +238,14 @@ export function DSL(store, product, module = 'type-map') {
         ...inOpt
       };
 
+      // Convert strings to regex's - we do this once here for efficiency
       for ( const k of ['ifHaveGroup', 'ifHaveType'] ) {
         if ( opt[k] ) {
-          opt[k] = regexToString(ensureRegex(opt[k]));
+          if (Array.isArray(opt[k])) {
+            opt[k] = opt[k].map((r) => regexToString(ensureRegex(r)));
+          } else {
+            opt[k] = regexToString(ensureRegex(opt[k]));
+          }
         }
       }
 
@@ -264,7 +268,7 @@ export function DSL(store, product, module = 'type-map') {
       store.commit(`${ module }/groupBy`, { type, field });
     },
 
-    headers(type, headers) {
+    headers(type, headers, paginationHeaders = []) {
       headers.forEach((header) => {
         // If on the client, then use the value getter if there is one
         if (header.getValue) {
@@ -277,6 +281,7 @@ export function DSL(store, product, module = 'type-map') {
       });
 
       store.commit(`${ module }/headers`, { type, headers });
+      store.commit(`${ module }/paginationHeaders`, { type, paginationHeaders });
     },
 
     hideBulkActions(type, field) {
@@ -406,6 +411,7 @@ export const state = function() {
     typeOptions:             [],
     groupBy:                 {},
     headers:                 {},
+    paginationHeaders:       {},
     hideBulkActions:         {},
     schemaGeneration:        1,
     cache:                   {
@@ -434,6 +440,7 @@ export const getters = {
   labelFor(state, getters, rootState, rootGetters) {
     return (schema, count = 1, language = null) => {
       return _applyMapping(schema, state.typeMappings, 'id', false, () => {
+        // i18n-uses typeLabel.*
         const key = `typeLabel."${ schema.id.toLowerCase() }"`;
 
         if ( rootGetters['i18n/exists'](key, language) ) {
@@ -501,22 +508,26 @@ export const getters = {
     };
   },
 
-  optionsFor(state) {
+  optionsFor(state, getters, rootState, rootGetters) {
     const def = {
-      isCreatable:          true,
-      isEditable:           true,
-      isRemovable:          true,
-      showState:            true,
-      showAge:              true,
-      canYaml:              true,
-      namespaced:           null,
-      listGroups:           [],
-      depaginate:           false,
-      customRoute:          undefined,
-      resourceEditMasthead: true,
+      isCreatable:            true,
+      isEditable:             true,
+      isRemovable:            true,
+      showState:              true,
+      showAge:                true,
+      canYaml:                true,
+      namespaced:             null,
+      listGroups:             [],
+      listGroupsWillOverride: false,
+      listMandatorySort:      null,
+      depaginate:             false,
+      customRoute:            undefined,
+      resourceEditMasthead:   true,
     };
 
-    return (schemaOrType) => {
+    return (schemaOrType, pagination) => {
+      // Note - This can run a LOT so needs to be performant
+
       if (!schemaOrType) {
         return {};
       }
@@ -530,7 +541,20 @@ export const getters = {
 
       const opts = Object.assign({}, def, found || {});
 
-      return opts;
+      // As this runs a lot, avoid anything we don't strictly need (like going out to another store)
+      if (!pagination) {
+        return opts;
+      }
+
+      const storeOptionsFor = schemaOrType?.$ctx?.getters?.['optionsFor'];
+      const storeOpts = storeOptionsFor ? storeOptionsFor({ getters, state }, {
+        schema: schemaOrType, pagination, opts
+      }) : {};
+
+      return {
+        ...opts,
+        ...storeOpts,
+      };
     };
   },
 
@@ -626,7 +650,7 @@ export const getters = {
           continue;
         } else if ( mode === TYPE_MODES.USED && count <= 0 ) {
           // If there's none of this type, ignore this entry when viewing only in-use types
-          // Note: count is sometimes null, which is <= 0.
+          // Note: count is sometimes null, in js `null <= 0` is `true`.
           continue;
         }
 
@@ -678,13 +702,14 @@ export const getters = {
         group.children.push({
           label,
           labelDisplay,
-          mode:     typeObj.mode,
-          exact:    typeObj.exact || false,
+          mode:         typeObj.mode,
+          exact:        typeObj.exact || false,
+          'exact-path': typeObj['exact-path'] || false,
           namespaced,
           route,
-          name:     typeObj.name,
-          weight:   typeObj.weight || getters.typeWeightFor(typeObj.schema?.id || label, isBasic),
-          overview: !!typeObj.overview,
+          name:         typeObj.name,
+          weight:       typeObj.weight || getters.typeWeightFor(typeObj.schema?.id || label, isBasic),
+          overview:     !!typeObj.overview,
         });
       }
 
@@ -708,6 +733,7 @@ export const getters = {
 
         // Translate if an entry exists
         let label = name;
+        // i18n-uses nav.group.*
         const key = `nav.group."${ name }"`;
 
         if ( rootGetters['i18n/exists'](key) ) {
@@ -938,11 +964,11 @@ export const getters = {
         const virtualTypes = state.virtualTypes[product] || [];
         const spoofedTypes = state.spoofedTypes[product] || [];
         const allTypes = [...virtualTypes, ...spoofedTypes];
-        const virtSpoofedModes = [...nonUsedModes];
 
         for ( const type of allTypes ) {
           const item = clone(type);
           const id = item.name;
+          const virtSpoofedModes = [...nonUsedModes];
 
           // Is there a virtual/spoofed type override for schema type?
           // Currently used by harvester, this should be investigated and removed if possible
@@ -961,16 +987,29 @@ export const getters = {
           }
 
           if ( item.ifHaveType ) {
-            const targetedSchemas = typeof item.ifHaveType === 'string' ? schemas : rootGetters[`${ item.ifHaveType.store }/all`](SCHEMA);
-            const type = typeof item.ifHaveType === 'string' ? item.ifHaveType : item.ifHaveType?.type;
+            const ifHaveTypeArray = Array.isArray(item.ifHaveType) ? item.ifHaveType : [item.ifHaveType];
+            let satisfiesIfHave = true;
 
-            const haveIds = filterBy(targetedSchemas, 'id', normalizeType(type)).map((s) => s.id);
+            // Support an array of required types that the user must have access to
+            for (let i = 0; i < ifHaveTypeArray.length; i++) {
+              const ifHaveType = ifHaveTypeArray[i];
+              const targetedSchemas = typeof ifHaveType === 'string' ? schemas : rootGetters[`${ ifHaveType.store }/all`](SCHEMA);
+              const type = typeof ifHaveType === 'string' ? ifHaveType : ifHaveType?.type;
 
-            if (!haveIds.length) {
-              continue;
+              const haveIds = filterBy(targetedSchemas, 'id', normalizeType(type)).map((s) => s.id);
+
+              if (!haveIds.length) {
+                satisfiesIfHave = false;
+                break;
+              }
+
+              if (item.ifHaveVerb && !ifHaveVerb(rootGetters, module, item.ifHaveVerb, haveIds)) {
+                satisfiesIfHave = false;
+                break;
+              }
             }
 
-            if (item.ifHaveVerb && !ifHaveVerb(rootGetters, module, item.ifHaveVerb, haveIds)) {
+            if (!satisfiesIfHave) {
               continue;
             }
           }
@@ -989,8 +1028,18 @@ export const getters = {
             continue;
           }
 
-          if (item.ifFeature && !rootGetters['features/get'](item.ifFeature)) {
-            continue;
+          if (item.ifFeature) {
+            if (item.ifFeature[0] === '!') {
+              const feature = item.ifFeature.replace('!', '');
+
+              if (rootGetters['features/get'](feature)) {
+                continue;
+              }
+            } else {
+              if (!rootGetters['features/get'](item.ifFeature)) {
+                continue;
+              }
+            }
           }
 
           if (virtSpoofedModes.includes(TYPE_MODES.BASIC) && !getters.groupForBasicType(product, id) ) {
@@ -1041,99 +1090,46 @@ export const getters = {
   },
 
   headersFor(state, getters, rootState, rootGetters) {
-    return (schema) => {
-      const attributes = schema.attributes || {};
-      const columns = attributes.columns || [];
-      const typeOptions = getters['optionsFor'](schema);
-
-      // A specific list has been provided
-      if ( state.headers[schema.id] ) {
-        return state.headers[schema.id].map((entry) => {
-          if ( typeof entry === 'string' ) {
-            const col = findBy(columns, 'name', entry);
-
-            if ( col ) {
-              return fromSchema(col, rootGetters);
-            } else {
-              return null;
-            }
-          } else {
-            return entry;
-          }
-        }).filter((col) => !!col);
-      }
+    return (schema, pagination) => {
+      if (pagination) {
+        const storeHeadersFor = schema?.$ctx?.getters?.['headersFor'];
 
-      // Otherwise make one up from schema
-      const out = typeOptions.showState ? [STATE] : [];
-      const namespaced = attributes.namespaced || false;
-      let hasName = false;
-
-      for ( const col of columns ) {
-        if ( col.format === 'name' ) {
-          hasName = true;
-          out.push(NAME);
-          if ( namespaced ) {
-            out.push(NAMESPACE_COL);
-          }
-        } else {
-          out.push(fromSchema(col, rootGetters));
-        }
-      }
+        if (storeHeadersFor) {
+          const res = storeHeadersFor({ getters, state }, { schema, pagination });
 
-      if ( !hasName ) {
-        insertAt(out, 1, NAME);
-        if ( namespaced ) {
-          insertAt(out, 2, NAMESPACE_COL);
-        }
-      }
-
-      // Age always goes last
-      if ( out.includes(AGE) ) {
-        removeObject(out, AGE);
-        if ( typeOptions.showAge ) {
-          out.push(AGE);
+          if (res) {
+            return res;
+          }
         }
       }
 
-      return out;
-
-      function fromSchema(col, rootGetters) {
-        let formatter, width, formatterOpts;
-
-        if ( (col.format === '' || col.format === 'date') && col.name === 'Age' ) {
-          return AGE;
-        }
-
-        if ( col.format === 'date' || col.type === 'date' ) {
-          formatter = 'Date';
-          width = 120;
-          formatterOpts = { multiline: true };
-        }
+      return createHeaders({ rootGetters }, {
+        headers:     state.headers,
+        typeOptions: getters['optionsFor'](schema, false),
+        schema,
+        columns:     {
+          state:     STATE,
+          name:      NAME,
+          namespace: NAMESPACE_COL,
+          age:       AGE,
+        },
+        pagination
+      });
+    };
+  },
 
-        if ( col.type === 'number' || col.type === 'int' ) {
-          formatter = 'Number';
-        }
+  /**
+   * Simple getter to fetch pre-configured headers used in pagination
+   */
+  configuredPaginationHeaders(state) {
+    return (schemaOrType) => state.paginationHeaders?.[schemaOrType.id || schemaOrType];
+  },
 
-        const colName = col.name.includes(' ') ? col.name.split(' ').map((word) => word.charAt(0).toUpperCase() + word.substring(1) ).join('') : col.name;
-
-        const exists = rootGetters['i18n/exists'];
-        const t = rootGetters['i18n/t'];
-        const labelKey = `tableHeaders.${ colName.charAt(0).toLowerCase() + colName.slice(1) }`;
-        const description = col.description || '';
-        const tooltip = description && description[description.length - 1] === '.' ? description.slice(0, -1) : description;
-
-        return {
-          name:  col.name.toLowerCase(),
-          label: exists(labelKey) ? t(labelKey) : col.name,
-          value: _rowValueGetter(col),
-          sort:  [col.field],
-          formatter,
-          formatterOpts,
-          width,
-          tooltip
-        };
-      }
-    };
+  /**
+   * Simple getter to fetch pre-configured headers (not used in paginated lists)
+   */
+  configuredHeaders(state) {
+    return (schemaOrType) => state.headers?.[schemaOrType.id || schemaOrType];
   },
 
   // ------------------------------------
@@ -1443,7 +1439,7 @@ export const getters = {
     return (schema, colName) => {
       const col = _findColumnByName(schema, colName);
 
-      return _rowValueGetter(col);
+      return rowValueGetter(col);
     };
   },
 
@@ -1454,6 +1450,10 @@ export const getters = {
       return !!prod;
     };
   },
+
+  productByName(state) {
+    return (productName) => state.products.find((p) => p.name === productName);
+  }
 };
 
 export const mutations = {
@@ -1513,12 +1513,27 @@ export const mutations = {
   },
 
   product(state, obj) {
-    const existing = findBy(state.products, 'name', obj.name);
+    let existing = state.products.find((p) => p.name === obj.name);
 
     if ( existing ) {
       Object.assign(existing, obj);
     } else {
       addObject(state.products, obj);
+      existing = state.products.find((p) => p.name === obj.name);
+    }
+
+    // Make sure deprecated `inExplorer` is synchronized with `rootProduct` (and vice-versa)
+    if (existing?.inExplorer) {
+      existing.rootProduct = EXPLORER;
+    } else if (existing?.rootProduct === EXPLORER) {
+      existing.inExplorer = true;
+    }
+
+    // We make an assumption that if the store for a product is 'cluster' it will be displayed within cluster explorer
+    // Detect that here and set rootProduct and inExporer in this case
+    if (!existing?.rootProduct && existing?.inStore === 'cluster') {
+      existing.rootProduct = EXPLORER;
+      existing.inExplorer = (existing.rootProduct === EXPLORER);
     }
   },
 
@@ -1614,6 +1629,10 @@ export const mutations = {
     state.headers[type] = headers;
   },
 
+  paginationHeaders(state, { type, paginationHeaders }) {
+    state.paginationHeaders[type] = paginationHeaders;
+  },
+
   hideBulkActions(state, { type, field }) {
     state.hideBulkActions[type] = field;
   },
@@ -1863,9 +1882,6 @@ function ifHave(getters, option) {
   case IF_HAVE.V2_MONITORING: {
     return haveV2Monitoring(getters);
   }
-  case IF_HAVE.V1_MONITORING: {
-    return haveV1Monitoring(getters);
-  }
   case IF_HAVE.PROJECT: {
     return !!project(getters);
   }
@@ -1913,22 +1929,6 @@ function _findColumnByName(schema, colName) {
   return findBy(columns, 'name', colName);
 }
 
-function _rowValueGetter(col) {
-  // 'field' comes from the schema - typically it is of the form $.metadata.field[N]
-  // We will use JsonPath to look up this value, which is costly - so if we can detect this format
-  // Use a more efficient function to get the value
-  const value = col.field.startsWith('.') ? `$${ col.field }` : col.field;
-  const found = value.match(FIELD_REGEX);
-
-  if (found && found.length === 2) {
-    const fieldIndex = parseInt(found[1], 10);
-
-    return (row) => row.metadata?.fields?.[fieldIndex];
-  }
-
-  return value;
-}
-
 // Is V1 Istio installed?
 function isV1Istio(getters) {
   const cluster = getters['currentCluster'];