@rancher/shell 3.0.8-rc.1 → 3.0.8-rc.12

package/plugins/dashboard-client-init.js

@@ -0,0 +1,3 @@
+export default async(context) => {
+  await context.store.dispatch('dashboardClientInit', context);
+};

package/plugins/dashboard-store/getters.js

@@ -1,5 +1,8 @@
 
-import { SCHEMA, COUNT, POD } from '@shell/config/types';
+import {
+  SCHEMA, COUNT, POD, MANAGEMENT, BRAND
+} from '@shell/config/types';
+import { SETTING } from '@shell/config/settings';
 
 import { matches } from '@shell/utils/selector';
 import { typeMunge, typeRef, SIMPLE_TYPES } from '@shell/utils/create-yaml';
@@ -204,6 +207,20 @@ export default {
     }
   },
 
+  brand: (state, getters) => {
+    const brand = getters['byId'](MANAGEMENT.SETTING, SETTING.BRAND);
+
+    if (!brand?.value) {
+      return undefined;
+    }
+
+    if ([BRAND.CSP, BRAND.FEDERAL, BRAND.RGS].includes(brand.value)) {
+      return BRAND.SUSE;
+    }
+
+    return brand.value;
+  },
+
   /**
    * Checks a schema for the given path
    *
@@ -526,7 +543,7 @@ export default {
     const store = state.config.namespace;
     const resource = id || context ? { id, context } : null;
 
-    return paginationUtils.isEnabled({ rootGetters, $plugin: rootState.$plugin }, { store, resource });
+    return paginationUtils.isEnabled({ rootGetters, $extension: rootState.$extension }, { store, resource });
   },
 
   /**

package/plugins/dashboard-store/model-loader.js

@@ -13,7 +13,7 @@ function find(cache, type, rootState) {
   }
 
   try {
-    const pluginModel = rootState.$plugin.getDynamic('models', type);
+    const pluginModel = rootState.$extension.getDynamic('models', type);
     let base;
 
     if (!pluginModel) {

package/plugins/dashboard-store/resource-class.js

@@ -39,7 +39,6 @@ import { handleConflict } from '@shell/plugins/dashboard-store/normalize';
 import { ExtensionPoint, ActionLocation } from '@shell/core/types';
 import { getApplicableExtensionEnhancements } from '@shell/core/plugin-helpers';
 import { parse } from '@shell/utils/selector';
-import { importDrawer } from '@shell/utils/dynamic-importer';
 
 export const DNS_LIKE_TYPES = ['dnsLabel', 'dnsLabelRestricted', 'hostname'];
 
@@ -611,7 +610,11 @@ export default class Resource {
   }
 
   get '$plugin'() {
-    return this.$ctx.rootState?.$plugin;
+    return this.$ctx.rootState?.$extension;
+  }
+
+  get '$extension'() {
+    return this.$ctx.rootState?.$extension;
   }
 
   get customValidationRules() {
@@ -906,11 +909,11 @@ export default class Resource {
     return out;
   }
 
-  showConfiguration(returnFocusSelector) {
+  showConfiguration(returnFocusSelector, defaultTab) {
     const onClose = () => this.$ctx.commit('slideInPanel/close', undefined, { root: true });
 
     this.$ctx.commit('slideInPanel/open', {
-      component:      importDrawer('ResourceDetailDrawer'),
+      component:      require(`@shell/components/Drawer/ResourceDetailDrawer/index.vue`).default,
       componentProps: {
         resource:           this,
         onClose,
@@ -921,7 +924,8 @@ export default class Resource {
         'z-index':          101, // We want this to be above the main side menu
         closeOnRouteChange: ['name', 'params', 'query'], // We want to ignore hash changes, tables in extensions can trigger the drawer to close while opening
         triggerFocusTrap:   true,
-        returnFocusSelector
+        returnFocusSelector,
+        defaultTab
       }
     }, { root: true });
   }
@@ -1777,7 +1781,7 @@ export default class Resource {
             CustomValidators[validatorName](pathValue, this.$rootGetters, errors, validatorArgs, displayKey, data);
           } else if (!isEmpty(validatorName) && !validatorExists) {
             // Check if validator is imported from plugin
-            const pluginValidator = this.$rootState.$plugin?.getValidator(validatorName);
+            const pluginValidator = this.$rootState.$extension?.getValidator(validatorName);
 
             if (pluginValidator) {
               pluginValidator(pathValue, this.$rootGetters, errors, validatorArgs, displayKey, data);

package/plugins/dynamic-content.js

@@ -0,0 +1,13 @@
+import { createHandler, DynamicContentAnnouncementHandlerName } from '@shell/utils/dynamic-content/notification-handler';
+import { NotificationHandlerExtensionName } from '@shell/types/notifications';
+
+/**
+ * Register the notification handler for dynamic content
+ */
+export default function(context) {
+  const { store, $extension } = context;
+
+  const handler = createHandler(store);
+
+  $extension.register(NotificationHandlerExtensionName, DynamicContentAnnouncementHandlerName, handler);
+}

package/plugins/i18n.js

@@ -3,6 +3,14 @@ import { escapeHtml } from '../utils/string';
 import { watchEffect, ref, h } from 'vue';
 import { useStore } from 'vuex';
 
+/**
+ * @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, key, args, raw = false, escapehtml = true) {
   const translation = store.getters['i18n/t'](key, args);
 

package/plugins/plugin.js

@@ -44,7 +44,7 @@ export default async function(context) {
     const res = await allHashSettled(fetches);
 
     // Initialize the built-in extensions now - this is now done here so that built-in extensions get the same, correct environment data (version etc)
-    context.$plugin.loadBuiltinExtensions();
+    context.$extension.loadBuiltinExtensions();
 
     if (res.plugins?.status === 'rejected') {
       throw new Error(res.reason);
@@ -60,7 +60,7 @@ export default async function(context) {
       const shouldNotLoad = shouldNotLoadPlugin(plugin, { rancherVersion, kubeVersion }, context.store.getters['uiplugins/plugins'] || []); // Error key string or boolean
 
       if (!shouldNotLoad) {
-        hash[plugin.name] = context.$plugin.loadPluginAsync(plugin);
+        hash[plugin.name] = context.$extension.loadPluginAsync(plugin);
       } else {
         context.store.dispatch('uiplugins/setError', { name: plugin.name, error: shouldNotLoad });
       }

package/plugins/steve/__tests__/steve-pagination-utils.test.ts

@@ -0,0 +1,333 @@
+
+import { PaginationFilterEquality, PaginationFilterField, PaginationParamFilter, PaginationParamProjectOrNamespace } from '@shell/types/store/pagination.types';
+import { NAMESPACE_FILTER_P_FULL_PREFIX } from '@shell/utils/namespace-filter';
+import stevePaginationUtils from '../steve-pagination-utils';
+import Schema from '@shell/models/schema';
+
+/**
+ * The `NamespaceProjectFilters` class is a protected class within `steve-pagination-utils.ts`.
+ * To test its protected methods, we extend it with a test class that exposes them.
+ */
+class TestNamespaceProjectFilters {
+  public handlePrefAndSettingFilter(args: any) {
+    return stevePaginationUtils.handlePrefAndSettingFilter(args);
+  }
+
+  public handleSystemOrUserFilter(args: any) {
+    return stevePaginationUtils.handleSystemOrUserFilter(args);
+  }
+
+  public handleSelectionFilter(neu: string[], isLocalCluster: boolean) {
+    return stevePaginationUtils.handleSelectionFilter(neu, isLocalCluster);
+  }
+}
+
+describe('class: NamespaceProjectFilters', () => {
+  const testNamespaceProjectFilters = new TestNamespaceProjectFilters();
+
+  const normalNs = {
+    id: 'normal', name: 'normal', isObscure: false, isSystem: false
+  };
+  const obscureNs = {
+    id: 'obscure', name: 'obscure', isObscure: true, isSystem: false
+  };
+  const systemNs = {
+    id: 'system', name: 'system', isObscure: false, isSystem: true
+  };
+  const obscureAndSystemNs = {
+    id: 'obscure-system', name: 'obscure-system', isObscure: true, isSystem: true
+  };
+
+  const allNamespaces = [normalNs, obscureNs, systemNs, obscureAndSystemNs];
+
+  describe('method: handlePrefAndSettingFilter', () => {
+    it('should return no filters if all namespaces are shown', () => {
+      const result = testNamespaceProjectFilters.handlePrefAndSettingFilter({
+        allNamespaces,
+        showReservedRancherNamespaces: true,
+        productHidesSystemNamespaces:  false,
+      });
+
+      expect(result).toStrictEqual([]);
+    });
+
+    it('should filter obscure namespaces if showReservedRancherNamespaces is false', () => {
+      const result = testNamespaceProjectFilters.handlePrefAndSettingFilter({
+        allNamespaces,
+        showReservedRancherNamespaces: false,
+        productHidesSystemNamespaces:  false,
+      });
+
+      expect(result).toHaveLength(1);
+      expect(result).toContainEqual(expect.objectContaining({
+        fields: [expect.objectContaining({
+          value: 'obscure,obscure-system', equality: ' NOTIN ', field: `metadata.namespace`
+        })]
+      }));
+    });
+
+    it('should filter system namespaces if productHidesSystemNamespaces is true', () => {
+      const result = testNamespaceProjectFilters.handlePrefAndSettingFilter({
+        allNamespaces,
+        showReservedRancherNamespaces: true,
+        productHidesSystemNamespaces:  true,
+      });
+
+      expect(result).toHaveLength(1);
+      expect(result).toContainEqual(expect.objectContaining({
+        fields: [expect.objectContaining({
+          value: 'system,obscure-system', equality: ' NOTIN ', field: `metadata.namespace`
+        })]
+      }));
+    });
+
+    it('should filter both obscure and system namespaces when both settings are active', () => {
+      const result = testNamespaceProjectFilters.handlePrefAndSettingFilter({
+        allNamespaces,
+        showReservedRancherNamespaces: false,
+        productHidesSystemNamespaces:  true,
+      });
+
+      expect(result).toHaveLength(1);
+      expect(result).toContainEqual(expect.objectContaining({
+        fields: [expect.objectContaining({
+          value: 'obscure,system,obscure-system', equality: ' NOTIN ', field: `metadata.namespace`
+        })]
+      }));
+    });
+  });
+
+  describe('method: handleSystemOrUserFilter', () => {
+    it('should create an OR filter for system namespaces when isAllSystem is true', () => {
+      const result = testNamespaceProjectFilters.handleSystemOrUserFilter({
+        allNamespaces,
+        isAllSystem: true,
+        isAllUser:   false,
+      });
+
+      expect(result).toHaveLength(1);
+      const filter = result[0] as PaginationParamFilter;
+
+      expect(filter.fields).toHaveLength(2);
+      expect(filter.fields).toContainEqual(expect.objectContaining({
+        value: 'system', equality: '=', field: 'metadata.namespace'
+      }));
+      expect(filter.fields).toContainEqual(expect.objectContaining({
+        value: 'obscure-system', equality: '=', field: 'metadata.namespace'
+      }));
+    });
+
+    it('should create AND filters to exclude system namespaces when isAllUser is true', () => {
+      const result = testNamespaceProjectFilters.handleSystemOrUserFilter({
+        allNamespaces,
+        isAllSystem: false,
+        isAllUser:   true,
+      });
+
+      expect(result).toHaveLength(2);
+      expect(result).toContainEqual(expect.objectContaining({
+        fields: [expect.objectContaining({
+          value: 'system', equality: '!=', field: 'metadata.namespace'
+        })]
+      }));
+      expect(result).toContainEqual(expect.objectContaining({
+        fields: [expect.objectContaining({
+          value: 'obscure-system', equality: '!=', field: 'metadata.namespace'
+        })]
+      }));
+    });
+  });
+
+  describe('method: handleSelectionFilter', () => {
+    const selection = ['ns-1', `${ NAMESPACE_FILTER_P_FULL_PREFIX }p-1`];
+
+    it('should create projectsOrNamespaces filter for a selection in a non-local cluster', () => {
+      const result = testNamespaceProjectFilters.handleSelectionFilter(selection, false);
+
+      expect(result.projectsOrNamespaces).toHaveLength(1);
+      const pnsFilter = result.projectsOrNamespaces[0] as PaginationParamProjectOrNamespace;
+
+      expect(pnsFilter.param).toBe('projectsornamespaces');
+      expect(pnsFilter.fields).toHaveLength(2);
+      expect(pnsFilter.fields).toContainEqual(expect.objectContaining({ value: 'ns-1' }));
+      expect(pnsFilter.fields).toContainEqual(expect.objectContaining({ value: 'p-1' }));
+      expect(result.filters).toStrictEqual([]);
+    });
+
+    it('should create projectsOrNamespaces and an exclusion filter for a selection in a local cluster', () => {
+      const result = testNamespaceProjectFilters.handleSelectionFilter(selection, true);
+
+      // projectsOrNamespaces part
+      expect(result.projectsOrNamespaces).toHaveLength(1);
+      const pnsFilter = result.projectsOrNamespaces[0] as PaginationParamProjectOrNamespace;
+
+      expect(pnsFilter.param).toBe('projectsornamespaces');
+      expect(pnsFilter.fields).toHaveLength(2);
+      expect(pnsFilter.fields).toContainEqual(expect.objectContaining({ value: 'ns-1' }));
+      expect(pnsFilter.fields).toContainEqual(expect.objectContaining({ value: 'p-1' }));
+
+      // filters part
+      expect(result.filters).toHaveLength(1);
+      const filter = result.filters[0] as PaginationParamFilter;
+
+      expect(filter.fields).toHaveLength(1);
+      expect(filter.fields).toContainEqual(expect.objectContaining({
+        field:    'metadata.namespace',
+        equality: '!=',
+        value:    'p-1',
+      }));
+    });
+
+    it('should handle selections with only namespaces in a local cluster', () => {
+      const nsSelection = ['ns-1', 'ns-2'];
+      const result = testNamespaceProjectFilters.handleSelectionFilter(nsSelection, true);
+
+      expect(result.projectsOrNamespaces).toHaveLength(1);
+      const pnsFilter = result.projectsOrNamespaces[0] as PaginationParamProjectOrNamespace;
+
+      expect(pnsFilter.fields).toHaveLength(2);
+      expect(pnsFilter.fields).toContainEqual(expect.objectContaining({ value: 'ns-1' }));
+      expect(pnsFilter.fields).toContainEqual(expect.objectContaining({ value: 'ns-2' }));
+      expect(result.filters).toStrictEqual([]);
+    });
+
+    it('should handle selections with only projects in a local cluster', () => {
+      const projectSelection = [`${ NAMESPACE_FILTER_P_FULL_PREFIX }p-1`, `${ NAMESPACE_FILTER_P_FULL_PREFIX }p-2`];
+      const result = testNamespaceProjectFilters.handleSelectionFilter(projectSelection, true);
+
+      expect(result.projectsOrNamespaces).toHaveLength(1);
+      const pnsFilter = result.projectsOrNamespaces[0] as PaginationParamProjectOrNamespace;
+
+      expect(pnsFilter.fields).toHaveLength(2);
+      expect(pnsFilter.fields).toContainEqual(expect.objectContaining({ value: 'p-1' }));
+      expect(pnsFilter.fields).toContainEqual(expect.objectContaining({ value: 'p-2' }));
+
+      expect(result.filters).toHaveLength(2);
+      expect(result.filters).toContainEqual(expect.objectContaining({
+        fields: [expect.objectContaining({
+          field:    'metadata.namespace',
+          equality: '!=',
+          value:    'p-1'
+        })],
+      }));
+      expect(result.filters).toContainEqual(expect.objectContaining({
+        fields: [expect.objectContaining({
+          field:    'metadata.namespace',
+          equality: '!=',
+          value:    'p-2'
+        })],
+      }));
+    });
+  });
+});
+
+class TestStevePaginationUtils {
+  public convertPaginationParams(args: any) {
+    return stevePaginationUtils.convertPaginationParams(args);
+  }
+}
+
+describe('class StevePaginationUtils', () => {
+  const testStevePaginationUtils = new TestStevePaginationUtils();
+  const schema = { id: 'pod' } as unknown as Schema;
+
+  it('should return an empty string for no filters', () => {
+    const result = testStevePaginationUtils.convertPaginationParams({ schema, filters: [] });
+
+    expect(result).toBe('');
+  });
+
+  it('should handle a single filter with a single field', () => {
+    const filters = [
+      new PaginationParamFilter({ fields: [new PaginationFilterField({ field: 'metadata.name', value: 'test' })] }),
+    ];
+    const result = testStevePaginationUtils.convertPaginationParams({ schema, filters });
+
+    expect(result).toBe('filter=metadata.name=test');
+  });
+
+  it('should handle a single filter with a single field with encoded char', () => {
+    const filters = [
+      new PaginationParamFilter({ fields: [new PaginationFilterField({ field: 'metadata.name', value: 'te/st' })] }),
+    ];
+    const result = testStevePaginationUtils.convertPaginationParams({ schema, filters });
+
+    expect(result).toBe('filter=metadata.name="te%2Fst"');
+  });
+
+  it('should handle a single filter with multiple fields (OR)', () => {
+    const filters = [
+      new PaginationParamFilter({
+        fields: [
+          new PaginationFilterField({ field: 'metadata.name', value: 'test1' }),
+          new PaginationFilterField({ field: 'metadata.namespace', value: 'ns1' }),
+        ],
+      }),
+    ];
+    const result = testStevePaginationUtils.convertPaginationParams({ schema, filters });
+
+    expect(result).toBe('filter=metadata.name=test1,metadata.namespace=ns1');
+  });
+
+  it('should handle multiple filters (AND)', () => {
+    const filters = [
+      new PaginationParamFilter({ fields: [new PaginationFilterField({ field: 'metadata.name', value: 'test1' })] }),
+      new PaginationParamFilter({ fields: [new PaginationFilterField({ field: 'metadata.namespace', value: 'ns1' })] }),
+    ];
+    const result = testStevePaginationUtils.convertPaginationParams({ schema, filters });
+
+    expect(result).toBe('filter=metadata.name=test1&filter=metadata.namespace=ns1');
+  });
+
+  it('should handle different equality operators', () => {
+    const filters = [
+      new PaginationParamFilter({
+        fields: [
+          new PaginationFilterField({
+            field:    'spec.containers.image',
+            value:    'nginx',
+            equality: PaginationFilterEquality.CONTAINS,
+          }),
+        ],
+      }),
+      new PaginationParamFilter({
+        fields: [
+          new PaginationFilterField({
+            field:    'metadata.name',
+            value:    'test',
+            equality: PaginationFilterEquality.NOT_EQUALS,
+          }),
+        ],
+      }),
+    ];
+    const result = testStevePaginationUtils.convertPaginationParams({ schema, filters });
+
+    expect(result).toBe('filter=spec.containers.image~nginx&filter=metadata.name!=test');
+  });
+
+  it('should handle IN and NOT_IN operators', () => {
+    const filters = [
+      new PaginationParamFilter({
+        fields: [
+          new PaginationFilterField({
+            field:    'metadata.name',
+            value:    'test1,test2',
+            equality: PaginationFilterEquality.IN,
+          }),
+        ],
+      }),
+      new PaginationParamFilter({
+        fields: [
+          new PaginationFilterField({
+            field:    'metadata.namespace',
+            value:    'ns1,ns2',
+            equality: PaginationFilterEquality.NOT_IN,
+          }),
+        ],
+      }),
+    ];
+    const result = testStevePaginationUtils.convertPaginationParams({ schema, filters });
+
+    expect(result).toBe('filter=metadata.name IN (test1,test2)&filter=metadata.namespace NOTIN (ns1,ns2)');
+  });
+});

package/plugins/steve/steve-class.js

@@ -47,7 +47,7 @@ export default class SteveModel extends HybridModel {
    * Get all model extensions for this model
    */
   get modelExtensions() {
-    return this.$plugin.getDynamic(EXT_IDS.MODEL_EXTENSION, this.type) || [];
+    return this.$extension.getDynamic(EXT_IDS.MODEL_EXTENSION, this.type) || [];
   }
 
   cleanForSave(data, forNew) {

package/plugins/steve/steve-pagination-utils.ts

@@ -1,5 +1,7 @@
 import { ActionFindPageArgs } from '@shell/types/store/dashboard-store.types';
-import { PaginationParam, PaginationFilterField, PaginationParamProjectOrNamespace, PaginationParamFilter } from '@shell/types/store/pagination.types';
+import {
+  PaginationParam, PaginationFilterField, PaginationParamProjectOrNamespace, PaginationParamFilter, PaginationFilterEquality
+} from '@shell/types/store/pagination.types';
 import { NAMESPACE_FILTER_ALL_SYSTEM, NAMESPACE_FILTER_ALL_USER, NAMESPACE_FILTER_P_FULL_PREFIX } from '@shell/utils/namespace-filter';
 import ModelNamespace from '@shell/models/namespace';
 import { uniq } from '@shell/utils/array';
@@ -48,7 +50,7 @@ class NamespaceProjectFilters {
 
     // These are AND'd together
     // Not ns 1 AND ns 2
-    return allNamespaces.reduce((res, ns) => {
+    const filterNamespaces = allNamespaces.reduce((res, ns) => {
       // Links to ns.isObscure and covers things like `c-`, `user-`, etc (see OBSCURE_NAMESPACE_PREFIX)
       const hideObscure = showReservedRancherNamespaces ? false : ns.isObscure;
 
@@ -56,13 +58,23 @@ class NamespaceProjectFilters {
       const hideSystem = productHidesSystemNamespaces ? ns.isSystem : false;
 
       if (hideObscure || hideSystem) {
-        res.push(PaginationParamFilter.createSingleField({
-          field: 'metadata.namespace', value: ns.name, equals: false
-        }));
+        res.push(ns.name);
       }
 
       return res;
-    }, [] as PaginationParamFilter[]);
+    }, [] as String[]);
+
+    if (filterNamespaces.length) {
+      return [new PaginationParamFilter({
+        fields: [{
+          value:    filterNamespaces.join(','),
+          equality: PaginationFilterEquality.NOT_IN,
+          field:    'metadata.namespace',
+        }],
+      })];
+    }
+
+    return [];
   }
 
   /**
@@ -502,29 +514,36 @@ class StevePaginationUtils extends NamespaceProjectFilters {
               // Check if the API supports filtering by this field
               this.validateField(validateFields, schema, field.field);
 
-              // we're just checking that the field exists, so there's no value
+              // we're just checking that the field exists, so there's no equality or value
               if (field.exists) {
                 return field.field;
               }
-              const encodedValue = encodeURIComponent(field.value || '');
 
-              // = exact match (equals + exact)
-              // ~ partial match (equals + !exact)
-              // != not exact match (!equals + exact)
-              // !~ not partial match (!equals + !exact)
-              const operator = `${ field.equals ? '' : '!' }${ field.exact ? '=' : '~' }`;
+              // If field was created by PaginationFilterField ctor equality will be set. If field created by json (legacy) it might not
+              const equality = field.equality || PaginationFilterField.safeEquality(field);
+
+              if (!equality) {
+                throw new Error(`A pagination filter must contain an equality. ${ JSON.stringify(field) }`);
+              }
+
               let safeValue;
 
-              if (StevePaginationUtils.VALID_FIELD_VALUE_REGEX.test(field.value || '')) {
-                // Does not contain any protected characters, send as is
-                safeValue = encodedValue;
+              if ([PaginationFilterEquality.IN, PaginationFilterEquality.NOT_IN].includes(equality)) {
+                safeValue = `(${ field.value })`;
               } else {
-                // Contains protected characters, wrap in quotes to ensure backend doesn't fail
-                // - replace reserver `"`/`%22` with empty string - see https://github.com/rancher/dashboard/issues/14549 for improvement
-                safeValue = `"${ encodedValue.replaceAll('%22', '') }"`;
+                const encodedValue = encodeURIComponent(field.value || '');
+
+                if (StevePaginationUtils.VALID_FIELD_VALUE_REGEX.test(field.value || '')) {
+                  // Does not contain any protected characters, send as is
+                  safeValue = encodedValue;
+                } else {
+                  // Contains protected characters, wrap in quotes to ensure backend doesn't fail
+                  // - replace reserver `"`/`%22` with empty string - see https://github.com/rancher/dashboard/issues/14549 for improvement
+                  safeValue = `"${ encodedValue.replaceAll('%22', '') }"`;
+                }
               }
 
-              return `${ this.convertArrayPath(field.field) }${ operator }${ safeValue }`;
+              return `${ this.convertArrayPath(field.field) }${ equality }${ safeValue }`;
             }
 
             return field.value;

package/plugins/steve/subscribe.js

@@ -888,16 +888,20 @@ const defaultActions = {
             }
           });
         }
-
         // Should any listeners be notified of this request for them to kick off their own event handling?
-        getters.listenerManager.triggerEventListener({ event: STEVE_WATCH_MODE.RESOURCE_CHANGES, params });
+        getters.listenerManager.triggerEventListener({
+          event:  STEVE_WATCH_MODE.RESOURCE_CHANGES,
+          params: {
+            ...params,
+            forceWatch: opt.forceWatch
+          }
+        });
       } else {
         have = getters['all'](resourceType).slice();
 
         if ( namespace ) {
           have = have.filter((x) => x.metadata?.namespace === namespace);
         }
-
         want = await dispatch('findAll', {
           type:           resourceType,
           watchNamespace: namespace,
@@ -1181,12 +1185,16 @@ const defaultActions = {
       });
 
       if (hasEventListeners) {
-        // If there's event listeners always kick them off
-        // - The re-watch associated with normal watches will watch from a revision from it's own cache
-        // - The revision in that cache might be ahead of the state the listeners have, so the watch won't ping something for the listeners to trigger on
-        // - so to work around this whenever we start the watches again trigger off the changes for it
-        // Improvement - we only do one event here (currently the only one supported), could expand to others
-        getters.listenerManager.triggerEventListener({ event: STEVE_WATCH_EVENT_TYPES.CHANGES, params: obj });
+        const inError = getters.inError(obj); // We don't want to force listeners to resync if the socket is in error (handled by resource.error mechanism)
+
+        if (!inError) {
+          // If there's event listeners kick them off
+          // - The re-watch associated with normal watches will watch from a revision from it's own cache
+          // - The revision in that cache might be ahead of the state the listeners have, so the watch won't ping something for the listeners to trigger on
+          // - so to work around this whenever we start the watches again trigger off the changes for it
+          // Improvement - we only do one event here (currently the only one supported), could expand to others
+          getters.listenerManager.triggerEventListener({ event: STEVE_WATCH_EVENT_TYPES.CHANGES, params: obj });
+        }
       }
     }
   },

package/plugins/subscribe-events.ts

@@ -167,7 +167,7 @@ export class SteveWatchEventListenerManager {
 
     if (eventWatcher) {
       Object.values(eventWatcher.callbacks).forEach((cb) => {
-        cb();
+        cb({ forceWatch: params.forceWatch }); // eslint-disable-line node/no-callback-literal
       });
     }
   }
@@ -176,7 +176,9 @@ export class SteveWatchEventListenerManager {
     const watch = this.getWatch({ params });
 
     watch.listeners.forEach((l) => {
-      Object.values(l.callbacks || {}).forEach((cb) => cb());
+      Object.values(l.callbacks || {}).forEach((cb) => {
+        cb({ forceWatch: params.forceWatch });// eslint-disable-line node/no-callback-literal
+      });
     });
   }