@salesforce/retail-react-app 7.1.0-preview.1 → 8.0.0-dev

package/app/utils/sfdc-user-agent-utils.js

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2025, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+/**
+ * Generates the sfdc_user_agent header value containing SDK version information.
+ * This header helps identify and track SDK versions invoking SCAPI for debugging
+ * and metrics purposes.
+ *
+ * @returns {string} The sfdc_user_agent header value in format: pwa-kit-react-sdk@version commerce-sdk-react@version
+ */
+export const generateSfdcUserAgent = () => {
+    try {
+        // Using require here because this runs at initialization time when version info is static
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const retailAppPkg = require('../../package.json')
+
+        const commerceSdkVersion =
+            retailAppPkg.dependencies?.['@salesforce/commerce-sdk-react'] || 'unknown'
+        const pwaKitVersion =
+            retailAppPkg.dependencies?.['@salesforce/pwa-kit-react-sdk'] || 'unknown'
+
+        // Using @ format to align with NPM package@version conventions for better tooling compatibility
+        return `pwa-kit-react-sdk@${pwaKitVersion} commerce-sdk-react@${commerceSdkVersion}`.trim()
+    } catch (error) {
+        console.warn('Unable to generate sfdc_user_agent header:', error)
+        return 'pwa-kit-react-sdk@unknown commerce-sdk-react@unknown'
+    }
+}

package/app/utils/sfdc-user-agent-utils.test.js

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2025, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+import {generateSfdcUserAgent} from '@salesforce/retail-react-app/app/utils/sfdc-user-agent-utils'
+
+describe('sfdc-user-agent-utils', () => {
+    describe('generateSfdcUserAgent', () => {
+        test('should generate correct sfdc_user_agent header value', () => {
+            const userAgent = generateSfdcUserAgent()
+
+            expect(userAgent).toMatch(/^pwa-kit-react-sdk@[\d\w.-]+ commerce-sdk-react@[\d\w.-]+$/)
+            expect(userAgent).toContain('pwa-kit-react-sdk@')
+            expect(userAgent).toContain('commerce-sdk-react@')
+        })
+
+        test('should return proper NPM-style package@version format', () => {
+            const userAgent = generateSfdcUserAgent()
+
+            const parts = userAgent.split(' ')
+            expect(parts).toHaveLength(2)
+
+            parts.forEach((part) => {
+                expect(part).toMatch(/^[\w-]+@[\d\w.-]+$/)
+                expect(part).toContain('@')
+            })
+        })
+
+        test('should not return null or undefined', () => {
+            const userAgent = generateSfdcUserAgent()
+
+            expect(userAgent).toBeDefined()
+            expect(userAgent).not.toBeNull()
+            expect(typeof userAgent).toBe('string')
+            expect(userAgent.length).toBeGreaterThan(0)
+        })
+
+        test('should handle error cases gracefully', () => {
+            expect(() => generateSfdcUserAgent()).not.toThrow()
+
+            const userAgent = generateSfdcUserAgent()
+            expect(userAgent).toBeDefined()
+            expect(typeof userAgent).toBe('string')
+            expect(userAgent.length).toBeGreaterThan(0)
+        })
+
+        test('should return valid package identifiers', () => {
+            // This test verifies that the function returns the expected package identifiers
+            const userAgent = generateSfdcUserAgent()
+
+            // Should always return a valid string
+            expect(typeof userAgent).toBe('string')
+            expect(userAgent.length).toBeGreaterThan(0)
+
+            // Should contain expected package identifiers
+            expect(userAgent).toMatch(/pwa-kit-react-sdk@/)
+            expect(userAgent).toMatch(/commerce-sdk-react@/)
+        })
+
+        test('should be valid HTTP header value', () => {
+            const userAgent = generateSfdcUserAgent()
+
+            // HTTP headers must contain only ASCII printable characters
+            const isValidHTTPHeader = /^[\x20-\x7E]*$/.test(userAgent)
+            expect(isValidHTTPHeader).toBe(true)
+
+            // Prevent excessively long headers that might cause issues with proxies/servers
+            expect(userAgent.length).toBeLessThan(500)
+        })
+
+        test('should use @ symbol for NPM convention alignment', () => {
+            const userAgent = generateSfdcUserAgent()
+
+            // Ensure both packages use @ format for consistency with NPM tooling
+            const atSymbolCount = (userAgent.match(/@/g) || []).length
+            expect(atSymbolCount).toBe(2)
+        })
+    })
+})

package/app/utils/shipment-utils.js

@@ -0,0 +1,196 @@
+/*
+ * Copyright (c) 2025, Salesforce, Inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+import {
+    cleanAddressForOrder,
+    areAddressesEqual,
+    isAddressEmpty
+} from '@salesforce/retail-react-app/app/utils/address-utils'
+import {DEFAULT_SHIPMENT_ID} from '@salesforce/retail-react-app/app/constants'
+
+/**
+ * Pure utility functions for shipment operations
+ * No side effects, easily testable
+ */
+
+/**
+ * Checks if a shipping method is a pickup method
+ * @param {Object} shippingMethod - The shipping method object
+ * @returns {boolean} True if the shipping method is a pickup method
+ */
+export const isPickupMethod = (shippingMethod) => {
+    return shippingMethod?.c_storePickupEnabled === true
+}
+
+/**
+ * Checks if a shipment is configured for pickup-in-store
+ * @param {object} shipment the shipment to check. can be null.
+ * @returns {boolean} true if the shipment is configured for pickup-in-store.
+ */
+export const isPickupShipment = (shipment) => {
+    return isPickupMethod(shipment?.shippingMethod)
+}
+
+/**
+ * Gets items that belong to a specific shipment
+ * @param {Object} basket - The basket object
+ * @param {string} shipmentId - The shipment ID
+ * @returns {Array} Array of product items
+ */
+export const getItemsForShipment = (basket, shipmentId) => {
+    if (!basket?.productItems || !shipmentId) return []
+    return basket.productItems.filter((item) => item.shipmentId === shipmentId)
+}
+
+/**
+ * Finds shipments that have no items assigned to them
+ * @param {Object} basket - The basket object
+ * @returns {Array} Array of empty shipments
+ */
+export const findEmptyShipments = (basket) => {
+    if (!basket?.shipments?.length) {
+        return []
+    }
+
+    return basket.shipments.filter((shipment) => {
+        const hasItems = basket.productItems?.some(
+            (item) => item.shipmentId === shipment.shipmentId
+        )
+        return !hasItems
+    })
+}
+
+/**
+ * Groups items by their address using a provided function to get the address for each item
+ * @param {Array} items - Array of items to group
+ * @param {Function} getAddressForItem - Function that returns the address for a given item
+ * @returns {Object} Object with addresses as keys and arrays of items as values
+ */
+export const groupItemsByAddress = (items, getAddressForItem) => {
+    if (!items?.length || typeof getAddressForItem !== 'function') {
+        return {}
+    }
+
+    return items.reduce((groups, item) => {
+        const address = getAddressForItem(item)
+        if (!address) return groups
+
+        // Create a key for the address
+        const addressKey = JSON.stringify(cleanAddressForOrder(address))
+
+        if (!groups[addressKey]) {
+            groups[addressKey] = []
+        }
+        groups[addressKey].push(item)
+
+        return groups
+    }, {})
+}
+
+/**
+ * Finds the first existing delivery shipment (not pickup)
+ * @param {Object} basket - The basket object
+ * @returns {Object|null} The delivery shipment object or null if not found
+ */
+export const findExistingDeliveryShipment = (basket) => {
+    if (!basket?.shipments) return null
+
+    return basket.shipments.find((shipment) => !isPickupMethod(shipment.shippingMethod)) || null
+}
+
+/**
+ * Finds the first existing pickup shipment for a specific store
+ * @param {Object} basket - The basket object
+ * @param {string} storeId - The store ID to search for
+ * @returns {Object|null} The pickup shipment object or null if not found
+ */
+export const findExistingPickupShipment = (basket, storeId) => {
+    if (!basket?.shipments || !storeId) return null
+
+    return (
+        basket.shipments.find(
+            (shipment) =>
+                isPickupMethod(shipment.shippingMethod) && shipment.c_fromStoreId === storeId
+        ) || null
+    )
+}
+
+/**
+ * Finds the first delivery shipment that is not in the provided list of shipment IDs
+ * @param {Object} basket - The basket object
+ * @param {Array} usedShipmentIds - Array of shipment IDs to exclude from search
+ * @returns {Object|null} The unused delivery shipment object or null if not found
+ */
+export const findUnusedDeliveryShipment = (basket, usedShipmentIds = []) => {
+    if (!basket?.shipments) return null
+
+    return (
+        basket.shipments.find(
+            (shipment) =>
+                !isPickupMethod(shipment.shippingMethod) &&
+                !usedShipmentIds.includes(shipment.shipmentId)
+        ) || null
+    )
+}
+
+/**
+ * Finds the first existing delivery shipment with matching address
+ * @param {Object} basket - The basket object
+ * @param {Object} address - The address to match
+ * @returns {Object|null} The shipment object with matching address or null if not found
+ */
+export const findDeliveryShipmentWithSameAddress = (basket, address) => {
+    if (!basket?.shipments || !address) return null
+
+    const foundShipment = basket.shipments.find((shipment) => {
+        // Must be a delivery shipment (not pickup)
+        if (isPickupMethod(shipment.shippingMethod)) {
+            return false
+        }
+
+        // Check if shipment has a shipping address that matches
+        return shipment.shippingAddress && areAddressesEqual(shipment.shippingAddress, address)
+    })
+    return foundShipment || null
+}
+
+/**
+ * Finds the best non-empty shipment to consolidate into the default shipment
+ * @param {Object} basket - The basket object
+ * @returns {Object|null} The shipment to consolidate or null if none found
+ */
+export const findShipmentToConsolidate = (basket) => {
+    if (!basket?.shipments?.length) {
+        return null
+    }
+
+    return (
+        basket.shipments.find((shipment) => {
+            const hasItems = basket.productItems?.some(
+                (item) => item.shipmentId === shipment.shipmentId
+            )
+            return hasItems && shipment.shipmentId !== DEFAULT_SHIPMENT_ID
+        }) || null
+    )
+}
+
+/**
+ * Checks if the default shipment is empty
+ * @param {Object} basket - The basket object
+ * @returns {boolean} True if the default shipment is empty
+ */
+export const isDefaultShipmentEmpty = (basket) => {
+    if (!basket?.shipments) return true
+
+    const defaultShipment = basket.shipments.find(
+        (shipment) => shipment.shipmentId === DEFAULT_SHIPMENT_ID
+    )
+
+    if (!defaultShipment) return true
+
+    return !basket.productItems?.some((item) => item.shipmentId === DEFAULT_SHIPMENT_ID)
+}