dashboard-shell-shell 3.0.2-test.20250913 → 3.0.5-logTest.1

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

@@ -1,9 +1,11 @@
-import { PaginationArgs } from '@shell/types/store/pagination.types';
+import { KubeLabelSelector } from '@shell/types/kube/kube-api';
+import { PaginationArgs, StorePagination } from '@shell/types/store/pagination.types';
 
 /**
  * Properties on all findX actions
  */
 export type ActionCoreFindArgs = {
+  url?: string,
   force?: boolean,
 }
 
@@ -13,7 +15,29 @@ export type ActionCoreFindArgs = {
 export interface ActionFindAllArgs extends ActionCoreFindArgs {
   watch?: boolean,
   namespaced?: string[],
-  incremental?: boolean,
+  /**
+   * Should resources be fetched in increments?
+   */
+  incremental?: {
+    /**
+     * load this amount of info first, to show something quickly
+     *
+     * helpful if resources per increments turns out to be large
+     */
+    quickLoadCount: number,
+    /**
+     * Number of resources to fetch in each increment
+     */
+    resourcesPerIncrement: number,
+    /**
+     * Number of increments to fetch
+     */
+    increments: number,
+    /**
+     * Fetch increments by page size and number (instead of limit and next)
+     */
+    pageByNumber: boolean,
+  },
   hasManualRefresh?: boolean,
   limit?: number,
   /**
@@ -24,6 +48,11 @@ export interface ActionFindAllArgs extends ActionCoreFindArgs {
   depaginate?: boolean,
 }
 
+export interface ActionFindPageTransientResult<T> {
+  pagination: StorePagination,
+  data: T[],
+}
+
 /**
  * Args used for findPage action
  */
@@ -39,8 +68,32 @@ export interface ActionFindPageArgs extends ActionCoreFindArgs {
    */
   namespaced?: string,
   /**
-   * Result of request is transient and not persisted to store
+   * Watch for changes
+   *
+   * false = no, all other values = yes
+   */
+  watch?: boolean,
+  /**
+   * Does this request stem from a list with manual refresh?
    */
-  transient?: boolean,
   hasManualRefresh?: boolean,
+  /**
+   * If true don't persist the http response to the store, just pass it back
+   */
+  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/types/store/pagination.types.ts

@@ -1,4 +1,5 @@
 import { NAMESPACE_FILTER_NS_FULL_PREFIX, NAMESPACE_FILTER_P_FULL_PREFIX } from '@shell/utils/namespace-filter';
+import { KubeLabelSelector } from '@shell/types/kube/kube-api';
 
 // Pagination Typing
 // These structures are designed to offer both convenience and flexibility based on a common structure and are
@@ -63,12 +64,14 @@ export class PaginationFilterField {
   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;
+  value?: string;
   /**
    * Equality field within the object to filter by for example the `=` or `!=` of x=y
    */
-  equals: boolean;
+  equals?: boolean;
   /**
    * Match the field exactly. False for partial matches
    *
@@ -76,18 +79,26 @@ export class PaginationFilterField {
    * Exact: true. "p" no, "pod", no, "pod1" yes
    * Exact: false. "p" yes, "pod", yes, "pod1" yes
    */
-  exact: boolean;
+  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;
 
   constructor(
     {
-      field, value, equals = true, exact = true
+      field, value = '', equals = true, exact = true, exists = false
     }:
-    { field?: string; value: string; equals?: boolean; exact?: boolean;}
+    { field?: string; value?: string; equals?: boolean; exact?: boolean; exists?:boolean;}
   ) {
     this.field = field;
     this.value = value;
     this.equals = equals;
     this.exact = exact;
+    this.exists = exists;
   }
 }
 
@@ -227,7 +238,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 }): PaginationParam {
+  static createSingleField(field: { field?: string; value?: string; equals?: boolean; exact?: boolean, exists?: boolean }): PaginationParam {
     return new PaginationParamFilter({ fields: [new PaginationFilterField(field)] });
   }
 
@@ -304,7 +315,7 @@ export class PaginationArgs {
    */
   sort: PaginationSort[];
   /**
-   * A collection of `filter` params
+   * A collection of traditional `filter` params covering logic such as x is y, x is like y, x is not y
    *
    * For more info see {@link PaginationParamFilter}
    */
@@ -316,6 +327,11 @@ export class PaginationArgs {
    */
   projectsOrNamespaces: PaginationParamProjectOrNamespace[];
 
+  /**
+   * Traditional Kube labelSelector consisting of matchLabels and matchExpressions
+   */
+  labelSelector?: KubeLabelSelector;
+
   /**
    * Creates an instance of PaginationArgs.
    *
@@ -327,6 +343,7 @@ export class PaginationArgs {
     sort = [],
     filters = [],
     projectsOrNamespaces = [],
+    labelSelector = undefined,
   }:
   // This would be neater as just Partial<PaginationArgs> but we lose all jsdoc
   {
@@ -354,6 +371,10 @@ export class PaginationArgs {
      * For definition see {@link PaginationArgs} `projectsOrNamespaces`
      */
     projectsOrNamespaces?: PaginationParamProjectOrNamespace | PaginationParamProjectOrNamespace[],
+    /**
+     * Traditional Kube labelSelector consisting of matchLabels and matchExpressions
+     */
+    labelSelector?: KubeLabelSelector,
   }) {
     this.page = page;
     this.pageSize = pageSize;
@@ -368,6 +389,7 @@ export class PaginationArgs {
     } else {
       this.projectsOrNamespaces = [];
     }
+    this.labelSelector = labelSelector;
   }
 }
 
@@ -386,6 +408,7 @@ export class FilterArgs extends PaginationArgs {
     sort = [],
     filters = [],
     projectsOrNamespaces = [],
+    labelSelector = undefined,
   }:
   // This would be neater as just Partial<PaginationArgs> but we lose all jsdoc
   {
@@ -405,9 +428,13 @@ export class FilterArgs extends PaginationArgs {
      * For definition see {@link PaginationArgs} `projectsOrNamespaces`
      */
     projectsOrNamespaces?: PaginationParamProjectOrNamespace | PaginationParamProjectOrNamespace[],
+    /**
+     * Traditional Kube labelSelector consisting of matchLabels and matchExpressions
+     */
+    labelSelector?: KubeLabelSelector
   }) {
     super({
-      page: null, pageSize: null, sort, filters, projectsOrNamespaces
+      page: null, pageSize: null, sort, filters, projectsOrNamespaces, labelSelector
     });
   }
 }
@@ -434,7 +461,12 @@ export interface StorePaginationRequest {
   /**
    * The set of pagination args used to create the request
    */
-  pagination: PaginationArgs
+  pagination: PaginationArgs,
+
+  /**
+   * Does this request stem from a list with manual refresh?
+   */
+  hasManualRefresh?: boolean,
 }
 
 /**

package/types/store/subscribe.types.ts

@@ -0,0 +1,50 @@
+/* eslint-disable no-unused-vars */
+export enum STEVE_WATCH_MODE {
+  DEFAULT = '',
+  RESOURCE_CHANGES = 'resource.changes'
+}
+/* eslint-enable no-unused-vars */
+
+/* eslint-disable no-unused-vars */
+export enum STEVE_WATCH_EVENT {
+  START = 'resource.start',
+  CREATE = 'resource.create',
+  CHANGE = 'resource.change',
+  CHANGES = 'resource.changes',
+  REMOVE = 'resource.resource.remove',
+  ERROR = 'resource.error',
+  STOP = 'resource.stop',
+}
+/* eslint-enable no-unused-vars */
+
+export interface STEVE_WATCH_PARAMS {
+  type: string,
+  selector?: string,
+  id?: string,
+  revision?: string,
+  namespace?: string,
+  stop?: boolean,
+  force?: boolean,
+  mode?: STEVE_WATCH_MODE
+}
+
+export type STEVE_WATCH_EVENT_LISTENER_CALLBACK = () => void
+export interface STEVE_WATCH_EVENT_LISTENER {
+  params: STEVE_WATCH_PARAMS,
+  callbacks: { [id: string]: STEVE_WATCH_EVENT_LISTENER_CALLBACK},
+}
+
+export interface STEVE_WATCH_EVENT_PARAMS_COMMON {
+  event: STEVE_WATCH_EVENT,
+  id: string,
+  /**
+   * of type @STEVE_WATCH_PARAMS
+   */
+  params: STEVE_WATCH_PARAMS,
+}
+
+export interface STEVE_WATCH_EVENT_PARAMS extends STEVE_WATCH_EVENT_PARAMS_COMMON {
+  callback: STEVE_WATCH_EVENT_LISTENER_CALLBACK,
+}
+
+export type STEVE_UNWATCH_EVENT_PARAMS = STEVE_WATCH_EVENT_PARAMS_COMMON

package/utils/__mocks__/tabbable.js

@@ -0,0 +1,13 @@
+// __mocks__/tabbable.js
+
+const lib = jest.requireActual('tabbable');
+
+const tabbable = {
+  ...lib,
+  tabbable:    (node, options) => lib.tabbable(node, { ...options, displayCheck: 'none' }),
+  focusable:   (node, options) => lib.focusable(node, { ...options, displayCheck: 'none' }),
+  isFocusable: (node, options) => lib.isFocusable(node, { ...options, displayCheck: 'none' }),
+  isTabbable:  (node, options) => lib.isTabbable(node, { ...options, displayCheck: 'none' }),
+};
+
+module.exports = tabbable;

package/utils/__tests__/back-off.test.ts

@@ -0,0 +1,354 @@
+// Import the BackOff instance from your code.
+// Assuming the file is named `backoff.ts` and the default export is the BackOff instance.
+import backOff from '../back-off';
+
+describe('backOff', () => {
+  // Use Jest's fake timers to control `setTimeout`. This is crucial for testing delays.
+  jest.useFakeTimers();
+
+  // Mock console.log to prevent test logs from cluttering the console output.
+  let consoleLogMock: jest.SpyInstance;
+  let consoleErrorMock: jest.SpyInstance;
+
+  beforeEach(() => {
+    // Before each test, reset the BackOff state.
+    backOff.resetAll();
+
+    // Create new mocks for each test to ensure a clean slate.
+    consoleLogMock = jest.spyOn(console, 'log').mockImplementation(() => {});
+    consoleErrorMock = jest.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    // Restore the original console functions after each test.
+    consoleLogMock.mockRestore();
+    consoleErrorMock.mockRestore();
+  });
+
+  // --- Test Suite for `execute` method ---
+
+  it('should execute the function immediately the first time without a delay', async() => {
+    const delayedFn = jest.fn();
+
+    // Call the function for the first time.
+    await backOff.execute({
+      id: 'test1', description: 'Test 1', delayedFn
+    });
+
+    // The function should have been called immediately, since the fake timer hasn't advanced.
+    expect(delayedFn).toHaveBeenCalledTimes(0);
+    expect(backOff.getBackOff('test1')).toBeDefined();
+  });
+
+  it('should back off and delay the second execution', async() => {
+    const delayedFn = jest.fn();
+    const id = 'backoff-test';
+
+    // First call, which should run immediately.
+    await backOff.execute({
+      id, description: 'Backoff Test', delayedFn,
+    });
+
+    jest.advanceTimersByTime(1);
+
+    // Expect the first call to be immediate.
+    expect(delayedFn).toHaveBeenCalledTimes(1);
+
+    // Call it a second time. This should initiate a backoff delay.
+    await backOff.execute({
+      id, description: 'Backoff Test', delayedFn
+    });
+
+    // The function should not have been called a second time yet.
+    expect(delayedFn).toHaveBeenCalledTimes(1);
+
+    // Advance the timer by less than the first backoff delay (250ms).
+    jest.advanceTimersByTime(200);
+    expect(delayedFn).toHaveBeenCalledTimes(1);
+
+    // Now, advance the timer by the required delay to trigger the second call.
+    jest.advanceTimersByTime(50);
+
+    // The function should have been called a second time.
+    await Promise.resolve();
+    expect(delayedFn).toHaveBeenCalledTimes(2);
+
+    // Verify the backoff entry was created correctly.
+    const backOffEntry = backOff.getBackOff(id);
+
+    expect(backOffEntry.try).toBe(2);
+  });
+
+  it('should implement exponential backoff on subsequent calls', async() => {
+    const delayedFn = jest.fn();
+    const id = 'exp-backoff';
+
+    // First call (immediate)
+    await backOff.execute({
+      id, description: 'Exponential Backoff Test', delayedFn
+    });
+
+    jest.advanceTimersByTime(1);
+    expect(delayedFn).toHaveBeenCalledTimes(1);
+
+    // Second call (should have a delay of 1^2 * 250 = 250ms)
+    await backOff.execute({
+      id, description: 'Exponential Backoff Test', delayedFn
+    });
+    jest.advanceTimersByTime(250);
+    await Promise.resolve();
+    expect(delayedFn).toHaveBeenCalledTimes(2);
+
+    // Third call (should have a delay of 2^2 * 250 = 1000ms)
+    await backOff.execute({
+      id, description: 'Exponential Backoff Test', delayedFn
+    });
+    jest.advanceTimersByTime(1000);
+    await Promise.resolve();
+    expect(delayedFn).toHaveBeenCalledTimes(3);
+
+    // Fourth call (should have a delay of 3^2 * 250 = 2250ms)
+    await backOff.execute({
+      id, description: 'Exponential Backoff Test', delayedFn
+    });
+    jest.advanceTimersByTime(2250);
+    await Promise.resolve();
+    expect(delayedFn).toHaveBeenCalledTimes(4);
+  });
+
+  it('should skip execution if a previous backoff process is already running', async() => {
+    const delayedFn = jest.fn();
+    const id = 'skip-test';
+
+    await backOff.execute({
+      id, description: 'Skip Test', delayedFn
+    });
+    expect(delayedFn).toHaveBeenCalledTimes(0);
+
+    // Second call, will be ignored
+    await backOff.execute({
+      id, description: 'Skip Test', delayedFn
+    });
+
+    expect(delayedFn).toHaveBeenCalledTimes(0);
+
+    // We should only have 1 call so far.
+    jest.advanceTimersByTime(1);
+    await Promise.resolve();
+    expect(delayedFn).toHaveBeenCalledTimes(1);
+
+    // A third call while the first is still pending.
+    // This call should be ignored and the delayedFn should not be executed.
+    await backOff.execute({
+      id, description: 'Skip Test', delayedFn
+    });
+
+    expect(delayedFn).toHaveBeenCalledTimes(1);
+
+    jest.advanceTimersByTime(300);
+    await Promise.resolve();
+    expect(delayedFn).toHaveBeenCalledTimes(2);
+
+    // Advance timers to complete the pending second call.
+    jest.advanceTimersByTime(1000);
+    await Promise.resolve();
+    // Now there should be 2 calls, not 3.
+    expect(delayedFn).toHaveBeenCalledTimes(2);
+  });
+
+  it('should not execute if the number of retries is exceeded', async() => {
+    const delayedFn = jest.fn();
+    const id = 'retries-test';
+
+    // Set retries to 2.
+    const retries = 2;
+
+    // Call 1 (immediate)
+    await backOff.execute({
+      id, description: 'Retries Test', retries, delayedFn
+    });
+    jest.advanceTimersByTime(1);
+    await Promise.resolve();
+    expect(delayedFn).toHaveBeenCalledTimes(1);
+
+    // Call 2 (after 250ms delay)
+    await backOff.execute({
+      id, description: 'Retries Test', retries, delayedFn
+    });
+    jest.advanceTimersByTime(250);
+    await Promise.resolve();
+    expect(delayedFn).toHaveBeenCalledTimes(2);
+
+    // Call 3 (should be ignored because it exceeds the `retries` limit of 2)
+    await backOff.execute({
+      id, description: 'Retries Test', retries, delayedFn
+    });
+    jest.advanceTimersByTime(250);
+    await Promise.resolve();
+
+    expect(delayedFn).toHaveBeenCalledTimes(2);
+  });
+
+  it('should skip execution if `canFn` returns false', async() => {
+    const delayedFn = jest.fn();
+    const canFn = jest.fn().mockResolvedValue(false);
+
+    await backOff.execute({
+      id: 'canfn-test', description: 'canFn Test', canFn, delayedFn
+    });
+
+    jest.advanceTimersByTime(250);
+    await Promise.resolve();
+
+    expect(delayedFn).not.toHaveBeenCalled();
+  });
+
+  it('should not clear backoff entry if the delayedFn throws an error', async() => {
+    const id = 'error-test';
+    const delayedFn = jest.fn().mockRejectedValue(new Error('Test Error'));
+
+    // Call the function for the first time.
+    await backOff.execute({
+      id, description: 'Error Test', delayedFn
+    });
+
+    // Wait for the immediate call to finish.
+    jest.advanceTimersByTime(1);
+    await Promise.resolve();
+    await Promise.resolve();
+    await Promise.resolve();
+
+    // The entry should be removed after success/failure.
+    expect(backOff.getBackOff(id).timeoutId).toBeUndefined();
+
+    // Call again to trigger a backoff delay and an error.
+    await backOff.execute({
+      id, description: 'Error Test', delayedFn
+    });
+
+    // Advance timers to trigger the delayed function.
+    jest.advanceTimersByTime(250);
+    await Promise.resolve();
+    await Promise.resolve();
+    await Promise.resolve();
+
+    // The timeoutId should be cleared, but the `try` count should be preserved on the next call.
+    expect(backOff.getBackOff(id).timeoutId).toBeUndefined();
+
+    // Check if the next call will still back off.
+    const newDelayedFn = jest.fn();
+
+    await backOff.execute({
+      id, description: 'Error Test', delayedFn: newDelayedFn
+    });
+    expect(newDelayedFn).not.toHaveBeenCalled(); // The next call should still be delayed
+  });
+
+  it('should save metadata', async() => {
+    const delayedFn = jest.fn();
+    const id = 'exp-backoff';
+    const metadata = { a: true };
+
+    // First call (immediate)
+    await backOff.execute({
+      id, description: 'Exponential Backoff Test', delayedFn, metadata
+    });
+
+    expect(backOff.getBackOff(id)).toBeDefined();
+    expect(backOff.getBackOff(id).metadata).toStrictEqual(metadata);
+  });
+
+  // --- Test Suite for Reset methods ---
+
+  it('should reset a specific backoff process', async() => {
+    const delayedFn = jest.fn();
+    const id = 'reset-test';
+
+    // Start a backoff process.
+    await backOff.execute({
+      id, description: 'Reset Test', delayedFn
+    });
+
+    expect(backOff.getBackOff(id)).toBeDefined();
+
+    // Reset the process.
+    backOff.reset(id);
+
+    // The entry should be deleted from the map.
+    expect(backOff.getBackOff(id)).toBeUndefined();
+
+    // Now, a new execution should not be delayed.
+    await backOff.execute({
+      id, description: 'Reset Test', delayedFn
+    });
+
+    jest.advanceTimersByTime(250);
+    await Promise.resolve();
+    expect(delayedFn).toHaveBeenCalledTimes(1);
+  });
+
+  it('should reset all backoff processes', async() => {
+    const delayedFn1 = jest.fn();
+    const delayedFn2 = jest.fn();
+
+    await backOff.execute({
+      id: 'all-1', description: 'All 1', delayedFn: delayedFn1
+    });
+    await backOff.execute({
+      id: 'all-1', description: 'All 1', delayedFn: delayedFn1
+    });
+
+    await backOff.execute({
+      id: 'all-2', description: 'All 2', delayedFn: delayedFn2
+    });
+    await backOff.execute({
+      id: 'all-2', description: 'All 2', delayedFn: delayedFn2
+    });
+
+    expect(backOff.getBackOff('all-1')).toBeDefined();
+    expect(backOff.getBackOff('all-2')).toBeDefined();
+
+    // Reset all processes.
+    backOff.resetAll();
+
+    expect(backOff.getBackOff('all-1')).toBeUndefined();
+    expect(backOff.getBackOff('all-2')).toBeUndefined();
+  });
+
+  it('should reset only processes with a specific prefix', async() => {
+    const delayedFn = jest.fn();
+
+    await backOff.execute({
+      id: 'prefix-test-1', description: 'Prefix Test 1', delayedFn
+    });
+    await backOff.execute({
+      id: 'prefix-test-1', description: 'Prefix Test 1', delayedFn
+    });
+
+    await backOff.execute({
+      id: 'prefix-test-2', description: 'Prefix Test 2', delayedFn
+    });
+    await backOff.execute({
+      id: 'prefix-test-2', description: 'Prefix Test 2', delayedFn
+    });
+
+    await backOff.execute({
+      id: 'other-test-1', description: 'Other Test 1', delayedFn
+    });
+    await backOff.execute({
+      id: 'other-test-1', description: 'Other Test 1', delayedFn
+    });
+
+    expect(backOff.getBackOff('prefix-test-1')).toBeDefined();
+    expect(backOff.getBackOff('prefix-test-2')).toBeDefined();
+    expect(backOff.getBackOff('other-test-1')).toBeDefined();
+
+    // Reset only the "prefix-test" processes.
+    backOff.resetPrefix('prefix-test');
+
+    expect(backOff.getBackOff('prefix-test-1')).toBeUndefined();
+    expect(backOff.getBackOff('prefix-test-2')).toBeUndefined();
+    // The other process should still exist.
+    expect(backOff.getBackOff('other-test-1')).toBeDefined();
+  });
+});