@rancher/shell 3.0.10 → 3.0.12-rc.1

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

@@ -83,6 +83,11 @@ export interface ActionFindPageArgs extends ActionCoreFindArgs {
 
   saveCountAs?: string,
 
+  /**
+   * When making a supporting HTTP request include associated resource data
+   */
+  includeAssociatedData?: boolean,
+
   /**
    * The target minimum revision for the resource.
    *

package/types/store/pagination.types.ts

@@ -607,6 +607,7 @@ export interface StorePaginationRequest {
    * The single namespace to filter results by (as part of url path, not pagination params)
    */
   namespace?: string,
+
   /**
    * The set of pagination args used to create the request
    */
@@ -616,6 +617,11 @@ export interface StorePaginationRequest {
    * Does this request stem from a list with manual refresh?
    */
   hasManualRefresh?: boolean,
+
+  /**
+   * When making a supporting HTTP request include associated resource data
+   */
+  includeAssociatedData?: boolean,
 }
 
 /**

package/utils/__tests__/require-asset.test.ts

@@ -0,0 +1,98 @@
+import { toContextKey, requireAsset, requireJson, _setContexts } from '@shell/utils/require-asset';
+
+describe('fx: toContextKey', () => {
+  it.each([
+    ['~shell/assets/images/providers/aws.svg', './images/providers/aws.svg'],
+    ['@shell/assets/images/providers/aws.svg', './images/providers/aws.svg'],
+    ['~shell/assets/brand/suse/metadata.json', './brand/suse/metadata.json'],
+    ['@shell/assets/images/pl/dark/logo.svg', './images/pl/dark/logo.svg'],
+  ])('should convert %s to %s', (input, expected) => {
+    expect(toContextKey(input)).toStrictEqual(expected);
+  });
+
+  it('should prepend ./ to paths without shell prefix', () => {
+    expect(toContextKey('images/providers/aws.svg')).toStrictEqual('./images/providers/aws.svg');
+  });
+});
+
+describe('fx: requireAsset', () => {
+  afterEach(() => {
+    _setContexts(null, null);
+  });
+
+  it('should return the resolved asset URL from the image context', () => {
+    const mockImgCtx = jest.fn().mockReturnValue('/static/images/aws.svg');
+
+    _setContexts(mockImgCtx, null);
+
+    const result = requireAsset('~shell/assets/images/providers/aws.svg');
+
+    expect(result).toStrictEqual('/static/images/aws.svg');
+    expect(mockImgCtx).toHaveBeenCalledWith('./images/providers/aws.svg');
+  });
+
+  it('should throw when the image context is not available', () => {
+    _setContexts(null, null);
+
+    expect(() => requireAsset('~shell/assets/images/foo.svg'))
+      .toThrow('Asset context not available for: ~shell/assets/images/foo.svg');
+  });
+
+  it('should propagate errors from the context function for missing assets', () => {
+    const mockImgCtx = jest.fn().mockImplementation(() => {
+      throw new Error('Cannot find module');
+    });
+
+    _setContexts(mockImgCtx, null);
+
+    expect(() => requireAsset('~shell/assets/images/missing.svg'))
+      .toThrow('Cannot find module');
+  });
+});
+
+describe('fx: requireJson', () => {
+  afterEach(() => {
+    _setContexts(null, null);
+  });
+
+  it('should return mod.default when available', () => {
+    const jsonData = { vendor: 'suse' };
+    const mockJsonCtx = jest.fn().mockReturnValue({ default: jsonData });
+
+    _setContexts(null, mockJsonCtx);
+
+    const result = requireJson('~shell/assets/brand/suse/metadata.json');
+
+    expect(result).toStrictEqual(jsonData);
+    expect(mockJsonCtx).toHaveBeenCalledWith('./brand/suse/metadata.json');
+  });
+
+  it('should return mod directly when no default export', () => {
+    const jsonData = { vendor: 'rancher' };
+    const mockJsonCtx = jest.fn().mockReturnValue(jsonData);
+
+    _setContexts(null, mockJsonCtx);
+
+    const result = requireJson('~shell/assets/brand/rancher/metadata.json');
+
+    expect(result).toStrictEqual(jsonData);
+  });
+
+  it('should throw when the JSON context is not available', () => {
+    _setContexts(null, null);
+
+    expect(() => requireJson('~shell/assets/brand/suse/metadata.json'))
+      .toThrow('JSON context not available for: ~shell/assets/brand/suse/metadata.json');
+  });
+
+  it('should propagate errors from the context function for missing files', () => {
+    const mockJsonCtx = jest.fn().mockImplementation(() => {
+      throw new Error('Cannot find module');
+    });
+
+    _setContexts(null, mockJsonCtx);
+
+    expect(() => requireJson('~shell/assets/brand/missing/metadata.json'))
+      .toThrow('Cannot find module');
+  });
+});

package/utils/async.ts

@@ -10,11 +10,7 @@ export const waitFor = (testFn: Function, msg = '', timeoutMs = 3000000, interva
       gatedLog('Wait for', msg, 'timed out');
       clearInterval(interval);
       clearTimeout(timeout);
-      if (msg) {
-        reject(new Error(`Failed waiting for: ${ msg }`));
-      } else {
-        throw new Error(`waitFor timed out after ${ timeoutMs / 1000 } seconds`);
-      }
+      reject(new Error(msg ? `Failed waiting for: ${ msg }` : `waitFor timed out after ${ timeoutMs / 1000 } seconds`));
     }, timeoutMs);
     const interval = setInterval(() => {
       if ( testFn() ) {

package/utils/axios.js

@@ -1,5 +1,5 @@
 import Axios from 'axios';
-import defu from 'defu';
+
 import axiosRetry from 'axios-retry';
 
 // Axios.prototype cannot be modified
@@ -37,9 +37,6 @@ const axiosExtra = {
   onError(fn) {
     this.onRequestError(fn);
     this.onResponseError(fn);
-  },
-  create(options) {
-    return createAxiosInstance(defu(options, this.defaults));
   }
 };
 

package/utils/brand.ts

@@ -1,3 +1,5 @@
+import { requireJson } from '@shell/utils/require-asset';
+
 /**
  * Brand/Theme metadata
  */
@@ -21,7 +23,7 @@ export function getBrandMeta(brand: string): BrandMeta {
 
   if (brand) {
     try {
-      brandMeta = require(`~shell/assets/brand/${ brand }/metadata.json`);
+      brandMeta = requireJson(`~shell/assets/brand/${ brand }/metadata.json`) as BrandMeta;
     } catch {}
   }
 

package/utils/dynamic-importer.js

@@ -94,8 +94,9 @@ export function loadProduct(name) {
 }
 
 export function listProducts() {
-  const ctx = require.context('@shell/config/product', true, /.*/);
-  const products = ctx.keys().filter(path => !path.endsWith('.js') && path.startsWith('./')).map(path => path.substr(2));
+  // We just want the .js or .ts files
+  const ctx = require.context('@shell/config/product', true, /\.\/.*\.[js|ts]/);
+  const products = ctx.keys().map(path => path.substr(2)).map(path => path.slice(0, -3));
 
   return products;
 }

package/utils/favicon.js

@@ -1,5 +1,6 @@
 import { SETTING } from '@shell/config/settings';
 import { MANAGEMENT } from '@shell/config/types';
+import { requireAsset } from '@shell/utils/require-asset';
 
 let favIconSet = false;
 
@@ -16,11 +17,11 @@ export function setFavIcon(store) {
     let brandImage;
 
     if (brandSetting === 'suse') {
-      brandImage = require('~shell/assets/brand/suse/favicon.png');
+      brandImage = requireAsset('~shell/assets/brand/suse/favicon.png');
     } else if (brandSetting === 'csp') {
-      brandImage = require('~shell/assets/brand/csp/favicon.png');
+      brandImage = requireAsset('~shell/assets/brand/csp/favicon.png');
     } else if (brandSetting === 'harvester') {
-      brandImage = require('~shell/assets/brand/harvester/favicon.png');
+      brandImage = requireAsset('~shell/assets/brand/harvester/favicon.png');
     }
 
     link.href = res?.value || brandImage || defaultFavIcon;

package/utils/pagination-utils.ts

@@ -299,7 +299,7 @@ class PaginationUtils {
     return isEqual(aPrimitiveTypes, bPrimitiveTypes) &&
       this.paginationFiltersEqual(aFilter, bFilter) &&
       this.paginationFiltersEqual(aPN, bPN) &&
-      sameArrayObjects<PaginationSort>(aSort, bSort, true);
+      sameArrayObjects<PaginationSort>(aSort, bSort, false);
   }
 }
 

package/utils/require-asset.ts

@@ -0,0 +1,95 @@
+/**
+ * Utility to replace dynamic require() calls for image/asset imports.
+ *
+ * Uses webpack's require.context to resolve assets at compile time,
+ * then provides lookup functions by path.
+ *
+ * When migrating to Vite, replace the require.context calls below with:
+ *
+ *   const imgCtx = import.meta.glob(
+ *     '@shell/assets/**\/*.{svg,png,jpg,jpeg,gif,ico,webp}',
+ *     { eager: true, query: '?url', import: 'default' }
+ *   );
+ *
+ *   const jsonCtx = import.meta.glob(
+ *     '@shell/assets/**\/*.json',
+ *     { eager: true }
+ *   );
+ */
+
+// --- Webpack: require.context type declarations ---
+
+interface WebpackRequireContext {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  (key: string): any;
+  keys(): string[];
+  resolve(key: string): string;
+  id: string;
+}
+
+// --- Webpack: require.context (compile-time transform) ---
+
+let imgCtx: WebpackRequireContext | null = null;
+let jsonCtx: WebpackRequireContext | null = null;
+
+try {
+  // @ts-expect-error — require.context is a webpack compile-time transform, not visible to TypeScript
+  imgCtx = require.context('@shell/assets', true, /\.(svg|png|jpe?g|gif|ico|webp)$/);
+} catch (e) {}
+
+try {
+  // @ts-expect-error — require.context is a webpack compile-time transform, not visible to TypeScript
+  jsonCtx = require.context('@shell/assets', true, /\.json$/);
+} catch (e) {}
+
+/**
+ * Convert an asset path to a require.context key.
+ *
+ * Input:  '~shell/assets/images/providers/aws.svg' or '@shell/assets/images/providers/aws.svg'
+ * Output: './images/providers/aws.svg'
+ */
+export function toContextKey(path: string): string {
+  return `./${ path.replace(/^[~@]shell\/assets\//, '') }`;
+}
+
+/**
+ * Look up an image asset URL by path, similar to Webpack's require() for images.
+ *
+ * Accepts paths with ~shell/ or @shell/ prefix.
+ * Throws if the asset is not found (matching the original require() behavior),
+ * so callers can use try/catch for fallback logic.
+ */
+export function requireAsset(path: string): string {
+  if (!imgCtx) {
+    // Throw to match original require() behavior — callers rely on try/catch for fallback logic
+    throw new Error(`Asset context not available for: ${ path }`);
+  }
+
+  const key = toContextKey(path);
+
+  return imgCtx(key);
+}
+
+/**
+ * Load a JSON file from @shell/assets.
+ *
+ * Throws if the JSON file is not found (matching the original require() behavior),
+ * so callers can use try/catch for fallback logic.
+ */
+export function requireJson(path: string): object {
+  if (!jsonCtx) {
+    // Throw to match original require() behavior — callers rely on try/catch for fallback logic
+    throw new Error(`JSON context not available for: ${ path }`);
+  }
+
+  const key = toContextKey(path);
+  const mod = jsonCtx(key);
+
+  return mod.default || mod;
+}
+
+// Exported for testing — allows injecting mock contexts
+export function _setContexts(img: WebpackRequireContext | null, json: WebpackRequireContext | null): void {
+  imgCtx = img;
+  jsonCtx = json;
+}

package/utils/uiplugins.ts

@@ -5,14 +5,15 @@ import { UI_PLUGIN_BASE_URL, isSupportedChartVersion, UI_PLUGIN_LABELS } from '@
 import { Plugin, Version } from '@shell/types/uiplugins';
 
 const MAX_RETRIES = 10;
-const RETRY_WAIT = 2500;
+const RETRY_WAIT = 2500; // 2.5 seconds
+const ACTIVE_STATUS_TIMEOUT = 200000; // 20 seconds
 
 type Action = 'install' | 'upgrade';
 export type HelmRepository = any;
 export type HelmChart = any;
 
 /**
- *
+ * Get the latest compatible version of a Helm Chart extension
  * @param store Vue store
  * @param chartName The chartName
  * @param rancherVersion Rancher version
@@ -68,8 +69,8 @@ export async function waitForUIExtension(store: any, name: string, maxRetries =
         return extension;
       }
     } catch (e) {
+      console.error('waiting for UI extension to be available: error =', e); // eslint-disable-line no-console
     }
-
     tries++;
 
     if (tries > maxRetries) {
@@ -106,7 +107,6 @@ export async function waitForUIPackage(store: any, extension: any, maxRetries =
       return true;
     } catch (error) {
     }
-
     tries++;
 
     if (tries > maxRetries) {
@@ -199,7 +199,7 @@ export async function getHelmRepositoryMatch(store: any, urlRegexes: string[], c
 }
 
 /**
- *
+ * Get a Helm Repository matching the given criteria.
  * @param store Vue store
  * @param matchFn Match function for repository's urls
  * @returns HelmRepository
@@ -225,15 +225,15 @@ export async function refreshHelmRepository(store: any, url: string): Promise<vo
   const now = (new Date()).toISOString().replace(/\.\d+Z$/, 'Z');
 
   repository.spec.forceUpdate = now;
-
   await repository.save();
 
-  await repository.waitForState('active', 10000, 1000);
+  await repository.waitForState('active', ACTIVE_STATUS_TIMEOUT, RETRY_WAIT);
 
   await new Promise((resolve) => setTimeout(resolve, 2000));
 }
 
 /**
+ * Create a Helm Repository and wait for it to be downloaded
  *
  * @param store Vue store
  * @param name Repository name
@@ -260,7 +260,7 @@ export async function createHelmRepository(store: any, name: string, url: string
 
   const helmRepo = await repo.save();
 
-  // Poll the repository until it says it has been downloaded
+  // Poll the repository status MAX_RETRIES times until it has been downloaded
   let fetched = false;
   let tries = 0;
 
@@ -275,23 +275,19 @@ export async function createHelmRepository(store: any, name: string, url: string
 
     const downloaded = repo.status.conditions.find((s: any) => s.type === 'Downloaded');
 
-    if (downloaded) {
-      if (downloaded.status === 'True') {
-        fetched = true;
-      }
+    console.log(`Waiting for helm repository to be downloaded... try ${ tries } time(s).`); // eslint-disable-line no-console
+
+    if (downloaded && downloaded.status === 'True') {
+      fetched = true;
     }
 
     if (!fetched) {
-      tries++;
-
       if (tries > MAX_RETRIES) {
         throw new Error('Failed to add Helm Chart Repository');
       }
 
       await new Promise((resolve) => setTimeout(resolve, RETRY_WAIT));
     }
-
-    fetched = true;
   }
 
   // Return the Helm Repository

package/utils/validators/__tests__/private-registry.test.ts

@@ -0,0 +1,76 @@
+import { privateRegistryRequired } from '@shell/utils/validators/private-registry';
+
+const makeCtx = (overrides: any = {}) => ({
+  t:                      jest.fn((key: string, params?: any) => (params ? `${ key }:${ JSON.stringify(params) }` : key)),
+  privateRegistryEnabled: false,
+  normanCluster:          { importedConfig: { privateRegistryURL: null } },
+  isImportedCluster:      true,
+  ...overrides,
+});
+
+describe('privateRegistryRequired', () => {
+  it('should return undefined when the cluster is not imported', () => {
+    const ctx = makeCtx({ isImportedCluster: false, privateRegistryEnabled: true });
+    const rule = privateRegistryRequired(ctx);
+
+    expect(rule()).toBeUndefined();
+  });
+
+  it('should default isImportedCluster to true when the property is absent from the context', () => {
+    const ctx: any = {
+      t:                      jest.fn((key: string, params?: any) => (params ? `${ key }:${ JSON.stringify(params) }` : key)),
+      privateRegistryEnabled: true,
+      normanCluster:          { importedConfig: { privateRegistryURL: null } },
+    };
+    const rule = privateRegistryRequired(ctx);
+
+    expect(rule()).toStrictEqual('validation.required:{"key":"cluster.privateRegistry.label"}');
+  });
+
+  it('should return undefined when the registry toggle is off', () => {
+    const ctx = makeCtx({ privateRegistryEnabled: false });
+    const rule = privateRegistryRequired(ctx);
+
+    expect(rule()).toBeUndefined();
+  });
+
+  it('should return a required error when enabled but the url is empty', () => {
+    const ctx = makeCtx({
+      privateRegistryEnabled: true,
+      normanCluster:          { importedConfig: { privateRegistryURL: '' } },
+    });
+    const rule = privateRegistryRequired(ctx);
+
+    expect(rule()).toStrictEqual('validation.required:{"key":"cluster.privateRegistry.label"}');
+  });
+
+  it('should return a required error when normanCluster.importedConfig is missing', () => {
+    const ctx = makeCtx({
+      privateRegistryEnabled: true,
+      normanCluster:          {},
+    });
+    const rule = privateRegistryRequired(ctx);
+
+    expect(rule()).toStrictEqual('validation.required:{"key":"cluster.privateRegistry.label"}');
+  });
+
+  it('should return a format error when enabled and the url is malformed', () => {
+    const ctx = makeCtx({
+      privateRegistryEnabled: true,
+      normanCluster:          { importedConfig: { privateRegistryURL: 'goober' } },
+    });
+    const rule = privateRegistryRequired(ctx);
+
+    expect(rule()).toStrictEqual('cluster.privateRegistry.privateRegistryUrlError');
+  });
+
+  it('should return undefined when enabled and the url is valid', () => {
+    const ctx = makeCtx({
+      privateRegistryEnabled: true,
+      normanCluster:          { importedConfig: { privateRegistryURL: 'registry.io:5000' } },
+    });
+    const rule = privateRegistryRequired(ctx);
+
+    expect(rule()).toBeUndefined();
+  });
+});

package/utils/validators/private-registry.ts

@@ -0,0 +1,28 @@
+import { Translation } from '@shell/types/t';
+import formRulesGenerator from '@shell/utils/validators/formRules';
+
+interface PrivateRegistryRuleContext {
+  t: Translation;
+  privateRegistryEnabled: boolean;
+  normanCluster: { importedConfig?: { privateRegistryURL?: string | null } } | null;
+  isImportedCluster?: boolean;
+}
+
+export function privateRegistryRequired(ctx: PrivateRegistryRuleContext) {
+  return () => {
+    // Check existence using `in` rather than direct access to avoid Vue's render-time warning
+    const isImported = 'isImportedCluster' in ctx ? !!ctx.isImportedCluster : true;
+
+    if (!isImported || !ctx.privateRegistryEnabled) {
+      return undefined;
+    }
+    const url = ctx.normanCluster?.importedConfig?.privateRegistryURL;
+
+    if (!url) {
+      return ctx.t('validation.required', { key: ctx.t('cluster.privateRegistry.label') });
+    }
+    const { registryUrl } = formRulesGenerator(ctx.t, { key: ctx.t('cluster.privateRegistry.label') });
+
+    return (registryUrl as (val: string) => string | undefined)(url);
+  };
+}

package/vue.config.js

@@ -143,7 +143,7 @@ const instrumentCode = (config) => {
   }
 };
 
-const getLoaders = (SHELL_ABS) => [
+const getLoaders = (SHELL_ABS, dir) => [
   // no fallback for pre-2013 browsers https://caniuse.com/webworkers
   {
     test:    /web-worker.[a-z-]+.js/i,
@@ -199,7 +199,8 @@ const getLoaders = (SHELL_ABS) => [
           appendTsxSuffixTo: [
             '\\.vue$'
           ],
-          configFile: path.join(SHELL_ABS, 'tsconfig.json')
+          configFile:      path.join(SHELL_ABS, 'tsconfig.json'),
+          compilerOptions: { rootDir: dir }
         }
       }
     ]
@@ -580,7 +581,7 @@ module.exports = function(dir, appConfig = {}) {
 
       config.resolve.symlinks = false;
       processShellFiles(config, SHELL_ABS);
-      config.module.rules.push(...getLoaders(SHELL_ABS));
+      config.module.rules.push(...getLoaders(SHELL_ABS, dir));
       instrumentCode(config);
       preserveWhitespace(config);
     },