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

package/utils/kontainer.ts

@@ -17,11 +17,9 @@ export function syncUpstreamConfig(configPrefix: string, normanCluster: {[key: s
 
   if (!isEmpty(upstreamConfig)) {
     Object.keys(upstreamConfig).forEach((key) => {
-      if (typeof upstreamConfig[key] === 'object') {
-        if (isEmpty(rancherConfig[key]) && !isEmpty(upstreamConfig[key])) {
-          set(rancherConfig, key, upstreamConfig[key]);
-        }
-      } else if ((rancherConfig[key] === null || rancherConfig[key] === undefined) && upstreamConfig[key] !== null && upstreamConfig[key] !== undefined) {
+      const empty = typeof upstreamConfig[key] === 'object' && isEmpty(upstreamConfig[key]);
+
+      if ((rancherConfig[key] === null || rancherConfig[key] === undefined) && upstreamConfig[key] !== null && upstreamConfig[key] !== undefined && !empty) {
         set(rancherConfig, key, upstreamConfig[key]);
       }
     });

package/utils/object.js

@@ -510,10 +510,6 @@ export function deepToRaw(obj, cache = new WeakSet()) {
  *                  with arrays in obj2 when both properties are arrays
  *                  false: default lodash merge behavior - recursively merges
  *                  array members
- * @param {boolean} [options.replaceObjectProps=false] - true: merges objects in
- *                  obj1 with objects in obj2, overwriting duplicate props
- *                  false: default lodash merge behavior - recursively merges
- *                  object props
  */
 export function mergeWithReplace(
   obj1 = {},
@@ -521,7 +517,6 @@ export function mergeWithReplace(
   {
     mutateOriginal = false,
     replaceArray = true,
-    replaceObjectProps = false,
   } = {}
 ) {
   const destination = mutateOriginal ? obj1 : {};
@@ -530,12 +525,41 @@ export function mergeWithReplace(
     if (replaceArray && Array.isArray(obj1Value) && Array.isArray(obj2Value)) {
       return obj2Value;
     }
-
-    if (replaceObjectProps && isObject(obj1Value) && isObject(obj2Value)) {
-      return {
-        ...obj1Value,
-        ...obj2Value,
-      };
-    }
   });
 }
+/**
+ * Converts Object into a string of a format "key1, val1, key2, val2"
+ * @param {Object} input - KV object to convert
+ * @returns string
+ */
+export const convertKVToString = (input) => {
+  if (!input || typeof input !== 'object') return '';
+
+  return Object.entries(input)
+    .flatMap(([key, value]) => [key, String(value)])
+    .join(',');
+};
+
+/**
+ * Converts kv string into object
+ * @param {string} input - a string of a format "key1, val1, key2, val2"
+ * @returns
+ */
+export const convertStringToKV = ( input ) => {
+  if (!input?.trim()) return {};
+
+  const parts = input.split(',').map((part) => part.trim());
+  const result = {};
+
+  for (let i = 0; i < parts.length - 1; i += 2) {
+    const key = parts[i];
+    const value = parts[i + 1];
+
+    // Accept empty keys but ignore undefined values
+    if (typeof key === 'string') {
+      result[key] = value ?? '';
+    }
+  }
+
+  return result;
+};

package/utils/pagination-utils.ts

@@ -1,4 +1,4 @@
-import { PaginationSettings, PaginationSettingsStore } from '@shell/types/resources/settings';
+import { PaginationFeature, PaginationSettings, PaginationSettingsStore } from '@shell/types/resources/settings';
 import {
   NAMESPACE_FILTER_ALL_USER as ALL_USER,
   NAMESPACE_FILTER_ALL as ALL,
@@ -15,17 +15,22 @@ import { isEqual } from '@shell/utils/object';
 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';
 
 /**
  * Helper functions for server side pagination
  */
 class PaginationUtils {
+  /**
+   * In places where we're using paginated features but not in a page... this is what the max results should be
+   */
+  readonly defaultPageSize = 100000;
   /**
    * When a ns filter isn't one or more projects/namespaces... what are the valid values?
    *
    * This basically blocks 'Not in a Project'.. which would involve a projectsornamespaces param with every ns not in a project.
    */
-  validNsProjectFilters = [ALL, ALL_SYSTEM, ALL_USER, ALL_SYSTEM, NAMESPACE_FILTER_KINDS.NAMESPACE, NAMESPACE_FILTER_KINDS.PROJECT, NAMESPACED_YES, NAMESPACED_NO];
+  readonly validNsProjectFilters = [ALL, ALL_SYSTEM, ALL_USER, ALL_SYSTEM, NAMESPACE_FILTER_KINDS.NAMESPACE, NAMESPACE_FILTER_KINDS.PROJECT, NAMESPACED_YES, NAMESPACED_NO];
 
   private getSettings({ rootGetters }: any): PaginationSettings {
     const perf = getPerformanceSetting(rootGetters);
@@ -50,6 +55,23 @@ class PaginationUtils {
     return rootGetters['features/get']?.(STEVE_CACHE);
   }
 
+  /**
+   * Determine if the downstream cluster has vai enabled
+   *
+   * Almost all the time the downstream cluster vai state will align with upstream (it manages it)
+   * ... unless it's harvester then weird things happen
+   */
+  async isDownstreamSteveCacheEnabled({ dispatch }: any, clusterId: string): Promise<boolean> {
+    const url = `/k8s/clusters/${ clusterId }/v1/${ MANAGEMENT.FEATURE }s/${ STEVE_CACHE }`;
+    const entry = await dispatch('cluster/request', { url });
+
+    if (entry.status.lockedValue !== null) {
+      return entry.status.lockedValue;
+    }
+
+    return (entry.spec.value !== null) ? entry.spec.value : entry.status.default;
+  }
+
   /**
    * Is pagination enabled at a global level or for a specific resource
    */
@@ -62,7 +84,7 @@ class PaginationUtils {
     const settings = this.getSettings({ rootGetters });
 
     // No setting, not enabled
-    if (!settings?.enabled) {
+    if (!settings) {
       return false;
     }
 
@@ -124,6 +146,31 @@ class PaginationUtils {
     return false;
   }
 
+  listAutoRefreshToggleEnabled({ rootGetters }: any): boolean {
+    return this.isFeatureEnabled({ rootGetters }, 'listAutoRefreshToggle');
+  }
+
+  isListManualRefreshEnabled({ rootGetters }: any): boolean {
+    return this.isFeatureEnabled({ rootGetters }, 'listManualRefresh');
+  }
+
+  private isFeatureEnabled({ rootGetters }: any, featureName: PaginationFeature): boolean {
+    // Cache must be enabled to support pagination api
+    if (!this.isSteveCacheEnabled({ rootGetters })) {
+      return false;
+    }
+
+    const settings = this.getSettings({ rootGetters });
+
+    return !!settings.features?.[featureName]?.enabled;
+  }
+
+  resourceChangesDebounceMs({ rootGetters }: any): number | undefined {
+    const settings = this.getSettings({ rootGetters });
+
+    return settings.resourceChangesDebounceMs;
+  }
+
   validateNsProjectFilters(nsProjectFilters: string[]) {
     return nsProjectFilters?.every((f) => this.validateNsProjectFilter(f));
   }

package/utils/pagination-wrapper.ts

@@ -1,70 +1,152 @@
 import paginationUtils from '@shell/utils/pagination-utils';
-import { PaginationArgs, PaginationResourceContext, StorePagination } from '@shell/types/store/pagination.types';
+import { PaginationArgs, PaginationResourceContext } from '@shell/types/store/pagination.types';
 import { VuexStore } from '@shell/types/store/vuex';
-import { ActionFindPageArgs } from '@shell/types/store/dashboard-store.types';
+import { ActionFindPageArgs, ActionFindPageTransientResult } from '@shell/types/store/dashboard-store.types';
+import {
+  STEVE_WATCH_EVENT_LISTENER_CALLBACK, STEVE_UNWATCH_EVENT_PARAMS, STEVE_WATCH_EVENT, STEVE_WATCH_EVENT_PARAMS, STEVE_WATCH_EVENT_PARAMS_COMMON, STEVE_WATCH_MODE
+} from '@shell/types/store/subscribe.types';
+import { Reactive, reactive } from 'vue';
 
-interface Result<T> {
-  data: Array<T>
-  pagination: StorePagination
+interface Args {
+  $store: VuexStore,
+  /**
+   * Unique ID for this request. Used for watch purposes
+   */
+  id: string,
+  /**
+   * Args used when determining if this resource type supports SSP
+   */
+  enabledFor: PaginationResourceContext,
+  /**
+   * Callback called when the resource is changed (notified by socket)
+   */
+  onChange?: () => void,
+
+  formatResponse?: {
+    /**
+     * Convert the response into a model class instance
+     */
+    classify?: boolean,
+    reactive?: boolean,
+  }
+}
+
+interface Result<T> extends Omit<ActionFindPageTransientResult<T>, 'data'> {
+  data: Reactive<T[]>
 }
 
 /**
- * This is a helper class that will assist in fetching a resource
- * - Handle if the resource can be fetched by the new pagination api
- * - Make a request to get a page (including classify)
- * - Provide updates when the resource changes
+ * This is a helper class that will assist in fetching a resource via the new Server-Side Pagination API
  *
  * This is designed to work in places where we don't/can't store the resource in the store
  * - There already exists a resource we don't want to overwrite
- * - We're transient and want something nicer than just cluster/request
+ * - We're transient and want something nicer than just `cluster/request` + all the trimmings
+ *
+ * It ...
+ * - Handles if the resource can be fetched by the new pagination api
+ * - Makes a request to get a page (including optional classify & reactive)
+ * - Provide updates when the resource changes
  */
-class PaginationWrapper<T = any> {
-    private $store: VuexStore;
-    private enabledFor: PaginationResourceContext;
-
-    // Blocked on https://github.com/rancher/rancher/issues/40773 / https://github.com/rancher/dashboard/issues/12734
-    private onUpdate: (out: Result<T>) => void;
-
-    public isEnabled: boolean;
-
-    constructor({
-      $store,
-      enabledFor,
-      onUpdate,
-    }: {
-        $store: VuexStore,
-        onUpdate: (res: Result<T>) => void,
-        enabledFor: PaginationResourceContext,
-    }) {
-      this.$store = $store;
-      this.isEnabled = paginationUtils.isEnabled({ rootGetters: $store.getters }, enabledFor);
-      this.enabledFor = enabledFor;
-      this.onUpdate = onUpdate;
+class PaginationWrapper<T extends object> {
+  private $store: VuexStore;
+  private enabledFor: PaginationResourceContext;
+  private onChange?: STEVE_WATCH_EVENT_LISTENER_CALLBACK;
+  private id: string;
+  private classify: boolean;
+  private reactive: boolean;
+
+  public isEnabled: boolean;
+  private steveWatchParams: STEVE_WATCH_EVENT_PARAMS_COMMON | undefined;
+
+  constructor(args: Args) {
+    const {
+      $store, id, enabledFor, onChange, formatResponse
+    } = args;
+
+    this.$store = $store;
+    this.id = id;
+    this.enabledFor = enabledFor;
+    this.onChange = onChange;
+    this.classify = formatResponse?.classify || false;
+    this.reactive = formatResponse?.reactive || false;
+
+    this.isEnabled = paginationUtils.isEnabled({ rootGetters: $store.getters }, enabledFor);
+  }
+
+  async request(args: {
+      pagination: PaginationArgs,
+  }): Promise<Result<T>> {
+    if (!this.isEnabled) {
+      throw new Error(`Wrapper for type '${ this.enabledFor.store }/${ this.enabledFor.resource?.id }' in context '${ this.enabledFor.resource?.context }' not supported`);
+    }
+    const { pagination } = args;
+    const opt: ActionFindPageArgs = {
+      watch:     false,
+      pagination,
+      transient: true,
+    };
+
+    // Fetch
+    const out: ActionFindPageTransientResult<T> = await this.$store.dispatch(`${ this.enabledFor.store }/findPage`, { opt, type: this.enabledFor.resource?.id });
+
+    // Watch
+    if (this.onChange && !this.steveWatchParams) {
+      this.steveWatchParams = {
+        event:  STEVE_WATCH_EVENT.CHANGES,
+        id:     this.id,
+        params: {
+          type: this.enabledFor.resource?.id as string,
+          mode: STEVE_WATCH_MODE.RESOURCE_CHANGES,
+        }
+      };
+
+      this.watch();
     }
 
-    async request(args: {
-        pagination: PaginationArgs,
-        classify?: boolean,
-    }): Promise<Result<T>> {
-      if (!this.isEnabled) {
-        throw new Error(`Wrapper for type '${ this.enabledFor.store }/${ this.enabledFor.resource?.id }' in context '${ this.enabledFor.resource?.context }' not supported`);
-      }
-      const { pagination, classify: doClassify } = args;
-      const opt: ActionFindPageArgs = {
-        transient: true,
-        pagination
+    // Convert Response
+    if (this.classify) {
+      out.data = await this.$store.dispatch(`${ this.enabledFor.store }/createMany`, out.data);
+    }
+
+    if (this.reactive) {
+      return {
+        ...out,
+        data: reactive(out.data)
       };
+    }
 
-      const out: Result<T> = await this.$store.dispatch(`${ this.enabledFor.store }/findPage`, { opt, type: this.enabledFor.resource?.id });
+    return out;
+  }
 
-      if (doClassify) {
-        for (let i = 0; i < out.data.length; i++) {
-          out.data[i] = await this.$store.dispatch(`${ this.enabledFor.store }/create`, out.data[i]);
-        }
-      }
+  private async watch() {
+    if (!this.steveWatchParams) {
+      console.error('Calling watch but no watch params created'); // eslint-disable-line no-console
 
-      return out;
+      return;
     }
+    const watchParams: STEVE_WATCH_EVENT_PARAMS = {
+      ...this.steveWatchParams,
+      callback: this.onChange as STEVE_WATCH_EVENT_LISTENER_CALLBACK, // we must have it by now
+    };
+
+    await this.$store.dispatch(`${ this.enabledFor.store }/watchEvent`, watchParams);
+  }
+
+  private async unWatch() {
+    if (!this.steveWatchParams) {
+      console.error('Calling unWatch but no watch params created'); // eslint-disable-line no-console
+
+      return;
+    }
+
+    const unWatchParams: STEVE_UNWATCH_EVENT_PARAMS = { ...this.steveWatchParams };
+
+    await this.$store.dispatch(`${ this.enabledFor.store }/unwatchEvent`, unWatchParams);
+  }
+
+  async onDestroy() {
+    await this.unWatch();
+  }
 }
 
 export default PaginationWrapper;

package/utils/perf-setting.utils.ts

@@ -0,0 +1,28 @@
+import { PerfSettings } from '@shell/config/settings';
+
+type PaginationSupersedesSettings = 'incrementalLoading' | 'manualRefresh'
+
+class _Utils {
+  private setting: PaginationSupersedesSettings;
+  constructor(setting: PaginationSupersedesSettings) {
+    this.setting = setting;
+  }
+
+  /**
+   * This is a centralised point to ensure SSP takes precedence over the performance setting
+   */
+  isEnabled(paginationEnabled: boolean, perfSettings: PerfSettings): boolean {
+    return !paginationEnabled && perfSettings[this.setting].enabled;
+  }
+}
+
+export default {
+  /**
+   * Helper functions for the 'incremental loading indicator' performance settings
+   */
+  incrementalLoadingUtils: new _Utils('incrementalLoading'),
+  /**
+   * Helper functions for the 'manual refresh' performance settings
+   */
+  manualRefreshUtils:      new _Utils('manualRefresh'),
+};

package/utils/release-notes.ts

@@ -0,0 +1,48 @@
+import { getVersionData } from '@shell/config/version';
+import { READ_WHATS_NEW } from '@shell/store/prefs';
+import { NotificationLevel } from '@shell/types/notifications';
+
+export async function addReleaseNotesNotification(dispatch: any, getters: any) {
+  const rancherVersion = getVersionData().Version.split('-')[0];
+  const prefix = 'release-notes-';
+  const id = `${ prefix }${ rancherVersion }`;
+  let found = false;
+  const all = getters['notifications/all'];
+  const lastReadVersion = getters['prefs/get'](READ_WHATS_NEW) || '';
+  const t = getters['i18n/t'];
+  const releaseNotesUrl = getters['releaseNotesUrl'];
+
+  // Delete notification(s) for old release notes
+  for (let i = 0; i < all.length; i++) {
+    const notification = all[i];
+
+    if (notification.id.startsWith(prefix)) {
+      if (notification.id === id) {
+        found = true;
+      } else {
+        await dispatch('notifications/delete', notification.id);
+      }
+    }
+  }
+
+  // Also use pref, so if we expired it, we don't add it back
+  if (!found && lastReadVersion !== rancherVersion) {
+    // Register notification
+    const notification = {
+      id,
+      level:      NotificationLevel.Info,
+      title:      t('landing.whatsNew.title', { version: rancherVersion }),
+      message:    t('landing.whatsNew.message'),
+      preference: {
+        key:   READ_WHATS_NEW,
+        value: rancherVersion
+      },
+      primaryAction: {
+        label:  t('landing.whatsNew.link'),
+        target: releaseNotesUrl
+      }
+    };
+
+    await dispatch('notifications/add', notification);
+  }
+}

package/utils/selector-typed.ts

@@ -0,0 +1,210 @@
+import { COUNT } from '@shell/config/types';
+import { KubeLabelSelector, KubeLabelSelectorExpression } from '@shell/types/kube/kube-api';
+import { ActionFindPageArgs } from '@shell/types/store/dashboard-store.types';
+import { FilterArgs, PaginationFilterField, PaginationParamFilter } from '@shell/types/store/pagination.types';
+import { isEmpty } from '@shell/utils/object';
+import { convert, matching as rootMatching } from '@shell/utils/selector';
+
+type MatchingResponse = {
+  matched: number,
+  matches: any[],
+  none: boolean,
+  sample: any,
+  total: number,
+}
+
+/**
+ * Find resources that match a labelSelector. This behaves differently if vai based pagination is on
+ * a) Pagination Enabled - fetch matching resources filtered on backend - findPage
+ * b) Pagination Disabled - fetch all resources and then filter locally - findAll --> root `matching` fn
+ *
+ * This is a much smarter version of root matching fn `matching` from shell/utils/selector.js  (which just does local filtering)
+ *
+  * If fetching all of a resource should be avoided or we don't want to mess around with the cache the action `findLabelSelector` should be used
+ * - sometimes some legacy code expects all resources are fetched
+ * - sometimes we want to fetch a resource but not override the cache
+ *   - already have a pods list cached, don't want to overwrite that when finding pods associated with a service
+ *
+ * Resources are returned in a common format which includes metadata
+ */
+export async function matching({
+  labelSelector,
+  type,
+  inStore,
+  $store,
+  inScopeCount = undefined,
+  namespace = undefined,
+  transient = true,
+}: {
+  /**
+   * Standard kube label selector object.
+   *
+   * If this is 'empty' (no matchLabels or matchExpressions) it will return all results
+   *
+   * If this is 'null' it will return no results
+   */
+  labelSelector: KubeLabelSelector,
+  /**
+   * Resource type
+   */
+  type: string,
+  /**
+   * Store in which resources will be cached
+   */
+  inStore: string,
+  /**
+   * Standard vuex store object
+   */
+  $store: any,
+  /**
+   * Number of resources that are applicable when filtering.
+   *
+   * Used to skip any potential http request if we know the result will be zero
+   *
+   * If this property is not supplied we'll try and discover it from the COUNTS resource.
+   */
+  inScopeCount?: number
+  /**
+   * Optional namespace or namespaces to apply selector to
+   *
+   * If this is undefined then namespaces will totally be ignored
+   *
+   * If this is provided all resources must be within them. If an empty array is provided then no resources will be matched
+   *
+   */
+  namespace?: string | string[],
+  /**
+   * Should the result bypass the store?
+   */
+  transient?: boolean,
+}): Promise<MatchingResponse> {
+  const isNamespaced = $store.getters[`${ inStore }/schemaFor`](type)?.attributes.namespaced;
+  const safeNamespaces = Array.isArray(namespace) ? namespace : !!namespace ? [namespace] : [];
+  const filterByNamespaces = isNamespaced && !!namespace ; // Result set must come from a resource in a namespace
+
+  // Determine if there's actually anything to filter on
+  if (typeof inScopeCount === 'undefined') {
+    const counts = $store.getters[`${ inStore }/all`](COUNT)?.[0]?.counts || {};
+
+    if (filterByNamespaces) {
+      inScopeCount = 0;
+      safeNamespaces.forEach((n) => {
+        inScopeCount += counts?.[type]?.namespaces[n]?.count || 0;
+      });
+    } else {
+      inScopeCount = counts?.[type]?.summary?.count || 0;
+    }
+  }
+
+  // Exit early if there are any situations that always return nothing
+  const noCandidates = (inScopeCount || 0) === 0;
+  const filterByNamespaceButNoNamespace = isNamespaced && !!namespace && (!safeNamespaces || safeNamespaces.length === 0);
+  const explicityNullLabelSelector = labelSelector === null || (labelSelector?.matchLabels === null && !labelSelector.matchExpressions === null);
+
+  // If we have matchLabels or matchExpression entries they must have a key
+  const matchLabelKeys = Object.keys(labelSelector.matchLabels || {});
+  const invalidMatchLabelKeys = matchLabelKeys.length && matchLabelKeys.filter((k) => !k).length;
+  const invalidMatchExpressionKeys = labelSelector?.matchExpressions?.length && labelSelector.matchExpressions.filter((me) => !me.key).length;
+
+  if (noCandidates || filterByNamespaceButNoNamespace || explicityNullLabelSelector || invalidMatchLabelKeys || invalidMatchExpressionKeys) {
+    return generateMatchingResponse([], inScopeCount || 0);
+  }
+
+  if ($store.getters[`${ inStore }/paginationEnabled`]?.({ id: type })) {
+    if (isLabelSelectorEmpty(labelSelector) && (!!namespace && !safeNamespaces?.length)) {
+      // no namespaces - ALL resources are candidates
+      // no labels - return all candidates
+      // too many to fetch...
+      throw new Error('Either populated labelSelector or namespace/s must be supplied in order to call findPage');
+    }
+
+    const findPageArgs: ActionFindPageArgs = {
+      pagination: new FilterArgs({
+        labelSelector,
+        filters: PaginationParamFilter.createMultipleFields(
+          safeNamespaces.map(
+            (n) => new PaginationFilterField({
+              field: 'metadata.namespace', // API only compatible with steve atm...
+              value: n,
+            })
+          )
+        ),
+      }),
+      transient,
+    };
+
+    let match = await $store.dispatch(`${ inStore }/findPage`, { type, opt: findPageArgs });
+
+    if (transient) {
+      match = match.data;
+    }
+
+    return generateMatchingResponse(match, inScopeCount || 0);
+  } else {
+    // Start off with everything as a candidate
+    let candidates = await $store.dispatch(`${ inStore }/findAll`, { type });
+
+    inScopeCount = candidates.length;
+
+    // Filter out namespace specific stuff
+    if (isNamespaced && safeNamespaces?.length > 0) {
+      candidates = candidates.filter((e: any) => safeNamespaces.includes(e.metadata?.namespace));
+      inScopeCount = candidates.length;
+    }
+
+    // Apply labelSelector
+    if (labelSelector.matchLabels || labelSelector.matchExpressions) {
+      candidates = matches(candidates, labelSelector, 'metadata.labels');
+    }
+
+    return generateMatchingResponse(candidates, inScopeCount || 0);
+  }
+}
+
+const generateMatchingResponse = <T extends { [key: string]: any, nameDisplay: string}>(match: T[], inScopeCount: number): MatchingResponse => {
+  const matched = match.length || 0;
+  const sample = match[0]?.nameDisplay;
+
+  return {
+    matched,
+    matches: match,
+    none:    matched === 0,
+    sample,
+    total:   inScopeCount || 0,
+  };
+};
+
+/**
+ * This is similar to shell/utils/selector.js `matches`, but accepts a kube labelSelector
+ */
+function matches<T = any>(candidates: T[], labelSelector: KubeLabelSelector, labelKey: string): T[] {
+  const convertedObject = convert(labelSelector.matchLabels, labelSelector.matchExpressions);
+
+  return rootMatching(candidates, convertedObject, labelKey);
+}
+
+export function isLabelSelectorEmpty(labelSelector?: KubeLabelSelector): boolean {
+  return !labelSelector?.matchExpressions?.length && isEmpty(labelSelector?.matchLabels);
+}
+
+export function labelSelectorToSelector(labelSelector?: KubeLabelSelector): string {
+  if (isLabelSelectorEmpty(labelSelector)) {
+    return '';
+  }
+
+  const res: string[] = [];
+
+  Object.entries(labelSelector?.matchLabels || {}).forEach(([key, value]) => {
+    res.push(`${ key }=${ value }`);
+  });
+
+  (labelSelector?.matchExpressions || []).forEach((value: KubeLabelSelectorExpression) => {
+    if (value.operator === 'In' && value.values?.length === 1) {
+      res.push(`${ value.key }=${ value.values[0] }`);
+    } else {
+      throw new Error(`Unsupported matchExpression found when converting to selector string. ${ value }`);
+    }
+  });
+
+  return res.join(',');
+}