@rancher/shell 3.0.6 → 3.0.7

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

@@ -0,0 +1,70 @@
+import { STEVE_WATCH_EVENT_TYPES, STEVE_WATCH_EVENT_TYPES_NAMES, STEVE_WATCH_PARAMS } from '@shell/types/store/subscribe.types';
+
+/**
+ * Common params used when a watcher adds or removes a listener to a watch
+ */
+export interface STEVE_WATCH_EVENT_PARAMS_COMMON {
+  event: STEVE_WATCH_EVENT_TYPES,
+  id: string,
+  /**
+   * of type @STEVE_WATCH_PARAMS
+   */
+  params: STEVE_WATCH_PARAMS,
+}
+
+/**
+ * Executes when a watch event has a listener and it's triggered
+ */
+export type STEVE_WATCH_EVENT_LISTENER_CALLBACK = () => void
+
+/**
+ * Common params used when a watcher adds a listener to a watch
+ */
+export interface STEVE_WATCH_EVENT_PARAMS extends STEVE_WATCH_EVENT_PARAMS_COMMON {
+  callback: STEVE_WATCH_EVENT_LISTENER_CALLBACK,
+}
+
+/**
+ * Common params used when a watcher removes a listener from a watch
+ */
+export type STEVE_UNWATCH_EVENT_PARAMS = STEVE_WATCH_EVENT_PARAMS_COMMON
+
+/**
+ * Common properties for identifying a subscribe watcher
+ */
+export interface SubscribeEventWatchArgs {
+  params: STEVE_WATCH_PARAMS,
+}
+
+/**
+ * Common properties for identifying a subscribe watcher's listeners
+ */
+export interface SubscribeEventListenerArgs extends SubscribeEventWatchArgs {
+  event: STEVE_WATCH_EVENT_TYPES_NAMES,
+}
+
+/**
+ * Common properties for identifying a subscribe watcher's listener
+ */
+export interface SubscribeEventCallbackArgs extends SubscribeEventListenerArgs {
+  id: string,
+}
+
+/**
+ * Represents a subscribe watcher listener
+ */
+export interface SubscribeEventListener {
+  event: STEVE_WATCH_EVENT_TYPES_NAMES,
+  callbacks: { [id: string]: STEVE_WATCH_EVENT_LISTENER_CALLBACK},
+}
+
+/**
+ * Represents a subscribe watcher
+ */
+export type SubscribeEventWatch = {
+  /**
+   * is there a standard non-listener watch for this type (i.e. vanilla watch)
+   */
+  hasStandardWatch: boolean,
+  listeners: SubscribeEventListener[],
+}

package/types/store/subscribe.types.ts

@@ -6,7 +6,7 @@ export enum STEVE_WATCH_MODE {
 /* eslint-enable no-unused-vars */
 
 /* eslint-disable no-unused-vars */
-export enum STEVE_WATCH_EVENT {
+export enum STEVE_WATCH_EVENT_TYPES {
   START = 'resource.start',
   CREATE = 'resource.create',
   CHANGE = 'resource.change',
@@ -17,6 +17,11 @@ export enum STEVE_WATCH_EVENT {
 }
 /* eslint-enable no-unused-vars */
 
+export type STEVE_WATCH_EVENT_TYPES_NAMES = `${ STEVE_WATCH_EVENT_TYPES }`;
+
+/**
+ * The content of the web socket messages sent (and partially received back from) steve
+ */
 export interface STEVE_WATCH_PARAMS {
   type: string,
   selector?: string,
@@ -27,24 +32,3 @@ export interface STEVE_WATCH_PARAMS {
   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/pagination-utils.ts

@@ -1,4 +1,4 @@
-import { PaginationFeature, PaginationSettings, PaginationSettingsStore } from '@shell/types/resources/settings';
+import { PaginationFeature, PaginationSettings, PaginationSettingsStore, PaginationSettingsStores } from '@shell/types/resources/settings';
 import {
   NAMESPACE_FILTER_ALL_USER as ALL_USER,
   NAMESPACE_FILTER_ALL as ALL,
@@ -16,6 +16,10 @@ import { STEVE_CACHE } from '@shell/store/features';
 import { getPerformanceSetting } from '@shell/utils/settings';
 import { PAGINATION_SETTINGS_STORE_DEFAULTS } from '@shell/plugins/steve/steve-pagination-utils';
 import { MANAGEMENT } from '@shell/config/types';
+import { VuexStore } from '@shell/types/store/vuex';
+import { ServerSidePaginationExtensionConfig } from '@shell/core/types';
+import { EXT_IDS } from '@shell/core/plugin';
+import { ExtensionManager } from '@shell/types/extension-manager';
 import { DEFAULT_PERF_SETTING } from '@shell/config/settings';
 
 /**
@@ -39,9 +43,9 @@ class PaginationUtils {
     return perf.serverPagination;
   }
 
-  public getStoreSettings(ctx: any): PaginationSettingsStore
-  public getStoreSettings(serverPagination: PaginationSettings): PaginationSettingsStore
-  public getStoreSettings(arg: any | PaginationSettings): PaginationSettingsStore {
+  public getStoreSettings(ctx: any): PaginationSettingsStores
+  public getStoreSettings(serverPagination: PaginationSettings): PaginationSettingsStores
+  public getStoreSettings(arg: any | PaginationSettings): PaginationSettingsStores {
     const serverPagination: PaginationSettings = arg?.rootGetters !== undefined ? this.getSettings(arg) : arg;
 
     // Ensure we use the current default store settings if
@@ -55,7 +59,7 @@ class PaginationUtils {
     return serverPagination?.stores || this.getStoreDefault();
   }
 
-  public getStoreDefault(): PaginationSettingsStore {
+  public getStoreDefault(): PaginationSettingsStores {
     return PAGINATION_SETTINGS_STORE_DEFAULTS;
   }
 
@@ -82,28 +86,17 @@ class PaginationUtils {
   }
 
   /**
-   * Is pagination enabled at a global level or for a specific resource
+   * Helper - check if a specific resource in a specific store is enabled given the provided settings
    */
-  isEnabled({ rootGetters }: any, enabledFor: PaginationResourceContext) {
-    // Cache must be enabled to support pagination api
-    if (!this.isSteveCacheEnabled({ rootGetters })) {
-      return false;
-    }
-
-    const settings = this.getSettings({ rootGetters });
-
-    // No setting, not enabled
-    if (!settings) {
-      return false;
-    }
-
-    // Missing required params, not enabled
-    if (!enabledFor) {
-      return false;
-    }
-
-    const storeSettings = this.getStoreSettings(settings)?.[enabledFor.store];
-
+  private isEnabledInStore({
+    ctx: { rootGetters },
+    storeSettings,
+    enabledFor
+  }: {
+    ctx: Partial<VuexStore>,
+    storeSettings: PaginationSettingsStore,
+    enabledFor: PaginationResourceContext
+  }): boolean {
     // No pagination setting for target store, not enabled
     if (!storeSettings) {
       return false;
@@ -130,16 +123,19 @@ class PaginationUtils {
       !rootGetters['type-map/configuredPaginationHeaders'](enabledFor.resource.id) &&
       !rootGetters['type-map/hasCustomList'](enabledFor.resource.id);
 
-    if (storeSettings.resources.enableSome.generic && isGeneric) {
+    // Store says generic resource with no custom pagination settings are supported
+    if (storeSettings.resources.enableSome?.generic && isGeneric) {
       return true;
     }
 
-    if (storeSettings.resources.enableSome.enabled.find((setting) => {
+    // Store says some specific resources are enabled
+    if (storeSettings.resources.enableSome?.enabled?.find((setting) => {
       if (typeof setting === 'string') {
         return setting === enabledFor.resource?.id;
       }
 
       if (setting.resource === enabledFor.resource?.id) {
+        // Store says only specific usages of this resource are enabled
         if (!!setting.context) {
           return enabledFor.resource?.context ? setting.context.includes(enabledFor.resource.context) : false;
         }
@@ -155,6 +151,69 @@ class PaginationUtils {
     return false;
   }
 
+  /**
+   * Is pagination enabled at a global level or for a specific resource
+   */
+  isEnabled({ rootGetters, $plugin }: any, enabledFor: PaginationResourceContext) {
+    // Cache must be enabled to support pagination api
+    if (!this.isSteveCacheEnabled({ rootGetters })) {
+      return false;
+    }
+
+    const settings = this.getSettings({ rootGetters });
+
+    // No setting, not enabled
+    if (!settings) {
+      return false;
+    }
+
+    // Missing required params, not enabled
+    if (!enabledFor) {
+      return false;
+    }
+
+    // Does an extension say this type is enabled?
+    const plugin = $plugin as ExtensionManager;
+    const paginationExtensionPoints = plugin.getAll()[EXT_IDS.SERVER_SIDE_PAGINATION_RESOURCES];
+
+    if (paginationExtensionPoints) {
+      const allowed = Object.entries(paginationExtensionPoints).find(([_, settingsFn]) => {
+        if (!settingsFn) {
+          return false;
+        }
+
+        const settings: ServerSidePaginationExtensionConfig = settingsFn();
+        const allowed = Object.entries(settings).find(([store, settings]) => {
+          if (store !== enabledFor.store) {
+            return false;
+          }
+
+          return this.isEnabledInStore({
+            ctx:           { rootGetters },
+            storeSettings: settings,
+            enabledFor
+          });
+        });
+
+        if (allowed) {
+          return true;
+        }
+      });
+
+      if (allowed) {
+        return true;
+      }
+    }
+
+    const storeSettings = this.getStoreSettings(settings)?.[enabledFor.store];
+
+    return this.isEnabledInStore({
+      ctx: { rootGetters },
+      storeSettings,
+      enabledFor
+    });
+  }
+
   listAutoRefreshToggleEnabled({ rootGetters }: any): boolean {
     return this.isFeatureEnabled({ rootGetters }, 'listAutoRefreshToggle');
   }

package/utils/pagination-wrapper.ts

@@ -2,10 +2,9 @@ import paginationUtils from '@shell/utils/pagination-utils';
 import { PaginationArgs, PaginationResourceContext } from '@shell/types/store/pagination.types';
 import { VuexStore } from '@shell/types/store/vuex';
 import { ActionFindPageArgs, ActionFindPageTransientResult } from '@shell/types/store/dashboard-store.types';
-import {
-  STEVE_WATCH_EVENT_LISTENER_CALLBACK, STEVE_UNWATCH_EVENT_PARAMS, STEVE_WATCH_EVENT, STEVE_WATCH_EVENT_PARAMS, STEVE_WATCH_EVENT_PARAMS_COMMON, STEVE_WATCH_MODE
-} from '@shell/types/store/subscribe.types';
+import { STEVE_WATCH_EVENT_TYPES, STEVE_WATCH_MODE } from '@shell/types/store/subscribe.types';
 import { Reactive, reactive } from 'vue';
+import { STEVE_UNWATCH_EVENT_PARAMS, STEVE_WATCH_EVENT_LISTENER_CALLBACK, STEVE_WATCH_EVENT_PARAMS, STEVE_WATCH_EVENT_PARAMS_COMMON } from '@shell/types/store/subscribe-events.types';
 
 interface Args {
   $store: VuexStore,
@@ -70,7 +69,7 @@ class PaginationWrapper<T extends object> {
     this.classify = formatResponse?.classify || false;
     this.reactive = formatResponse?.reactive || false;
 
-    this.isEnabled = paginationUtils.isEnabled({ rootGetters: $store.getters }, enabledFor);
+    this.isEnabled = paginationUtils.isEnabled({ rootGetters: $store.getters, $plugin: this.$store.$plugin }, enabledFor);
   }
 
   async request(args: {
@@ -92,7 +91,7 @@ class PaginationWrapper<T extends object> {
     // Watch
     if (this.onChange && !this.steveWatchParams) {
       this.steveWatchParams = {
-        event:  STEVE_WATCH_EVENT.CHANGES,
+        event:  STEVE_WATCH_EVENT_TYPES.CHANGES,
         id:     this.id,
         params: {
           type: this.enabledFor.resource?.id as string,
@@ -126,7 +125,7 @@ class PaginationWrapper<T extends object> {
     }
     const watchParams: STEVE_WATCH_EVENT_PARAMS = {
       ...this.steveWatchParams,
-      callback: this.onChange as STEVE_WATCH_EVENT_LISTENER_CALLBACK, // we must have it by now
+      callback: this.onChange as STEVE_WATCH_EVENT_LISTENER_CALLBACK, // we must have onChange by now
     };
 
     await this.$store.dispatch(`${ this.enabledFor.store }/watchEvent`, watchParams);
@@ -134,8 +133,7 @@ class PaginationWrapper<T extends object> {
 
   private async unWatch() {
     if (!this.steveWatchParams) {
-      console.error('Calling unWatch but no watch params created'); // eslint-disable-line no-console
-
+      // We're unwatching before we've made the initial request
       return;
     }
 

package/utils/sort.js

@@ -169,6 +169,11 @@ export function compare(a, b) {
   return 0;
 }
 
+/**
+ * Should the logic of this sort field be flipped?
+ *
+ * For instance show descending but sort by ascending
+ */
 export function parseField(str) {
   const parts = str.split(/:/);
 

package/utils/unit-tests/pagination-utils.spec.ts

@@ -0,0 +1,283 @@
+import { STEVE_CACHE } from '@shell/store/features';
+import { SETTING } from '@shell/config/settings';
+import { EXT_IDS } from '@shell/core/plugin';
+import { PaginationResourceContext } from '@shell/types/store/pagination.types';
+import { PaginationSettings, PaginationSettingsStore } from '@shell/types/resources/settings';
+import paginationUtils from '@shell/utils/pagination-utils';
+
+describe('pagination-utils', () => {
+  describe('isEnabledInStore', () => {
+    const mockRootGetters = {
+      'type-map/configuredHeaders':           jest.fn(),
+      'type-map/configuredPaginationHeaders': jest.fn(),
+      'type-map/hasCustomList':               jest.fn(),
+    };
+
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+
+    it('should return false if no store settings are provided', () => {
+      const result = paginationUtils.isEnabledInStore({
+        ctx:           { rootGetters: mockRootGetters },
+        storeSettings: undefined as unknown as PaginationSettingsStore,
+        enabledFor:    { store: 'cluster' }
+      });
+
+      expect(result).toBe(false);
+    });
+
+    it('should return true if no specific resource is being checked', () => {
+      const storeSettings: PaginationSettingsStore = { resources: {} };
+      const result = paginationUtils.isEnabledInStore({
+        ctx:        { rootGetters: mockRootGetters },
+        storeSettings,
+        enabledFor: { store: 'cluster' }
+      });
+
+      expect(result).toBe(true);
+    });
+
+    it('should return true if enableAll is true for the store', () => {
+      const storeSettings: PaginationSettingsStore = { resources: { enableAll: true } };
+      const result = paginationUtils.isEnabledInStore({
+        ctx:        { rootGetters: mockRootGetters },
+        storeSettings,
+        enabledFor: { store: 'cluster', resource: { id: 'pod' } }
+      });
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false if a resource is checked but has no id', () => {
+      const storeSettings: PaginationSettingsStore = { resources: {} };
+      const result = paginationUtils.isEnabledInStore({
+        ctx:        { rootGetters: mockRootGetters },
+        storeSettings,
+        enabledFor: { store: 'cluster', resource: { id: undefined as unknown as string } }
+      });
+
+      expect(result).toBe(false);
+    });
+
+    it('should return true for a generic resource when generic is enabled', () => {
+      mockRootGetters['type-map/configuredHeaders'].mockReturnValue(false);
+      mockRootGetters['type-map/configuredPaginationHeaders'].mockReturnValue(false);
+      mockRootGetters['type-map/hasCustomList'].mockReturnValue(false);
+
+      const storeSettings: PaginationSettingsStore = { resources: { enableSome: { generic: true } } };
+      const result = paginationUtils.isEnabledInStore({
+        ctx:        { rootGetters: mockRootGetters },
+        storeSettings,
+        enabledFor: { store: 'cluster', resource: { id: 'pod' } }
+      });
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false for a non-generic resource when only generic is enabled', () => {
+      mockRootGetters['type-map/hasCustomList'].mockReturnValue(true);
+
+      const storeSettings: PaginationSettingsStore = { resources: { enableSome: { generic: true } } };
+      const result = paginationUtils.isEnabledInStore({
+        ctx:        { rootGetters: mockRootGetters },
+        storeSettings,
+        enabledFor: { store: 'cluster', resource: { id: 'pod' } }
+      });
+
+      expect(result).toBe(false);
+    });
+
+    it('should return true if resource id is in enabled list as a string', () => {
+      const storeSettings: PaginationSettingsStore = { resources: { enableSome: { enabled: ['pod'] } } };
+      const result = paginationUtils.isEnabledInStore({
+        ctx:        { rootGetters: mockRootGetters },
+        storeSettings,
+        enabledFor: { store: 'cluster', resource: { id: 'pod' } }
+      });
+
+      expect(result).toBe(true);
+    });
+
+    it('should return true if resource id is in enabled list as an object without context', () => {
+      const storeSettings: PaginationSettingsStore = { resources: { enableSome: { enabled: [{ resource: 'pod' }] } } };
+      const result = paginationUtils.isEnabledInStore({
+        ctx:        { rootGetters: mockRootGetters },
+        storeSettings,
+        enabledFor: { store: 'cluster', resource: { id: 'pod' } }
+      });
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false if resource id is in enabled list as an object with empty context', () => {
+      const storeSettings: PaginationSettingsStore = { resources: { enableSome: { enabled: [{ resource: 'pod', context: [] }] } } };
+      const result = paginationUtils.isEnabledInStore({
+        ctx:        { rootGetters: mockRootGetters },
+        storeSettings,
+        enabledFor: { store: 'cluster', resource: { id: 'pod' } }
+      });
+
+      expect(result).toBe(false);
+    });
+
+    it('should return true if resource id and context match an enabled setting', () => {
+      const storeSettings: PaginationSettingsStore = { resources: { enableSome: { enabled: [{ resource: 'pod', context: ['list'] }] } } };
+      const result = paginationUtils.isEnabledInStore({
+        ctx:        { rootGetters: mockRootGetters },
+        storeSettings,
+        enabledFor: { store: 'cluster', resource: { id: 'pod', context: 'list' } }
+      });
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false if resource context does not match enabled setting', () => {
+      const storeSettings: PaginationSettingsStore = { resources: { enableSome: { enabled: [{ resource: 'pod', context: ['detail'] }] } } };
+      const result = paginationUtils.isEnabledInStore({
+        ctx:        { rootGetters: mockRootGetters },
+        storeSettings,
+        enabledFor: { store: 'cluster', resource: { id: 'pod', context: 'list' } }
+      });
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('isEnabled', () => {
+    let mockRootGetters: any;
+    let mockPlugin: any;
+    let enabledFor: PaginationResourceContext;
+
+    beforeEach(() => {
+      enabledFor = { store: 'cluster', resource: { id: 'pod' } };
+      mockPlugin = { getAll: jest.fn().mockReturnValue({}) };
+      mockRootGetters = {
+        'features/get':                         jest.fn(),
+        'management/byId':                      jest.fn(),
+        'type-map/configuredHeaders':           jest.fn().mockReturnValue(false),
+        'type-map/configuredPaginationHeaders': jest.fn().mockReturnValue(false),
+        'type-map/hasCustomList':               jest.fn().mockReturnValue(false),
+      };
+    });
+
+    it('should return false if steve cache is disabled', () => {
+      mockRootGetters['features/get'].mockImplementation((feature: string) => feature === STEVE_CACHE ? false : undefined);
+      const result = paginationUtils.isEnabled({ rootGetters: mockRootGetters, $plugin: mockPlugin }, enabledFor);
+
+      expect(result).toBe(false);
+    });
+
+    it('should return false if pagination settings are not defined', () => {
+      jest.spyOn(paginationUtils, 'getSettings').mockReturnValue(undefined);
+      const result = paginationUtils.isEnabled({ rootGetters: mockRootGetters, $plugin: mockPlugin }, enabledFor);
+
+      expect(result).toBe(false);
+
+      jest.clearAllMocks();
+    });
+
+    it('should return false if enabledFor is not provided', () => {
+      mockRootGetters['features/get'].mockReturnValue(true);
+      const settings: PaginationSettings = { useDefaultStores: true };
+
+      mockRootGetters['management/byId'].mockImplementation((type: string, id: string) => {
+        if (type === 'management.cattle.io.setting' && id === SETTING.UI_PERFORMANCE) {
+          return { value: JSON.stringify({ serverPagination: settings }) };
+        }
+
+        return null;
+      });
+
+      const result = paginationUtils.isEnabled({ rootGetters: mockRootGetters, $plugin: mockPlugin }, undefined as unknown as PaginationResourceContext);
+
+      expect(result).toBe(false);
+    });
+
+    it('should return true if an extension enables the resource', () => {
+      mockRootGetters['features/get'].mockReturnValue(true);
+      const extensionSettings = { cluster: { resources: { enableAll: true } } };
+
+      mockPlugin.getAll.mockReturnValue({ [EXT_IDS.SERVER_SIDE_PAGINATION_RESOURCES]: { 'my-ext': () => extensionSettings } });
+
+      const result = paginationUtils.isEnabled({ rootGetters: mockRootGetters, $plugin: mockPlugin }, enabledFor);
+
+      expect(result).toBe(true);
+    });
+
+    it('should still return true if an extension enables the resource but core store does not', () => {
+      mockRootGetters['features/get'].mockReturnValue(true);
+      const extensionSettings = { cluster: { resources: { enableAll: true } } };
+      const defaultSettings = { cluster: { resources: { enableAll: false, enableSome: { enabled: [] } } } };
+
+      mockPlugin.getAll.mockReturnValue({ [EXT_IDS.SERVER_SIDE_PAGINATION_RESOURCES]: { 'my-ext': () => extensionSettings } });
+
+      // Mocking PAGINATION_SETTINGS_STORE_DEFAULTS behavior
+      jest.spyOn(paginationUtils, 'getStoreDefault').mockReturnValue(defaultSettings);
+
+      const result = paginationUtils.isEnabled({ rootGetters: mockRootGetters, $plugin: mockPlugin }, enabledFor);
+
+      expect(result).toBe(true);
+    });
+
+    it('should use default store settings and enable the resource', () => {
+      mockRootGetters['features/get'].mockReturnValue(true);
+      const settings: PaginationSettings = { useDefaultStores: true };
+
+      mockRootGetters['management/byId'].mockImplementation((type: string, id: string) => {
+        if (type === 'management.cattle.io.setting' && id === SETTING.UI_PERFORMANCE) {
+          return { value: JSON.stringify({ serverPagination: settings }) };
+        }
+
+        return null;
+      });
+
+      // Mocking PAGINATION_SETTINGS_STORE_DEFAULTS behavior
+      jest.spyOn(paginationUtils, 'getStoreDefault').mockReturnValue({ cluster: { resources: { enableAll: true } } });
+
+      const result = paginationUtils.isEnabled({ rootGetters: mockRootGetters, $plugin: mockPlugin }, enabledFor);
+
+      expect(result).toBe(true);
+    });
+
+    it('should use custom store settings and enable the resource', () => {
+      mockRootGetters['features/get'].mockReturnValue(true);
+      const settings: PaginationSettings = {
+        useDefaultStores: false,
+        stores:           { cluster: { resources: { enableSome: { enabled: ['pod'] } } } }
+      };
+
+      mockRootGetters['management/byId'].mockImplementation((type: string, id: string) => {
+        if (type === 'management.cattle.io.setting' && id === SETTING.UI_PERFORMANCE) {
+          return { value: JSON.stringify({ serverPagination: settings }) };
+        }
+
+        return null;
+      });
+
+      const result = paginationUtils.isEnabled({ rootGetters: mockRootGetters, $plugin: mockPlugin }, enabledFor);
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false if neither extension nor main settings enable the resource', () => {
+      mockRootGetters['features/get'].mockReturnValue(true);
+      const settings: PaginationSettings = {
+        useDefaultStores: false,
+        stores:           { cluster: { resources: { enableSome: { enabled: ['service'] } } } }
+      };
+
+      mockRootGetters['management/byId'].mockImplementation((type: string, id: string) => {
+        if (type === 'management.cattle.io.setting' && id === SETTING.UI_PERFORMANCE) {
+          return { value: JSON.stringify({ serverPagination: settings }) };
+        }
+
+        return null;
+      });
+
+      const result = paginationUtils.isEnabled({ rootGetters: mockRootGetters, $plugin: mockPlugin }, enabledFor);
+
+      expect(result).toBe(false);
+    });
+  });
+});

package/utils/validators/formRules/__tests__/index.test.ts

@@ -116,6 +116,10 @@ describe('formRules', () => {
       ['git@github.com:rancher/dashboard/%20', undefined],
       ['git@git.apps.local:fleet/fleet-local.git', undefined],
       ['git@git.apps.local:33333/fleet/fleet-local.git', undefined],
+      ['ssh://git@github.com:rancher/dashboard', undefined],
+      ['ssh://git@github.com:rancher/dashboard/', undefined],
+      ['ssh://git@git.apps.local:fleet/fleet-local.git', undefined],
+      ['ssh://git@git.apps.local:33333/fleet/fleet-local.git', undefined],
 
       // Not valid HTTP(s)
       ['https://github.com/rancher/  dashboard.git', message],
@@ -145,6 +149,9 @@ describe('formRules', () => {
       ['git@git.apps.local:/fleet/fleet-local.git', message],
       ['git@.git', message],
       ['git@', message],
+      ['ssh://git@github.com:/rancher/dashboard.git ', message],
+      ['ssh://git@github.com/rancher/ dashboard.git', message],
+      ['ssh://git@github.com/rancher/ dashboard', message],
 
       [undefined, message],
       ['', message]

package/utils/validators/formRules/index.ts

@@ -200,8 +200,8 @@ export default function(
       return message;
     }
 
-    // Test http(s) protocol
-    if (protocol && (!/^(http|http(s))/gm.test(protocol) || (!url.startsWith('https://') && !url.startsWith('http://')))) {
+    // Test http(s)/ssh protocol
+    if (protocol && (!/^(http|https|ssh)$/gm.test(protocol) || (!url.startsWith('https://') && !url.startsWith('http://') && !url.startsWith('ssh://')))) {
       return message;
     }