@rancher/shell 0.5.3 → 2.0.0

package/plugins/dashboard-store/actions.js

@@ -8,11 +8,11 @@ import { normalizeType } from './normalize';
 import garbageCollect from '@shell/utils/gc/gc';
 import { addSchemaIndexFields } from '@shell/plugins/steve/schema.utils';
 import { addParam } from '@shell/utils/url';
+import { conditionalDepaginate } from '@shell/store/type-map.utils';
 
 export const _ALL = 'all';
 export const _MERGE = 'merge';
 export const _MULTI = 'multi';
-export const _ALL_IF_AUTHED = 'allIfAuthed';
 export const _NONE = 'none';
 
 const SCHEMA_CHECK_RETRIES = 15;
@@ -124,7 +124,7 @@ export default {
           }
         });
       } else {
-      // We have everything!
+        // We have everything!
         if (opt.hasManualRefresh) {
           dispatch('resource-fetch/updateManualRefreshIsLoading', false, { root: true });
         }
@@ -143,6 +143,11 @@ export default {
     }
   },
 
+  /**
+   *
+   * @param {*} ctx
+   * @param { {type: string, opt: ActionFindPageArgs} } opt
+   */
   async findAll(ctx, { type, opt }) {
     const {
       getters, commit, dispatch, rootGetters
@@ -156,16 +161,22 @@ export default {
     }
 
     // No need to request the resources if we have them already
-    if ( opt.force !== true && (getters['haveAll'](type) || getters['haveAllNamespace'](type, opt.namespaced))) {
-      const args = {
-        type,
-        revision:  '',
-        // watchNamespace - used sometimes when we haven't fetched the results of a single namespace
-        // namespaced - used when we have fetched the result of a single namespace (see https://github.com/rancher/dashboard/pull/7329/files)
-        namespace: opt.watchNamespace || opt.namespaced
-      };
-
+    if (
+      !opt.force &&
+      (
+        getters['haveAll'](type) ||
+        getters['haveAllNamespace'](type, opt.namespaced)
+      )
+    ) {
       if (opt.watch !== false ) {
+        const args = {
+          type,
+          revision:  '',
+          // watchNamespace - used sometimes when we haven't fetched the results of a single namespace
+          // namespaced - used when we have fetched the result of a single namespace (see https://github.com/rancher/dashboard/pull/7329/files)
+          namespace: opt.watchNamespace || opt.namespaced
+        };
+
         dispatch('watch', args);
       }
 
@@ -176,14 +187,6 @@ export default {
 
     if ( opt.load === false || opt.load === _NONE ) {
       load = _NONE;
-    } else if ( opt.load === _ALL_IF_AUTHED ) {
-      const header = rootGetters['auth/fromHeader'];
-
-      if ( `${ header }` === 'true' || `${ header }` === 'none' ) {
-        load = _ALL;
-      } else {
-        load = _MULTI;
-      }
     }
 
     const typeOptions = rootGetters['type-map/optionsFor'](type);
@@ -192,7 +195,7 @@ export default {
     opt = opt || {};
     opt.url = getters.urlFor(type, null, opt);
     opt.stream = opt.stream !== false && load !== _NONE;
-    opt.depaginate = typeOptions?.depaginate;
+    opt.depaginate = conditionalDepaginate(typeOptions?.depaginate, { ctx, args: { type, opt } });
 
     let skipHaveAll = false;
 
@@ -200,6 +203,8 @@ export default {
     // on for a limit of 100, to quickly show data
     // another one with 1st page of the subset of the resource we are fetching
     // the default is 4 pages, but it can be changed on mixin/resource-fetch.js
+    let pageFetchOpts;
+
     if (opt.incremental) {
       commit('incrementLoadCounter', type);
 
@@ -207,7 +212,7 @@ export default {
         dispatch('resource-fetch/updateManualRefreshIsLoading', true, { root: true });
       }
 
-      const pageFetchOpts = {
+      pageFetchOpts = {
         ...opt,
         url: addParam(opt.url, 'limit', `${ opt.incremental }`),
       };
@@ -223,8 +228,6 @@ export default {
       if (opt.force) {
         commit('forgetType', type);
       }
-
-      dispatch('loadDataPage', { type, opt: pageFetchOpts });
     }
 
     let streamStarted = false;
@@ -313,12 +316,25 @@ export default {
         commit('loadAll', {
           ctx,
           type,
-          data:      out.data,
-          revision:  out.revision,
+          data:       out.data,
+          revision:   out.revision,
           skipHaveAll,
-          namespace: opt.namespaced
+          namespace:  opt.namespaced,
+          pagination: opt.pagination ? {
+            request: opt.pagination,
+            result:  {
+              count:     out.count,
+              pages:     out.pages,
+              timestamp: new Date().getTime()
+            }
+          } : undefined,
         });
       }
+
+      if (opt.incremental) {
+        // This needs to come after the loadAll (which resets state) so supplements via loadDataPage aren't lost
+        dispatch('loadDataPage', { type, opt: pageFetchOpts });
+      }
     }
 
     // ToDo: SM if we start a "bigger" watch (such as watch without a namespace vs a watch with a namespace), we should stop the stop the "smaller" watch so we don't have duplicate events coming back
@@ -345,6 +361,81 @@ export default {
     return all;
   },
 
+  /**
+   *
+   * @param {*} ctx
+   * @param { {type: string, opt: FindPageOpt} } opt
+   */
+  async findPage(ctx, { type, opt }) {
+    const { getters, commit, dispatch } = ctx;
+
+    opt = opt || {};
+
+    if (!opt.pagination) {
+      console.error('Attempting to find a page for a resource but no pagination settings supplied', type); // eslint-disable-line no-console
+
+      return;
+    }
+
+    type = getters.normalizeType(type);
+
+    if ( !getters.typeRegistered(type) ) {
+      commit('registerType', type);
+    }
+
+    // No need to request the resources if we have them already
+    if (!opt.force && getters['havePaginatedPage'](type, opt)) {
+      return findAllGetter(getters, type, opt);
+    }
+
+    console.log(`Find Page: [${ ctx.state.config.namespace }] ${ type }. Page: ${ opt.pagination.page }. Size: ${ opt.pagination.pageSize }`); // eslint-disable-line no-console
+    opt = opt || {};
+    opt.url = getters.urlFor(type, null, opt);
+
+    let out;
+
+    try {
+      if (opt.hasManualRefresh) {
+        dispatch('resource-fetch/updateManualRefreshIsLoading', true, { root: true });
+      }
+
+      out = await dispatch('request', { opt, type });
+    } catch (e) {
+      if (opt.hasManualRefresh) {
+        dispatch('resource-fetch/updateManualRefreshIsLoading', false, { root: true });
+      }
+
+      return Promise.reject(e);
+    }
+
+    commit('loadPage', {
+      ctx,
+      type,
+      data:       out.data,
+      pagination: opt.pagination ? {
+        request: {
+          namespace:  opt.namespaced,
+          pagination: opt.pagination
+        },
+        result: {
+          count:     out.count,
+          pages:     out.pages,
+          timestamp: new Date().getTime()
+        }
+      } : undefined,
+    });
+
+    const all = findAllGetter(getters, type, opt);
+
+    if (opt.hasManualRefresh) {
+      dispatch('resource-fetch/updateManualRefreshIsLoading', false, { root: true });
+    }
+
+    garbageCollect.gcUpdateLastAccessed(ctx, type);
+
+    return all;
+  },
+
   async findMatching(ctx, {
     type,
     selector,
@@ -371,7 +462,7 @@ export default {
     opt = opt || {};
     opt.labelSelector = selector;
     opt.url = getters.urlFor(type, null, opt);
-    opt.depaginate = typeOptions?.depaginate;
+    opt.depaginate = conditionalDepaginate(typeOptions?.depaginate, { ctx, args: { type, opt } });
 
     const res = await dispatch('request', { opt, type });
 
@@ -443,8 +534,13 @@ export default {
       const watchMsg = {
         type,
         id,
-        revision: res?.metadata?.resourceVersion,
-        force:    opt.forceWatch === true,
+        // Although not used by sockets, we need this for when resyncWatch calls find... which needs namespace to construct the url
+        namespace: opt.namespaced,
+        // Override the revision. Used in cases where we need to avoid using the resource's own revision which would be `too old`.
+        // For the above case opt.revision will be `null`. If left as `undefined` the subscribe mechanism will try to determine a revision
+        // from resources in store (which would be this one, with the too old revision)
+        revision:  typeof opt.revision !== 'undefined' ? opt.revision : res?.metadata?.resourceVersion,
+        force:     opt.forceWatch === true,
       };
 
       const idx = id.indexOf('/');
@@ -543,8 +639,18 @@ export default {
     return data.map((d) => classify(ctx, d));
   },
 
-  createPopulated(ctx, userData) {
-    const data = ctx.getters['defaultFor'](userData.type);
+  async createPopulated(ctx, userData) {
+    let data = null;
+
+    const schema = ctx.getters['schemaFor'](userData.type);
+
+    if (schema) {
+      if (schema.fetchResourceFields) {
+        // fetch resourceFields for createYaml
+        await schema.fetchResourceFields();
+      }
+      data = ctx.getters['defaultFor'](userData.type, schema);
+    }
 
     merge(data, userData);
 
@@ -613,7 +719,9 @@ export default {
     let schema = null;
 
     while (!schema && tries > 0) {
-      schema = getters['schemaFor'](type);
+      // Schemas may not have been loaded, so don't error out if they are not loaded yet
+      // the wait here will wait for schemas to load and then for the desired schema to be available
+      schema = getters['schemaFor'](type, false, false);
 
       if (!schema) {
         if (tries === RETRY_LOG) {

package/plugins/dashboard-store/getters.js

@@ -3,21 +3,22 @@ import { SCHEMA, COUNT } from '@shell/config/types';
 
 import { matches } from '@shell/utils/selector';
 import { typeMunge, typeRef, SIMPLE_TYPES } from '@shell/utils/create-yaml';
-import { splitObjectPath } from '@shell/utils/string';
-import { parseType } from '@shell/models/schema';
 import Resource from '@shell/plugins/dashboard-store/resource-class';
 import mutations from './mutations';
 import { keyFieldFor, normalizeType } from './normalize';
 import { lookup } from './model-loader';
 import garbageCollect from '@shell/utils/gc/gc';
+import paginationUtils from '@shell/utils/pagination-utils';
 
 export const urlFor = (state, getters) => (type, id, opt) => {
   opt = opt || {};
   type = getters.normalizeType(type);
   let url = opt.url;
 
+  let schema;
+
   if ( !url ) {
-    const schema = getters.schemaFor(type);
+    schema = getters.schemaFor(type);
 
     if ( !schema ) {
       throw new Error(`Unknown schema for type: ${ type }`);
@@ -40,7 +41,7 @@ export const urlFor = (state, getters) => (type, id, opt) => {
     url = `${ baseUrl }/${ url }`;
   }
 
-  url = getters.urlOptions(url, opt);
+  url = getters.urlOptions(url, opt, schema);
 
   return url;
 };
@@ -70,6 +71,9 @@ function matchingCounts(typeObj, namespaces) {
 
 export default {
 
+  /**
+   * Get all entries in the store. This might not mean all entries of this type
+   */
   all: (state, getters, rootState) => (type) => {
     type = getters.normalizeType(type);
 
@@ -122,30 +126,13 @@ export default {
     }
   },
 
+  /**
+   * Checks a schema for the given path
+   *
+   * Given that schema are primarily a rancher thing most logic is in the `steve` store
+   */
   pathExistsInSchema: (state, getters) => (type, path) => {
-    let schema = getters.schemaFor(type);
-    const parts = splitObjectPath(path);
-
-    while ( parts.length ) {
-      const key = parts.shift();
-
-      type = schema.resourceFields?.[key]?.type;
-
-      if ( !type ) {
-        return false;
-      }
-
-      if ( parts.length ) {
-        type = parseType(type).pop(); // Get the main part of array[map[something]] => something
-        schema = getters.schemaFor(type);
-
-        if ( !schema ) {
-          return false;
-        }
-      }
-    }
-
-    return true;
+    return false;
   },
 
   // @TODO resolve difference between this and schemaFor and have only one of them.
@@ -216,17 +203,28 @@ export default {
     return out;
   },
 
-  defaultFor: (state, getters) => (type) => {
-    const schema = getters['schemaFor'](type);
+  defaultFor: (state, getters) => (type, rootSchema, schemaDefinitions = null) => {
+    let resourceFields;
 
-    if ( !schema ) {
-      return null;
+    if (!schemaDefinitions) {
+      // Depth 0. Get the schemaDefinitions that will contain the child schema resourceFields for recursive calls
+
+      schemaDefinitions = rootSchema.schemaDefinitions || {}; // norman...
+      resourceFields = rootSchema.resourceFields || {};
+    } else {
+      if (rootSchema.requiresResourceFields) {
+        resourceFields = schemaDefinitions[type]?.resourceFields || {};
+      } else {
+        const schema = getters['schemaFor'](type);
+
+        resourceFields = schema?.resourceFields || {};
+      }
     }
 
     const out = {};
 
-    for ( const key in schema.resourceFields ) {
-      const field = schema.resourceFields[key];
+    for ( const key in resourceFields ) {
+      const field = resourceFields[key];
 
       if ( !field ) {
         // Not much to do here...
@@ -234,12 +232,12 @@ export default {
       }
 
       const type = typeMunge(field.type);
-      const mapOf = typeRef('map', type);
-      const arrayOf = typeRef('array', type);
+      const mapOf = typeRef('map', type, field);
+      const arrayOf = typeRef('array', type, field);
       const referenceTo = typeRef('reference', type);
 
       if ( mapOf || type === 'map' || type === 'json' ) {
-        out[key] = getters.defaultFor(type);
+        out[key] = getters.defaultFor(type, rootSchema, schemaDefinitions);
       } else if ( arrayOf || type === 'array' ) {
         out[key] = [];
       } else if ( referenceTo ) {
@@ -251,7 +249,7 @@ export default {
           out[key] = field['default'];
         }
       } else {
-        out[key] = getters.defaultFor(type);
+        out[key] = getters.defaultFor(type, rootSchema, schemaDefinitions);
       }
     }
 
@@ -302,12 +300,39 @@ export default {
     return false;
   },
 
+  havePaginatedPage: (state, getters) => (type, opt) => {
+    if (!opt.pagination) {
+      return false;
+    }
+
+    type = getters.normalizeType(type);
+    const entry = state.types[type];
+
+    if ( entry?.havePage ) {
+      const { namespace: aNamespace = undefined, pagination: aPagination } = entry.havePage.request;
+      const { namespace: bNamespace = undefined, pagination: bPagination } = {
+        namespace:  opt.namespaced,
+        pagination: opt.pagination
+      };
+
+      return entry.havePage && aNamespace === bNamespace && paginationUtils.paginationEqual(aPagination, bPagination);
+    }
+
+    return false;
+  },
+
   haveNamespace: (state, getters) => (type) => {
     type = getters.normalizeType(type);
 
     return state.types[type]?.haveNamespace || null;
   },
 
+  havePage: (state, getters) => (type) => {
+    type = getters.normalizeType(type);
+
+    return state.types[type]?.havePage || null;
+  },
+
   haveSelector: (state, getters) => (type, selector) => {
     type = getters.normalizeType(type);
     const entry = state.types[type];
@@ -329,7 +354,7 @@ export default {
 
   urlFor,
 
-  urlOptions: () => (url, opt) => {
+  urlOptions: () => (url, opt, schema) => {
     return url;
   },
 
@@ -375,6 +400,10 @@ export default {
    *
    * This takes into account if the type is namespaced.
    *
+   * Used in currently two places
+   * - Type
+   * - getTree
+   *
    * @param typeObj see inners for properties. must have at least `name` (resource type)
    *
    */
@@ -391,6 +420,7 @@ export default {
       const counts = getters.all(COUNT)?.[0]?.counts || {};
       const count = counts[type];
 
+      // This object aligns with `Type.vue` `type`
       _typeObj = {
         count:       count ? count.summary.count || 0 : null,
         byNamespace: count ? count.namespaces : {},
@@ -399,9 +429,26 @@ export default {
       };
     }
 
-    const namespaces = Object.keys(rootGetters.activeNamespaceCache || {});
+    const namespaces = _typeObj?.namespaced ? Object.keys(rootGetters.activeNamespaceCache || {}) : [];
 
     return matchingCounts(_typeObj, namespaces.length ? namespaces : null);
   },
 
+  generation: (state, getters) => (type) => {
+    type = getters.normalizeType(type);
+    const entry = state.types[type];
+
+    if ( entry ) {
+      return entry.generation;
+    }
+
+    return undefined;
+  },
+
+  paginationEnabled: (state, getters, rootState, rootGetters) => (type = null) => {
+    const store = state.config.namespace;
+    const resource = type ? { id: type } : null;
+
+    return paginationUtils.isEnabled({ rootGetters }, { store, resource });
+  }
 };

package/plugins/dashboard-store/index.js

@@ -1,7 +1,3 @@
-import Vue from 'vue';
-
-import { isArray } from '@shell/utils/array';
-import { classify } from '@shell/plugins/dashboard-store/classify';
 import actions from './actions';
 import getters from './getters';
 import mutations from './mutations';
@@ -37,7 +33,6 @@ export default (vuexModule, config, init) => {
     store.commit(`${ namespace }/applyConfig`, config);
 
     const module = store._modules.root._children[namespace];
-    const fromServer = window.__NUXT__;
 
     const ctx = new Proxy(module.context, {
       get(obj, key) {
@@ -52,99 +47,5 @@ export default (vuexModule, config, init) => {
     if (init) {
       init(store, ctx);
     }
-
-    // Turn all the objects in the store from the server into proxies
-    const state = fromServer?.state?.[namespace];
-
-    if ( state ) {
-      Object.keys(state.types).forEach((type) => {
-        const keyField = store.getters[`${ namespace }/keyFieldForType`](type);
-        const cache = state.types[type];
-        const map = new Map();
-
-        for ( let i = 0 ; i < cache.list.length ; i++ ) {
-          const proxy = classify(ctx, cache.list[i]);
-
-          cache.list[i] = proxy;
-          map.set(proxy[keyField], proxy);
-        }
-
-        Vue.set(cache, 'map', map);
-        Vue.set(state.types, type, state.types[type]);
-      });
-    }
-
-    // Turn all the objects in data from the server into the object from the store;
-    if ( state && fromServer?.data ) {
-      fromServer.data = recurse(fromServer.data);
-    }
-
-    if ( state && fromServer?.fetch ) {
-      fromServer.fetch = recurse(fromServer.fetch);
-    }
-
-    function recurse(obj, parent, key) {
-      if ( isArray(obj) ) {
-        const rehydrateKey = `__rehydrateAll__${ key }`;
-
-        if ( parent && key && parent[rehydrateKey] ) {
-          const [ns, type] = parent[rehydrateKey].split('/', 2);
-
-          if ( ns === namespace ) {
-            // Don't delete the key, so that all the stores go through this path,
-            // and then do nothing if they are not for this namespace,
-            // instead of doing the else obj.map()
-            // and breaking the "live" reference to the cache.list array
-            // delete parent[rehydrateKey];
-
-            const cache = state.types[type];
-
-            if ( cache ) {
-              return cache.list;
-            }
-          }
-        } else {
-          return obj.map((x) => recurse(x));
-        }
-      } else if ( obj && typeof obj === 'object' ) {
-        if ( obj.__rehydrate ) {
-          if ( obj.__rehydrate !== namespace ) {
-            // Ignore types that are for another vuex namespace
-            return obj;
-          }
-
-          const type = obj.type;
-          const cache = state.types[type];
-
-          if ( cache && !obj.__clone ) {
-            const map = cache.map;
-            const keyField = store.getters[`${ namespace }/keyFieldForType`](type);
-            const entry = map.get(obj[keyField]);
-
-            // Map the object to the same instance in the store if possible
-            if ( entry ) {
-              return entry;
-            }
-          }
-
-          // Or just return a proxied object
-          delete obj.__rehydrate;
-
-          return classify(ctx, obj);
-        } else {
-          for ( const k of Object.keys(obj) ) {
-            if ( k.startsWith('__rehydrateAll__') ) {
-              continue;
-            }
-
-            if ( isArray(obj[k]) || typeof obj[k] === 'object' ) {
-              obj[k] = recurse(obj[k], obj, k);
-            }
-          }
-        }
-      }
-
-      return obj;
-    }
   };
 };