@rancher/shell 3.0.8-rc.7 → 3.0.8-rc.9

package/types/shell/index.d.ts

@@ -79,6 +79,7 @@ export namespace CATALOG {
     let _RANCHER: string;
     let _PARTNER: string;
     let _OTHER: string;
+    let PRIME_ONLY: string;
     let EXPERIMENTAL: string;
     let NAMESPACE: string;
     let RELEASE_NAME: string;
@@ -2206,6 +2207,12 @@ export namespace MANAGEMENT {
     export let CLUSTER_PROXY_CONFIG: string;
     export let OIDC_CLIENT: string;
 }
+export namespace BRAND {
+    let SUSE: string;
+    let CSP: string;
+    let FEDERAL: string;
+    let RGS: string;
+}
 export namespace EXT {
     let USER_ACTIVITY: string;
 }
@@ -2442,6 +2449,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: BooleanConstructor;
         default: any;
     };
+    defaultTab: {
+        type: StringConstructor;
+        default: any;
+    };
 }>, {}, {
     errors: any[];
 }, {
@@ -2499,6 +2510,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: BooleanConstructor;
         default: any;
     };
+    defaultTab: {
+        type: StringConstructor;
+        default: any;
+    };
 }>> & Readonly<{
     [x: `on${Capitalize<string>}`]: (...args: any[]) => any;
 }>, {
@@ -2509,6 +2524,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     liveValue: Record<string, any>;
     realMode: string;
     useTabbedHash: boolean;
+    defaultTab: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;
 }
@@ -3315,7 +3331,7 @@ export default class Resource {
         weight: number;
         divider?: undefined;
     })[];
-    showConfiguration(returnFocusSelector: any): void;
+    showConfiguration(returnFocusSelector: any, defaultTab: any): void;
     get _availableActions(): ({
         action: string;
         label: any;
@@ -3633,6 +3649,26 @@ export default class Resource {
 }
 }
 
+// @shell/plugins/i18n
+
+declare module '@shell/plugins/i18n' {
+/**
+ * @param {import('vuex').Store<any>} store
+ * @param {string} key
+ * @param {Record<string, any>} [args]
+ * @param {boolean} [raw]
+ * @param {boolean} [escapehtml]
+ * @returns {string}
+ */
+export function stringFor(store: import("vuex").Store<any>, key: string, args?: Record<string, any>, raw?: boolean, escapehtml?: boolean): string;
+export function directiveSsr(vnode: any, binding: any): void;
+export default i18n;
+declare namespace i18n {
+    let name: string;
+    function install(vueApp: any, _options: any): void;
+}
+}
+
 // @shell/plugins/steve/hybrid-class
 
 declare module '@shell/plugins/steve/hybrid-class' {
@@ -4083,7 +4119,7 @@ export function contrastColor(color: any, contrastOptions?: {
     dark: string;
     light: string;
 }): string;
-export function parseColor(str: any): any;
+export function parseColor(str: any): import("color").ColorInstance;
 export function textColor(color: any): "black" | "white";
 export function hexToRgb(hex: any): {
     r: number;
@@ -5257,6 +5293,7 @@ export function parse(str: any): any;
 export function sortable(str: any): any;
 export function compare(in1: any, in2: any): any;
 export function isPrerelease(version?: string): boolean;
+export function isUpgradeFromPreToStable(currentVersion: any, targetVersion: any): any;
 export function isDevBuild(version: any): boolean;
 export function getVersionInfo(store: any): {
     displayVersion: any;

package/types/store/__tests__/pagination.types.spec.ts

@@ -0,0 +1,137 @@
+import { PaginationFilterEquality, PaginationFilterField } from '@shell/types/store/pagination.types';
+
+describe('pagination-types', () => {
+  describe('class: PaginationFilterField', () => {
+    describe('constructor', () => {
+      it('should set properties correctly with default values', () => {
+        const field = 'testField';
+        const value = 'testValue';
+        const filterField = new PaginationFilterField({ field, value });
+
+        expect(filterField.field).toBe(field);
+        expect(filterField.value).toBe(value);
+        expect(filterField.equals).toBe(true);
+        expect(filterField.exact).toBe(true);
+        expect(filterField.exists).toBe(false);
+        expect(filterField.equality).toBe(PaginationFilterEquality.EQUALS);
+      });
+
+      it('should handle deprecated `equals` and `exact` to set `equality`', () => {
+      // equals: true, exact: true
+        let ff = new PaginationFilterField({
+          field: 'f', value: 'v', equals: true, exact: true
+        });
+
+        expect(ff.equality).toBe(PaginationFilterEquality.EQUALS);
+
+        // equals: true, exact: false
+        ff = new PaginationFilterField({
+          field: 'f', value: 'v', equals: true, exact: false
+        });
+        expect(ff.equality).toBe(PaginationFilterEquality.CONTAINS);
+
+        // equals: false, exact: true
+        ff = new PaginationFilterField({
+          field: 'f', value: 'v', equals: false, exact: true
+        });
+        expect(ff.equality).toBe(PaginationFilterEquality.NOT_EQUALS);
+
+        // equals: false, exact: false
+        ff = new PaginationFilterField({
+          field: 'f', value: 'v', equals: false, exact: false
+        });
+        expect(ff.equality).toBe(PaginationFilterEquality.NOT_CONTAINS);
+      });
+
+      it('should prioritize `equality` over `equals` and `exact`', () => {
+        const filterField = new PaginationFilterField({
+          field:    'f',
+          value:    'v',
+          equals:   false,
+          exact:    false,
+          equality: PaginationFilterEquality.GREATER_THAN
+        });
+
+        expect(filterField.equality).toBe(PaginationFilterEquality.GREATER_THAN);
+      });
+
+      it('should throw an error if no equality can be determined', () => {
+        expect(() => new PaginationFilterField({
+          field:  'f',
+          value:  'v',
+          equals: null,
+          exact:  null
+        })).toThrow('A pagination filter must have either equals or equality set');
+      });
+
+      it('should set `exists` property', () => {
+        const filterField = new PaginationFilterField({ field: 'f', exists: true });
+
+        expect(filterField.exists).toBe(true);
+      });
+    });
+
+    describe('safeEquality', () => {
+      it('should return EQUALS for equals=true, exact=true', () => {
+        const equality = PaginationFilterField.safeEquality({ equals: true, exact: true });
+
+        expect(equality).toBe(PaginationFilterEquality.EQUALS);
+      });
+
+      it('should return CONTAINS for equals=true, exact=false', () => {
+        const equality = PaginationFilterField.safeEquality({ equals: true, exact: false });
+
+        expect(equality).toBe(PaginationFilterEquality.CONTAINS);
+      });
+
+      it('should return NOT_EQUALS for equals=false, exact=true', () => {
+        const equality = PaginationFilterField.safeEquality({ equals: false, exact: true });
+
+        expect(equality).toBe(PaginationFilterEquality.NOT_EQUALS);
+      });
+
+      it('should return NOT_CONTAINS for equals=false, exact=false', () => {
+        const equality = PaginationFilterField.safeEquality({ equals: false, exact: false });
+
+        expect(equality).toBe(PaginationFilterEquality.NOT_CONTAINS);
+      });
+
+      it('should return equality if it is provided', () => {
+        const equality = PaginationFilterField.safeEquality({ equality: PaginationFilterEquality.IN });
+
+        expect(equality).toBe(PaginationFilterEquality.IN);
+      });
+
+      it('should prioritize equality over equals/exact', () => {
+        const equality = PaginationFilterField.safeEquality({
+          equals:   true,
+          exact:    false,
+          equality: PaginationFilterEquality.LESS_THAN
+        });
+
+        expect(equality).toBe(PaginationFilterEquality.LESS_THAN);
+      });
+
+      it('should return undefined if no equality can be determined', () => {
+        const equality = PaginationFilterField.safeEquality({});
+
+        expect(equality).toBeUndefined();
+      });
+
+      it('should work with an instance of PaginationFilterField', () => {
+        const ff = new PaginationFilterField({
+          field:    'f',
+          value:    'v',
+          equals:   false,
+          exact:    false,
+          equality: PaginationFilterEquality.GREATER_THAN
+        });
+
+        // safeEquality will prioritize the `equality` property on the instance
+        const equality = PaginationFilterField.safeEquality(ff);
+
+        expect(equality).toBe(PaginationFilterEquality.GREATER_THAN);
+      });
+    });
+  });
+});

package/types/store/pagination.types.ts

@@ -13,6 +13,8 @@ import { KubeLabelSelector } from '@shell/types/kube/kube-api';
 // The two important / complex params are currently
 // - `filter` https://github.com/rancher/steve?tab=readme-ov-file#filter
 //   - represented by `PaginationParamFilter extends PaginationParam`
+//   - a filter has filter fields which are made up of a field name, equality and value/s
+//     - filter=<field><equality><value>
 //   - Examples
 //     - filter=metadata.name=123
 //     - filter=metadata.name=123,metadata.name=456 (name is 123 OR 456)
@@ -45,14 +47,111 @@ export interface PaginationSort {
   asc: boolean
 }
 
+/**
+ * Equalities that can be used with a `filter` query param
+ *
+ * filter=<field><equality><values>
+ *
+ * For example
+ * - filter=a=b
+ * - filter=a!=b
+ * - filter=a NOT IN (b,c,d)
+ */
+export const enum PaginationFilterEquality {
+  /**
+   * Field is in a collection of values
+   */
+  IN = ' IN ', // eslint-disable-line no-unused-vars
+  /**
+   * Field is not in a collection of values
+   */
+  NOT_IN = ' NOTIN ', // eslint-disable-line no-unused-vars
+  /**
+   * Field matches a value
+   */
+  EQUALS= '=', // eslint-disable-line no-unused-vars
+  /**
+   * Field does not match a value
+   */
+  NOT_EQUALS= '!=', // eslint-disable-line no-unused-vars
+  /**
+   * Unknown
+   */
+  STRICT_EQUALS = '==', // eslint-disable-line no-unused-vars
+  /**
+   * Field must partially match a value
+   */
+  CONTAINS= '~', // eslint-disable-line no-unused-vars
+  /**
+   * Field must not partially match a value
+   */
+  NOT_CONTAINS= '!~', // eslint-disable-line no-unused-vars
+  /**
+   * Field must be greater than a value
+   */
+  GREATER_THAN= 'gt', // eslint-disable-line no-unused-vars
+  /**
+   * Field must be less than a value
+   */
+  LESS_THAN= 'lt', // eslint-disable-line no-unused-vars
+}
+
+/**
+ * Ctor args for a @PaginationFilterField
+ */
+type FilterFieldCtorArgs = {
+  /**
+   * Name of field within the object to filter by for example the x of x=y
+   *
+   * This can be optional for some (projectsornamespaces)
+   */
+  field?: string;
+    /**
+   * Value of field within the object to filter by for example the y of x=y
+   *
+   * This can be empty if `exists` is true
+   */
+  value?: string;
+  /**
+   * Equality field within the object to filter by for example the `=` or `!=` of x=y
+   *
+   * @deprecated Please use `equality` instead of equals and exact
+   */
+  equals?: boolean;
+  /**
+   * Match the field exactly. False for partial matches
+   *
+   * Value: pod1
+   * Exact: true. "p" no, "pod", no, "pod1" yes
+   * Exact: false. "p" yes, "pod", yes, "pod1" yes
+   *
+   * @deprecated Please use `equality` instead of equals and exact
+   */
+  exact?: boolean,
+  /**
+   * Check if the field/property exists, regardless of value
+   *
+   * If this is false it does not flip the expectation, just doesn't add the field
+   */
+  exists?: boolean,
+  /**
+   * Equality symbol used to compare the field with the value
+   */
+  equality?: PaginationFilterEquality
+}
+
 /**
  * Filter the pagination result by these specific fields
  *
+ * In format of <field><equality><value>
+ *
  * For example
  *
  * - metadata.name=test
  * - metadata.namespace!=system
  *
+ * These are sub items for @PaginationParam, for example filter=<PaginationFilterField>
+ *
  * For more information regarding the API see https://github.com/rancher/steve?tab=readme-ov-file#query-parameters
  */
 export class PaginationFilterField {
@@ -70,6 +169,8 @@ export class PaginationFilterField {
   value?: string;
   /**
    * Equality field within the object to filter by for example the `=` or `!=` of x=y
+   *
+   * @deprecated Please use `equality` instead of equals and exact
    */
   equals?: boolean;
   /**
@@ -78,9 +179,14 @@ export class PaginationFilterField {
    * Value: pod1
    * Exact: true. "p" no, "pod", no, "pod1" yes
    * Exact: false. "p" yes, "pod", yes, "pod1" yes
+   *
+   * @deprecated Please use `equality` instead of equals and exact
    */
   exact?: boolean;
-
+  /**
+   * Equality symbol used to compare the field with the value
+   */
+  equality?: PaginationFilterEquality;
   /**
    * Check if the field/property exists, regardless of value
    *
@@ -88,17 +194,51 @@ export class PaginationFilterField {
    */
   exists?: boolean;
 
-  constructor(
-    {
-      field, value = '', equals = true, exact = true, exists = false
-    }:
-    { field?: string; value?: string; equals?: boolean; exact?: boolean; exists?:boolean;}
-  ) {
+  constructor(args: FilterFieldCtorArgs) {
+    const {
+      field, value = '', equals = true, exact = true, equality = undefined, exists = false
+    } = args;
+
     this.field = field;
     this.value = value;
     this.equals = equals;
     this.exact = exact;
     this.exists = exists;
+
+    const _equality = PaginationFilterField.safeEquality({
+      field, value, equals, exact, equality, exists
+    });
+
+    if (_equality) {
+      this.equality = _equality;
+    } else {
+      throw new Error('A pagination filter must have either equals or equality set');
+    }
+  }
+
+  /**
+   * Determine equality for this field.
+   *
+   * Mainly to ensure legacy objects using deprecated fields instead of new equality field fall back on something sensible
+   */
+  static safeEquality(args: FilterFieldCtorArgs | PaginationFilterField): PaginationFilterEquality | undefined {
+    if (args.equality) {
+      return args.equality;
+    }
+
+    if (args.equals === true) {
+      if (args.exact === true) {
+        return PaginationFilterEquality.EQUALS;
+      } else {
+        return PaginationFilterEquality.CONTAINS;
+      }
+    } else if (args.equals === false) {
+      if (args.exact === true) {
+        return PaginationFilterEquality.NOT_EQUALS;
+      } else {
+        return PaginationFilterEquality.NOT_CONTAINS;
+      }
+    }
   }
 }
 
@@ -202,7 +342,15 @@ export abstract class PaginationParam {
 }
 
 /**
- * This is a convenience class for the `filter` param which works some magic, adds defaults and converts to the required PaginationParam format
+ * This is a convenience class for the `filter` param which works some magic, adds defaults and converts to the required PaginationParam format.
+ *
+ * for example
+ *
+ * - filter=???
+ *
+ * including `fields` this could be
+ *
+ * - filter=a=b
  *
  * See description for {@link PaginationParam} for how multiple of these can be combined together to AND or OR together
  *
@@ -238,7 +386,7 @@ export class PaginationParamFilter extends PaginationParam {
   /**
    * Convenience method when you just want an instance of {@link PaginationParamFilter} with a simple `filter=x=y` param
    */
-  static createSingleField(field: { field?: string; value?: string; equals?: boolean; exact?: boolean, exists?: boolean }): PaginationParam {
+  static createSingleField(field: FilterFieldCtorArgs): PaginationParam {
     return new PaginationParamFilter({ fields: [new PaginationFilterField(field)] });
   }
 

package/types/store/subscribe-events.types.ts

@@ -12,10 +12,17 @@ export interface STEVE_WATCH_EVENT_PARAMS_COMMON {
   params: STEVE_WATCH_PARAMS,
 }
 
+/**
+ * Args for @STEVE_WATCH_EVENT_LISTENER_CALLBACK
+ */
+export type STEVE_WATCH_EVENT_LISTENER_CALLBACK_PARAMS = {
+  forceWatch?: boolean,
+}
+
 /**
  * Executes when a watch event has a listener and it's triggered
  */
-export type STEVE_WATCH_EVENT_LISTENER_CALLBACK = () => void
+export type STEVE_WATCH_EVENT_LISTENER_CALLBACK = (params: STEVE_WATCH_EVENT_LISTENER_CALLBACK_PARAMS) => void
 
 /**
  * Common params used when a watcher adds a listener to a watch

package/types/store/subscribe.types.ts

@@ -30,5 +30,6 @@ export interface STEVE_WATCH_PARAMS {
   namespace?: string,
   stop?: boolean,
   force?: boolean,
+  forceWatch?: boolean,
   mode?: STEVE_WATCH_MODE
 }

package/utils/__tests__/provider.test.ts

@@ -0,0 +1,98 @@
+import { getHostedProviders, isHostedProvider } from '../provider';
+import { ClusterProvisionerContext, IClusterProvisioner } from '@shell/core/types';
+
+const DEFAULT_CONTEXT = {
+  dispatch: {},
+  getters:  {},
+  axios:    {},
+  t:        (args: any) => args.join(' '),
+};
+
+const MOCK_PROVIDERS: IClusterProvisioner[] = [
+  { id: 'AKS', group: 'hosted' } as IClusterProvisioner,
+  { id: 'EKS', group: 'hosted' } as IClusterProvisioner,
+  { id: 'GKE', group: 'hosted' } as IClusterProvisioner,
+  { id: 'alibaba', group: 'hosted' } as IClusterProvisioner,
+  { id: 'other', group: 'other' } as IClusterProvisioner,
+];
+
+describe('utils/provider', () => {
+  describe('getHostedProviders', () => {
+    it('should return an empty array when context.$extension is undefined', () => {
+      const context = { ...DEFAULT_CONTEXT } as ClusterProvisionerContext;
+      const result = getHostedProviders(context);
+
+      expect(result).toStrictEqual([]);
+    });
+
+    it('should return hosted providers when context.$extension is defined', () => {
+      const context = {
+        ...DEFAULT_CONTEXT,
+        $extension: { getProviders: jest.fn().mockReturnValue(MOCK_PROVIDERS) }
+      } as unknown as ClusterProvisionerContext;
+
+      const result = getHostedProviders(context);
+
+      expect(result).toStrictEqual([
+        { id: 'AKS', group: 'hosted' },
+        { id: 'EKS', group: 'hosted' },
+        { id: 'GKE', group: 'hosted' },
+        { id: 'alibaba', group: 'hosted' },
+      ]);
+      expect(context.$extension.getProviders).toHaveBeenCalledWith(context);
+    });
+
+    it('should return an empty array if getProviders returns null', () => {
+      const context = {
+        ...DEFAULT_CONTEXT,
+        $extension: { getProviders: jest.fn().mockReturnValue(null) }
+      } as unknown as ClusterProvisionerContext;
+
+      const result = getHostedProviders(context);
+
+      expect(result).toStrictEqual([]);
+    });
+
+    it('should return an empty array if getProviders returns undefined', () => {
+      const context = {
+        ...DEFAULT_CONTEXT,
+        $extension: { getProviders: jest.fn().mockReturnValue(undefined) }
+      } as unknown as ClusterProvisionerContext;
+
+      const result = getHostedProviders(context);
+
+      expect(result).toStrictEqual([]);
+    });
+  });
+
+  describe('isHostedProvider', () => {
+    it('should return false if provisioner is not provided', () => {
+      const context = {
+        ...DEFAULT_CONTEXT,
+        $extension: { getProviders: jest.fn().mockReturnValue(MOCK_PROVIDERS) }
+      } as ClusterProvisionerContext;
+
+      expect(isHostedProvider(context, '')).toBe(false);
+      expect(isHostedProvider(context, undefined as any)).toBe(false);
+      expect(isHostedProvider(context, null as any)).toBe(false);
+    });
+
+    it('should return true only if provisioner is in the list of hosted providers', () => {
+      const context = {
+        ...DEFAULT_CONTEXT,
+        $extension: { getProviders: jest.fn().mockReturnValue(MOCK_PROVIDERS) }
+      } as ClusterProvisionerContext;
+
+      expect(isHostedProvider(context, 'AKS')).toBe(true);
+      expect(isHostedProvider(context, 'eks')).toBe(true);
+      expect(isHostedProvider(context, 'different')).toBe(false); // case-insensitive check
+      expect(isHostedProvider(context, 'other')).toBe(false); // case-insensitive check
+    });
+
+    it('should return false if there are no hosted providers', () => {
+      const context = { ...DEFAULT_CONTEXT, $extension: { getProviders: jest.fn().mockReturnValue([]) } } as ClusterProvisionerContext;
+
+      expect(isHostedProvider(context, 'prov1')).toBe(false);
+    });
+  });
+});