@rancher/shell 3.0.12-rc.2 → 3.0.12-rc.4

package/core/plugin-products-base.ts

@@ -1,8 +1,9 @@
 import { IExtension } from '@shell/core/types';
 import {
   ProductChild, ProductMetadata,
-  ConfigureTypeConfiguration, VirtualTypeConfiguration,
-  ProductChildCustomPage, VueRouteComponent, OverviewPageRoutingMetadata
+  ResourcePageConfiguration, CustomPageConfiguration,
+  ProductChildCustomPage, VueRouteComponent,
+  OverviewPageRoutingMetadata
 } from '@shell/core/plugin-types';
 import EmptyProductPage from '@shell/components/EmptyProductPage.vue';
 import pluginProductsHelpers from '@shell/core/plugin-products-helpers';
@@ -11,7 +12,7 @@ import {
   isProductChildWithComponent,
   isProductChildWithType,
   hasNameProperty,
-  hasTypeProperty
+  hasTypeProperty,
 } from '@shell/core/plugin-products-type-guards';
 
 /**
@@ -27,6 +28,16 @@ export abstract class BasePluginProduct {
 
   protected registeredPageNames: Set<string> = new Set();
 
+  // Maps user-friendly group name → internal resolved name (e.g. 'monitoring' → 'myapp-monitoring')
+  // Populated during processGroupRecursively, consumed by moveToGroup resolution in processProductLevelDSLOptions
+  protected groupNameMap: Map<string, string> = new Map();
+
+  // Maps user-facing page identifier → internal basicType key
+  // Resource pages: type → type (identity, e.g. 'pod' → 'pod')
+  // Custom pages: name → prefixed name (e.g. 'myPage' → 'product1-myPage')
+  // Populated during configurePageItem, consumed by moveToGroup resolution in processProductLevelDSLOptions
+  protected pageIdMap: Map<string, string> = new Map();
+
   protected DSLMethods: any;
 
   protected config: ProductChild[];
@@ -40,11 +51,16 @@ export abstract class BasePluginProduct {
    */
   abstract get isNewProduct(): boolean;
 
+  get productName(): string {
+    return this.name;
+  }
+
   /**
    * Helper to throw errors during product registration
    */
-  protected surfaceError(message: string): void {
-    throw new Error(`Extensions - product "${ this.name }" registration error ::: ${ message }`);
+  protected surfaceError(message: string, e?: any): never {
+    console.error(`Extensions - product "${ this.name }" registration error ::: ${ message }`); // eslint-disable-line no-console
+    throw new Error(`Extensions - product "${ this.name }" registration error ::: ${ message }`, { cause: e });
   }
 
   /**
@@ -106,6 +122,12 @@ export abstract class BasePluginProduct {
         this.processGroupRecursively(item, this.name);
       }
     });
+
+    // Process product-level DSL options after all groups are registered
+    // so that the groupNameMap is fully populated for moveToGroup resolution
+    if (this.product) {
+      this.processProductLevelDSLOptions();
+    }
   }
 
   /**
@@ -124,6 +146,10 @@ export abstract class BasePluginProduct {
     const itemGroup = item;
     const groupName = parentGroupName ? `${ productName }-${ parentGroupName }-${ itemGroup.name }` : `${ productName }-${ itemGroup.name }`;
 
+    // Map the user's friendly group name to the resolved internal name
+    // so that moveToGroup can translate friendly names automatically
+    this.groupNameMap.set(itemGroup.name, groupName);
+
     if (!Array.isArray(itemGroup.children)) {
       this.surfaceError('Children defined for group are not in an array format');
 
@@ -181,7 +207,7 @@ export abstract class BasePluginProduct {
   }
 
   /**
-   * Handles product registration via DSL
+   * Handles product registration via DSL (we also define entry route for the product here based on the config of the product - ordering)
    */
   protected handleProductRegistration(): void {
     const { basicType, product } = this.DSLMethods;
@@ -196,7 +222,7 @@ export abstract class BasePluginProduct {
 
       if (isProductChildGroup(firstConfig)) {
         // First config item is a group
-        if (firstConfig.children.length) {
+        if (firstConfig.children.length > 0) {
           const entryChild = firstConfig.children[0];
 
           if (!firstConfig.component) {
@@ -241,11 +267,67 @@ export abstract class BasePluginProduct {
     });
   }
 
+  /**
+   * Process product-level DSL options: renameGroups, ignoreGroups, moveToGroup.
+   * Called after all config items and groups are registered so that the groupNameMap is fully populated.
+   */
+  protected processProductLevelDSLOptions(): void {
+    const {
+      mapGroup, ignoreGroup, moveType, basicType
+    } = this.DSLMethods;
+
+    if (this.product?.renameGroups?.length) {
+      this.product.renameGroups.forEach((mapping) => {
+        mapGroup(mapping.groupSelector, mapping.newName);
+      });
+    }
+
+    if (this.product?.ignoreGroups?.length) {
+      this.product.ignoreGroups.forEach((ignore) => {
+        if (ignore.condition) {
+          ignoreGroup(ignore.groupSelector, ignore.condition);
+        } else {
+          ignoreGroup(ignore.groupSelector);
+        }
+      });
+    }
+
+    if (this.product?.moveToGroup?.length) {
+      this.product.moveToGroup.forEach((move) => {
+        const resolvedGroup = this.groupNameMap.get(move.groupName);
+
+        if (!resolvedGroup) {
+          this.surfaceError(`moveToGroup target group "${ move.groupName }" not found. Available groups: ${ Array.from(this.groupNameMap.keys()).join(', ') }`);
+        }
+
+        const resolvedPageId = this.pageIdMap.get(move.entryId);
+
+        if (!resolvedPageId) {
+          this.surfaceError(`moveToGroup entryId "${ move.entryId }" not found. Available pages: ${ Array.from(this.pageIdMap.keys()).join(', ') }`);
+        }
+
+        // Re-register via basicType to move the page in the nav tree (basic view mode)
+        basicType([resolvedPageId], resolvedGroup);
+
+        // Also register via moveType for non-basic view modes (e.g. "in use" mode).
+        // moveType uses regex matching against schema IDs, so it only works for resource types.
+        const isResourceType = resolvedPageId === move.entryId;
+
+        if (isResourceType) {
+          moveType(move.entryId, resolvedGroup, move.weight);
+        }
+      });
+    }
+  }
+
   /**
    * Configure virtualType (custom page) or configureType (resource page) for a page item
    */
   protected configurePageItem(parentName: string, item: ProductChild, groupNaming?: string): void {
-    const { configureType, virtualType, weightType } = this.DSLMethods;
+    const {
+      configureType, virtualType, weightType,
+      mapType, ignoreType, hideBulkActions, headers
+    } = this.DSLMethods;
 
     // Page with a "component" specified maps to a virtualType
     if (isProductChildWithComponent(item) || (isProductChildGroup(item) && item.component)) {
@@ -259,8 +341,9 @@ export abstract class BasePluginProduct {
       }
 
       this.registeredPageNames.add(finalName);
+      this.pageIdMap.set(item.name, finalName);
 
-      const virtualTypeConfig: VirtualTypeConfiguration = {
+      const virtualTypeConfig: CustomPageConfiguration = {
         label:      item.label,
         labelKey:   item.labelKey,
         namespaced: false,
@@ -290,10 +373,11 @@ export abstract class BasePluginProduct {
       }
 
       this.registeredPageNames.add(typeValue);
+      this.pageIdMap.set(typeValue, typeValue);
 
       const route = pluginProductsHelpers.generateConfigureTypeRoute(parentName, item, { extendProduct: !this.isNewProduct });
 
-      const configureTypeConfig: ConfigureTypeConfiguration = {
+      const configureTypeConfig: ResourcePageConfiguration = {
         isCreatable: true,
         isEditable:  true,
         isRemovable: true,
@@ -301,6 +385,22 @@ export abstract class BasePluginProduct {
         customRoute: route
       };
 
+      if (item.headers || item.sspHeaders) {
+        headers(item.type, item.headers, item.sspHeaders);
+      }
+
+      if (item.overrideListResourceName) {
+        mapType(item.type, item.overrideListResourceName);
+      }
+
+      if (item.hideFromNav) {
+        ignoreType(item.type);
+      }
+
+      if (item.hideBulkActions) {
+        hideBulkActions(item.type, true);
+      }
+
       configureType(typeValue, { ...configureTypeConfig, ...(item.config || {}) });
 
       if (item.weight) {

package/core/plugin-products.ts

@@ -47,4 +47,8 @@ export class PluginProduct {
   get newProduct(): boolean {
     return this.instance.isNewProduct;
   }
+
+  get productName(): string {
+    return this.instance.productName;
+  }
 }

package/core/plugin-types.ts

@@ -4,7 +4,7 @@ import { NAME as EXPLORER_PROD_NAME } from '@shell/config/product/explorer.js';
 import { NAME as CLUSTER_MAN_PROD_NAME } from '@shell/config/product/manager.js';
 import { NAME as SETTINGS_PROD_NAME } from '@shell/config/product/settings.js';
 import { NAME as AUTH_PROD_NAME } from '@shell/config/product/auth.js';
-import { ProductOptions } from '@shell/core/types';
+import { ProductOptions, HeaderOptions, PaginationHeaderOptions } from '@shell/core/types';
 
 type Async<T> = () => Promise<T>;
 
@@ -35,6 +35,12 @@ export type ProductRegistrationRouteGenerationOptions = {
    * Generated route should omit the path property
    */
   omitPath?: boolean;
+  /**
+   * @internal
+   * Whether the route should start with the product name or not (e.g. "my-product/c/:cluster/:resource" vs "c/:cluster/my-product/:resource")
+   * only to be used in very special usecases (internal use only - check FLEET product config for an example)
+   * */
+  startRouteWithProduct?: boolean;
 }
 
 /**
@@ -72,7 +78,7 @@ export type ProductChildMetadata = {
 /**
  * Represents the allowed configuration for a custom page (virtualType)
  */
-export type VirtualTypeConfiguration = {
+export type CustomPageConfiguration = {
   /** Display only if condition is met (relates to IF_HAVE in shell/store/type-map) */
   ifHave?: boolean;
   /** Display only if feature is present (relates to shell/store/features) */
@@ -81,23 +87,44 @@ export type VirtualTypeConfiguration = {
   ifHaveType?: string;
   /** Used in conjunction with "ifHaveType", display only if resource type allows this verb (GET, POST, PUT, DELETE) */
   ifHaveVerb?: string;
-  /** Display label for the custom page */
+  /**
+   * @internal
+   * Display label for the custom page
+   */
   label?: string;
-  /** Translation key for the label */
+  /**
+   * @internal
+   * Translation key for the label
+   * */
   labelKey?: string;
-  /** Name of the page (unique identifier) */
+  /**
+   * @internal
+   * Name of the page (unique identifier)
+   */
   name?: string;
-  /** Entry route definition for this custom page */
+  /**
+   * @internal
+   * Entry route definition for this custom page
+   */
   route?: RouteRecordRawWithParams | PluginRouteRecordRaw | Object;
-  /** Icon for the custom page (relates to icons in https://github.com/rancher/icons) */
+  /**
+   * @internal
+   * Icon for the custom page (relates to icons in https://github.com/rancher/icons)
+   */
   icon?: 'compass';
   /** Whether this custom page is namespaced or not */
   namespaced?: boolean;
-  /** Ordering weight for the custom page */
+  /**
+   * @internal
+   * Ordering weight for the custom page
+   */
   weight?: number;
   /** Whether this custom page is exact match */
   exact?: boolean;
-  /** Whether this custom page will act as an overview page */
+  /**
+   * @internal
+   * Whether this custom page will act as an overview page
+   * */
   overview?: boolean;
   /** Whether this custom page has an exact path match */
   'exact-path'?: boolean;
@@ -106,7 +133,11 @@ export type VirtualTypeConfiguration = {
 /**
  * Represents the allowed configuration for a resource page (configureType)
  */
-export type ConfigureTypeConfiguration = {
+export type ResourcePageConfiguration = {
+  /**
+   * @internal
+   * Entry route definition for this custom page
+   */
   /** Override for the name displayed */
   displayName?: string;
   /** Override for the create button string on a list view */
@@ -129,25 +160,47 @@ export type ConfigureTypeConfiguration = {
   canYaml?: boolean;
   /** Show the Masthead in the edit resource component */
   resourceEditMasthead?: boolean;
-  /** Entry route definition for this resource page */
+  /**
+   * @internal
+   * Entry route definition for this resource page
+   */
   customRoute?: RouteRecordRawWithParams;
   /** Hide this type from the nav/search bar on downstream clusters (will only show in "local" cluster) */
   localOnly?: boolean;
+  /** Whether this custom page is namespaced or not */
+  namespaced?: boolean;
+  /**
+   * @internal
+   * Whether this custom page has list groups (definition for grouping items in the list view)
+   */
+  listGroups?: {
+    /** Icon for the group (relates to icons in rancher-icons */
+    icon?: string;
+    /** Value for the group (used for grouping items in the list view) */
+    value?: string;
+    /** Field for the group (used for grouping items in the list view) */
+    field?: string;
+    /** Column to hide when this group is active */
+    hideColumn?: string;
+    /** Tooltip key for the group */
+    tooltipKey?: string;
+  }[];
+  /**
+   * @internal
+   * Whether the provided list groups will override the default grouping options (e.g. group by namespace, group by cluster, etc.) or be added to them
+   */
+  listGroupsWillOverride?: boolean;
+  /**
+   * @internal
+   * Use this to configure subtypes that should be shown in the list view for this type (e.g. show "pods" and "deployments" in the list view for "workloads")
+   */
+  subTypes?: string[];
   // resource: undefined; // Use this resource in ResourceDetails instead
   // resourceDetail: undefined; // Use this resource specifically for ResourceDetail's detail component
   // resourceEdit: undefined; // Use this resource specifically for ResourceDetail's edit component
   // depaginate: undefined; // Use this to depaginate requests for this type
   // notFilterNamespace: undefined; // Define namespaces that do not need to be filtered
   // used in configureType options, to be typed later if needed
-  // listGroups: [
-  //       {
-  //         icon:       'icon-role-binding',
-  //         value:      'node',
-  //         field:      'roleDisplay',
-  //         hideColumn: ROLE.name,
-  //         tooltipKey: 'resourceTable.groupBy.role'
-  //       }
-  //     ]
 }
 
 /**
@@ -165,16 +218,6 @@ export type OverviewPageRoutingMetadata = {
   component: VueRouteComponent;
 }
 
-/**
- * Represents a custom page with a component
- */
-export type ProductChildCustomPage = ProductChildMetadata & {
-  /** Component to render for this custom page */
-  component: VueRouteComponent;
-  /** Optional configuration for the page */
-  config?: VirtualTypeConfiguration;
-};
-
 /**
  * Represents a resource page with a type (K8s resource)
  */
@@ -182,9 +225,29 @@ export type ProductChildResourcePage = {
   /** K8s resource type name for a resource page */
   type: string;
   /** Optional configuration for the resource page */
-  config?: ConfigureTypeConfiguration;
+  config?: ResourcePageConfiguration;
   /** Ordering weight for this page among its siblings */
   weight?: number;
+  /** Use this to override the resource name used in the list view for this type */
+  overrideListResourceName?: string;
+  /** Whether to hide this resource from the side-menu entirely */
+  hideFromNav?: boolean;
+  /** Whether to hide bulk actions for this resource */
+  hideBulkActions?: boolean;
+  /** Table headers for this resource type (client-side pagination) */
+  headers?: HeaderOptions[];
+  /** Table headers for this resource type (server-side pagination) */
+  sspHeaders?: PaginationHeaderOptions[];
+};
+
+/**
+ * Represents a custom page with a component
+ */
+export type ProductChildCustomPage = ProductChildMetadata & {
+  /** Component to render for this custom page */
+  component: VueRouteComponent;
+  /** Optional configuration for the page */
+  config?: CustomPageConfiguration;
 };
 
 /**
@@ -218,6 +281,106 @@ export type ProductMetadata = Omit<ProductOptions, 'name' | 'label' | 'labelKey'
    * Product name (unique identifier)
    */
   name: string;
+  /**
+   * @internal
+   * Use `renameGroups` on the product metadata to remap group display names in the side-menu. Each entry matches a group's internal ID (via string or regex) and replaces its display label with a new name. This only changes how the group is labelled in the UI — it does not move resources between groups.
+   *
+   * The `groupSelector` is evaluated against group internal IDs. It can be an exact string or a `RegExp` pattern. The `newName` value is the new display name.
+   *
+   * const product: ProductMetadata = {
+   *   name:  'my-app',
+   *   label: 'My App',
+   *   renameGroups: [
+   *     // Rename a group with an ugly internal ID to a friendlier display name
+   *     { groupSelector: 'cert-manager.io', newName: 'Certificates' },
+   *     // Use a regex to rename all groups matching a pattern
+   *     { groupSelector: /^networking\./, newName: 'Networking' },
+   *   ],
+   * };
+   */
+  renameGroups?: {
+    /** String or regex to match against group internal IDs */
+    groupSelector: RegExp | string;
+    /** Display name to use for matching groups */
+    newName: string;
+  }[];
+  /**
+   * @internal
+   *
+   * Use `moveToGroup` on the product metadata to move pages (resource types or custom pages) into specific side-menu groups. This is useful when a page should appear inside a group but isn't defined as a child of that group in the config.
+   * Each entry identifies a page by its `entryId` — the resource `type` string or the custom page `name` — and moves it into the specified group. Use the group's `name` as you defined it in your config.
+   *
+   * const monitoringGroup: ProductChildGroup = {
+   *   name:     'monitoring',
+   *   label:    'Monitoring',
+   *   children: [
+   *    { name: 'alerts', label: 'Alerts', component: () => import('./pages/Alerts.vue') },
+   *   ],
+   * };
+
+   * const dashboardPage: ProductChildCustomPage = {
+   *   name: 'dashboard', label: 'Dashboard', component: () => import('./pages/Dashboard.vue'),
+   * };
+
+   * const product: ProductMetadata = {
+   *   name:        'my-app',
+   *   label:       'My App',
+   *   moveToGroup: [
+   *    // Move the 'pod' resource type into the 'monitoring' group
+   *    { entryId: 'pod', groupName: 'monitoring' },
+   *    // Move a custom page into the 'monitoring' group
+   *    { entryId: 'dashboard', groupName: 'monitoring' },
+   *   ],
+   * };
+   *
+   * extension.addProduct(product, [monitoringGroup, { type: 'pod' }, dashboardPage]);
+   *
+   * Note: The `entryId` must match a page declared in the same product config — either a resource page's `type` or a custom page's `name`. The target `groupName` must be a `ProductChildGroup` defined in the same config. If either is not found, an error is thrown at registration time listing the available options. Only exact string identifiers are supported (no regex).
+   *
+   * The optional `weight` parameter controls precedence when multiple `moveToGroup` rules target the same page (default: `5`). Higher weight takes precedence.
+  */
+  moveToGroup?: {
+    /** Page identifier — the resource `type` string or the custom page `name` */
+    entryId: string;
+    /** Target group name as defined in your group config (`name` property) */
+    groupName: string;
+    /** Ordering weight for the mapping (default: 5). Higher weight takes precedence when multiple rules match */
+    weight?: number;
+  }[];
+  /**
+   * @internal
+   *
+   * maps to DSL ignoreGroup
+   *
+   * Use `ignoreGroups` on the product metadata to hide specific side-menu groups. Each entry specifies a `groupSelector` to match group names — either an exact string or a regex pattern.
+   *
+   * The `condition` callback is optional. When provided, it receives the store getters and returns `true` to hide the group (conditional hide). When omitted, the group is always hidden (unconditional hide).
+   *
+   * Example usage:
+   * const product: ProductMetadata = {
+   *   name:  'my-app',
+   *   label: 'My App',
+   *   ignoreGroups: [
+   *     // Always hide the "internal" group (unconditional — no condition)
+   *     { groupSelector: 'internal' },
+   *     // Hide all groups matching a regex pattern (unconditional)
+   *     { groupSelector: /^deprecated/ },
+   *     // Conditionally hide based on a feature flag
+   *     {
+   *       groupSelector: 'experimental',
+   *       condition:     (getters) => !getters['features/isEnabled']('experimental-feature'),
+   *     },
+   *   ],
+   * };
+   *
+   *
+   * In this example, the "internal" group is always hidden, any group with a name starting with "deprecated-" is hidden, and the "experimental" group is hidden unless the "experimental-feature" flag is enabled in the store.
+   */
+  ignoreGroups?: {
+    /** String or regex to match against group names */
+    groupSelector: string | RegExp;
+    /** Optional conditional function that accepts the root Dashboard Vuex store getters and returns true if the group should be ignored */
+    condition?: (getters: any) => boolean }[];
 } & (
   /** Human-readable label for the product
    * Either label or labelKey are required */

package/core/plugin.ts

@@ -124,6 +124,9 @@ export class Plugin implements IPlugin {
     this.topLevelProduct = true;
   }
 
+  _setStartRouteWithProduct(_value: boolean): void {
+  }
+
   // Track which products the plugin creates
   // Legacy DSL method
   DSL(store: any, productName: string) {
@@ -135,21 +138,29 @@ export class Plugin implements IPlugin {
   }
 
   addProduct(product: ProductFunction | ProductMetadata | ProductSinglePage | string, config?: ProductChild[]): void {
+    let pluginProduct: PluginProduct;
+
     if (typeof product === 'string') {
-      this.productConfigs.push(PluginProduct.fromName(this, product));
+      pluginProduct = PluginProduct.fromName(this, product);
     } else if (product?.name) {
       if (!config) {
-        const p = product as ProductSinglePage;
-
-        this.productConfigs.push(new PluginProduct(this, p, []));
+        pluginProduct = new PluginProduct(this, product as ProductSinglePage, []);
       } else {
-        const p = product as ProductMetadata;
-
-        this.productConfigs.push(new PluginProduct(this, p, config));
+        pluginProduct = new PluginProduct(this, product as ProductMetadata, config);
       }
     } else {
       this.products.push(product as ProductFunction);
+
+      return;
     }
+
+    const existingProduct = this.productConfigs.find((p) => p.newProduct && p.productName === pluginProduct.productName);
+
+    if (existingProduct) {
+      throw new Error(`Extensions - product "${ pluginProduct.productName }" registration error ::: addProduct can only be called once per product. Use extendProduct to add pages to an existing product.`);
+    }
+
+    this.productConfigs.push(pluginProduct);
   }
 
   extendProduct(product: StandardProductName | string, config: ProductChild[] | ProductChild): void {

package/core/productDebugger.js

@@ -21,8 +21,13 @@ export function DSLRegistrationsPerProduct(store, prodName) {
     }
 
     // prod configureType
-    if (dataType === 'typeOptions' && typeMapData[dataType].filter((item) => item.customRoute && item.customRoute.name.includes(prodName))) {
-      parsedData['configureType'] = typeMapData[dataType].filter((item) => item.customRoute && item.customRoute.name.includes(prodName));
+    if (dataType === 'typeOptions') {
+      const allTypeOptions = Object.values(typeMapData[dataType]).flat();
+      const filtered = allTypeOptions.filter((item) => item.customRoute && item.customRoute.name.includes(prodName));
+
+      if (filtered.length > 0) {
+        parsedData['configureType'] = filtered;
+      }
     }
 
     // other types which map with prodName
@@ -36,7 +41,7 @@ export function DSLRegistrationsPerProduct(store, prodName) {
     }
   });
 
-  console.error('*** PRODUCT DATA DEBUGGER **** DSLRegistrationsPerProduct', parsedData); // eslint-disable-line no-console
+  console.error(`*** PRODUCT DATA DEBUGGER ${ prodName } **** DSLRegistrationsPerProduct`, parsedData); // eslint-disable-line no-console
 }
 
 export function registeredRoutes(store, prodName) {
@@ -44,5 +49,5 @@ export function registeredRoutes(store, prodName) {
 
   const parsedData = routes.filter((route) => route.path.includes(prodName));
 
-  console.error('*** PRODUCT DATA DEBUGGER **** registeredRoutes', parsedData); // eslint-disable-line no-console
+  console.error(`*** PRODUCT DATA DEBUGGER ${ prodName } **** registeredRoutes`, parsedData); // eslint-disable-line no-console
 }