@rancher/shell 1.2.3 → 2.0.1

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;
@@ -72,6 +72,10 @@ export async function loadSchemas(ctx, watch = true) {
   return all;
 }
 
+const findAllGetter = (getters, type, opt) => {
+  return opt.namespaced ? getters.matching(type, null, opt.namespaced, { skipSelector: true }) : getters.all(type);
+};
+
 export default {
   request() {
     throw new Error('Not Implemented');
@@ -120,7 +124,7 @@ export default {
           }
         });
       } else {
-      // We have everything!
+        // We have everything!
         if (opt.hasManualRefresh) {
           dispatch('resource-fetch/updateManualRefreshIsLoading', false, { root: true });
         }
@@ -139,6 +143,11 @@ export default {
     }
   },
 
+  /**
+   *
+   * @param {*} ctx
+   * @param { {type: string, opt: ActionFindPageArgs} } opt
+   */
   async findAll(ctx, { type, opt }) {
     const {
       getters, commit, dispatch, rootGetters
@@ -152,7 +161,13 @@ 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))) {
+    if (
+      !opt.force &&
+      (
+        getters['haveAll'](type) ||
+        getters['haveAllNamespace'](type, opt.namespaced)
+      )
+    ) {
       if (opt.watch !== false ) {
         const args = {
           type,
@@ -165,21 +180,13 @@ export default {
         dispatch('watch', args);
       }
 
-      return getters.all(type);
+      return findAllGetter(getters, type, opt);
     }
 
     let load = (opt.load === undefined ? _ALL : opt.load);
 
     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);
@@ -188,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;
 
@@ -196,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);
 
@@ -203,7 +212,7 @@ export default {
         dispatch('resource-fetch/updateManualRefreshIsLoading', true, { root: true });
       }
 
-      const pageFetchOpts = {
+      pageFetchOpts = {
         ...opt,
         url: addParam(opt.url, 'limit', `${ opt.incremental }`),
       };
@@ -219,8 +228,6 @@ export default {
       if (opt.force) {
         commit('forgetType', type);
       }
-
-      dispatch('loadDataPage', { type, opt: pageFetchOpts });
     }
 
     let streamStarted = false;
@@ -309,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
@@ -330,7 +350,7 @@ export default {
       dispatch('watch', args);
     }
 
-    const all = getters.all(type);
+    const all = findAllGetter(getters, type, opt);
 
     if (!opt.incremental && opt.hasManualRefresh) {
       dispatch('resource-fetch/updateManualRefreshIsLoading', false, { root: true });
@@ -341,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,
@@ -367,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 });
 
@@ -439,7 +534,7 @@ export default {
       const watchMsg = {
         type,
         id,
-        // Although not used by sockets, we need this for when resyncWatch calls find.... which needs namespace to construct the url
+        // 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
@@ -544,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);
 
@@ -614,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/classify.js

@@ -12,24 +12,7 @@ export function classify(ctx, obj, isClone = false) {
 
   const customModel = ctx.getters['classify'](obj);
 
-  const out = new customModel(obj, ctx, (process.server ? ctx.state.config.namespace : null), isClone);
-
-  if ( process.server ) {
-    Object.defineProperty(obj, '__rehydrate', {
-      value:        ctx.state.config.namespace,
-      enumerable:   true,
-      configurable: true
-    });
-
-    if ( isClone ) {
-      Object.defineProperty(obj, '__clone', {
-        value:        true,
-        enumerable:   true,
-        configurable: true,
-        writable:     true
-      });
-    }
-  }
+  const out = new customModel(obj, ctx, null, isClone);
 
   return out;
 }

package/plugins/dashboard-store/getters.js

@@ -1,23 +1,24 @@
 
-import { SCHEMA } from '@shell/config/types';
+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,13 +41,39 @@ export const urlFor = (state, getters) => (type, id, opt) => {
     url = `${ baseUrl }/${ url }`;
   }
 
-  url = getters.urlOptions(url, opt);
+  url = getters.urlOptions(url, opt, schema);
 
   return url;
 };
 
+/**
+ * Find the number of resources given
+ * - if the type is namespaced
+ * - if there are any counts per namespace
+ * - if there are no namespaces
+ * - if there is no total count
+ */
+function matchingCounts(typeObj, namespaces) {
+  // That was easy
+  if ( !typeObj.namespaced || !typeObj.byNamespace || namespaces === null || typeObj.count === null) {
+    return typeObj.count;
+  }
+
+  let out = 0;
+
+  // Otherwise start with 0 and count up
+  for ( const namespace of namespaces ) {
+    out += typeObj.byNamespace[namespace]?.count || 0;
+  }
+
+  return out;
+}
+
 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);
 
@@ -64,19 +91,24 @@ export default {
     return state.types[type].list;
   },
 
-  matching: (state, getters, rootState) => (type, selector, namespace) => {
-    let all = getters['all'](type);
+  matching: (state, getters, rootState) => (type, selector, namespace, config = { skipSelector: false }) => {
+    let matching = getters['all'](type);
 
     // Filter first by namespace if one is provided, since this is efficient
-    if (namespace) {
-      all = all.filter((obj) => obj.namespace === namespace);
+    if (namespace && typeof namespace === 'string') {
+      matching = matching.filter((obj) => obj.namespace === namespace);
     }
 
     garbageCollect.gcUpdateLastAccessed({
       state, getters, rootState
     }, type);
 
-    return all.filter((obj) => {
+    // Looks like a falsy selector is a thing, so if we're not interested in filtering by the selector... explicitly avoid it
+    if (config.skipSelector) {
+      return matching;
+    }
+
+    return matching.filter((obj) => {
       return matches(obj, selector);
     });
   },
@@ -94,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.
@@ -188,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...
@@ -206,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 ) {
@@ -223,7 +249,7 @@ export default {
           out[key] = field['default'];
         }
       } else {
-        out[key] = getters.defaultFor(type);
+        out[key] = getters.defaultFor(type, rootSchema, schemaDefinitions);
       }
     }
 
@@ -274,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];
@@ -301,7 +354,7 @@ export default {
 
   urlFor,
 
-  urlOptions: () => (url, opt) => {
+  urlOptions: () => (url, opt, schema) => {
     return url;
   },
 
@@ -340,5 +393,62 @@ export default {
 
   gcIgnoreTypes: () => {
     return {};
+  },
+
+  /**
+   * For the given type, and it's settings, find the number of resources associated with it
+   *
+   * 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)
+   *
+   */
+  count: (state, getters, rootState, rootGetters) => (typeObj) => {
+    let _typeObj = typeObj;
+    const { name: type, count } = _typeObj;
+
+    if (!type) {
+      throw new Error(`Resource type required to calc count: ${ JSON.stringify(typeObj) }`);
+    }
+
+    if (!count) {
+      const schema = getters.schemaFor(type);
+      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 : {},
+        revision:    count ? count.revision : null,
+        namespaced:  schema?.attributes?.namespaced
+      };
+    }
+
+    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 });
   }
 };