@rancher/shell 3.0.8-rc.12 → 3.0.8-rc.13

package/plugins/steve/steve-pagination-utils.ts

@@ -37,20 +37,35 @@ interface Namespace extends ModelNamespace {
   }
 }
 
+interface NamespaceProjectFilterResult {
+  /**
+   * True if the ns should be filtered IN. False if filtered OUT.
+   */
+  [nsName: string]: boolean;
+}
+
+/**
+ * Helper class, contains namespace / project filter specific functions
+ */
 class NamespaceProjectFilters {
   /**
    * User needs all resources.... except if there's some settings which should remove resources in specific circumstances
    */
   protected handlePrefAndSettingFilter(args: {
     allNamespaces: Namespace[],
+    /**
+     * Reserved / Obscure namespaces are ones used to support clusters and users. By default these are hidden
+     */
     showReservedRancherNamespaces: boolean,
+    /**
+     * Has product config disabled system projects and namespaces
+     */
     productHidesSystemNamespaces: boolean,
-  }): PaginationParamFilter[] {
+  }): NamespaceProjectFilterResult {
     const { allNamespaces, showReservedRancherNamespaces, productHidesSystemNamespaces } = args;
 
-    // These are AND'd together
     // Not ns 1 AND ns 2
-    const filterNamespaces = allNamespaces.reduce((res, ns) => {
+    return allNamespaces.reduce((res, ns) => {
       // Links to ns.isObscure and covers things like `c-`, `user-`, etc (see OBSCURE_NAMESPACE_PREFIX)
       const hideObscure = showReservedRancherNamespaces ? false : ns.isObscure;
 
@@ -58,23 +73,11 @@ class NamespaceProjectFilters {
       const hideSystem = productHidesSystemNamespaces ? ns.isSystem : false;
 
       if (hideObscure || hideSystem) {
-        res.push(ns.name);
+        res[ns.name] = false;
       }
 
       return res;
-    }, [] as String[]);
-
-    if (filterNamespaces.length) {
-      return [new PaginationParamFilter({
-        fields: [{
-          value:    filterNamespaces.join(','),
-          equality: PaginationFilterEquality.NOT_IN,
-          field:    'metadata.namespace',
-        }],
-      })];
-    }
-
-    return [];
+    }, {} as NamespaceProjectFilterResult);
   }
 
   /**
@@ -88,31 +91,88 @@ class NamespaceProjectFilters {
     allNamespaces: Namespace[],
     isAllSystem: boolean,
     isAllUser: boolean,
-  }) {
-    const { allNamespaces, isAllSystem } = args;
+  }): NamespaceProjectFilterResult {
+    const { allNamespaces, isAllSystem, isAllUser } = args;
     const allSystem = allNamespaces.filter((ns) => ns.isSystem);
 
-    // > Neither of these use projectsOrNamespaces to avoid scenarios where the local cluster provides a namespace which has
-    // > a matching project... which could lead to results in the user project resource being included in the system filter
-    if (isAllSystem) {
-      // return resources in system ns 1 OR in system ns 2 ...
-      // &filter=metadata.namespace=system ns 1,metadata.namespace=system ns 2
-      return [PaginationParamFilter.createMultipleFields(
-        allSystem.map(
-          (ns) => new PaginationFilterField({ field: 'metadata.namespace', value: ns.name })
-        )
-      )];
-    } else { // if isAllUser
-      // return resources not in system ns 1 AND not in system ns 2 ...
-      // &filter=metadata.namespace!=system ns 1&filter=metadata.namespace!=system ns 2
-      return allSystem.map((ns) => PaginationParamFilter.createSingleField({
-        field: 'metadata.namespace', value: ns.name, equals: false
+    return allSystem.reduce((res, ns) => {
+      if (isAllSystem) {
+        // We want to filter IN system namespaces
+        res[ns.name] = true;
+      }
+
+      if (isAllUser) {
+        // We want to filter OUT system namespaces
+        res[ns.name] = false;
+      }
+
+      return res;
+    }, {} as NamespaceProjectFilterResult);
+  }
+
+  /**
+   * Combine result `b` into `a` and return result
+   */
+  protected combineNsProjectFilterResults(a: NamespaceProjectFilterResult, b: NamespaceProjectFilterResult): NamespaceProjectFilterResult {
+    // Start with `a`
+    const res = { ...a };
+
+    // Merge entries from `b` into `a` if they don't exist in `a`. This maintains a hierarchy
+    // 1. if something has been excluded in `a` ignore requests to include given `b`
+    // 2. if something has been included in `a` ignore requests to exclude given `b`
+    Object.entries(b).forEach(([ns, include]) => {
+      if (res[ns] === undefined) {
+        res[ns] = include;
+      }
+    });
+
+    return res;
+  }
+
+  /**
+   * Convert @NamespaceProjectFilterResult into @PaginationParamFilter
+   */
+  protected createFiltersFromNamespaceProjectFilterResult(filterResult: NamespaceProjectFilterResult): PaginationParamFilter[] {
+    const inList: string[] = [];
+    const outList: string[] = [];
+
+    Object.entries(filterResult).forEach(([ns, include]) => {
+      if (include) {
+        inList.push(ns);
+      } else {
+        outList.push(ns);
+      }
+    });
+
+    const res: PaginationParamFilter[] = [];
+
+    // There's no point having both IN and OUT lists together, so prefer the IN list
+    if (inList.length) {
+      res.push(new PaginationParamFilter({
+        fields: [{
+          value:    inList.join(','),
+          equality: PaginationFilterEquality.IN,
+          field:    'metadata.namespace',
+        }],
+      }));
+    } else if (outList.length) {
+      res.push(new PaginationParamFilter({
+        fields: [{
+          value:    outList.join(','),
+          equality: PaginationFilterEquality.NOT_IN,
+          field:    'metadata.namespace',
+        }],
       }));
     }
+
+    return res;
   }
 
   /**
    * User needs resources in a set of projects or namespaces
+   *
+   * Mainly deals with the projectornamespaces filter, also ensures namespace in local cluster matching target project's aren't included
+   *
    */
   protected handleSelectionFilter(neu: string[], isLocalCluster: boolean) {
     // User has one or more projects or namespaces. We can pass this straight through to projectsornamespaces
@@ -124,12 +184,12 @@ class NamespaceProjectFilters {
     ];
 
     if (isLocalCluster) {
-      // > As per `handleSystemOrUserFilter` above, we need to be careful of the local cluster where there's namespaces related to projects with the same id
-      // > In this case
+      // We need to be careful of the local cluster where there's namespaces related to projects with the same id
+      // In this case
       // - We're including resources in the project and it's related namespace (via projectsornamespaces)
       // - We're also then excluding resources in the related namespace (via below `filter`)
 
-      // Exclude resources NOT in projects namespace 1 AND not in projects namespace 2
+      // Exclude resources NOT in project's backing namespace 1 AND not in project's backing namespace 2
       // &filter=metadata.namespace!=pn1&filter=metadata.namespace!=pn2
       return {
         projectsOrNamespaces,
@@ -352,24 +412,29 @@ class StevePaginationUtils extends NamespaceProjectFilters {
     let projectsOrNamespaces: PaginationParamProjectOrNamespace[] = [];
     // used to return resources in / not in namespaces
     // &filter=metadata.namespace=abc
-    let filters: PaginationParamFilter[] = [];
+    const filters: PaginationParamFilter[] = [];
+    let nsProjectFilterResults = {};
 
     if (!showReservedRancherNamespaces || productHidesSystemNamespaces) {
-      // We need to hide reserved namespaces ('c-', 'user-', etc) OR system namespaces
-      filters = this.handlePrefAndSettingFilter({
+      // We need to hide reserved namespaces ('c-', 'user-', etc) OR system namespaces (given product may hide them)
+      nsProjectFilterResults = this.combineNsProjectFilterResults(nsProjectFilterResults, this.handlePrefAndSettingFilter({
         allNamespaces, showReservedRancherNamespaces, productHidesSystemNamespaces
-      });
+      }));
     }
 
     const isAllSystem = selection[0] === NAMESPACE_FILTER_ALL_SYSTEM;
     const isAllUser = selection[0] === NAMESPACE_FILTER_ALL_USER;
 
     if (selection.length === 1 && (isAllSystem || isAllUser)) {
-      // Filter by resources either in or not in system namespaces
-      filters.push(...this.handleSystemOrUserFilter({
+      // Filter by resources either in or not in system namespaces (given user selection)
+      nsProjectFilterResults = this.combineNsProjectFilterResults(nsProjectFilterResults, this.handleSystemOrUserFilter({
         allNamespaces, isAllSystem, isAllUser
       }));
+
+      filters.push(...this.createFiltersFromNamespaceProjectFilterResult(nsProjectFilterResults));
     } else {
+      filters.push(...this.createFiltersFromNamespaceProjectFilterResult(nsProjectFilterResults));
+
       // User has one or more projects or namespaces
       const res = this.handleSelectionFilter(selection, isLocalCluster);
 

package/scripts/publish-shell.sh

@@ -8,6 +8,7 @@ SHELL_DIR=$BASE_DIR/shell/
 CREATORS_DIR=$BASE_DIR/creators/extension
 FORCE_PUBLISH_TO_NPM="false"
 DEFAULT_NPM_REGISTRY="https://registry.npmjs.org"
+DUMMY_VERSION="99.99.99"
 
 # if TAG doesn't exist, we can exit as it's needed for any type of publish.
 if [ -z "$TAG" ]; then
@@ -84,6 +85,14 @@ function publish() {
   fi
 }
 
+update_version_in_package_json() {
+  local package_json_path="$1"
+  local version="$2"
+
+  sed -i.bak -e "s/\"version\": \"[0-9]*.[0-9]*.[0-9]*\(-alpha\.[0-9]*\|-release[0-9]*.[0-9]*.[0-9]*\|-rc\.[0-9]*\)\{0,1\}\",/\"version\": \"${version}\",/g" "$package_json_path"
+  rm "${package_json_path}.bak"
+}
+
 echo "TAG ${TAG}"
   
   # let's get the package name and version from the tag
@@ -102,10 +111,26 @@ fi
 case $PKG_NAME in
   "shell")
     echo "Publishing only Shell pkg via tagged release"
+
+    # with the changes in https://github.com/rancher/dashboard/pull/16166/files#diff-d954ab41ef46f7fdbaaf6d8c2bc715ad2cc823a829317b6ff93a3c94a92811f1
+    #  with NPM 11.3 --dry--run now does additional checks, one of them is the version number
+    #  so for dry runs we need to provide a valid version number here (not something published before)
+    if [ ${DRY_RUN} == "true" ]; then
+      update_version_in_package_json "${SHELL_DIR}/package.json" "${DUMMY_VERSION}"
+    fi
+
     publish "Shell" ${SHELL_DIR} ${PKG_V}
     ;;
   "creators")
     echo "Publishing only Creators pkg via tagged release"
+
+    # with the changes in https://github.com/rancher/dashboard/pull/16166/files#diff-d954ab41ef46f7fdbaaf6d8c2bc715ad2cc823a829317b6ff93a3c94a92811f1
+    #  with NPM 11.3 --dry--run now does additional checks, one of them is the version number
+    #  so for dry runs we need to provide a valid version number here (not something published before)
+    if [ ${DRY_RUN} == "true" ]; then
+      update_version_in_package_json "${CREATORS_DIR}/package.json" "${DUMMY_VERSION}"
+    fi
+
     publish "Extension creator" ${CREATORS_DIR} ${PKG_V}
     ;;
   *)

package/store/__tests__/type-map.test.ts

@@ -1116,7 +1116,169 @@ describe('type-map', () => {
         });
       });
     });
+
+    describe('activeProducts', () => {
+      // Basic schemas for product filtering tests
+      const productSchemas = {
+        myType: {
+          id:     'mytype',
+          _id:    'mytype',
+          type:   SCHEMA,
+          _group: 'mygroup',
+        },
+        anotherType: {
+          id:     'anothertype',
+          _id:    'anothertype',
+          type:   SCHEMA,
+          _group: 'anothergroup',
+        },
+      };
+
+      const createProductState = (products) => ({
+        products,
+        schemaGeneration: 1,
+      });
+
+      const createProductRootGetters = (moduleSchemas = [], moduleName = 'cluster') => ({
+        'prefs/get':             () => false,
+        [`${ moduleName }/all`]: (resource) => {
+          if (resource === SCHEMA) {
+            return moduleSchemas;
+          }
+
+          return [];
+        },
+      });
+
+      describe('ifHaveType', () => {
+        it('should show product when matching type exists', () => {
+          const state = createProductState([{
+            name:       'test-product',
+            inStore:    'cluster',
+            ifHaveType: 'mytype',
+          }]);
+          const rootGetters = createProductRootGetters([productSchemas.myType]);
+
+          const active = getters.activeProducts(state, {}, {}, rootGetters);
+
+          expect(active).toHaveLength(1);
+          expect(active[0].name).toBe('test-product');
+        });
+
+        it('should hide product when matching type does not exist', () => {
+          const state = createProductState([{
+            name:       'test-product',
+            inStore:    'cluster',
+            ifHaveType: 'missingtype',
+          }]);
+          const rootGetters = createProductRootGetters([productSchemas.myType]);
+
+          const active = getters.activeProducts(state, {}, {}, rootGetters);
+
+          expect(active).toHaveLength(0);
+        });
+      });
+
+      describe('ifNotHaveType', () => {
+        it('should show product when matching type does NOT exist', () => {
+          const state = createProductState([{
+            name:          'test-product',
+            inStore:       'cluster',
+            ifNotHaveType: 'missingtype',
+          }]);
+          const rootGetters = createProductRootGetters([productSchemas.myType]);
+
+          const active = getters.activeProducts(state, {}, {}, rootGetters);
+
+          expect(active).toHaveLength(1);
+          expect(active[0].name).toBe('test-product');
+        });
+
+        it('should hide product when matching type exists', () => {
+          const state = createProductState([{
+            name:          'test-product',
+            inStore:       'cluster',
+            ifNotHaveType: 'mytype',
+          }]);
+          const rootGetters = createProductRootGetters([productSchemas.myType]);
+
+          const active = getters.activeProducts(state, {}, {}, rootGetters);
+
+          expect(active).toHaveLength(0);
+        });
+
+        it('should support regex pattern in ifNotHaveType', () => {
+          const state = createProductState([{
+            name:          'test-product',
+            inStore:       'cluster',
+            ifNotHaveType: 'my.*',
+          }]);
+          const rootGetters = createProductRootGetters([productSchemas.myType]);
+
+          const active = getters.activeProducts(state, {}, {}, rootGetters);
+
+          expect(active).toHaveLength(0);
+        });
+
+        it('should show product when regex pattern does not match any type', () => {
+          const state = createProductState([{
+            name:          'test-product',
+            inStore:       'cluster',
+            ifNotHaveType: 'nomatch.*',
+          }]);
+          const rootGetters = createProductRootGetters([productSchemas.myType]);
+
+          const active = getters.activeProducts(state, {}, {}, rootGetters);
+
+          expect(active).toHaveLength(1);
+          expect(active[0].name).toBe('test-product');
+        });
+      });
+
+      describe('combined ifHaveType and ifNotHaveType', () => {
+        it('should show product when ifHaveType matches and ifNotHaveType does not match', () => {
+          const state = createProductState([{
+            name:          'test-product',
+            inStore:       'cluster',
+            ifHaveType:    'mytype',
+            ifNotHaveType: 'missingtype',
+          }]);
+          const rootGetters = createProductRootGetters([productSchemas.myType]);
+
+          const active = getters.activeProducts(state, {}, {}, rootGetters);
+
+          expect(active).toHaveLength(1);
+          expect(active[0].name).toBe('test-product');
+        });
+
+        it('should hide product when ifHaveType matches but ifNotHaveType also matches', () => {
+          const state = createProductState([{
+            name:          'test-product',
+            inStore:       'cluster',
+            ifHaveType:    'mytype',
+            ifNotHaveType: 'anothertype',
+          }]);
+          const rootGetters = createProductRootGetters([productSchemas.myType, productSchemas.anotherType]);
+
+          const active = getters.activeProducts(state, {}, {}, rootGetters);
+
+          expect(active).toHaveLength(0);
+        });
+
+        it('should hide product when ifHaveType does not match', () => {
+          const state = createProductState([{
+            name:          'test-product',
+            inStore:       'cluster',
+            ifHaveType:    'missingtype',
+            ifNotHaveType: 'anothermissingtype',
+          }]);
+          const rootGetters = createProductRootGetters([productSchemas.myType]);
+
+          const active = getters.activeProducts(state, {}, {}, rootGetters);
+
+          expect(active).toHaveLength(0);
+        });
+      });
+    });
   });
 });
-
-// getTree - Remove ignored schemas, not-applicable to ns filter

package/store/notifications.ts

@@ -299,6 +299,8 @@ export const actions = {
 
     // Show a growl for the notification if necessary
     dispatch('growl/notification', notification, { root: true });
+
+    return notification.id;
   },
 
   async fromGrowl( { commit, getters }: any, notification: Notification) {

package/store/type-map.js

@@ -35,6 +35,7 @@
 //   ifHave,                  -- Show this product only if the given capability is available
 //   ifHaveGroup,             -- Show this product only if the given group exists in the store [inStore]
 //   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]
+//   ifNotHaveType,           -- Hide this product if the given type exists in the store [inStore] (opposite of ifHaveType)
 //   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
@@ -238,7 +239,7 @@ export function DSL(store, product, module = 'type-map') {
       };
 
       // Convert strings to regex's - we do this once here for efficiency
-      for ( const k of ['ifHaveGroup', 'ifHaveType'] ) {
+      for ( const k of ['ifHaveGroup', 'ifHaveType', 'ifNotHaveType'] ) {
         if ( opt[k] ) {
           if (Array.isArray(opt[k])) {
             opt[k] = opt[k].map((r) => regexToString(ensureRegex(r)));
@@ -1419,6 +1420,14 @@ export const getters = {
         }
       }
 
+      if ( p.ifNotHaveType ) {
+        const haveIds = knownTypes[module].filter((t) => t.match(stringToRegex(p.ifNotHaveType)) );
+
+        if ( haveIds.length ) {
+          return false;
+        }
+      }
+
       if ( p.ifHaveGroup && !knownGroups[module].find((t) => t.match(stringToRegex(p.ifHaveGroup)) ) ) {
         return false;
       }

package/types/internal-api/shell/modal.d.ts

@@ -14,7 +14,7 @@ export interface ModalConfig {
    *
    * this.$shell.modal({
    *   component: MyCustomModal,
-   *   componentProps: { title: 'Hello Modal' }
+   *   props: { title: 'Hello Modal' }
    * });
    * ```
    */
@@ -25,10 +25,10 @@ export interface ModalConfig {
    *
    * Example:
    * ```ts
-   * componentProps: { title: 'Hello Modal', isVisible: true }
+   * props: { title: 'Hello Modal', isVisible: true }
    * ```
    */
-  componentProps?: Record<string, any>;
+  props?: Record<string, any>;
 
   /**
    * Optional array of resources that the modal component might need.
@@ -47,11 +47,11 @@ export interface ModalConfig {
    *
    * Examples:
    * ```ts
-   * modalWidth: '800px' // Width in pixels
-   * modalWidth: '75%'   // Width as a percentage
+   * width: '800px' // Width in pixels
+   * width: '75%'   // Width as a percentage
    * ```
    */
-  modalWidth?: string;
+  width?: string;
 
   /**
    * Determines if clicking outside the modal will close it. Defaults to `true`.