@rancher/shell 3.0.5-rc.5 → 3.0.5-rc.6

package/types/shell/index.d.ts

@@ -158,6 +158,11 @@ export const SYSTEM_LABELS: string[];
 export namespace CLOUD_CREDENTIALS {
     let EXPIRATION: string;
 }
+export namespace OIDC_CLIENT_SECRET_ANNOTATIONS {
+    let CREATE: string;
+    let REGEN: string;
+    let REMOVE: string;
+}
 }
 
 // @shell/config/query-params
@@ -224,6 +229,7 @@ export const PROVIDER: "provider";
 export const CLOUD_CREDENTIAL: "cloud";
 export const PROJECT_ID: "projectId";
 export const FLAT_VIEW: "flatView";
+export const RANCHER_AS_OIDC_QUERY_PARAMS: string[];
 }
 
 // @shell/config/table-headers
@@ -2045,6 +2051,12 @@ export namespace CATALOG {
     export { APP_1 as APP };
     export let REPO: string;
 }
+export namespace CATALOG_SORT_OPTIONS {
+    let RECOMMENDED: string;
+    let LAST_UPDATED_DESC: string;
+    let ALPHABETICAL_ASC: string;
+    let ALPHABETICAL_DESC: string;
+}
 export const UI_PLUGIN: "catalog.cattle.io.uiplugin";
 export namespace HELM {
     let PROJECTHELMCHART: string;
@@ -2126,6 +2138,7 @@ export namespace MANAGEMENT {
     export let RKE_TEMPLATE: string;
     export let RKE_TEMPLATE_REVISION: string;
     export let CLUSTER_PROXY_CONFIG: string;
+    export let OIDC_CLIENT: string;
 }
 export namespace CAPI {
     let CAPI_CLUSTER: string;
@@ -2202,7 +2215,7 @@ export namespace BACKUP_RESTORE {
     let BACKUP: string;
     let RESTORE: string;
 }
-export namespace CIS {
+export namespace COMPLIANCE {
     let CLUSTER_SCAN: string;
     let CLUSTER_SCAN_PROFILE: string;
     let BENCHMARK: string;
@@ -2341,6 +2354,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: BooleanConstructor;
         default: boolean;
     };
+    useTabbedHash: {
+        type: BooleanConstructor;
+        default: any;
+    };
 }>, {}, {
     errors: any[];
 }, {
@@ -2394,6 +2411,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: BooleanConstructor;
         default: boolean;
     };
+    useTabbedHash: {
+        type: BooleanConstructor;
+        default: any;
+    };
 }>> & Readonly<{
     [x: `on${Capitalize<string>}`]: (...args: any[]) => any;
 }>, {
@@ -2403,6 +2424,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     initialValue: Record<string, any>;
     liveValue: Record<string, any>;
     realMode: string;
+    useTabbedHash: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;
 }
@@ -2660,6 +2682,7 @@ declare namespace _default {
      *
      * @param {*} ctx
      * @param { {type: string, opt: ActionFindPageArgs} } opt
+     * @returns @ActionFindPageResponse
      */
     export function findPage(ctx: any, { type, opt }: {
         type: string;
@@ -2675,6 +2698,9 @@ declare namespace _default {
      * b) Pagination Disabled - use the old 'native kube api' - findMatching
      *
      * Filter is defined via the kube labelSelector object (see KubeLabelSelector)
+     *
+     * opt: @ActionFindLabelSelectorArgs
+     * @returns @ActionFindMatchingResponse (resources[], or if transient { data: resources[], pagination: StorePagination })
      */
     export function findLabelSelector(ctx: any, { type, context, matching: { namespace, labelSelector }, opt }: {
         type: any;
@@ -2685,6 +2711,9 @@ declare namespace _default {
         };
         opt: any;
     }): Promise<any>;
+    /**
+     * opt: @ActionFindMatchingArgs
+     */
     export function findMatching(ctx: any, { type, selector, opt, namespace }: {
         type: any;
         selector: any;
@@ -2723,7 +2752,7 @@ declare namespace _default {
         commit: any;
         dispatch: any;
         state: any;
-    }, type: any): void;
+    }, type: any, compareWatches: any): void;
     export function promptRemove({ commit, state }: {
         commit: any;
         state: any;
@@ -2948,6 +2977,11 @@ export default class Resource {
     setAnnotation(key: any, val: any): void;
     get stateDisplay(): any;
     get stateColor(): any;
+    get stateColorPair(): {
+        state: any;
+        color: any;
+    };
+    get stateSimpleColor(): any;
     get stateBackground(): any;
     get stateIcon(): string;
     get stateSort(): string;
@@ -3328,7 +3362,6 @@ export const HIDE_REPOS: any;
 export const HIDE_DESC: any;
 export const HIDE_SENSITIVE: any;
 export const SHOW_PRE_RELEASE: any;
-export const SHOW_CHART_MODE: any;
 export const DATE_FORMAT: any;
 export const TIME_FORMAT: any;
 export const TIME_ZONE: any;
@@ -3487,7 +3520,7 @@ export function tryInitialSetup(store: any, password?: string): Promise<boolean>
 /**
  * Record in our state management that we're indeed logged in
  */
-export function isLoggedIn(store: any, me: any): void;
+export function isLoggedIn(store: any, userData: any): Promise<void>;
 /**
  * Record in our state management that we're not logged in and then redirect to the login page
  */
@@ -4116,6 +4149,8 @@ export function mergeWithReplace(obj1?: any, obj2?: any, { mutateOriginal, repla
 }): any;
 export { isEqualBasic as isEqual };
 export function toDictionary(array: any, callback: any): any;
+export function convertKVToString(input: any): string;
+export function convertStringToKV(input: string): {};
 /**
  * Super simple lodash isEqual equivalent.
  *
@@ -4528,6 +4563,13 @@ export function sanitizeIP(v: any): any;
 export function xOfy(x: any, y: any): string;
 export function isBase64(value: any): boolean;
 export function generateRandomAlphaString(length: any): string;
+/**
+ * Generate a key-value nested object from a list of paths that represents a directory tree.
+ *
+ * Each key is a subpath
+ * Each value contains the children of the subpath
+ */
+export function pathArrayToTree(paths: any): any[];
 export namespace CHARSET {
     export { num as NUMERIC };
     export let NO_VOWELS: string;
@@ -4600,34 +4642,6 @@ declare class Color {
 export {};
 }
 
-// @shell/utils/time
-
-declare module '@shell/utils/time' {
-export function diffFrom(value: any, from: any, t: any): {
-    diff: any;
-    absDiff: number;
-    label: string;
-    unitsKey: string;
-    units: string;
-    next: number;
-};
-export function safeSetTimeout(timeout: any, callback: any, that: any): NodeJS.Timeout;
-export function getSecondsDiff(startDate: any, endDate: any): number;
-/**
- * return { diff: number; label: string }
- *
- * diff:  update frequency in seconds
- * label: content of the cell's column
- */
-export function elapsedTime(seconds: any): {
-    diff?: undefined;
-    label?: undefined;
-} | {
-    diff: number;
-    label: string;
-};
-}
-
 // @shell/utils/units
 
 declare module '@shell/utils/units' {

package/types/store/dashboard-store.types.ts

@@ -1,3 +1,4 @@
+import { KubeLabelSelector } from '@shell/types/kube/kube-api';
 import { PaginationArgs, StorePagination } from '@shell/types/store/pagination.types';
 
 /**
@@ -81,3 +82,18 @@ export interface ActionFindPageArgs extends ActionCoreFindArgs {
    */
   transient?: boolean,
 }
+
+export type ActionFindPageResponse<T = any> = {
+  data: T[],
+  pagination?: StorePagination
+} | T[];
+
+export interface ActionFindMatchingArgs extends ActionCoreFindArgs {
+  labelSelector: KubeLabelSelector,
+  namespaced?: string,
+  depaginate?: boolean
+}
+
+export type ActionFindMatchingResponse<T = any> = ActionFindPageResponse<T>
+
+export type ActionFindLabelSelectorArgs = ActionFindPageArgs | ActionFindMatchingArgs;

package/utils/__tests__/fleet.test.ts

@@ -0,0 +1,148 @@
+import { Target } from '@shell/types/fleet';
+import FleetUtils from '@shell/utils/fleet';
+
+describe('fx: util.getTargetMode', () => {
+  const util = FleetUtils.Application;
+
+  it('should return "all" when targets contain excludeHarvesterRule and namespace is not fleet-local', () => {
+    const targets = [{
+      clusterSelector: {
+        matchExpressions: [{
+          key:      'provider.cattle.io',
+          operator: 'NotIn',
+          values:   ['harvester'],
+        }],
+      },
+    }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('all');
+  });
+
+  it('should return "clusters" when targets include clusterName and clusterSelector', () => {
+    const targets = [{ clusterName: 'fleet-5-france' }, { clusterSelector: { matchLabels: { foo: 'true' } } }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('clusters');
+  });
+
+  it('should return "clusters" when targets only include multiple clusterSelectors', () => {
+    const targets: Target[] = [{ clusterSelector: { matchLabels: { foo: 'true' } } }, { clusterSelector: { matchLabels: { hci: 'true' } } }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('clusters');
+  });
+
+  it('should return "advanced" when a target contains clusterGroupSelector', () => {
+    const targets = [{ clusterGroupSelector: {} }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('advanced');
+  });
+
+  it('should return "advanced" when any target contains clusterGroup or clusterGroupSelector', () => {
+    const targets = [{
+      clusterGroup:         'cg1',
+      clusterGroupSelector: {
+        matchExpressions: [{
+          key:      'string',
+          operator: 'string',
+          values:   ['string']
+        }],
+        matchLabels: { foo: 'bar' }
+      },
+      clusterName:     'pippo',
+      clusterSelector: {
+        matchExpressions: [{
+          key:      'string',
+          operator: 'string',
+          values:   ['vvv']
+        }],
+        matchLabels: { foo: 'bar' }
+      },
+      name: 'tt1',
+    }, {
+      clusterGroup:         'cg2',
+      clusterGroupSelector: {
+        matchExpressions: [{
+          key:      'string',
+          operator: 'string',
+          values:   ['string']
+        }],
+        matchLabels: { foo: 'bar' }
+      },
+      clusterName:     'pippo',
+      clusterSelector: {
+        matchExpressions: [{
+          key:      'string',
+          operator: 'string',
+          values:   ['vvv']
+        }],
+        matchLabels: { foo: 'bar' }
+      },
+      name: 'tt1',
+    }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('advanced');
+  });
+
+  it('should return "none" when targets is an empty array', () => {
+    const targets: Target[] = [];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('none');
+  });
+
+  it('should return "local" when namespace is "fleet-local" regardless of targets', () => {
+    const targets: Target[] = [{ clusterSelector: { matchLabels: { foo: 'true' } } }, { clusterSelector: { matchLabels: { hci: 'true' } } }];
+    const namespace = 'fleet-local';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('local');
+  });
+
+  it('should return "all" if no specific target type (clusterName, clusterSelector, clusterGroup, clusterGroupSelector) is present', () => {
+    const targets = [{ name: 'target1' }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('all');
+  });
+
+  it('should return "clusters" if multiple targets include only clusterName', () => {
+    const targets = [{ clusterName: 'cluster-a' }, { clusterName: 'cluster-b' }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('clusters');
+  });
+
+  it('should return "clusters" if a mix of clusterName and empty clusterSelector is present', () => {
+    const targets = [{ clusterName: 'cluster-c' }, { clusterSelector: {} },
+    ];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('clusters');
+  });
+
+  it('should return "advanced" if one target has clusterGroup but others have clusterName or clusterSelector', () => {
+    const targets = [{ clusterName: 'cluster-x' }, { clusterGroup: 'my-group' }, { clusterSelector: { matchLabels: { env: 'prod' } } }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('advanced');
+  });
+
+  it('should return "all" when targets contain excludeHarvesterRule along with other irrelevant properties', () => {
+    const targets = [{
+      clusterSelector: {
+        matchExpressions: [{
+          key:      'provider.cattle.io',
+          operator: 'NotIn',
+          values:   ['harvester'],
+        }],
+      },
+      name: 'some-other-name'
+    }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('all');
+  });
+});

package/utils/__tests__/object.test.ts

@@ -1,6 +1,6 @@
 import { reactive, isReactive } from 'vue';
 import {
-  clone, get, getter, isEmpty, toDictionary, remove, diff, definedKeys, deepToRaw, mergeWithReplace
+  clone, get, getter, isEmpty, toDictionary, remove, diff, definedKeys, deepToRaw, mergeWithReplace, convertKVToString, convertStringToKV
 } from '@shell/utils/object';
 
 describe('fx: get', () => {
@@ -441,3 +441,56 @@ describe('fx: mergeWithReplace', () => {
     expect(result).toStrictEqual(expected);
   });
 });
+
+describe('fx: convertKVToString', () => {
+  it.each([
+    [{}, ''],
+    [{ foo: 'bar' }, 'foo,bar'],
+    [{ foo: 'bar', baz: 'bang' }, 'foo,bar,baz,bang'],
+    [{ foo: 'bar', baz: null }, 'foo,bar,baz,null'],
+    [{ ' spaced ': ' value ' }, ' spaced , value '], // preserves raw keys/values
+    [{ 0: 42, truthy: true }, '0,42,truthy,true'],
+  ])('should convert %p -> "%s"', (input, expected) => {
+    const result = convertKVToString(input);
+
+    expect(result).toBe(expected);
+  });
+
+  it('should produce a string with an even number of comma-separated parts', () => {
+    const str = convertKVToString({
+      a: 1, b: 2, c: 3
+    });
+    const parts = str.split(',');
+
+    expect(parts.length % 2).toBe(0);
+  });
+});
+
+describe('fx: convertStringToKV', () => {
+  it.each([
+    ['', {}],
+    ['foo,bar', { foo: 'bar' }],
+    ['foo,bar,baz,bang', { foo: 'bar', baz: 'bang' }],
+    ['  foo  ,  bar  ', { foo: 'bar' }], // trims whitespace
+    ['foo,bar,baz', { foo: 'bar' }], // dangling key ignored
+    ['foo,bar,,bang', { foo: 'bar', '': 'bang' }], // empty key retained when present
+  ])('should convert "%s" -> %p', (input, expected) => {
+    const result = convertStringToKV(input);
+
+    expect(result).toStrictEqual(expected);
+  });
+});
+
+describe('fx: convertStringToKV to convertKVToString and back (round-trip)', () => {
+  it.each([
+    '',
+    'foo,bar',
+    'foo,bar,baz,bang',
+    'answer,42,truthy,true,falsy,false',
+  ])('should round-trip %p without loss', (input) => {
+    const asObj = convertStringToKV(input);
+    const backToString = convertKVToString(asObj);
+
+    expect(backToString).toStrictEqual(input);
+  });
+});