[Local catalog] Handle missing products during order creation

Modules/Sources/NetworkingCore/Network/NetworkError.swift

@@ -51,14 +51,24 @@ public enum NetworkError: Error, Equatable {
     }
 
     /// Content of the `code` field in the response if available
-    var errorCode: String? {
+    public var errorCode: String? {
         guard let response else { return nil }
         let decoder = JSONDecoder()
         guard let decodedResponse = try? decoder.decode(NetworkErrorResponse.self, from: response) else {
             return nil
         }
         return decodedResponse.code
     }
+
+    /// Content of the `data` field in the response if available
+    public var errorData: [String: AnyDecodable]? {
+        guard let response else { return nil }
+        let decoder = JSONDecoder()
+        guard let decodedResponse = try? decoder.decode(NetworkErrorResponse.self, from: response) else {
+            return nil
+        }
+        return decodedResponse.data
+    }
 }
 
 
@@ -134,6 +144,7 @@ extension NetworkError: CustomStringConvertible {
 
 struct NetworkErrorResponse: Decodable {
     let code: String?
+    let data: [String: AnyDecodable]?
 
     init(from decoder: Decoder) throws {
         let container = try decoder.container(keyedBy: CodingKeys.self)
@@ -144,12 +155,14 @@ struct NetworkErrorResponse: Decodable {
             }
             return try container.decodeIfPresent(String.self, forKey: .code)
         }()
+        self.data = try container.decodeIfPresent([String: AnyDecodable].self, forKey: .data)
     }
 
     /// Coding Keys
     ///
     private enum CodingKeys: String, CodingKey {
         case error
         case code
+        case data
     }
 }

Modules/Sources/PointOfSale/Controllers/PointOfSaleOrderController.swift

@@ -3,6 +3,7 @@ import Observation
 import protocol Experiments.FeatureFlagService
 import class WooFoundation.VersionHelpers
 import protocol Yosemite.POSOrderServiceProtocol
+import class Yosemite.POSOrderService
 import protocol Yosemite.POSReceiptServiceProtocol
 import protocol Yosemite.PluginsServiceProtocol
 import protocol Yosemite.PaymentCaptureCelebrationProtocol
@@ -11,6 +12,7 @@ import struct Yosemite.Order
 import struct Yosemite.POSCart
 import struct Yosemite.POSCartItem
 import struct Yosemite.POSCoupon
+import struct Yosemite.POSVariation
 import struct Yosemite.CouponsError
 import enum Yosemite.OrderAction
 import enum Yosemite.OrderUpdateField
@@ -21,6 +23,9 @@ import class Yosemite.PluginsService
 import enum WooFoundation.CurrencyCode
 import protocol WooFoundation.Analytics
 import enum Alamofire.AFError
+import enum Networking.DotcomError
+import enum Networking.NetworkError
+import struct Networking.AnyDecodable
 import class Yosemite.OrderTotalsCalculator
 import struct WooFoundation.WooAnalyticsEvent
 import protocol WooFoundationCore.WooAnalyticsEventPropertyType
@@ -94,15 +99,16 @@ protocol PointOfSaleOrderControllerProtocol {
             return .success(.newOrder)
         } catch {
             self.order = nil
-            trackOrderCreationFailed(error: error)
-            setOrderStateToError(error, retryHandler: retryHandler)
+            trackOrderCreationFailed(error: error, cart: posCart)
+            setOrderStateToError(error, cart: posCart, retryHandler: retryHandler)
             return .failure(SyncOrderStateError.syncFailure)
         }
     }
 
     private func setOrderStateToError(_ error: Error,
+                                      cart: POSCart,
                                       retryHandler: @escaping () async -> Void) {
-        orderState = .error(orderStateError(from: error), {
+        orderState = .error(orderStateError(from: error, cart: cart), {
             Task {
                 await retryHandler()
             }
@@ -187,15 +193,150 @@ private extension PointOfSaleOrderController {
 // MARK: - Error Handling
 
 private extension PointOfSaleOrderController {
-    func orderStateError(from error: Error) -> PointOfSaleOrderState.OrderStateError {
-        if let couponsError = CouponsError(underlyingError: error) {
+    func orderStateError(from error: Error, cart: POSCart) -> PointOfSaleOrderState.OrderStateError {
+        // Check for missing products error first
+        if case .missingProductsInOrder(let missingItems) = error as? POSOrderService.POSOrderServiceError {
+            let missingProductInfo = missingItems.map {
+                PointOfSaleOrderState.OrderStateError.MissingProductInfo(
+                    productID: $0.productID,
+                    variationID: $0.variationID,
+                    name: $0.name,
+                    quantity: $0.expectedQuantity
+                )
+            }
+            return .missingProducts(missingProductInfo)
+        }
+        // Check for server-side validation errors about invalid products/variations
+        else if let missingProductInfo = extractMissingProductsFromServerError(error, cart: cart) {
+            return .missingProducts(missingProductInfo)
+        }
+        else if let couponsError = CouponsError(underlyingError: error) {
             return .invalidCoupon(couponsError.message)
         } else if let afErrorDescription = (error as? AFError)?.underlyingError?.localizedDescription {
             return .other(afErrorDescription)
         } else {
             return .other(error.localizedDescription)
         }
     }
+
+    /// Extracts missing product information from server validation errors
+    /// Handles cases where the server rejects order creation due to invalid product/variation IDs
+    func extractMissingProductsFromServerError(_ error: Error, cart: POSCart) -> [PointOfSaleOrderState.OrderStateError.MissingProductInfo]? {
+        // Check if this is an AFError wrapping a DotcomError or NetworkError
+        let underlyingError: Error? = {
+            if let afError = error as? AFError {
+                return afError.underlyingError
+            }
+            return error
+        }()
+
+        // Check for DotcomError with product/variation validation error codes
+        if case .unknown(let code, _) = underlyingError as? DotcomError {
+            if isProductValidationError(code: code) {
+                // DotcomError doesn't include data field, fall back to generic error
+                return extractMissingProductsFromCart()
+            }
+        }
+
+        // Check for NetworkError with product/variation validation error codes
+        if let networkError = underlyingError as? NetworkError,
+           let errorCode = networkError.errorCode,
+           isProductValidationError(code: errorCode) {
+            // Try to extract variation_id from NetworkError data if available
+            if let variationID = extractVariationID(from: networkError.errorData) {
+                return createMissingProductInfo(forVariationID: variationID, cart: cart)
+            }
+            // Fall back to generic error if no variation_id in data
+            return extractMissingProductsFromCart()
+        }
+
+        return nil
+    }
+
+    /// Extracts variation_id from error data dictionary
+    private func extractVariationID(from data: [String: AnyDecodable]?) -> Int64? {
+        guard let data = data,
+              let variationIDValue = data["variation_id"]?.value else {
+            return nil
+        }
+
+        // Handle different number types
+        if let intValue = variationIDValue as? Int {
+            return Int64(intValue)
+        } else if let int64Value = variationIDValue as? Int64 {
+            return int64Value
+        }
+        return nil
+    }
+
+    /// Creates MissingProductInfo for a specific variation ID
+    /// Searches the cart to find the variation's name and parent product ID
+    private func createMissingProductInfo(forVariationID variationID: Int64, cart: POSCart) -> [PointOfSaleOrderState.OrderStateError.MissingProductInfo] {
+        // Search the cart for the variation to get its name
+        let cartItem = cart.items.first { item in
+            if let variation = item.item as? POSVariation {
+                return variation.productVariationID == variationID
+            }
+            return false
+        }
+
+        let productName: String
+        let parentProductID: Int64
+
+        if let cartItem = cartItem,
+           let variation = cartItem.item as? POSVariation {
+            // Found the variation in the cart - use its parent product name and variation name
+            productName = "\(variation.parentProductName) - \(variation.name)"
+            parentProductID = variation.productID
+        } else {
+            // Couldn't find it in cart, use generic name
+            productName = Localization.unknownProductName
+            parentProductID = 0
+        }
+
+        return [
+            PointOfSaleOrderState.OrderStateError.MissingProductInfo(
+                productID: parentProductID,
+                variationID: variationID,
+                name: productName,
+                quantity: 1
+            )
+        ]
+    }
+
+    /// Checks if an error code indicates a product validation error
+    /// Currently only handles the confirmed error code from WooCommerce server responses
+    private func isProductValidationError(code: String) -> Bool {
+        // Only check for the one confirmed error code we've observed
+        // Additional codes can be added as they are discovered through testing
+        return code == "order_item_product_invalid_variation_id"
+    }
+
+    /// Extracts missing products by trying to identify items in cart that might have caused the validation error
+    /// Since server doesn't tell us which specific products failed, we return generic error info
+    private func extractMissingProductsFromCart() -> [PointOfSaleOrderState.OrderStateError.MissingProductInfo]? {
+        // We can't determine which specific products are invalid from the server error
+        // So we return a generic missing product message with 0 for both IDs (meaning unknown)
+        // The user will need to remove all products and retry
+        return [
+            PointOfSaleOrderState.OrderStateError.MissingProductInfo(
+                productID: 0,
+                variationID: 0,
+                name: Localization.unknownProductName,
+                quantity: 1
+            )
+        ]
+    }
+}
+
+private extension PointOfSaleOrderController {
+    enum Localization {
+        static let unknownProductName = NSLocalizedString(
+            "pointOfSale.orderController.unknownProduct",
+            value: "One or more products",
+            comment: "Generic product name used when we can't identify which specific product is unavailable"
+        )
+    }
 }
 
 
@@ -256,11 +397,15 @@ extension PointOfSaleOrderController {
 
 
 private extension PointOfSaleOrderController {
-    func trackOrderCreationFailed(error: Error) {
+    func trackOrderCreationFailed(error: Error, cart: POSCart) {
         var errorType: WooAnalyticsEvent.Orders.OrderCreationErrorType?
 
         if let _ = CouponsError(underlyingError: error) {
             errorType = .invalidCoupon
+        } else if case .missingProductsInOrder = error as? POSOrderService.POSOrderServiceError {
+            errorType = .missingProducts
+        } else if extractMissingProductsFromServerError(error, cart: cart) != nil {
+            errorType = .missingProducts
         }
 
         analytics.track(event: WooAnalyticsEvent.Orders.orderCreationFailed(
@@ -290,9 +435,9 @@ private extension WooAnalyticsEvent {
         // MARK: - Order Creation Events
 
         /// Matches errors on Android for consistency
-        /// Only coupon tracking is relevant for now
         enum OrderCreationErrorType: String {
             case invalidCoupon = "INVALID_COUPON"
+            case missingProducts = "MISSING_PRODUCTS"
         }
 
         static func orderCreationFailed(

Modules/Sources/PointOfSale/Models/PointOfSaleAggregateModel.swift

@@ -17,6 +17,8 @@ import enum Yosemite.PointOfSaleBarcodeScanError
 import protocol Yosemite.POSCatalogSyncCoordinatorProtocol
 import class Yosemite.POSCatalogSyncCoordinator
 import enum Yosemite.CardReaderSoftwareUpdateState
+import struct Yosemite.POSSimpleProduct
+import struct Yosemite.POSVariation
 
 protocol PointOfSaleAggregateModelProtocol {
     var cart: Cart { get }
@@ -193,6 +195,60 @@ extension PointOfSaleAggregateModel {
         paymentState = .idle
         cardPresentPaymentInlineMessage = nil
     }
+
+    /// Removes missing products from the cart only (catalog is auto-cleaned when errors are detected)
+    /// - Parameters:
+    ///   - productIDs: Product IDs to remove (for simple products)
+    ///   - variationIDs: Variation IDs to remove (for variations)
+    func removeMissingProductsFromCart(productIDs: Set<Int64>, variationIDs: Set<Int64>) {
+        cart.purchasableItems.removeAll { item in
+            guard case .loaded(let orderableItem) = item.state else { return false }
+
+            // Check if it's a simple product matching the product IDs
+            if let simpleProduct = orderableItem as? POSSimpleProduct {
+                return productIDs.contains(simpleProduct.productID)
+            }
+            // Check if it's a variation matching the variation IDs
+            else if let variation = orderableItem as? POSVariation {
+                return variationIDs.contains(variation.productVariationID)
+            }
+            return false
+        }
+    }
+
+    /// Removes identified missing products from the catalog only (not from cart)
+    /// - Parameter missingProducts: Array of missing product info
+    private func removeIdentifiedMissingProductsFromCatalog(_ missingProducts: [PointOfSaleOrderState.OrderStateError.MissingProductInfo]) async {
+        // Extract product and variation IDs from missing products
+        var productIDs = Set<Int64>()
+        var variationIDs = Set<Int64>()
+
+        for missingProduct in missingProducts {
+            // Only process items where we can identify specific products (not 0,0)
+            if missingProduct.variationID != 0 {
+                variationIDs.insert(missingProduct.variationID)
+            } else if missingProduct.productID != 0 {
+                productIDs.insert(missingProduct.productID)
+            }
+            // Skip items with both IDs as 0 (generic errors where we can't identify the product)
+        }
+
+        // Remove from local catalog only if we have identifiable products
+        guard !productIDs.isEmpty || !variationIDs.isEmpty else { return }
+
+        if let catalogSyncCoordinator {
+            do {
+                try await catalogSyncCoordinator.deleteProductsFromCatalog(
+                    Array(productIDs),
+                    variationIDs: Array(variationIDs),
+                    siteID: siteID
+                )
+                DDLogInfo("🗑️ Auto-removed \(productIDs.count) products and \(variationIDs.count) variations from local catalog (unavailable items)")
+            } catch {
+                DDLogError("⚠️ Failed to auto-remove unavailable products from local catalog: \(error)")
+            }
+        }
+    }
 }
 
 // MARK: - Barcode Scanning
@@ -619,6 +675,12 @@ extension PointOfSaleAggregateModel {
             await self?.checkOut()
         })
         trackOrderSyncState(syncOrderResult)
+
+        // If we identified specific missing products, remove them from the catalog immediately
+        if case .error(.missingProducts(let missingProducts), _) = orderController.orderState.externalState {
+            await removeIdentifiedMissingProductsFromCatalog(missingProducts)
+        }
+
         await startPaymentWhenCardReaderConnected()
     }
 }

Modules/Sources/PointOfSale/Models/PointOfSaleOrderState.swift

@@ -11,13 +11,23 @@ enum PointOfSaleOrderState: Equatable {
     enum OrderStateError: Equatable {
         case other(String)
         case invalidCoupon(String)
+        case missingProducts([MissingProductInfo])
+
+        struct MissingProductInfo: Equatable {
+            let productID: Int64
+            let variationID: Int64
+            let name: String
+            let quantity: Decimal // periphery:ignore - Part of public API for future use
+        }
 
         static func == (lhs: OrderStateError, rhs: OrderStateError) -> Bool {
             switch (lhs, rhs) {
             case (.other(let lhsError), .other(let rhsError)):
                 return lhsError == rhsError
             case (.invalidCoupon(let lhsCoupon), .invalidCoupon(let rhsCoupon)):
                 return lhsCoupon == rhsCoupon
+            case (.missingProducts(let lhsProducts), .missingProducts(let rhsProducts)):
+                return lhsProducts == rhsProducts
             default:
                 return false
             }