dashboard-shell-shell 1.0.10000011122 → 1.6.0-alpha.2

package/store/type-map.js

@@ -154,7 +154,6 @@ import { haveV2Monitoring } from '@shell/utils/monitoring';
 import { NEU_VECTOR_NAMESPACE } from '@shell/config/product/neuvector';
 import { createHeaders, rowValueGetter } from '@shell/store/type-map.utils';
 import { defineAsyncComponent } from 'vue';
-import { cloud2harvesterhci } from '@shell/utils/router';
 
 export const NAMESPACED = 'namespaced';
 export const CLUSTER_LEVEL = 'cluster';
@@ -396,6 +395,7 @@ export function productsLoaded() {
 
 export const state = function() {
   return {
+    actionsWidth:            0,
     products:                [],
     virtualTypes:            {},
     spoofedTypes:            {},
@@ -465,6 +465,8 @@ export const getters = {
     };
   },
 
+  actionsWidth: (state) => state.actionsWidth,
+
   // Turns a group name into a display label (e.g. management.cattle.io.v3.cluster -> Cluster)
   groupLabelFor(state) {
     return (schemaOrName) => {
@@ -513,26 +515,28 @@ export const getters = {
   
   groupsForVirTypes(state) {
     return (product, name) => {
-      return state.virtualTypes?.[product].find(item => item.name === name)?.icon;
+      return state?.virtualTypes?.[product]?.find(item => item.name === name)?.icon;
     };
   },
 
   optionsFor(state, getters, rootState, rootGetters) {
     const def = {
-      isCreatable:            true,
-      isEditable:             true,
-      isRemovable:            true,
-      showState:              true,
-      showAge:                true,
-      canYaml:                true,
-      namespaced:             null,
-      listGroups:             [],
-      listGroupsWillOverride: false,
-      listMandatorySort:      null,
-      depaginate:             false,
-      customRoute:            undefined,
-      resourceEditMasthead:   true,
-      custom:                 {},
+      listCreateButtonLabelKey: undefined,
+      isCreatable:              true,
+      isEditable:               true,
+      isRemovable:              true,
+      showState:                true,
+      showAge:                  true,
+      canYaml:                  true,
+      namespaced:               null,
+      listGroups:               [],
+      listGroupsWillOverride:   false,
+      listMandatorySort:        null,
+      depaginate:               false,
+      customRoute:              undefined,
+      resourceEditMasthead:     true,
+      custom:                   {},
+      subTypes:                 [],
     };
 
     return (schemaOrType, pagination) => {
@@ -677,7 +681,14 @@ export const getters = {
           }
         }
 
-        const labelDisplay = highlightLabel(label,icon, count, typeObj.schema);
+        let labelDisplay = highlightLabel(label, icon, count, typeObj.schema);
+
+        // If we did not match on just the label, add the schema name and see if that matches
+        if (!labelDisplay && typeObj.schema?.attributes) {
+          const schemaName = `${ typeObj.schema.attributes.resource }.${ typeObj.schema.attributes.group }`;
+
+          labelDisplay = highlightLabel(`${ label } (${ schemaName })`, count, typeObj.schema);
+        }
 
         if ( !labelDisplay ) {
           // Search happens in highlight and returns null if not found
@@ -764,11 +775,13 @@ export const getters = {
         let group = findBy(tree.children, 'name', name);
 
         if ( !group ) {
+          const groupDefaultTypeFor = getters.groupDefaultTypeFor(name);
+
           group = {
             name,
             label,
             weight:      getters.groupWeightFor(name, forBasic),
-            defaultType: getters.groupDefaultTypeFor(name),
+            defaultType: typeof groupDefaultTypeFor === 'function' ? groupDefaultTypeFor() : groupDefaultTypeFor,
           };
 
           tree.children.push(group);
@@ -1484,6 +1497,10 @@ export const getters = {
 };
 
 export const mutations = {
+  setActionsWidth(state, width) {
+    state.actionsWidth = width
+  },
+
   schemaChanged(state) {
     state.schemaGeneration = state.schemaGeneration + 1;
   },

package/store/type-map.utils.ts

@@ -62,12 +62,12 @@ export function createHeaders(
   } = columns;
   const { rootGetters } = ctx;
   const out = typeOptions.showState ? [stateColumn] : [];
-  const attributes = (schema.attributes as SchemaAttribute) || {};
-  const columnsFromSchema = attributes.columns || [];
+  const attributes = (schema?.attributes as SchemaAttribute) || {};
+  const columnsFromSchema = attributes?.columns || [];
 
   // A specific list has been provided
-  if ( headers?.[schema.id]?.length ) {
-    return headers[schema.id].map((entry: any) => {
+  if ( headers?.[schema?.id]?.length ) {
+    return headers[schema?.id].map((entry: any) => {
       if ( typeof entry === 'string' ) {
         const col = findBy(columnsFromSchema, 'name', entry);
 
@@ -100,7 +100,7 @@ export function createHeaders(
 
   // Always try to have an identifier
   if ( !hasName ) {
-    insertAt(out, 1, idColumn || nameColumn);
+    insertAt(out, 1, nameColumn || idColumn );
     if ( namespaced ) {
       insertAt(out, 2, namespaceColumn);
     }
@@ -181,6 +181,49 @@ export function headerFromSchemaCol(col: SchemaAttributeColumn, rootGetters: Vue
   };
 }
 
+/**
+ * Rewrite a JSON Path expression, so that it is compatible with the library we use.
+ * Specifically, ensure we can handle path keys that contain an escaped '.' character (\.)
+ *
+ * For example, this function re-writes the expression:
+ *   $.metadata.labels.topology\.kubernetes\.io/zone
+ * to:
+ *   $.metadata.labels.["topology.kubernetes.io/zone"]
+ *
+ * @param path JSON Path expression
+ * @returns Re-written JSON Path expression
+ */
+function rewriteJsonPath(path: any): any {
+  // Check if we should re-write, otherwise just return the input expression as is
+  if (typeof path === 'string' && path.startsWith('$') && path.includes('\\.')) {
+    const parts = path.split('.');
+    let inField = false;
+    let res = '';
+
+    parts.forEach((part) => {
+      let prefix = res.length ? '.' : '';
+
+      if (part.endsWith('\\')) {
+        if (!inField) {
+          inField = true;
+          prefix = `${ prefix }["`;
+        }
+
+        res = `${ res }${ prefix }${ part.substr(0, part.length - 1) }`;
+      } else {
+        const postfix = inField ? '"]' : '';
+
+        res += `${ prefix }${ part }${ postfix }`;
+        inField = false;
+      }
+    });
+
+    return res;
+  }
+
+  return path;
+}
+
 export function rowValueGetter(col: SchemaAttributeColumn, asFn = true): string | ((row: any) => string) {
   // 'field' comes from the schema - typically it is of the form $.metadata.field[N]
   // We will use JsonPath to look up this value, which is costly - so if we can detect this format
@@ -198,7 +241,7 @@ export function rowValueGetter(col: SchemaAttributeColumn, asFn = true): string
     return `metadata.fields.${ fieldIndex }`;
   }
 
-  return value;
+  return rewriteJsonPath(value);
 }
 
 type conditionalDepaginateArgs ={

package/store/uiplugins.ts

@@ -9,6 +9,7 @@ import { Plugin } from '@shell/core/plugin';
 interface UIPluginState {
   plugins: Plugin[],
   errors: any,
+  ready: boolean,
 }
 
 interface LoadError {
@@ -20,6 +21,7 @@ export const state = function(): UIPluginState {
   return {
     plugins: [],
     errors:  {},
+    ready:   false,
   };
 };
 
@@ -31,6 +33,10 @@ export const getters = {
   errors: (state: any) => {
     return state.errors;
   },
+
+  ready: (state: any) => {
+    return state.ready;
+  },
 };
 
 export const mutations = {
@@ -50,6 +56,10 @@ export const mutations = {
       state.plugins.splice(index, 1);
     }
   },
+
+  setReady(state: UIPluginState, ready: boolean) {
+    state.ready = ready;
+  },
 };
 
 export const actions = {
@@ -63,5 +73,9 @@ export const actions = {
 
   removePlugin({ commit }: any, pluginName: string) {
     commit('removePlugin', pluginName);
-  }
+  },
+
+  setReady( { commit }: any, ready: boolean ) {
+    commit('setReady', ready);
+  },
 };

package/types/fleet.d.ts

@@ -1 +1,60 @@
-export type WorkloadType = 'pods' | 'apps.deployments' | 'replicasets' | 'daemonsets' | 'statefulsets' | 'jobs' | 'cronjobs'
+export type WorkloadType = 'workload' | 'pods' | 'apps.deployments' | 'replicasets' | 'daemonsets' | 'statefulsets' | 'jobs' | 'cronjobs'
+
+export interface FleetResourceState {
+  count: number,
+  label: string,
+  color?: string,
+  status?: string
+}
+
+export interface FleetDashboardState {
+  index: number,
+  id: string,
+  label: string,
+  color: string,
+  icon: string,
+  stateBackground: string
+}
+
+export interface FleetDashboardResourceStates {
+  stateDisplay: string,
+  stateSort: string,
+  statePanel: FleetDashboardState,
+  resources: object[]
+}
+
+// TODO complete type definition
+export interface Application {
+  id: string,
+  metadata: {
+    namespace: string,
+    name: string,
+  }
+  _detailLocation: {
+    name: string
+  }
+}
+
+export type TargetMode = 'none' | 'all' | 'clusters' | 'local' | 'advanced';
+
+export type MatchLabels = Record<string, string>;
+
+export interface Expression {
+  key: string,
+  operator: string,
+  values: string[]
+}
+
+export interface Selector {
+  key?: number,
+  matchLabels?: MatchLabels,
+  matchExpressions?: Expression[]
+}
+
+export interface Target {
+  name?: string,
+  clusterName?: string,
+  clusterSelector?: Selector,
+  clusterGroup?: string,
+  clusterGroupSelector?: Selector
+}

package/types/kube/kube-api.ts

@@ -0,0 +1,34 @@
+export interface KubeLabelSelectorExpression {
+  key: string,
+  /**
+   * Gt and Lt are only applicable to node selectors
+   */
+  operator: 'In' | 'NotIn' | 'Exists' | 'DoesNotExist' | 'Gt' | 'Lt',
+  /**
+   * An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
+   */
+  values?: string[],
+}
+
+/**
+ * https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.31/#labelselector-v1-meta
+ */
+export interface KubeLabelSelector {
+  matchExpressions?: KubeLabelSelectorExpression[],
+  /**
+   * matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
+   */
+  matchLabels?: { [key: string]: string }
+}
+
+/**
+ * https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.31/#objectmeta-v1-meta
+ */
+export interface KubeMetadata {
+  labels?: { [key: string]: string },
+  annotations?: { [key: string]: string },
+}
+
+export interface RancherKubeMetadata extends KubeMetadata {
+  namespace: string,
+}

package/types/notifications/index.ts

@@ -0,0 +1,74 @@
+import { RouteLocationRaw } from 'vue-router';
+
+/**
+ * Type definitions for the Notification Center
+ */
+
+/**
+ * Notification Level for a notification in the Notification Center
+ */
+export enum NotificationLevel {
+  Announcement = 0, // eslint-disable-line no-unused-vars
+  Task, // eslint-disable-line no-unused-vars
+  Info, // eslint-disable-line no-unused-vars
+  Success, // eslint-disable-line no-unused-vars
+  Warning, // eslint-disable-line no-unused-vars
+  Error, // eslint-disable-line no-unused-vars
+}
+
+/**
+ * An action that is shown as a button in the Notification Center
+ */
+export type NotificationAction = {
+  label: string; // Button label for the action
+  target?: string; // HREF target when the button is clicked
+  route?: RouteLocationRaw; // Route to navigate to when the button is clicked
+};
+
+/**
+ * Defines the User Preference linked to a notification
+ */
+export type NotificationPreference = {
+  key: string; // User preference key to use when setting the preference when the notification is marked as read
+  value: string; // User preference value to use when setting the preference when the notification is marked as read
+  unsetValue?: string; // User preference value to use when setting the preference when the notification is marked as unread - defaults to empty string
+};
+
+/**
+ * Type for Encrypted Notification data that is stored in local storage
+ */
+export type EncryptedNotification = {
+  title: string;
+  // Message to be shown in the notification (optional)
+  message?: string;
+  // Notification Level
+  level: NotificationLevel;
+  // Primary action to be shown in the notification (optional)
+  primaryAction?: NotificationAction;
+  // Secondary to be shown in the notification (optional)
+  secondaryAction?: NotificationAction;
+};
+
+/**
+ * Type for Notification that is sent
+ */
+export type Notification = {
+  // Unique ID for the notification
+  id: string;
+  // Progress (0-100) for notifications of type `Task` (optional)
+  progress?: number;
+  // User Preference tied to the notification (optional) (the preference will be updated when the notification is marked read)
+  preference?: NotificationPreference;
+} & EncryptedNotification;
+
+/**
+ * Type for notification that is stored
+ *
+ * This should not be used outside of this store or the Notification Center UI components
+ *
+ * Includes extra fields managed by the notification center
+ */
+export type StoredNotification = {
+  created: Date;
+  read: Boolean;
+} & Notification;

package/types/resources/fleet.d.ts

@@ -0,0 +1,43 @@
+export interface BundleResourceKey {
+  kind: string,
+  apiVersion: string,
+  namespace?: string,
+  name: string,
+}
+
+export interface BundleDeploymentResource extends BundleResourceKey {
+  createdAt?: string,
+}
+
+export interface BundleModifiedResource extends BundleResourceKey {
+  missing?: boolean,
+  delete?: boolean,
+  patch: string,
+}
+
+export interface BundleNonReadyResource extends BundleResourceKey {
+  summary: { [state: string]: string }
+}
+
+export interface Condition {
+  status: string,
+  type: string,
+}
+
+export interface BundleDeploymentStatus {
+  resources?: BundleDeploymentResource[],
+  modifiedStatus?: BundleModifiedResource[],
+  nonReadyStatus?: BundleNonReadyResource[],
+  appliedDeploymentId?: string,
+  ready: boolean
+  nonModified: boolean
+  conditions: Condition[],
+}
+
+export interface BundleDeployment {
+  spec: {
+    deploymentId: string,
+    stagedDeploymentId: string,
+  }
+  status?: BundleDeploymentStatus
+}

package/types/resources/pod-security-admission.ts

@@ -0,0 +1,36 @@
+/**
+ * Mode Description
+ * - 'enforce': Policy violations will cause the pod to be rejected.
+ * - 'audit':   Policy violations will trigger the addition of an audit annotation to the event recorded in the audit log, but are otherwise allowed.
+ * - 'warn':    Policy violations will trigger a user-facing warning, but are otherwise allowed.
+ */
+export type PSAMode = 'enforce' | 'audit' | 'warn';
+
+/**
+ * Pod Security admission places requirements on a Pod's Security Context and other related fields according to the three levels defined by the Pod Security Standards:
+ * privileged, baseline, and restricted.
+ * Refer to the Pod Security Standards page for an in-depth look at those requirements.
+ */
+export type PSALevel = 'privileged' | 'baseline' | 'restricted';
+
+/**
+ * Usernames:         requests from users with an exempt authenticated (or impersonated) username are ignored.
+ * RuntimeClassNames: pods and workload resources specifying an exempt runtime class name are ignored.
+ * Namespaces:        pods and workload resources in an exempt namespace are ignored.
+ */
+export type PSADimension = 'usernames' | 'runtimeClasses' | 'namespaces'
+
+export type PSADefaults = Record<PSAMode, PSALevel>
+export type PSAExemptions = Record<PSADimension, string[]>
+
+export interface PSAConfig {
+  defaults: PSADefaults,
+  exemptions: PSAExemptions
+}
+
+export interface PSA {
+  configuration: PSAConfig,
+  metadata: {
+    labels: Record<string, string>
+  }
+}

package/types/resources/settings.d.ts

@@ -0,0 +1,107 @@
+
+export interface PaginationSettingsStore {
+  [name: string]: {
+    resources: {
+      /**
+       * Enable for all resources in this store
+       */
+      enableAll: boolean,
+      enableSome: {
+        /**
+         * Specific resource type to enable
+         */
+        enabled: (string | { resource: string, context: string[]})[],
+        /**
+         * There's no hardcoded headers or custom list for the resource type, headers will be generated from schema attributes.columns
+         */
+        generic: boolean,
+      },
+    }
+  }
+}
+
+export type PaginationFeature = 'listAutoRefreshToggle' | 'listManualRefresh'
+
+/**
+ * Settings to handle server side pagination
+ */
+export interface PaginationSettings {
+  /**
+   * Override `stores` and apply pagination to a set of default resource types that can change between versions
+   */
+  useDefaultStores: boolean,
+  /**
+   * Should pagination be enabled for resources in a store
+   */
+  stores?: PaginationSettingsStore,
+
+  /**
+   * List of specific features that can be enabled / disabled
+   */
+  features?: {
+    [key in PaginationFeature]: { // eslint-disable-line no-unused-vars
+      enabled: boolean,
+    }
+  },
+
+  /**
+   * Debounce the amount of time between a resource changing and the backend sending a resource.changes message
+   *
+   * This greatly reduces spam in systems with high resource churn. It needs to be more than it takes for the UI to make a http request to fetch changes
+   */
+  resourceChangesDebounceMs?: number
+}
+
+type Links = {
+  remove: string;
+  self: string;
+  update: string;
+  view: string;
+};
+
+type FieldsV1 = {
+  'f:customized': {};
+  'f:default': {};
+  'f:source': {};
+  'f:value': {};
+};
+
+type ManagedFields = {
+  apiVersion: string;
+  fieldsType: string;
+  fieldsV1: FieldsV1;
+  manager: string;
+  operation: string;
+  time: string;
+};
+
+type Metadata = {
+  creationTimestamp: string;
+  fields: string[];
+  generation: number;
+  managedFields: ManagedFields[];
+  name: string;
+  relationships: null;
+  resourceVersion: string;
+  state: {
+    error: boolean;
+    message: string;
+    name: string;
+    transitioning: boolean;
+  };
+  uid: string;
+};
+
+export type Setting = {
+  id: string;
+  type: string;
+  links: Links;
+  apiVersion: string;
+  customized: boolean;
+  default: string;
+  kind: string;
+  metadata: Metadata;
+  source: string;
+  value: string | null;
+  save: () => void;
+};

package/types/resources/userPreferences.d.ts

@@ -0,0 +1,13 @@
+export interface UserPreferences {
+  'after-login-route': string,
+  cluster: string,
+  'group-by': string,
+  'home-page-cards': string,
+  'last-namespace': string,
+  'last-visited': string,
+  'ns-by-cluster': string,
+  provisioner: string,
+  'read-whatsnew': string,
+  'seen-whatsnew': string,
+  theme: string,
+}