@rancher/shell 3.0.5-rc.9 → 3.0.6

package/scripts/test-plugins-build.sh

@@ -98,12 +98,11 @@ createTestComponent() {
   # Add test list component to the test package
   # Validates rancher-components imports
 
-  # NOTE - This fails if importing some components with TS imports...
-  # cp ${SHELL_DIR}/list/catalog.cattle.io.clusterrepo.vue pkg/test-pkg/list
-  # See https://github.com/rancher/dashboard/issues/12918
-
-  # Use a basic list instead
+  # Basic list instead
   cp ${SHELL_DIR}/list/namespace.vue pkg/test-pkg/list
+
+  # More complex list
+  cp ${SHELL_DIR}/list/catalog.cattle.io.clusterrepo.vue pkg/test-pkg/list
 }
 
 # Publish shell pkg (tag is needed as publish-shell is optimized to work with release-shell-pkg workflow)
@@ -239,7 +238,6 @@ function clone_repo_test_extension_build() {
 clone_repo_test_extension_build "rancher" "kubewarden-ui" "kubewarden"
 clone_repo_test_extension_build "rancher" "elemental-ui" "elemental"
 clone_repo_test_extension_build "neuvector" "manager-ext" "neuvector-ui-ext"
-clone_repo_test_extension_build "rancher" "capi-ui-extension" "capi"
 clone_repo_test_extension_build "StackVista" "rancher-extension-stackstate" "observability"
 clone_repo_test_extension_build "harvester" "harvester-ui-extension" "harvester"
 

package/scripts/typegen.sh

@@ -39,6 +39,8 @@ ${BASE_DIR}/node_modules/.bin/tsc ${SHELL_DIR}/plugins/steve/hybrid-class.js --d
 # # mixins
 ${BASE_DIR}/node_modules/.bin/tsc ${SHELL_DIR}/mixins/create-edit-view/index.js --declaration --allowJs --emitDeclarationOnly --outDir ${SHELL_DIR}/tmp/mixins/create-edit-view > /dev/null
 ${BASE_DIR}/node_modules/.bin/tsc ${SHELL_DIR}/mixins/resource-fetch.js --declaration --allowJs --emitDeclarationOnly --outDir ${SHELL_DIR}/tmp/mixins > /dev/null
+${BASE_DIR}/node_modules/.bin/tsc ${SHELL_DIR}/mixins/resource-fetch-namespaced.js --declaration --allowJs --emitDeclarationOnly --outDir ${SHELL_DIR}/tmp/mixins > /dev/null
+${BASE_DIR}/node_modules/.bin/tsc ${SHELL_DIR}/mixins/resource-fetch-api-pagination.js --declaration --allowJs --emitDeclarationOnly --outDir ${SHELL_DIR}/tmp/mixins > /dev/null
 
 # # models
 ${BASE_DIR}/node_modules/.bin/tsc ${SHELL_DIR}/models/namespace.js --declaration --allowJs --emitDeclarationOnly --outDir ${SHELL_DIR}/tmp/models/ > /dev/null

package/store/__tests__/cookies.test.ts

@@ -0,0 +1,72 @@
+import cookieStore from '../cookies';
+
+// Mock cookie-universal
+const mockCookie = {
+  get:                  jest.fn(),
+  set:                  jest.fn(),
+  remove:               jest.fn(),
+  getAll:               jest.fn(),
+  addChangeListener:    jest.fn(),
+  removeChangeListener: jest.fn()
+};
+
+jest.mock('cookie-universal', () => {
+  return jest.fn(() => mockCookie);
+});
+
+describe('store: cookies', () => {
+  let state: any;
+
+  beforeEach(() => {
+    state = cookieStore.state();
+    // Reset mocks before each test
+    mockCookie.get.mockClear();
+    mockCookie.set.mockClear();
+    mockCookie.remove.mockClear();
+  });
+
+  describe('getters', () => {
+    it('get should call cookies.get with the correct parameters', () => {
+      const { getters } = cookieStore;
+      const key = 'test-key';
+      const options = { from: 'server' };
+
+      getters.get(state, {}, {}, {})({ key, options });
+      expect(mockCookie.get).toHaveBeenCalledWith(key, options);
+    });
+  });
+
+  describe('mutations', () => {
+    it('set should call cookies.set with the correct parameters', () => {
+      const { mutations } = cookieStore;
+      const key = 'test-key';
+      const value = { data: 'test-value' };
+      const options = { path: '/' };
+
+      mutations.set(state, {
+        key, value, options
+      });
+      expect(mockCookie.set).toHaveBeenCalledWith(key, value, options);
+    });
+
+    it('remove should call cookies.remove with the correct key', () => {
+      const { mutations } = cookieStore;
+      const key = 'test-key';
+
+      mutations.remove(state, { key });
+      expect(mockCookie.remove).toHaveBeenCalledWith(key);
+    });
+  });
+
+  describe('state', () => {
+    it('should return a cookies object', () => {
+      expect(state.cookies).toBeDefined();
+    });
+  });
+
+  describe('namespaced', () => {
+    it('should be namespaced', () => {
+      expect(cookieStore.namespaced).toBe(true);
+    });
+  });
+});

package/store/auth.js

@@ -8,6 +8,13 @@ import { removeEmberPage } from '@shell/utils/ember-page';
 import { randomStr } from '@shell/utils/string';
 import { addParams, parse as parseUrl, removeParam } from '@shell/utils/url';
 
+// configuration for Single Logout/SLO
+// admissable auth providers compatible with SLO, based on shell/models/management.cattle.io.authconfig "configType"
+export const SLO_AUTH_PROVIDERS = ['oidc', 'saml'];
+
+// this is connected to the redirect url, for which the logic can be found in "shell/store/auth"
+const SLO_TOKENS_ENDPOINT_LOGOUT_RES_BASETYPE = ['authConfigLogoutOutput'];
+
 export const BASE_SCOPES = {
   github:       ['read:org'],
   googleoauth:  ['openid profile email'],
@@ -85,8 +92,6 @@ export const mutations = {
   loggedInAs(state, principalId) {
     state.loggedIn = true;
     state.principalId = principalId;
-
-    this.$cookies.remove(KEY);
   },
 
   loggedOut(state) {
@@ -136,10 +141,18 @@ export const actions = {
     commit('initialPass', pass);
   },
 
-  getAuthProviders({ dispatch }) {
+  getAuthProviders({ dispatch }, opt) {
+    let force = false;
+
+    if (opt?.force) {
+      force = true;
+    }
+
     return dispatch('rancher/findAll', {
       type: 'authProvider',
-      opt:  { url: `/v3-public/authProviders`, watch: false }
+      opt:  {
+        url: `/v3-public/authProviders`, watch: false, force
+      }
     }, { root: true });
   },
 
@@ -183,14 +196,18 @@ export const actions = {
    * Save nonce details. Information it contains will be used to validate auth requests/responses
    * Note - this may be structurally different than the nonce we encode and send
    */
-  saveNonce(ctx, opt) {
+  saveNonce({ commit }, opt) {
     const strung = JSON.stringify(opt);
 
-    this.$cookies.set(KEY, strung, {
+    const options = {
       path:     '/',
       sameSite: true,
       secure:   true,
-    });
+    };
+
+    commit('cookies/set', {
+      key: KEY, value: strung, options
+    }, { root: true });
 
     return strung;
   },
@@ -265,8 +282,8 @@ export const actions = {
     }
   },
 
-  verifyOAuth({ dispatch }, { nonce, code, provider }) {
-    const expectJSON = this.$cookies.get(KEY, { parseJSON: false });
+  verifyOAuth({ dispatch, rootGetters }, { nonce, code, provider }) {
+    const expectJSON = rootGetters['cookies/get']({ key: KEY, options: { parseJSON: false } });
     let parsed;
 
     try {
@@ -351,6 +368,12 @@ export const actions = {
     }
   },
 
+  loggedInAs({ commit }, principalId) {
+    commit('loggedInAs', principalId);
+
+    commit('cookies/remove', { key: KEY }, { root: true });
+  },
+
   uiLogout({ commit, dispatch }) {
     removeEmberPage();
 
@@ -398,8 +421,8 @@ export const actions = {
         redirectUnauthorized: false,
       }, { root: true });
 
-      // Single-sign logout for SAML providers that allow for it
-      if (res.baseType === 'samlConfigLogoutOutput' && res.idpRedirectUrl) {
+      // Single-sign logout redirect for SLO compatible auth providers
+      if (SLO_TOKENS_ENDPOINT_LOGOUT_RES_BASETYPE.includes(res.baseType) && res.idpRedirectUrl) {
         window.location.href = res.idpRedirectUrl;
 
         return;

package/store/cookies.ts

@@ -0,0 +1,30 @@
+import { MutationTree, GetterTree, ActionTree } from 'vuex';
+import Cookie, { ICookie, ICookieGetOpts } from 'cookie-universal';
+
+type State = { cookies: ICookie };
+const options = { parseJSON: true };
+const state = (): State => ({ cookies: Cookie(undefined, undefined, options.parseJSON) });
+
+const getters: GetterTree<State, any> = {
+  get(state) {
+    return ({ key, options }: {key: string, options?: ICookieGetOpts}) => state.cookies.get(key, options);
+  }
+};
+const mutations: MutationTree<State> = {
+  set(state, { key, value, options }) {
+    return state.cookies.set(key, value, options);
+  },
+
+  remove(state, { key }) {
+    return state.cookies.remove(key);
+  },
+};
+const actions: ActionTree<State, any> = {};
+
+export default {
+  namespaced: true,
+  state,
+  getters,
+  mutations,
+  actions
+};

package/store/prefs.js

@@ -289,12 +289,16 @@ export const actions = {
     commit('load', { key, value });
 
     if ( definition.asCookie ) {
-      const opt = {
+      const options = {
         ...cookieOptions,
         parseJSON: definition.parseJSON === true
       };
 
-      this.$cookies.set(`${ cookiePrefix }${ key }`.toUpperCase(), value, opt);
+      const computedKey = `${ cookiePrefix }${ key }`.toUpperCase();
+
+      commit('cookies/set', {
+        key: computedKey, value, options
+      }, { root: true });
     }
 
     if ( definition.asUserPreference ) {
@@ -336,7 +340,7 @@ export const actions = {
     await dispatch('set', { key: THEME, value: val });
   },
 
-  loadCookies({ state, commit }) {
+  loadCookies({ state, commit, rootGetters }) {
     if ( state.cookiesLoaded ) {
       return;
     }
@@ -348,8 +352,9 @@ export const actions = {
         continue;
       }
 
-      const opt = { parseJSON: definition.parseJSON === true };
-      const value = this.$cookies.get(`${ cookiePrefix }${ key }`.toUpperCase(), opt);
+      const options = { parseJSON: definition.parseJSON === true };
+      const computedKey = `${ cookiePrefix }${ key }`.toUpperCase();
+      const value = rootGetters['cookies/get']({ key: computedKey, options });
 
       if (value !== undefined) {
         commit('load', { key, value });

package/types/shell/index.d.ts

@@ -2323,6 +2323,18 @@ export function setKubeVersionData(v: any): void;
 export const CURRENT_RANCHER_VERSION: "2.12";
 }
 
+// @shell/mixins/components/ResourceList/resource-list.config
+
+declare module '@shell/mixins/components/ResourceList/resource-list.config' {
+/**
+ * Component name of the `ResourceList`
+ *
+ * This needs to be a in separate file to avoid circular dependency of
+ * index.vue --> resource-fetch mixin --> resource-fetch-namespaced mixin --> index.vue
+ */
+export const ResourceListComponentName: "ResourceList";
+}
+
 // @shell/mixins/create-edit-view/impl
 
 declare module '@shell/mixins/create-edit-view/impl' {
@@ -2468,6 +2480,175 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
 export default _default;
 }
 
+// @shell/mixins/mixins/resource-fetch-api-pagination
+
+declare module '@shell/mixins/mixins/resource-fetch-api-pagination' {
+declare namespace _default {
+    namespace props {
+        namespace namespaced {
+            export let type: BooleanConstructor;
+            let _default: any;
+            export { _default as default };
+        }
+        namespace context {
+            let type_1: StringConstructor;
+            export { type_1 as type };
+            let _default_1: any;
+            export { _default_1 as default };
+        }
+    }
+    function data(): {
+        forceUpdateLiveAndDelayed: number;
+        /**
+         * This of type `OptPagination`
+         */
+        pPagination: any;
+        debouncedSetPagination: any;
+        /**
+         * Apply these additional filters given the ns / project header selection
+         */
+        requestFilters: {
+            filters: any[];
+            projectsOrNamespaces: any[];
+        };
+        paginationFromList: any;
+        isPaginationManualRefreshEnabled: any;
+    };
+    namespace methods {
+        /**
+         * @param {PaginationArgs} pagination
+         */
+        function setPagination(pagination: PaginationArgs): void;
+        /**
+         * Primary point that handles changes from either a table or the namespace filter
+         */
+        function paginationChanged(event: any): void;
+        /**
+         * @param {PaginationArgs} neu
+         * @param {PaginationArgs} old
+         */
+        function paginationEqual(neu: PaginationArgs, old: PaginationArgs): boolean;
+        function calcCanPaginate(): any;
+    }
+    namespace computed {
+        /**
+         * Why is this a specific getter and not not in mapGetters?
+         *
+         * Adding it to mapGetters means the kubewarden unit tests fail as they don't mock it....
+         */
+        function namespaceFilters(): any;
+        /**
+         * Does the user need to update the filter to supply valid options?
+         */
+        function paginationNsFilterRequired(): boolean;
+        /**
+         * Check if the Project/Namespace filter from the header contains a valid ns / project filter
+         */
+        function __validPaginationNsFilter(): any;
+        /**
+         * ResourceList imports resource-fetch --> this mixin
+         * When there is no custom list this is fine (ResourceList with mixins --> ResourceTable)
+         * When there is a custom list there are two instances of this mixin (ResourceList with mixins --> CustomList with mixins --> ResourceTable)
+         * - In this scenario, reduce churn by exiting earlier if mixin is from parent ResourceList and leave work for CustomList mixins
+         */
+        function isResourceList(): any;
+        /**
+         * Is Pagination supported and has the table supplied pagination settings from the table?
+         */
+        function pagination(): any;
+        /**
+         * Should this list be paginated via API?
+         */
+        function canPaginate(): any;
+        function paginationResult(): any;
+        function havePaginated(): any;
+        /**
+          * Links to ns.isSystem and covers things like ns with system annotation, hardcoded list, etc
+          */
+        function productHidesSystemNamespaces(): any;
+        /**
+          * Links to ns.isObscure and covers things like `c-`, `user-`, etc (see OBSCURE_NAMESPACE_PREFIX)
+          */
+        function showDynamicRancherNamespaces(): any;
+        function isNamespaced(): any;
+        let currentProduct: import("vuex").Computed;
+        let isAllNamespaces: import("vuex").Computed;
+    }
+    let watch: {
+        /**
+         * Monitor the rows to ensure deleting the last entry in a server-side paginated page doesn't
+         * result in an empty page
+         */
+        rows(neu: any): void;
+        namespaceFilters: {
+            immediate: boolean;
+            handler(neu: any, old: any): Promise<void>;
+        };
+        'requestFilters.filters'(): void;
+        'requestFilters.projectsOrNamespaces'(): void;
+        /**
+         * When a pagination is required and the user changes page / sort / filter, kick off a new set of API requests
+         *
+         * @param {StorePaginationResult} neu
+         * @param {StorePaginationResult} old
+         */
+        pagination(neu: StorePaginationResult, old: StorePaginationResult): Promise<void>;
+        /**
+         * If the pagination result has changed fetch secondary resources
+         *
+         * Lists should implement fetchPageSecondaryResources to fetch them
+         *
+         * @param {StorePaginationResult} neu
+         * @param {StorePaginationResult} old
+         */
+        paginationResult(neu: StorePaginationResult, old: StorePaginationResult): Promise<void>;
+    };
+    function beforeUnmount(): Promise<void>;
+}
+export default _default;
+}
+
+// @shell/mixins/mixins/resource-fetch-namespaced
+
+declare module '@shell/mixins/mixins/resource-fetch-namespaced' {
+declare namespace _default {
+    function data(): {
+        forceUpdateLiveAndDelayed: number;
+    };
+    namespace computed {
+        /**
+         * Does the user need to update the filter to supply a single namespace?
+         */
+        function namespaceFilterRequired(): boolean;
+        /**
+         * Returns the namespace that requests should be filtered by
+         */
+        function namespaceFilter(): "" | (() => import("vuex").Computed);
+        /**
+         * If the Project/Namespace filter from the header contains a valid ns / project filter ... return it
+         */
+        function __validFilter(): import("vuex").Computed;
+        /**
+         * Do we need to filter the list by a namespace? This will control whether the user is shown an error
+         *
+         * We shouldn't show an error on pages with resources that aren't namespaced
+         */
+        function __namespaceRequired(): false | (() => any);
+        /**
+         * Are all core list resources namespaced?
+         */
+        function __areResourcesNamespaced(): any;
+        let currentProduct: import("vuex").Computed;
+        let currentCluster: import("vuex").Computed;
+        let namespaceFilters: import("vuex").Computed;
+    }
+    namespace watch {
+        function namespaceFilter(neu: any): Promise<void>;
+    }
+}
+export default _default;
+}
+
 // @shell/mixins/resource-fetch
 
 declare module '@shell/mixins/resource-fetch' {
@@ -3601,9 +3782,10 @@ export namespace actions {
     function setTheme({ dispatch }: {
         dispatch: any;
     }, val: any): Promise<void>;
-    function loadCookies({ state, commit }: {
+    function loadCookies({ state, commit, rootGetters }: {
         state: any;
         commit: any;
+        rootGetters: any;
     }): void;
     function loadTheme({ dispatch }: {
         dispatch: any;
@@ -3850,16 +4032,6 @@ declare function _default(context: any, inject: any): void;
 export default _default;
 }
 
-// @shell/utils/cookie-universal
-
-declare module '@shell/utils/cookie-universal' {
-declare function _default({ req, res }: {
-    req: any;
-    res: any;
-}, inject: any): void;
-export default _default;
-}
-
 // @shell/utils/create-yaml
 
 declare module '@shell/utils/create-yaml' {

package/types/store/vuex.d.ts

@@ -10,7 +10,8 @@ export interface VuexStoreGetters {
 
 export interface VuexStore {
   getters: VuexStoreGetters,
-  dispatch: any,
+  dispatch: <T = any>(action: string, payload?: any) => Promise<T>,
+  commit: (mutation: string, payload?: any) => void,
 
   // When we have exact properties above we can remove below
   [name:string]: any

package/types/vue-shim.d.ts

@@ -1,5 +1,6 @@
 /* eslint-disable */
 import type ShellApi from '@shell/plugins/internal-api/shell/shell.api';
+import { VuexStore } from '@shell/types/store/vuex';
 
 export {};
 
@@ -13,11 +14,7 @@ declare module 'vue' {
       (key: string, args?: Record<string, any>, raw?: boolean): string;
       (options: { k: string; raw?: boolean; tag?: string | Record<string, any>; escapehtml?: boolean }): string;
     },
-    $store: {
-      getters: Record<string, any>,
-      dispatch: (action: string, payload?: any) => Promise<any>,
-      commit: (mutation: string, payload?: any) => void,
-    },
+    $store: VuexStore,
     $shell: ShellApi,
   }
 }

package/utils/auth.js

@@ -263,7 +263,7 @@ export async function tryInitialSetup(store, password = 'admin') {
  */
 export async function isLoggedIn(store, userData) {
   store.commit('auth/hasAuth', true);
-  store.commit('auth/loggedInAs', userData.id);
+  store.dispatch('auth/loggedInAs', userData.id);
 
   // Init the notification center now that we know who the user is
   await store.dispatch('notifications/init', userData);

package/utils/pagination-utils.ts

@@ -16,6 +16,7 @@ import { STEVE_CACHE } from '@shell/store/features';
 import { getPerformanceSetting } from '@shell/utils/settings';
 import { PAGINATION_SETTINGS_STORE_DEFAULTS } from '@shell/plugins/steve/steve-pagination-utils';
 import { MANAGEMENT } from '@shell/config/types';
+import { DEFAULT_PERF_SETTING } from '@shell/config/settings';
 
 /**
  * Helper functions for server side pagination
@@ -43,7 +44,15 @@ class PaginationUtils {
   public getStoreSettings(arg: any | PaginationSettings): PaginationSettingsStore {
     const serverPagination: PaginationSettings = arg?.rootGetters !== undefined ? this.getSettings(arg) : arg;
 
-    return serverPagination?.useDefaultStores ? this.getStoreDefault() : serverPagination?.stores || this.getStoreDefault();
+    // Ensure we use the current default store settings if
+    // 1. from 2.11.0 user saved `ui-performance` setting and it's applied the default pagination settings containing useDefaultStores
+    // 2. before 2.11.0 user has saved `ui-performance` setting and it's applied an obsolete pagination settings that lack useDefaultStore
+    // 3. user has manually set the `ui-performance` pagination setting useDefaultStores value
+    if (serverPagination?.useDefaultStores || serverPagination?.useDefaultStores === undefined) {
+      return this.getStoreDefault();
+    }
+
+    return serverPagination?.stores || this.getStoreDefault();
   }
 
   public getStoreDefault(): PaginationSettingsStore {
@@ -168,7 +177,7 @@ class PaginationUtils {
   resourceChangesDebounceMs({ rootGetters }: any): number | undefined {
     const settings = this.getSettings({ rootGetters });
 
-    return settings.resourceChangesDebounceMs;
+    return settings.resourceChangesDebounceMs || DEFAULT_PERF_SETTING.serverPagination.resourceChangesDebounceMs;
   }
 
   validateNsProjectFilters(nsProjectFilters: string[]) {

package/utils/cookie-universal.js

@@ -1,10 +0,0 @@
-import cookieUniversal from 'cookie-universal';
-
-export default ({ req, res }, inject) => {
-  const options = {
-    alias:     'cookies',
-    parseJSON: true
-  };
-
-  inject(options.alias, cookieUniversal(req, res, options.parseJSON));
-};