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

package/plugins/steve/subscribe.js

@@ -3,8 +3,57 @@
  *
  * Covers three use cases
  * 1) Handles subscription within this file
- * 2) Handles `cluster` subscriptions for some basic types in a web worker (SETTING.UI_PERFORMANCE advancedWorker = false)
+ * 2) Handles `cluster` subscriptions for some basic types in a web worker (SETTING.UI_PERFORMANCE advancedWorker = false) (is this true??)
  * 2) Handles `cluster` subscriptions and optimisations in an advanced worker (SETTING.UI_PERFORMANCE advancedWorker = true)
+ *
+ * Very roughly this does...
+ *
+ * 1. _Subscribes_ to a web socket (v1, v3, v1 cluster)
+ * 2. UI --> Rancher: Sends a _watch_ message for a specific resource type (which can have qualifying filters)
+ * 3. Rancher --> UI: Rancher can send a number of messages back
+ *   - `resource.start`   - watch has started
+ *   - `resource.error`   - watch has errored, usually a result of bad data in the resource.start message
+ *   - `resource.change`  - a resource has changed, this is it's new value
+ *   - `resource.changes` - if in this mode, no resource.change events are sent, instead one debounced message is sent without any resource data
+ *   - `resource.stop`    - either we have requested the watch stops, or there has been a resource.error
+ * 4. UI --> Rancher: Sends an _unwatch_ request for a matching _watch_ request
+ *
+ * Below are some VERY brief steps for common flows. Some will link together
+ *
+ * Successfully flow - watch
+ * 1. UI --> Rancher: _watch_ request
+ * 2. Rancher --> UI: `resource.start`. UI sets watch as started
+ * 3. Rancher --> UI: `resource.change` (contains data). UI caches data
+ *
+ * Successful flow - watch - new mode
+ * 1. UI --> Rancher: _watch_ request
+ * 2. Rancher --> UI: `resource.start`. UI sets watch as started
+ * 3. Rancher --> UI: `resource.changes` (contains no data). UI makes a HTTP request to fetch data
+ *
+ * Successful flow - unwatch
+ * 1. UI --> Rancher: _unwatch_ request
+ * 2. Rancher --> UI: `resource.stop`. UI sets watch as stopped
+ *
+ * Successful flow - resource.stop received
+ * 1. Rancher --> UI: `resource.stop`. UI sets watch as stopped
+ * 2. UI --> Rancher: _watch_ request
+ *
+ * Successful flow - socket disconnected
+ * 1. Socket closes|disconnects (not sure which)
+ * 2. UI: reopens socket
+ * 3. UI --> Rancher: _watch_ request (for every started watch)
+ *
+ * Error Flow
+ * 1. UI --> Rancher: _watch_ request
+ * 2. Rancher --> UI: `resource.start`. UI sets watch as started
+ * 3. Rancher --> UI: `resource.error`. UI sets watch as errored.
+ *   a) UI: in the event of 'too old' the UI will make a http request to fetch a new revision and re-watch with it. This process is delayed on each call
+ * 4. Rancher --> UI: `resource.stop`. UI sets watch as stop (note the resource.stop flow above is avoided given error state)
+ *
+ * Additionally
+ * - if we receive resource.stop, unless the watch is in error, we immediately send back a watch event
+ * - if the web socket is disconnected (for steve based sockets it happens every 30 mins, or when there are permission changes)
+ *   the ui will re-connect it and re-watch all previous watches using a best effort revision
  */
 
 import { addObject, clear, removeObject } from '@shell/utils/array';
@@ -34,7 +83,10 @@ import { waitFor } from '@shell/utils/async';
 import { WORKER_MODES } from './worker';
 import acceptOrRejectSocketMessage from './accept-or-reject-socket-message';
 import { BLANK_CLUSTER, STORE } from '@shell/store/store-types.js';
+import { _MERGE } from '@shell/plugins/dashboard-store/actions';
+import { STEVE_WATCH_EVENT, STEVE_WATCH_MODE } from '@shell/types/store/subscribe.types';
 import paginationUtils from '@shell/utils/pagination-utils';
+import backOff from '@shell/utils/back-off';
 
 // minimum length of time a disconnect notification is shown
 const MINIMUM_TIME_NOTIFIED = 3000;
@@ -86,7 +138,7 @@ export async function createWorker(store, ctx) {
       postMessage: (msg) => {
         if (Object.keys(msg)?.[0] === 'destroyWorker') {
           // The worker has been destroyed before it's been set up. Flag this so we stop waiting for mgmt settings and then can destroy worker.
-          // This can occurr when the user is redirected to the log in page
+          // This can occur when the user is redirected to the log in page
           // - workers created (but waiting)
           // - logout is called
           // - <store>/unsubscribe is dispatched
@@ -185,10 +237,14 @@ export async function createWorker(store, ctx) {
 }
 
 export function equivalentWatch(a, b) {
-  const aresourceType = a.resourceType || a.type;
-  const bresourceType = b.resourceType || b.type;
+  const aResourceType = a.resourceType || a.type;
+  const bResourceType = b.resourceType || b.type;
 
-  if ( aresourceType !== bresourceType ) {
+  if ( aResourceType !== bResourceType ) {
+    return false;
+  }
+
+  if (a.mode !== b.mode && (a.mode || b.mode)) {
     return false;
   }
 
@@ -256,6 +312,34 @@ function growlsDisabled(rootGetters) {
   return getPerformanceSetting(rootGetters)?.disableWebsocketNotification;
 }
 
+/**
+ * Supported events are listed
+ *
+ * of type { [key: STEVE_WATCH_EVENT]: STEVE_WATCH_EVENT_LISTENER[]}
+ */
+const listeners = { [STEVE_WATCH_EVENT.CHANGES]: [] };
+
+/**
+ * Given a started or error entry, is it compatible with the given change in mode?
+ */
+const shouldUnwatchIncompatible = (messageMeta, mode) => {
+  if (messageMeta.mode === STEVE_WATCH_EVENT.CHANGES) {
+    return mode !== STEVE_WATCH_EVENT.CHANGES;
+  }
+
+  return mode === STEVE_WATCH_EVENT.CHANGES;
+};
+
+/**
+ * clear the provided error, but also ensure any backoff request associated with it is cleared as well
+ */
+const clearInError = ({ getters, commit }, error) => {
+  // for this watch ... get the specific prefix we care about ... reset back-offs related to it
+  backOff.resetPrefix(getters.backOffId(error.obj, ''));
+  // Clear out stale error state (next time around we can try again with a new revision that was just fetched)
+  commit('clearInError', error.obj);
+};
+
 /**
  * Actions that cover all cases (see file description)
  */
@@ -334,7 +418,9 @@ const sharedActions = {
     }
   },
 
-  unsubscribe({ commit, getters, state }) {
+  async unsubscribe({
+    commit, getters, state, dispatch
+  }) {
     const socket = state.socket;
 
     commit('setWantSocket', false);
@@ -351,17 +437,85 @@ const sharedActions = {
       cleanupTasks.push(socket.disconnect());
     }
 
+    await dispatch('resetWatchBackOff');
+
     return Promise.all(cleanupTasks);
   },
 
+  /**
+   * Create a trigger for a specific type of watch event
+   *
+   * For example if a watch on mgmt clusters exists and a page wants to know when any changes occur
+   * @param {} ctx
+   * @param {STEVE_WATCH_EVENT_PARAMS} event
+   */
+  watchEvent(ctx, {
+    event = STEVE_WATCH_EVENT.CHANGES,
+    id,
+    callback,
+    /**
+     * of type @STEVE_WATCH_PARAMS
+     */
+    params
+  }) {
+    if (!listeners[event]) {
+      console.error(`Unknown event type "${ event }", only ${ Object.keys(listeners).join(',') } are supported`); // eslint-disable-line no-console
+
+      return;
+    }
+
+    // STEVE_WATCH_EVENT_LISTENER | undefined
+    let listener = listeners[event].find((l) => equivalentWatch(l.params, params));
+
+    if (!listener) {
+      listener = {
+        params,
+        callbacks: { }
+      };
+      listeners[event].push(listener);
+    }
+
+    if (!listener.callbacks[id]) {
+      listener.callbacks[id] = callback;
+      ctx.dispatch('watch', params);
+    }
+  },
+
+  /**
+   * @param {} ctx
+   * @param {STEVE_UNWATCH_EVENT_PARAMS} event
+   */
+  unwatchEvent(ctx, {
+    event = STEVE_WATCH_EVENT.CHANGES,
+    id,
+    /**
+     * of type @STEVE_WATCH_PARAMS
+     */
+    params
+  }) {
+    if (!listeners[event]) {
+      console.info(`Attempted to unwatch for an event "${ event }" but it had no watchers`); // eslint-disable-line no-console
+
+      return;
+    }
+
+    const existing = listeners[event].find((l) => equivalentWatch(l.params, params));
+
+    if (existing) {
+      delete existing.callbacks[id];
+    }
+  },
+
+  /**
+   * @param {STEVE_WATCH_PARAMS} params
+   */
   watch({
     state, dispatch, getters, rootGetters
   }, params) {
     state.debugSocket && console.info(`Watch Request [${ getters.storeName }]`, JSON.stringify(params)); // eslint-disable-line no-console
-
     let {
       // eslint-disable-next-line prefer-const
-      type, selector, id, revision, namespace, stop, force
+      type, selector, id, revision, namespace, stop, force, mode
     } = params;
 
     namespace = acceptOrRejectSocketMessage.subscribeNamespace(namespace);
@@ -393,29 +547,43 @@ const sharedActions = {
       return;
     }
 
-    if ( !stop && getters.watchStarted({
-      type, id, selector, namespace
-    }) ) {
+    const messageMeta = {
+      type, id, selector, namespace, mode
+    };
+
+    if (!stop && getters.watchStarted(messageMeta)) {
       // eslint-disable-next-line no-console
       state.debugSocket && console.debug(`Already Watching [${ getters.storeName }]`, {
-        type, id, selector, namespace
+        type, id, selector, namespace, mode
       });
 
       return;
     }
 
-    // isSteveCacheEnabled check is temporary and will be removed once Part 3 of https://github.com/rancher/dashboard/pull/10349 is resolved by backend
-    // Steve cache backed api does not return a revision, so `revision` here is always undefined
-    // Which means we find a revision within a resource itself and use it in the watch
-    // That revision is probably too old and results in a watch error
+    if (!stop) {
+      dispatch('unwatchIncompatible', messageMeta);
+    }
+
     // Watch errors mean we make a http request to get latest revision (which is still missing) and try to re-watch with it...
     // etc
-    if (typeof revision === 'undefined' && !paginationUtils.isSteveCacheEnabled({ rootGetters })) {
+    if (typeof revision === 'undefined') {
       revision = getters.nextResourceVersion(type, id);
     }
 
     const msg = { resourceType: type };
 
+    if (mode) {
+      msg.mode = mode;
+
+      if (mode === STEVE_WATCH_MODE.RESOURCE_CHANGES) {
+        const debounceMs = paginationUtils.resourceChangesDebounceMs({ rootGetters });
+
+        if (debounceMs) {
+          msg.debounceMs = debounceMs;
+        }
+      }
+    }
+
     if ( revision ) {
       msg.resourceVersion = `${ revision }`;
     }
@@ -451,8 +619,11 @@ const sharedActions = {
     return dispatch('send', msg);
   },
 
+  /**
+   * @param {STEVE_WATCH_PARAMS} params
+   */
   unwatch(ctx, {
-    type, id, namespace, selector, all
+    type, id, namespace, selector, all, mode
   }) {
     const { commit, getters, dispatch } = ctx;
 
@@ -464,6 +635,7 @@ const sharedActions = {
         id,
         namespace,
         selector,
+        mode,
         stop: true, // Stops the watch on a type
       };
 
@@ -477,13 +649,15 @@ const sharedActions = {
           // Make sure anything in the pending queue for the type is removed, since we've now removed the type
           commit('clearFromQueue', type);
         }
+        // Ensure anything pinging in the background is stopped
+        backOff.resetPrefix(getters.backOffId(obj));
       };
 
       if (isAdvancedWorker(ctx)) {
         dispatch('watch', obj); // Ask the backend to stop watching the type
       } else if (all) {
         getters['watchesOfType'](type).forEach((obj) => {
-          unwatch(obj);
+          unwatch({ ...obj, stop: true });
         });
       } else if (getters['watchStarted'](obj)) {
         unwatch(obj);
@@ -491,6 +665,68 @@ const sharedActions = {
     }
   },
 
+  /**
+   * Unwatch watches that are incompatible with the new type
+   */
+  unwatchIncompatible({
+    state, dispatch, getters, commit
+  }, messageMeta) {
+    // Step 1 - Clear incompatible watches that have STARTED
+    const watchesOfType = getters.watchesOfType(messageMeta.type);
+
+    watchesOfType
+      .filter((entry) => shouldUnwatchIncompatible(messageMeta, entry.mode))
+      .forEach((entry) => {
+        dispatch('unwatch', entry);
+      });
+
+    // Step 2 - Clear inError state for incompatible watches (these won't appear in watchesOfType / state.started)
+    // (important for the backoff case... for example backoff request to find would overwrite findPage res if executed after nav from detail to list)
+    const inErrorOfType = Object.values(state.inError || {})
+      .filter((error) => error.obj.type === messageMeta.type);
+
+    inErrorOfType
+      .filter((error) => shouldUnwatchIncompatible(messageMeta, error.obj.mode))
+      .forEach((error) => clearInError({ getters, commit }, error));
+  },
+
+  /**
+   * Ensure there's no back-off process waiting to run for
+   * - resource.changes fetchResources
+   * - resource.error resyncWatches
+   */
+  resetWatchBackOff({ state, getters, commit }, {
+    type, compareWatches, resetInError = true, resetStarted = true
+  } = { resetInError: true, resetStarted: true }) {
+    // Step 1 - Reset back-offs related to watches that have STARTED
+    if (resetStarted && state.started?.length) {
+      let entries = state.started;
+
+      if (type) { // Filter out ones for types we're no interested in
+        entries = entries
+          .filter((obj) => compareWatches ? compareWatches(obj) : obj.type === type);
+      }
+
+      entries.forEach((obj) => backOff.resetPrefix(getters.backOffId(obj, '')));
+    }
+
+    // Step 2 - Reset back-offs related to watches that are in error (and may not be started)
+    if (resetInError && state.inError) {
+      // (it would be nicer if we could store backOff state in `state.started`,
+      // however resource.stop clears `started` and we need the settings to persist over start-->error-->stop-->start cycles
+      let entries = Object.values(state.inError || {});
+
+      if (type) { // Filter out ones for types we're no interested in
+        entries = entries
+          .filter((error) => compareWatches ? compareWatches(error.obj) : error.obj.type === type);
+      }
+
+      entries
+        .filter((error) => error.reason === REVISION_TOO_OLD) // Filter out ones for reasons we're not interested in
+        .forEach((error) => clearInError({ getters, commit }, error));
+    }
+  },
+
   'ws.ping'({ getters, dispatch }, msg) {
     if ( getters.storeName === 'management' ) {
       const version = msg?.data?.version || null;
@@ -587,16 +823,30 @@ const defaultActions = {
     return Promise.all(promises);
   },
 
-  async resyncWatch({
+  /**
+   * Socket has been closed, restart afresh (make http request, ensure we re-watch)
+   */
+  async resyncWatch({ getters, dispatch }, params) {
+    console.info(`Resync [${ getters.storeName }]`, params); // eslint-disable-line no-console
+
+    await dispatch('fetchResources', {
+      ...params,
+      opt: { force: true, forceWatch: true }
+    });
+  },
+
+  async fetchResources({
     state, getters, dispatch, commit
-  }, params) {
+  }, { opt, ...params }) {
     const {
-      resourceType, namespace, id, selector
+      resourceType, namespace, id, selector, mode
     } = params;
 
-    console.info(`Resync [${ getters.storeName }]`, params); // eslint-disable-line no-console
+    if (!resourceType) {
+      console.error(`A socket message has prompted a request to fetch a resource but no resource type was supplied`); // eslint-disable-line no-console
 
-    const opt = { force: true, forceWatch: true };
+      return;
+    }
 
     if ( id ) {
       await dispatch('find', {
@@ -613,7 +863,7 @@ const defaultActions = {
 
       return;
     }
-    let have, want;
+    let have = []; let want = [];
 
     if ( selector ) {
       have = getters['matching'](resourceType, selector).slice();
@@ -623,17 +873,50 @@ const defaultActions = {
         opt,
       });
     } else {
-      have = getters['all'](resourceType).slice();
+      if (mode === STEVE_WATCH_MODE.RESOURCE_CHANGES) {
+        // Other findX use options (id/ns/selector) from the messages received over socket.
+        // However paginated requests have more complex params so grab them from store from the store.
+        // of type @StorePagination
+        const storePagination = getters['havePage'](resourceType);
+
+        if (!!storePagination) {
+          have = []; // findPage removes stale entries, so we don't need to rely on below process to remove them
+
+          // This could have been kicked off given a resource.changes message
+          // If the messages come in quicker than findPage completes (resource.changes debounce time >= http request time),
+          // and the request is the same, only the first request will be processed. all others until it finishes will be ignored
+          // (see deferred process - `waiting.push(later);` - in request action).
+          // If this becomes an issue we need to debounce and work around the deferred issue within request
+          want = await dispatch('findPage', {
+            type: resourceType,
+            opt:  {
+              ...opt,
+              namespaced: namespace,
+              // This brings in page, page size, filter, etc
+              ...storePagination.request
+            }
+          });
+        }
 
-      if ( namespace ) {
-        have = have.filter((x) => x.metadata?.namespace === namespace);
-      }
+        // Should any listeners be notified of this request for them to kick off their own event handling?
+        const listener = listeners[STEVE_WATCH_MODE.RESOURCE_CHANGES].find((sl) => equivalentWatch(sl.params, params));
 
-      want = await dispatch('findAll', {
-        type:           resourceType,
-        watchNamespace: namespace,
-        opt
-      });
+        if (listener) {
+          Object.values(listener.callbacks).forEach((cb) => cb());
+        }
+      } else {
+        have = getters['all'](resourceType).slice();
+
+        if ( namespace ) {
+          have = have.filter((x) => x.metadata?.namespace === namespace);
+        }
+
+        want = await dispatch('findAll', {
+          type:           resourceType,
+          watchNamespace: namespace,
+          opt
+        });
+      }
     }
 
     const wantMap = {};
@@ -701,15 +984,20 @@ const defaultActions = {
     }
   },
 
-  closed({ state, getters }) {
+  async closed({ state, getters, dispatch }) {
     state.debugSocket && console.info(`WebSocket Closed [${ getters.storeName }]`); // eslint-disable-line no-console
+
+    await dispatch('resetWatchBackOff');
     clearTimeout(state.queueTimer);
     state.queueTimer = null;
   },
 
-  error({
+  async error({
     getters, state, dispatch, rootGetters
   }, e) {
+    state.debugSocket && console.info(`WebSocket Error [${ getters.storeName }]`); // eslint-disable-line no-console
+
+    await dispatch('resetWatchBackOff');
     clearTimeout(state.queueTimer);
     state.queueTimer = null;
 
@@ -792,7 +1080,8 @@ const defaultActions = {
       type:      msg.resourceType,
       namespace: msg.namespace,
       id:        msg.id,
-      selector:  msg.selector
+      selector:  msg.selector,
+      mode:      msg.mode,
     };
 
     state.started.filter((entry) => {
@@ -823,7 +1112,23 @@ const defaultActions = {
       // 1) blocks attempts by resource.stop to resub (as type is in error)
       // 2) will be cleared when resyncWatch --> watch (with force) --> resource.start completes
       commit('setInError', { msg, reason: REVISION_TOO_OLD });
-      dispatch('resyncWatch', msg);
+
+      // See Scenario 1 from https://github.com/rancher/dashboard/issues/14974
+      // The watch that results from resyncWatch will fail and end up here if the revision isn't (yet) known
+      // So re-retry resyncWatch until it does OR
+      // - we're already re-retrying
+      //   - early exist from `execute`
+      // - we give up (exceed max retries)
+      //   - early exist from `execute`
+      // - we need to stop (socket is disconnected or closed, type is 'forgotten', watch is unwatched)
+      //   - `reset` called asynchronously
+      //   - Note - we won't need to clear the id outside of the above scenarios because `too old` only occurs on fresh watches (covered by above scenarios)
+      backOff.execute({
+        id:          getters.backOffId(msg, REVISION_TOO_OLD),
+        description: `Invalid watch revision, re-syncing`,
+        canFn:       () => getters.canBackoff(this.$socket),
+        delayedFn:   () => dispatch('resyncWatch', msg),
+      });
     } else if ( err.includes('the server does not allow this method on the requested resource')) {
       commit('setInError', { msg, reason: NO_PERMS });
     }
@@ -846,7 +1151,8 @@ const defaultActions = {
       type,
       id:        msg.id,
       namespace: msg.namespace,
-      selector:  msg.selector
+      selector:  msg.selector,
+      mode:      msg.mode
     };
 
     state.debugSocket && console.info(`Resource Stop [${ getters.storeName }]`, type, msg); // eslint-disable-line no-console
@@ -922,6 +1228,13 @@ const defaultActions = {
     }
   },
 
+  'ws.resource.changes'({ dispatch }, msg) {
+    dispatch('fetchResources', {
+      ...msg,
+      opt: { force: true, load: _MERGE }
+    } );
+  },
+
   'ws.resource.remove'(ctx, msg) {
     const data = msg.data;
     const type = data.type;
@@ -999,21 +1312,33 @@ const defaultMutations = {
   setInError(state, { msg, reason }) {
     const key = keyForSubscribe(msg);
 
-    state.inError[key] = reason;
+    const { data, resourceType, ...obj } = msg;
+
+    obj.type = msg.resourceType || msg.type;
+
+    state.inError[key] = { obj, reason };
   },
 
   clearInError(state, msg) {
+    // Callers of this should consider using local clearInError instead
+
     const key = keyForSubscribe(msg);
 
     delete state.inError[key];
   },
 
+  /**
+   * Clear out socket state
+   */
   resetSubscriptions(state) {
-    // Clear out socket state. This is only ever called from reset... which is always called after we `disconnect` above.
-    // This could probably be folded in to there
     clear(state.started);
     clear(state.pendingFrames);
     clear(state.queue);
+    // Note - we clear async operations here (like queueTimer) and we should also do so for backoff requests via
+    // resetWatchBackOff, however can't because this is a mutation and it's an action
+    // We shouldn't need to though given resetSubscription is called from store reset, which includes forgetType
+    // on everything in the store, which resets backoff requests.
+    // Additionally this is probably called on a cluster store, so we also call resetWatchBackOff when the socket disconnects
     clearTimeout(state.queueTimer);
     state.deferredRequests = {};
     state.queueTimer = null;
@@ -1031,8 +1356,27 @@ const defaultMutations = {
  * Getters that cover cases 1 & 2 (see file description)
  */
 const defaultGetters = {
+  /**
+   * Get a unique id that can be used to track a process that can be backed-off
+   *
+   * @param obj - the usual id/namespace/selector, etc,
+   * @param postFix - something else to uniquely id this back-off
+   */
+  backOffId: () => (obj, postFix) => {
+    return `${ keyForSubscribe(obj) }${ postFix ? `:${ postFix }` : '' }`;
+  },
+
+  /**
+   * Can the back off process run?
+   *
+   * If we're not connected no.
+   */
+  canBackoff: () => ($socket) => {
+    return $socket.state === EVENT_CONNECTED;
+  },
+
   inError: (state) => (obj) => {
-    return state.inError[keyForSubscribe(obj)];
+    return state.inError[keyForSubscribe(obj)]?.reason;
   },
 
   watchesOfType: (state) => (type) => {
@@ -1040,9 +1384,24 @@ const defaultGetters = {
   },
 
   watchStarted: (state) => (obj) => {
-    return !!state.started.find((entry) => equivalentWatch(obj, entry));
+    const existing = state.started.find((entry) => equivalentWatch(obj, entry));
+
+    return !!existing;
   },
 
+  /**
+   * Try to determine the latest revision to use in a watch request.
+   *
+   * It does some dodgy revision comparisons (revisions are not guaranteed to be numerical or equate higher to newer)
+   *
+   * If we have an id - and that resource has a revision - use it
+   * If we have a list - and the store has a revision - and it's a string - use it straight away
+   * If we have a list - and the store has a revision - and it's a number - compare it to the revisions in the list and use overall highest
+   *
+   * Note - This used to use parseInt which does stuff like `abc-123` --> NaN, `123-abc` --> 123
+   *
+   * Returns string, non-zero number or null
+   */
   nextResourceVersion: (state, getters) => (type, id) => {
     type = normalizeType(type);
     let revision = 0;
@@ -1050,32 +1409,38 @@ const defaultGetters = {
     if ( id ) {
       const existing = getters['byId'](type, id);
 
-      revision = parseInt(existing?.metadata?.resourceVersion, 10);
+      revision = existing?.metadata?.resourceVersion;
     }
 
     if ( !revision ) {
       const cache = state.types[type];
 
+      // No Cache, nothing to compare to, return early
       if ( !cache ) {
         return null;
       }
 
-      revision = cache.revision; // This is always zero.....
+      revision = Number(cache.revision);
 
-      for ( const obj of cache.list ) {
+      // Cached LIST revision isn't a number, cannot compare to, return early
+      if (Number.isNaN(revision)) {
+        return cache.revision || null;
+      }
+
+      for ( const obj of cache.list || [] ) {
         if ( obj && obj.metadata ) {
-          const neu = parseInt(obj.metadata.resourceVersion, 10);
+          const neu = Number(obj.metadata.resourceVersion);
+
+          if (Number.isNaN(neu)) {
+            continue;
+          }
 
           revision = Math.max(revision, neu);
         }
       }
     }
 
-    if ( revision ) {
-      return revision;
-    }
-
-    return null;
+    return revision || null;
   },
 };