@rancher/shell 3.0.12-rc.1 → 3.0.12-rc.3

package/store/aws.js

@@ -12,9 +12,10 @@ export const state = () => {
 };
 
 class Handler {
-  constructor(cloudCredentialId, options) {
+  constructor(cloudCredentialId, options, proxyApi) {
     this.cloudCredentialId = (cloudCredentialId || '');
     this.fetchHandler = new FetchHttpHandler(options);
+    this.proxyApi = proxyApi;
   }
 
   async handle(httpRequest, options = {}) {
@@ -24,24 +25,34 @@ class Handler {
 
     httpRequest.headers['x-api-headers-restrict'] = 'Content-Length';
 
-    if (this.cloudCredentialId) {
-      httpRequest.headers['x-api-cattleauth-header'] = `awsv4 credID=${ this.cloudCredentialId }`;
-    } else if (httpRequest?.headers['authorization']) {
-      httpRequest.headers['x-api-auth-header'] = httpRequest.headers['authorization'];
-    }
+    // Build proxy options: use awsv4 credential signing when a cloud credential
+    // is available, otherwise forward the SDK-generated Authorization header
+    // directly via x-api-auth-header.
+    const upstreamUrl = new URL(`https://${ httpRequest.hostname }${ httpRequest.path }`);
+    const proxyOptions = this.cloudCredentialId ? {
+      url:            upstreamUrl,
+      authentication: {
+        id:         this.cloudCredentialId,
+        authSigner: 'awsv4',
+      },
+    } : {
+      url:     upstreamUrl,
+      headers: httpRequest?.headers['authorization'] ? { 'x-api-auth-header': httpRequest.headers['authorization'] } : {},
+    };
+
+    const { url: proxyPath, headers: proxyHeaders } = this.proxyApi.prepareRequest(proxyOptions);
 
+    // Merge proxy auth headers; remove the upstream Authorization and the
+    // Accept header added by prepareRequest (AWS SDK manages its own Accept).
+    Object.assign(httpRequest.headers, proxyHeaders);
     delete httpRequest.headers['authorization'];
+    delete httpRequest.headers['Accept'];
 
     const originalContentType = httpRequest.headers['content-type'] ?? '';
 
     httpRequest.headers['content-type'] = originalContentType ? `rancher:${ originalContentType }` : 'rancher:';
 
-    const endpoint = `/meta/proxy/`;
-
-    if (!httpRequest.path.startsWith(endpoint)) {
-      httpRequest.path = endpoint + httpRequest.hostname + httpRequest.path;
-    }
-
+    httpRequest.path = proxyPath;
     httpRequest.protocol = window.location.protocol;
     httpRequest.hostname = window.location.hostname;
     httpRequest.port = window.location.port;
@@ -114,7 +125,7 @@ export const actions = {
     const client = new lib.EC2({
       region,
       credentialDefaultProvider: credentialDefaultProvider(accessKey, secretKey),
-      requestHandler:            new Handler(cloudCredentialId),
+      requestHandler:            new Handler(cloudCredentialId, undefined, this.$shell.proxy),
       useDualstackEndpoint:      true,
     });
 
@@ -129,7 +140,7 @@ export const actions = {
     const client = new lib.EKS({
       region,
       credentialDefaultProvider: credentialDefaultProvider(accessKey, secretKey),
-      requestHandler:            new Handler(cloudCredentialId),
+      requestHandler:            new Handler(cloudCredentialId, undefined, this.$shell.proxy),
       useDualstackEndpoint:      true,
     });
 
@@ -144,7 +155,7 @@ export const actions = {
     const client = new lib.KMS({
       region,
       credentialDefaultProvider: credentialDefaultProvider(accessKey, secretKey),
-      requestHandler:            new Handler(cloudCredentialId),
+      requestHandler:            new Handler(cloudCredentialId, undefined, this.$shell.proxy),
       useDualstackEndpoint:      true,
     });
 
@@ -159,7 +170,7 @@ export const actions = {
     const client = new lib.IAM({
       region,
       credentialDefaultProvider: credentialDefaultProvider(accessKey, secretKey),
-      requestHandler:            new Handler(cloudCredentialId),
+      requestHandler:            new Handler(cloudCredentialId, undefined, this.$shell.proxy),
       useDualstackEndpoint:      true,
     });
 

package/store/catalog.js

@@ -325,8 +325,12 @@ export const actions = {
    * force: Always refresh catalog's helm repo by re-fetching index.yaml
    *
    * reset: clear existing charts and version cache
+   *
+   * repoKeys: Optional array of specific repo keys (IDs) to refresh. When provided, only these specific
+   * repos will be fetched, and only their existing charts will be cleared from the cache to avoid
+   * duplicate chart entries or wiping out unrelated chart data.
    */
-  async load(ctx, { force, reset } = {}) {
+  async load(ctx, { force, reset, repoKeys = [] } = {}) {
     const {
       state, getters, rootGetters, commit, dispatch
     } = ctx;
@@ -360,14 +364,34 @@ export const actions = {
     promises = {};
 
     for ( const repo of repos ) {
-      if ( (force === true || !getters.isLoaded(repo)) && repo.canLoad ) {
+      let shouldLoad = false;
+
+      if (repoKeys.length) {
+        // If repoKeys are explicitly provided (e.g. refreshing a single repo from the UI),
+        // we ONLY want to load the repos in that array. We intentionally ignore `!getters.isLoaded(repo)`
+        // here so we don't accidentally fetch other unrelated repos just because they haven't loaded yet.
+        shouldLoad = repoKeys.includes(repo._key);
+      } else {
+        // Default behavior: load if explicitly forced, OR if the repo hasn't been loaded into state yet.
+        shouldLoad = force === true || !getters.isLoaded(repo);
+      }
+
+      if ( shouldLoad && repo.canLoad ) {
         console.info('Loading index for repo', repo.name, `(${ repo._key })`); // eslint-disable-line no-console
         promises[repo._key] = repo.followLink('index');
       }
     }
 
     const res = await allHashSettled(promises);
-    const charts = reset ? {} : state.charts;
+    const charts = reset ? {} : { ...state.charts };
+    let versionInfos = null;
+
+    if (reset) {
+      versionInfos = {};
+    } else if (repoKeys.length) {
+      versionInfos = { ...state.versionInfos };
+    }
+
     const errors = [];
 
     for ( const key of Object.keys(res) ) {
@@ -379,6 +403,28 @@ export const actions = {
         continue;
       }
 
+      // We are targeting specific repos. To prevent duplicate chart versions from appearing,
+      // we must remove the old charts for this specific repo before appending the newly fetched ones,
+      // but ONLY if the fetch was successful.
+      if (repoKeys.length && repoKeys.includes(key)) {
+        for (const chartKey in charts) {
+          if (charts[chartKey].repoKey === key) {
+            delete charts[chartKey];
+          }
+        }
+
+        // Also clear out cached version info for this repo so we don't display stale READMEs/values
+        const repoType = repo.type === CATALOG.CLUSTER_REPO ? 'cluster' : 'namespace';
+        const repoName = repo.metadata.name;
+        const versionPrefix = `${ repoType }/${ repoName }/`;
+
+        for (const versionKey in versionInfos) {
+          if (versionKey.startsWith(versionPrefix)) {
+            delete versionInfos[versionKey];
+          }
+        }
+      }
+
       for ( const k in obj.value.entries ) {
         for ( const entry of obj.value.entries[k] ) {
           addChart(ctx, charts, entry, repo);
@@ -394,13 +440,17 @@ export const actions = {
       loaded,
     });
 
-    if (reset) {
-      commit('setVersions', {});
+    if (versionInfos) {
+      commit('setVersions', versionInfos);
     }
   },
 
+  /**
+   * Globally refreshes all loaded repositories by triggering their refresh actions concurrently,
+   * bypassing individual catalog loads, and then performs a single, global catalog/load.
+   */
   async refresh({ getters, commit, dispatch }) {
-    const promises = getters.repos.map((x) => x.refresh());
+    const promises = getters.repos.map((x) => x.refresh(false));
 
     // @TODO wait for repo state to indicate they're done once the API has that
 
@@ -488,7 +538,9 @@ function addChart(ctx, map, chart, repo) {
     certified = CATALOG_ANNOTATIONS._OTHER;
   }
 
-  if ( chart.deprecated ) {
+  const isDeprecated = !!chart.deprecated || chart.annotations?.[CATALOG_ANNOTATIONS.DEPRECATED] === 'true';
+
+  if ( isDeprecated ) {
     sideLabel = DEPRECATED;
   } else if ( chart.annotations?.[CATALOG_ANNOTATIONS.EXPERIMENTAL] ) {
     sideLabel = EXPERIMENTAL;
@@ -507,7 +559,10 @@ function addChart(ctx, map, chart, repo) {
 
     const primeOnly = chart.annotations?.[CATALOG_ANNOTATIONS.PRIME_ONLY] === 'true';
     const experimental = !!chart.annotations?.[CATALOG_ANNOTATIONS.EXPERIMENTAL];
-    const windowsIncompatible = !(chart.annotations?.[CATALOG_ANNOTATIONS.PERMITTED_OS] || '').includes('windows');
+
+    const isRancherRepoFlag = isRancherRepo(repo, chart);
+    const permittedSystems = getPermittedOSs(chart.annotations, isRancherRepoFlag);
+    const windowsIncompatible = permittedSystems.length > 0 && !permittedSystems.includes('windows');
     const deploysOnWindows = (chart.annotations?.[CATALOG_ANNOTATIONS.DEPLOYED_OS] || '').includes('windows');
     const tags = [];
 
@@ -546,7 +601,7 @@ function addChart(ctx, map, chart, repo) {
       versions:         [],
       keywords:         chart.keywords || [],
       categories:       filterCategories(chart.keywords),
-      deprecated:       !!chart.deprecated,
+      deprecated:       isDeprecated,
       primeOnly,
       experimental,
       hidden:           !!chart.annotations?.[CATALOG_ANNOTATIONS.HIDDEN],
@@ -556,6 +611,7 @@ function addChart(ctx, map, chart, repo) {
       provides:         [],
       windowsIncompatible,
       deploysOnWindows,
+      isRancherRepo:    isRancherRepoFlag,
       tags
     });
 
@@ -640,13 +696,13 @@ export function compatibleVersionsFor(chart, os, includePrerelease = true) {
   }
 
   return versions.filter((ver) => {
-    const osPermitted = (ver?.annotations?.[CATALOG_ANNOTATIONS.PERMITTED_OS] || LINUX).split(',');
+    const osPermitted = getPermittedOSs(ver?.annotations, chart?.isRancherRepo);
 
     if ( !includePrerelease && isPrerelease(ver.version) ) {
       return false;
     }
 
-    if ( !os || difference(os, osPermitted).length === 0) {
+    if ( !os || osPermitted.length === 0 || difference(os, osPermitted).length === 0) {
       return true;
     }
 
@@ -735,3 +791,23 @@ export function filterAndArrangeCharts(charts, {
 
   return sortBy(out, ['certifiedSort', 'repoName', 'chartNameDisplay']);
 }
+
+/**
+ * Detects if a repository is a Rancher repository.
+ */
+export function isRancherRepo(repo, chart) {
+  return !!(chart?.isRancherRepo || repo?.isRancherSource);
+}
+
+/**
+ * Returns an array of permitted operating systems for a given chart or version.
+ * If the chart explicitly defines permitted OSs via annotation, those are returned.
+ * Otherwise, if the chart is from a Rancher repository, it defaults to Linux.
+ * External charts with no annotations have no OS restrictions (returns empty array).
+ */
+export function getPermittedOSs(annotations, isRancher) {
+  const permittedOs = annotations?.[CATALOG_ANNOTATIONS.PERMITTED_OS];
+  const fallbackOs = isRancher ? LINUX : '';
+
+  return (permittedOs || fallbackOs).split(',').filter(Boolean);
+}

package/store/digitalocean.js

@@ -1,5 +1,5 @@
 import { sortBy } from '@shell/utils/sort';
-import { addParam, addParams } from '@shell/utils/url';
+import { createDepaginator } from '@shell/apis/shell/proxy';
 
 const ENDPOINT = 'api.digitalocean.com/v2';
 
@@ -149,50 +149,32 @@ export const actions = {
     return out;
   },
 
-  async request({ dispatch }, {
-    token, credentialId, command, opt, out
+  async request(_, {
+    token, credentialId, command, opt
   }) {
     opt = opt || {};
 
-    let url = '/meta/proxy/';
+    const url = new URL(opt.url || `https://${ ENDPOINT }/${ command }`);
 
-    if ( opt.url ) {
-      url += opt.url.replace(/^https?:\/\//, '');
-    } else {
-      url += `${ ENDPOINT }/${ command }`;
-      url = addParam(url, 'per_page', opt.per_page || 1000);
-      url = addParams(url, opt.params || {});
-    }
-
-    const headers = { Accept: 'application/json' };
-
-    if ( credentialId ) {
-      headers['x-api-cattleauth-header'] = `Bearer credID=${ credentialId } passwordField=accessToken`;
-    } else if ( token ) {
-      headers['x-api-auth-header'] = `Bearer ${ token }`;
-    }
-
-    const res = await dispatch('management/request', {
-      url,
-      headers,
-      redirectUnauthorized: false,
-    }, { root: true });
-
-    if ( out ) {
-      out[command] = out[command].concat(res[command]);
-    } else {
-      out = res;
+    url.searchParams.set('per_page', `${ opt.per_page || 1000 }`);
+    if (opt.params) {
+      for (const [key, value] of Object.entries(opt.params)) {
+        url.searchParams.set(key, value);
+      }
     }
 
-    // De-pagination
-    if ( res?.links?.pages?.next ) {
-      opt.url = res.links.pages.next;
+    const authentication = credentialId ? {
+      id:            credentialId,
+      authSigner:    'bearer',
+      passwordField: 'accessToken',
+    } : { token };
 
-      return dispatch('request', {
-        token, credentialId, command, opt, out
-      });
-    }
+    const proxy = this.$shell?.proxy;
+    const requestOptions = { url, authentication };
 
-    return out;
+    return proxy.request({
+      ...requestOptions,
+      postProcess: createDepaginator(proxy, requestOptions, { mergeKey: command }),
+    });
   },
 };

package/store/index.js

@@ -1041,6 +1041,8 @@ export const actions = {
     // This is a workaround for a timing issue where the mgmt cluster schema may not be available
     // Try and wait until the schema exists before proceeding
     await dispatch('management/waitForSchema', { type: MANAGEMENT.CLUSTER });
+    // Similarly to above, we somehow get here without everything in management land being ready. FF needed to determine pagination state
+    await dispatch('management/waitForHaveAll', { type: MANAGEMENT.FEATURE });
 
     // If SSP is on we won't have requested all clusters
     if (!paginateClusters({ rootGetters, state })) {

package/store/linode.js

@@ -1,5 +1,5 @@
 import { sortBy } from '@shell/utils/sort';
-import { addParam, addParams } from '@shell/utils/url';
+import { createDepaginator } from '@shell/apis/shell/proxy';
 
 const ENDPOINT = 'api.linode.com/v4';
 
@@ -93,50 +93,35 @@ export const actions = {
     return out;
   },
 
-  async request({ dispatch }, {
-    token, credentialId, command, opt, out
+  async request(_, {
+    token, credentialId, command, opt
   }) {
     opt = opt || {};
 
-    let url = '/meta/proxy/';
+    const url = new URL(opt.url || `https://${ ENDPOINT }/${ command }`);
 
-    if ( opt.url ) {
-      url += opt.url.replace(/^https?:\/\//, '');
-    } else {
-      url += `${ ENDPOINT }/${ command }`;
-      url = addParam(url, 'per_page', opt.per_page || 1000);
-      url = addParams(url, opt.params || {});
+    url.searchParams.set('per_page', `${ opt.per_page || 1000 }`);
+    if (opt.params) {
+      for (const [key, value] of Object.entries(opt.params)) {
+        url.searchParams.set(key, value);
+      }
     }
 
-    const headers = { Accept: 'application/json' };
-
-    if ( credentialId ) {
-      headers['X-API-CattleAuth-Header'] = `Bearer credID=${ credentialId } passwordField=token`;
-    } else if ( token ) {
-      headers['X-API-Auth-Header'] = `Bearer ${ token }`;
-    }
-
-    const res = await dispatch('management/request', {
-      url,
-      headers,
-      redirectUnauthorized: false,
-    }, { root: true });
-
-    if ( out ) {
-      out[command] = out[command].concat(res[command]);
-    } else {
-      out = res;
-    }
-
-    // De-pagination
-    if ( res?.links?.pages?.next ) {
-      opt.url = res.links.pages.next;
-
-      return dispatch('request', {
-        token, credentialId, command, opt, out
-      });
-    }
-
-    return out;
+    const authentication = credentialId ? {
+      id:            credentialId,
+      authSigner:    'bearer',
+      passwordField: 'token',
+    } : { token };
+
+    const proxy = this.$shell.proxy;
+    const requestOptions = { url, authentication };
+
+    return proxy.request({
+      ...requestOptions,
+      postProcess: createDepaginator(proxy, requestOptions, {
+        nextUrlPath: 'links.pages.next',
+        mergeKey:    command,
+      }),
+    });
   }
 };

package/store/pnap.js

@@ -68,6 +68,7 @@ export const actions = {
     return out;
   },
 
+  // DEPRECATED: accessing /meta/proxy directly is deprecated
   async request({ dispatch }, {
     clientId, clientSecret, credentialId, command, opt, out
   }) {

package/store/type-map.js

@@ -20,7 +20,7 @@
 // importList(type)                 Returns a promise that resolves to the list component for type
 // importDetail(type[,subType])     Returns a promise that resolves to the detail component for type
 // importEdit(type[,subType])       Returns a promise that resolves to the edit component for type
-// optionsFor(schemaOrType)         Return the configured options for a type (from configureType)
+// optionsFor(schemaOrType, pagination(bool), product(string)) Return the configured options for a type (from configureType) - additional product param can be passed if "optionsFor" needed isn't the current product
 //
 // 3) Changing specialization info about a type
 // For all:
@@ -107,6 +107,7 @@
 //                               notFilterNamespace:  undefined -- Define namespaces that do not need to be filtered
 //                               localOnly: False -- Hide this type from the nav/search bar on downstream clusters
 //                               custom: any - Custom options for a given type
+//                               product: string - If set, this type's options will only apply when that product is active
 //                           }
 // )
 // ignoreGroup(group):        Never show group or any types in it
@@ -269,20 +270,25 @@ export function DSL(store, product, module = 'type-map') {
       store.commit(`${ module }/groupBy`, { type, field });
     },
 
-    headers(type, headers, paginationHeaders = []) {
-      headers.forEach((header) => {
+    headers(type, headers = [], paginationHeaders = []) {
+      if (headers.length) {
+        headers.forEach((header) => {
         // If on the client, then use the value getter if there is one
-        if (header.getValue) {
+          if (header.getValue) {
           // we need to store the .value prop for the advanced filtering
-          header.valueProp = header.value;
-          header.value = header.getValue;
-        }
+            header.valueProp = header.value;
+            header.value = header.getValue;
+          }
 
-        delete header.getValue;
-      });
+          delete header.getValue;
+        });
 
-      store.commit(`${ module }/headers`, { type, headers });
-      store.commit(`${ module }/paginationHeaders`, { type, paginationHeaders });
+        store.commit(`${ module }/headers`, { type, headers });
+      }
+
+      if (paginationHeaders.length) {
+        store.commit(`${ module }/paginationHeaders`, { type, paginationHeaders });
+      }
     },
 
     hideBulkActions(type, field) {
@@ -290,7 +296,9 @@ export function DSL(store, product, module = 'type-map') {
     },
 
     configureType(match, options) {
-      store.commit(`${ module }/configureType`, { ...options, match });
+      store.commit(`${ module }/configureType`, {
+        ...options, match, product
+      });
     },
 
     componentForType(match, replace) {
@@ -371,6 +379,18 @@ export function DSL(store, product, module = 'type-map') {
   };
 }
 
+const LEGACY_COMPATIBILITY_BUCKET = 'legacyCompatibilityProdRegistration';
+
+function validateProductName(product) {
+  if (!product || typeof product !== 'string' || product.trim() === '') {
+    throw new Error(`Product name must be a non-empty string, got: ${ JSON.stringify(product) }`);
+  }
+
+  if (product === LEGACY_COMPATIBILITY_BUCKET) {
+    throw new Error(`Product name cannot be "${ LEGACY_COMPATIBILITY_BUCKET }" as it is reserved for backward compatibility`);
+  }
+}
+
 let called = false;
 
 export async function applyProducts(store, $extension) {
@@ -412,7 +432,7 @@ export const state = function() {
     typeMappings:            [],
     typeMoveMappings:        [],
     typeToComponentMappings: [],
-    typeOptions:             [],
+    typeOptions:             {},
     groupBy:                 {},
     headers:                 {},
     paginationHeaders:       {},
@@ -549,15 +569,37 @@ export const getters = {
       subTypes:                 [],
     };
 
-    return (schemaOrType, pagination) => {
+    return (schemaOrType, pagination, product) => {
       // Note - This can run a LOT so needs to be performant
 
       if (!schemaOrType) {
         return {};
       }
 
+      if (product) {
+        validateProductName(product);
+      }
+
       const type = (typeof schemaOrType === 'object' ? schemaOrType.id : schemaOrType);
-      const found = state.typeOptions.find((entry) => {
+      const productToUse = product || rootGetters['productId'];
+
+      // Handle both array (pre-2.15) and object (2.15+) state.typeOptions formats for backwards compatibility
+      let productTypeOptions = [];
+
+      if (Array.isArray(state.typeOptions)) {
+        // Legacy format: filter the flat array for entries matching the product or entries without a product field
+        productTypeOptions = state.typeOptions.filter((entry) => entry.product === productToUse || !entry.product
+        );
+      } else {
+        // New format: direct object lookup by product, with fallback to legacy compatibility bucket for unscoped entries
+        // (e.g., extensions compiled with pre-2.15 shell that don't send product parameter)
+        productTypeOptions = [
+          ...(state.typeOptions[productToUse] || []),
+          ...(state.typeOptions[LEGACY_COMPATIBILITY_BUCKET] || [])
+        ];
+      }
+
+      const found = productTypeOptions.find((entry) => {
         const re = stringToRegex(entry.match);
 
         return re.test(type);
@@ -944,7 +986,7 @@ export const getters = {
         });
 
         const attrs = schema.attributes || {};
-        const typeOptions = getters['optionsFor'](schema);
+        const typeOptions = getters['optionsFor'](schema, undefined, product);
 
         schemaModes[TYPE_MODES.BASIC] = schemaModes[TYPE_MODES.BASIC] && getters.groupForBasicType(product, schema.id);
 
@@ -1522,6 +1564,10 @@ export const mutations = {
       delete state.virtualTypes[product];
     }
 
+    if (state.typeOptions[product]) {
+      delete state.typeOptions[product];
+    }
+
     if (state.basicTypes[product]) {
       // Remove table header configuration
       Object.keys(state.basicTypes[product]).forEach((type) => {
@@ -1784,20 +1830,54 @@ export const mutations = {
   },
 
   configureType(state, options) {
-    const match = regexToString(ensureRegex(options.match));
+    const { product, ...typeOptions } = options;
+    const match = regexToString(ensureRegex(typeOptions.match));
+
+    // Handle both old (array) and new (object) state.typeOptions formats for backwards compatibility
+    // Old format (pre-2.15): state.typeOptions = []
+    // New format (2.15+): state.typeOptions = { productName: [...] }
+    if (Array.isArray(state.typeOptions)) {
+      // Legacy path: old format for extensions compiled with pre-2.15 shell
+      // In 2.14, product parameter is not validated/enforced
+      const idx = state.typeOptions.findIndex((obj) => obj.match === match);
+      let obj = { ...options, match };
+
+      if ( idx >= 0 ) {
+        // Merge the custom data object - multiple configures will update existing rather than overwrite
+        obj.custom = Object.assign(state.typeOptions[idx].custom || {}, obj.custom || {});
+        obj = Object.assign(state.typeOptions[idx], obj);
+        state.typeOptions.splice(idx, 1, obj);
+      } else {
+        state.typeOptions.push(obj);
+      }
+    } else {
+      // New path: object format with product scoping (2.15+)
+      // Product is required in new format
+      if (!product) {
+        throw new Error(`configureType: product parameter is required in Rancher 2.15+, not provided for type "${ match }"`);
+      }
 
-    const idx = state.typeOptions.findIndex((obj) => obj.match === match);
-    let obj = { ...options, match };
+      validateProductName(product);
 
-    if ( idx >= 0 ) {
-      // Merge the custom data object - multiple configures will update existing rather than overwrite
-      obj.custom = Object.assign(state.typeOptions[idx].custom || {}, obj.custom || {});
-      obj = Object.assign(state.typeOptions[idx], obj);
-      state.typeOptions.splice(idx, 1, obj);
-    } else {
-      const obj = Object.assign({}, options, { match });
+      // Initialize product's typeOptions array if needed
+      if (!state.typeOptions[product]) {
+        state.typeOptions[product] = [];
+      }
+
+      const productTypeOptions = state.typeOptions[product];
+      const idx = productTypeOptions.findIndex((obj) => obj.match === match);
+      let obj = { ...typeOptions, match };
 
-      state.typeOptions.push(obj);
+      if ( idx >= 0 ) {
+        // Merge the custom data object - multiple configures will update existing rather than overwrite
+        obj.custom = Object.assign(productTypeOptions[idx].custom || {}, obj.custom || {});
+        obj = Object.assign(productTypeOptions[idx], obj);
+        productTypeOptions.splice(idx, 1, obj);
+      } else {
+        const obj = Object.assign({}, typeOptions, { match });
+
+        productTypeOptions.push(obj);
+      }
     }
   },
 
@@ -1836,8 +1916,10 @@ export const actions = {
     dispatch('prefs/set', { key: EXPANDED_GROUPS, value: groups }, { root: true });
   },
 
-  configureType({ commit }, options) {
-    commit('configureType', options);
+  configureType({ commit, rootGetters }, options) {
+    const product = options.product || rootGetters['productId'];
+
+    commit('configureType', { ...options, product });
   }
 };