@salesforce/retail-react-app 8.3.0 → 8.4.0-nightly-20260116000329

package/app/utils/bonus-product/cart.test.js

@@ -1639,4 +1639,357 @@ describe('Bonus Product Cart Utilities', () => {
             expect(result[0].productId).toBe('bonus-product-1')
         })
     })
+
+    describe('consolidateDuplicateBonusProducts', () => {
+        test('returns empty array for null input', () => {
+            const result = cartUtils.consolidateDuplicateBonusProducts(null)
+            expect(result).toEqual([])
+        })
+
+        test('returns empty array for undefined input', () => {
+            const result = cartUtils.consolidateDuplicateBonusProducts(undefined)
+            expect(result).toEqual([])
+        })
+
+        test('returns empty array for empty array input', () => {
+            const result = cartUtils.consolidateDuplicateBonusProducts([])
+            expect(result).toEqual([])
+        })
+
+        test('returns regular products as-is when no bonus products', () => {
+            const productItems = [
+                {
+                    productId: 'regular-product-1',
+                    itemId: 'item-1',
+                    quantity: 2
+                },
+                {
+                    productId: 'regular-product-2',
+                    itemId: 'item-2',
+                    quantity: 1
+                }
+            ]
+
+            const result = cartUtils.consolidateDuplicateBonusProducts(productItems)
+
+            expect(result).toHaveLength(2)
+            expect(result[0].productId).toBe('regular-product-1')
+            expect(result[0].quantity).toBe(2)
+            expect(result[1].productId).toBe('regular-product-2')
+            expect(result[1].quantity).toBe(1)
+        })
+
+        test('consolidates duplicate bonus products by productId', () => {
+            const productItems = [
+                {
+                    productId: 'bonus-product-1',
+                    itemId: 'bonus-item-1',
+                    quantity: 1,
+                    bonusProductLineItem: true,
+                    bonusDiscountLineItemId: 'bonus-123'
+                },
+                {
+                    productId: 'bonus-product-1',
+                    itemId: 'bonus-item-2',
+                    quantity: 2,
+                    bonusProductLineItem: true,
+                    bonusDiscountLineItemId: 'bonus-123'
+                },
+                {
+                    productId: 'bonus-product-1',
+                    itemId: 'bonus-item-3',
+                    quantity: 1,
+                    bonusProductLineItem: true,
+                    bonusDiscountLineItemId: 'bonus-456'
+                }
+            ]
+
+            const result = cartUtils.consolidateDuplicateBonusProducts(productItems)
+
+            expect(result).toHaveLength(1)
+            expect(result[0].productId).toBe('bonus-product-1')
+            expect(result[0].quantity).toBe(4) // 1 + 2 + 1
+            expect(result[0].bonusProductLineItem).toBe(true)
+        })
+
+        test('keeps different bonus products separate', () => {
+            const productItems = [
+                {
+                    productId: 'bonus-product-1',
+                    itemId: 'bonus-item-1',
+                    quantity: 2,
+                    bonusProductLineItem: true,
+                    bonusDiscountLineItemId: 'bonus-123'
+                },
+                {
+                    productId: 'bonus-product-2',
+                    itemId: 'bonus-item-2',
+                    quantity: 1,
+                    bonusProductLineItem: true,
+                    bonusDiscountLineItemId: 'bonus-456'
+                }
+            ]
+
+            const result = cartUtils.consolidateDuplicateBonusProducts(productItems)
+
+            expect(result).toHaveLength(2)
+            expect(result[0].productId).toBe('bonus-product-1')
+            expect(result[0].quantity).toBe(2)
+            expect(result[1].productId).toBe('bonus-product-2')
+            expect(result[1].quantity).toBe(1)
+        })
+
+        test('preserves order: regular products first, then bonus products', () => {
+            const productItems = [
+                {
+                    productId: 'bonus-product-1',
+                    itemId: 'bonus-item-1',
+                    quantity: 1,
+                    bonusProductLineItem: true,
+                    bonusDiscountLineItemId: 'bonus-123'
+                },
+                {
+                    productId: 'regular-product-1',
+                    itemId: 'regular-item-1',
+                    quantity: 2
+                },
+                {
+                    productId: 'bonus-product-2',
+                    itemId: 'bonus-item-2',
+                    quantity: 1,
+                    bonusProductLineItem: true,
+                    bonusDiscountLineItemId: 'bonus-456'
+                },
+                {
+                    productId: 'regular-product-2',
+                    itemId: 'regular-item-2',
+                    quantity: 1
+                }
+            ]
+
+            const result = cartUtils.consolidateDuplicateBonusProducts(productItems)
+
+            expect(result).toHaveLength(4)
+            // Regular products should come first
+            expect(result[0].productId).toBe('regular-product-1')
+            expect(result[0].bonusProductLineItem).toBeUndefined()
+            expect(result[1].productId).toBe('regular-product-2')
+            expect(result[1].bonusProductLineItem).toBeUndefined()
+            // Bonus products should come after
+            expect(result[2].productId).toBe('bonus-product-1')
+            expect(result[2].bonusProductLineItem).toBe(true)
+            expect(result[3].productId).toBe('bonus-product-2')
+            expect(result[3].bonusProductLineItem).toBe(true)
+        })
+
+        test('consolidates multiple duplicate bonus products and preserves other properties', () => {
+            const productItems = [
+                {
+                    productId: 'bonus-product-1',
+                    itemId: 'bonus-item-1',
+                    quantity: 1,
+                    bonusProductLineItem: true,
+                    bonusDiscountLineItemId: 'bonus-123'
+                },
+                {
+                    productId: 'bonus-product-1',
+                    itemId: 'bonus-item-2',
+                    quantity: 3,
+                    bonusProductLineItem: true,
+                    bonusDiscountLineItemId: 'bonus-123'
+                },
+                {
+                    productId: 'bonus-product-2',
+                    itemId: 'bonus-item-3',
+                    quantity: 2,
+                    bonusProductLineItem: true,
+                    bonusDiscountLineItemId: 'bonus-456'
+                }
+            ]
+
+            const result = cartUtils.consolidateDuplicateBonusProducts(productItems)
+
+            expect(result).toHaveLength(2)
+            // First bonus product should be consolidated
+            expect(result[0].productId).toBe('bonus-product-1')
+            expect(result[0].quantity).toBe(4) // 1 + 3
+            expect(result[0].bonusProductLineItem).toBe(true)
+            expect(result[0].bonusDiscountLineItemId).toBe('bonus-123')
+            // Second bonus product should remain separate
+            expect(result[1].productId).toBe('bonus-product-2')
+            expect(result[1].quantity).toBe(2)
+        })
+
+        test('handles mixed regular and bonus products with duplicates', () => {
+            const productItems = [
+                {
+                    productId: 'regular-product-1',
+                    itemId: 'regular-item-1',
+                    quantity: 1
+                },
+                {
+                    productId: 'bonus-product-1',
+                    itemId: 'bonus-item-1',
+                    quantity: 1,
+                    bonusProductLineItem: true,
+                    bonusDiscountLineItemId: 'bonus-123'
+                },
+                {
+                    productId: 'regular-product-2',
+                    itemId: 'regular-item-2',
+                    quantity: 2
+                },
+                {
+                    productId: 'bonus-product-1',
+                    itemId: 'bonus-item-2',
+                    quantity: 2,
+                    bonusProductLineItem: true,
+                    bonusDiscountLineItemId: 'bonus-123'
+                },
+                {
+                    productId: 'bonus-product-2',
+                    itemId: 'bonus-item-3',
+                    quantity: 1,
+                    bonusProductLineItem: true,
+                    bonusDiscountLineItemId: 'bonus-456'
+                }
+            ]
+
+            const result = cartUtils.consolidateDuplicateBonusProducts(productItems)
+
+            expect(result).toHaveLength(4)
+            // Regular products first
+            expect(result[0].productId).toBe('regular-product-1')
+            expect(result[0].quantity).toBe(1)
+            expect(result[1].productId).toBe('regular-product-2')
+            expect(result[1].quantity).toBe(2)
+            // Consolidated bonus products
+            expect(result[2].productId).toBe('bonus-product-1')
+            expect(result[2].quantity).toBe(3) // 1 + 2
+            expect(result[3].productId).toBe('bonus-product-2')
+            expect(result[3].quantity).toBe(1)
+        })
+
+        test('handles bonus products with zero quantity', () => {
+            const productItems = [
+                {
+                    productId: 'bonus-product-1',
+                    itemId: 'bonus-item-1',
+                    quantity: 0,
+                    bonusProductLineItem: true,
+                    bonusDiscountLineItemId: 'bonus-123'
+                },
+                {
+                    productId: 'bonus-product-1',
+                    itemId: 'bonus-item-2',
+                    quantity: 2,
+                    bonusProductLineItem: true,
+                    bonusDiscountLineItemId: 'bonus-123'
+                }
+            ]
+
+            const result = cartUtils.consolidateDuplicateBonusProducts(productItems)
+
+            expect(result).toHaveLength(1)
+            expect(result[0].productId).toBe('bonus-product-1')
+            expect(result[0].quantity).toBe(2) // 0 + 2
+        })
+
+        test('handles bonus products with missing quantity property', () => {
+            const productItems = [
+                {
+                    productId: 'bonus-product-1',
+                    itemId: 'bonus-item-1',
+                    bonusProductLineItem: true,
+                    bonusDiscountLineItemId: 'bonus-123'
+                },
+                {
+                    productId: 'bonus-product-1',
+                    itemId: 'bonus-item-2',
+                    quantity: 2,
+                    bonusProductLineItem: true,
+                    bonusDiscountLineItemId: 'bonus-123'
+                }
+            ]
+
+            const result = cartUtils.consolidateDuplicateBonusProducts(productItems)
+
+            expect(result).toHaveLength(1)
+            expect(result[0].productId).toBe('bonus-product-1')
+            expect(result[0].quantity).toBe(2) // undefined treated as 0, then + 2
+        })
+
+        test('consolidates same bonus product from different qualifying products', () => {
+            // Scenario: Same product (bonus-product-1) is a bonus for two different qualifying products
+            // This tests that consolidation happens by productId only, regardless of which
+            // qualifying product triggered the bonus or which bonusDiscountLineItemId it has
+            const productItems = [
+                {
+                    productId: 'regular-product-A',
+                    itemId: 'regular-item-A',
+                    quantity: 1
+                },
+                {
+                    productId: 'bonus-product-1',
+                    itemId: 'bonus-item-1',
+                    quantity: 2,
+                    bonusProductLineItem: true,
+                    bonusDiscountLineItemId: 'bonus-123' // From regular-product-A
+                },
+                {
+                    productId: 'regular-product-B',
+                    itemId: 'regular-item-B',
+                    quantity: 1
+                },
+                {
+                    productId: 'bonus-product-1',
+                    itemId: 'bonus-item-2',
+                    quantity: 1,
+                    bonusProductLineItem: true,
+                    bonusDiscountLineItemId: 'bonus-456' // From regular-product-B (different line item)
+                }
+            ]
+
+            const result = cartUtils.consolidateDuplicateBonusProducts(productItems)
+
+            expect(result).toHaveLength(3)
+            // Regular products first
+            expect(result[0].productId).toBe('regular-product-A')
+            expect(result[1].productId).toBe('regular-product-B')
+            // Bonus products consolidated - same productId from different sources merged
+            expect(result[2].productId).toBe('bonus-product-1')
+            expect(result[2].quantity).toBe(3) // 2 + 1, consolidated from both qualifying products
+            expect(result[2].bonusProductLineItem).toBe(true)
+            // Note: The bonusDiscountLineItemId will be from the first item found (bonus-123)
+            // This is a side effect of using sampleItem - information about the second source is lost
+        })
+
+        test('itemId is not used in consolidation logic (only for display keys)', () => {
+            // itemId is unique per line item but consolidation only uses productId
+            const productItems = [
+                {
+                    productId: 'bonus-product-1',
+                    itemId: 'unique-item-id-1',
+                    quantity: 1,
+                    bonusProductLineItem: true,
+                    bonusDiscountLineItemId: 'bonus-123'
+                },
+                {
+                    productId: 'bonus-product-1',
+                    itemId: 'unique-item-id-2', // Different itemId
+                    quantity: 2,
+                    bonusProductLineItem: true,
+                    bonusDiscountLineItemId: 'bonus-123'
+                }
+            ]
+
+            const result = cartUtils.consolidateDuplicateBonusProducts(productItems)
+
+            expect(result).toHaveLength(1)
+            expect(result[0].productId).toBe('bonus-product-1')
+            expect(result[0].quantity).toBe(3) // Consolidated despite different itemIds
+            // The itemId in result will be from the first item found (unique-item-id-1)
+            // This is preserved for React key generation but not used in consolidation logic
+        })
+    })
 })

package/app/utils/routes-utils.js

@@ -9,25 +9,99 @@ import {getSites} from '@salesforce/retail-react-app/app/utils/site-utils'
 import {urlPartPositions} from '@salesforce/retail-react-app/app/constants'
 
 /**
- * Construct literal routes based on url config
- *      with site and locale references (ids and aliases) from each in your application config
+ * Build regex patterns for site and locale route parameters.
+ * Creates patterns like "siteA|siteB|siteC" from all valid site/locale refs.
+ *
+ * @param {array} allSites - array of site configurations
+ * @returns {object} - { sitePattern, localePattern }
+ */
+const buildRoutePatterns = (allSites) => {
+    const siteRefs = allSites.flatMap((site) => [site.alias, site.id]).filter(Boolean)
+
+    const localeRefs = allSites
+        .flatMap((site) => site.l10n.supportedLocales)
+        .flatMap((locale) => [locale.alias, locale.id])
+        .filter(Boolean)
+
+    // Remove duplicates and join into regex pattern
+    const sitePattern = [...new Set(siteRefs)].join('|')
+    const localePattern = [...new Set(localeRefs)].join('|')
+
+    return {sitePattern, localePattern}
+}
+
+/**
+ * Configure routes using parameterized paths with regex constraints.
+ * This approach generates fewer routes by using patterns like:
+ *   /:site(siteA|siteB)/:locale(en|fr)/path
+ *
+ * Note: This may match site/locale combinations that aren't valid together
+ * (e.g., a locale not supported by a specific site). Runtime validation
+ * should be performed after route matching.
  *
  * @param {array} routes - array of routes to be reconstructed
- * @param {object} urlConfig
- * @param {object} options - options if there are any
- * @param {array} options.ignoredRoutes - routes that does not need be reconstructed
- * @return {array} - list of routes objects that has site and locale refs
+ * @param {object} urlConfig - url configuration with site/locale positions
+ * @param {array} allSites - array of site configurations
+ * @param {array} ignoredRoutes - routes that should not be reconstructed
+ * @returns {array} - list of parameterized route objects
  */
-export const configureRoutes = (routes = [], config, {ignoredRoutes = []}) => {
-    if (!routes.length) return []
-    if (!config) return routes
+const configureRoutesWithFuzzyMatching = (routes, urlConfig, allSites, ignoredRoutes) => {
+    const {sitePattern, localePattern} = buildRoutePatterns(allSites)
+    const {locale: localePosition, site: sitePosition} = urlConfig
 
-    const {url: urlConfig} = config.app
+    const outputRoutes = []
 
-    const allSites = getSites()
-    if (!allSites) return routes
+    for (const route of routes) {
+        const {path, ...rest} = route
+
+        if (ignoredRoutes.includes(path)) {
+            outputRoutes.push(route)
+            continue
+        }
+
+        if (localePosition === urlPartPositions.PATH && sitePosition === urlPartPositions.PATH) {
+            // Both site and locale in path
+            outputRoutes.push({
+                path: `/:site(${sitePattern})/:locale(${localePattern})${path}`,
+                ...rest
+            })
+        } else if (sitePosition === urlPartPositions.PATH) {
+            // Site only in path
+            outputRoutes.push({
+                path: `/:site(${sitePattern})${path}`,
+                ...rest
+            })
+        } else if (localePosition === urlPartPositions.PATH) {
+            // Locale only in path
+            outputRoutes.push({
+                path: `/:locale(${localePattern})${path}`,
+                ...rest
+            })
+        }
+
+        // Original route as fallback
+        outputRoutes.push(route)
+    }
+
+    return outputRoutes
+}
+
+/**
+ * Configure routes using explicit paths for each site/locale combination.
+ * This is the original approach that generates literal routes like:
+ *   /siteA/en/path, /siteA/fr/path, /siteB/en/path, etc.
+ *
+ * @param {array} routes - array of routes to be reconstructed
+ * @param {object} urlConfig - url configuration with site/locale positions
+ * @param {array} allSites - array of site configurations
+ * @param {array} ignoredRoutes - routes that should not be reconstructed
+ * @returns {array} - list of explicit route objects
+ */
+const configureRoutesWithExplicitMatching = (routes, urlConfig, allSites, ignoredRoutes) => {
+    const {locale: localePosition, site: sitePosition} = urlConfig
 
     let outputRoutes = []
+
     for (let i = 0; i < routes.length; i++) {
         const {path, ...rest} = routes[i]
 
@@ -44,7 +118,6 @@ export const configureRoutes = (routes = [], config, {ignoredRoutes = []}) => {
                     localeRefs.push(locale.id)
                 })
                 localeRefs = localeRefs.filter(Boolean)
-                const {locale: localePosition, site: sitePosition} = urlConfig
 
                 if (
                     localePosition === urlPartPositions.PATH &&
@@ -100,6 +173,7 @@ export const configureRoutes = (routes = [], config, {ignoredRoutes = []}) => {
             outputRoutes.push(routes[i])
         }
     }
+
     // Remove any duplicate routes
     outputRoutes = outputRoutes.reduce((res, route) => {
         if (!res.some(({path}) => path === route.path)) {
@@ -107,5 +181,49 @@ export const configureRoutes = (routes = [], config, {ignoredRoutes = []}) => {
         }
         return res
     }, [])
+
+    return outputRoutes
+}
+
+/**
+ * Construct routes based on url config with site and locale references
+ * (ids and aliases) from each site in your application config.
+ *
+ * @param {array} routes - array of routes to be reconstructed
+ * @param {object} config - application configuration
+ * @param {object} options - options if there are any
+ * @param {array} options.ignoredRoutes - routes that should not be reconstructed
+ * @param {boolean} options.fuzzyPathMatching - when true, uses parameterized routes with
+ *        regex constraints (e.g., /:site(a|b)/:locale(en|fr)/path) for fewer, more efficient
+ *        route configurations. When false (default), generates explicit routes for each
+ *        site/locale combination. Fuzzy matching may match invalid site/locale combinations
+ *        that require runtime validation.
+ * @returns {array} - list of route objects with site and locale refs
+ */
+export const configureRoutes = (
+    routes = [],
+    config,
+    {ignoredRoutes = [], fuzzyPathMatching = false}
+) => {
+    if (!routes.length) return []
+    if (!config) return routes
+
+    let outputRoutes = []
+    const {url: urlConfig} = config.app
+
+    const allSites = getSites()
+    if (!allSites) return routes
+
+    if (fuzzyPathMatching) {
+        outputRoutes = configureRoutesWithFuzzyMatching(routes, urlConfig, allSites, ignoredRoutes)
+    } else {
+        outputRoutes = configureRoutesWithExplicitMatching(
+            routes,
+            urlConfig,
+            allSites,
+            ignoredRoutes
+        )
+    }
+
     return outputRoutes
 }