[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/Analytics/WooAnalyticsEvent+PointOfSale.swift

@@ -44,6 +44,8 @@ extension WooAnalyticsEvent {
             static let listPosition = "list_position"
             static let daysSinceCreated = "days_since_created"
             static let pageNumber = "page_number"
+            static let reason = "reason"
+            static let syncStrategy = "sync_strategy"
         }
 
         /// Source of the event where the event is triggered
@@ -457,6 +459,47 @@ extension WooAnalyticsEvent {
         static func ordersListLoaded() -> WooAnalyticsEvent {
             WooAnalyticsEvent(statName: .ordersListLoaded, properties: [:])
         }
+
+        // MARK: - Checkout Outdated Item Detection Events
+
+        static func checkoutOutdatedItemDetectedScreenShown(
+            reason: String,
+            syncStrategy: String
+        ) -> WooAnalyticsEvent {
+            WooAnalyticsEvent(
+                statName: .pointOfSaleCheckoutOutdatedItemDetectedScreenShown,
+                properties: [
+                    Key.reason: reason,
+                    Key.syncStrategy: syncStrategy
+                ]
+            )
+        }
+
+        static func checkoutOutdatedItemDetectedEditOrderTapped(
+            reason: String,
+            syncStrategy: String
+        ) -> WooAnalyticsEvent {
+            WooAnalyticsEvent(
+                statName: .pointOfSaleCheckoutOutdatedItemDetectedEditOrderTapped,
+                properties: [
+                    Key.reason: reason,
+                    Key.syncStrategy: syncStrategy
+                ]
+            )
+        }
+
+        static func checkoutOutdatedItemDetectedRemoveTapped(
+            reason: String,
+            syncStrategy: String
+        ) -> WooAnalyticsEvent {
+            WooAnalyticsEvent(
+                statName: .pointOfSaleCheckoutOutdatedItemDetectedRemoveTapped,
+                properties: [
+                    Key.reason: reason,
+                    Key.syncStrategy: syncStrategy
+                ]
+            )
+        }
     }
 }
 

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
@@ -20,7 +22,6 @@ import class WooFoundation.CurrencySettings
 import class Yosemite.PluginsService
 import enum WooFoundation.CurrencyCode
 import protocol WooFoundation.Analytics
-import enum Alamofire.AFError
 import class Yosemite.OrderTotalsCalculator
 import struct WooFoundation.WooAnalyticsEvent
 import protocol WooFoundationCore.WooAnalyticsEventPropertyType
@@ -188,17 +189,25 @@ private extension PointOfSaleOrderController {
 
 private extension PointOfSaleOrderController {
     func orderStateError(from error: Error) -> PointOfSaleOrderState.OrderStateError {
-        if let couponsError = CouponsError(underlyingError: error) {
+        // 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
+                )
+            }
+            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)
         }
     }
 }
 
-
 // This is named to note that it is for use within the AggregateModel and OrderController.
 // Conversely, PointOfSaleOrderState is available to the Views, as it doesn't include the Order.
 enum PointOfSaleInternalOrderState {
@@ -261,6 +270,8 @@ private extension PointOfSaleOrderController {
 
         if let _ = CouponsError(underlyingError: error) {
             errorType = .invalidCoupon
+        } else if case .missingProductsInOrder = error as? POSOrderService.POSOrderServiceError {
+            errorType = .missingProducts
         }
 
         analytics.track(event: WooAnalyticsEvent.Orders.orderCreationFailed(
@@ -290,9 +301,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,48 @@ 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 {
+        let (productIDs, variationIDs) = missingProducts.extractProductAndVariationIDs()
+
+        // 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,8 +663,18 @@ extension PointOfSaleAggregateModel {
             await self?.checkOut()
         })
         trackOrderSyncState(syncOrderResult)
+        await removeMissingProductsFromCatalogAfterSync()
         await startPaymentWhenCardReaderConnected()
     }
+
+    /// Removes unavailable products from the local catalog after detecting them during order sync
+    @MainActor
+    private func removeMissingProductsFromCatalogAfterSync() async {
+        // If we identified specific missing products, remove them from the catalog immediately
+        if case .error(.missingProducts(let missingProducts), _) = orderController.orderState.externalState {
+            await removeIdentifiedMissingProductsFromCatalog(missingProducts)
+        }
+    }
 }
 
 // MARK: - Lifecycle

Modules/Sources/PointOfSale/Models/PointOfSaleOrderState.swift

@@ -11,13 +11,22 @@ 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
+        }
 
         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
             }
@@ -64,3 +73,27 @@ enum PointOfSaleOrderState: Equatable {
         }
     }
 }
+
+// MARK: - Missing Product Helpers
+extension Array where Element == PointOfSaleOrderState.OrderStateError.MissingProductInfo {
+    /// Extracts product and variation IDs from missing product info
+    /// Returns a tuple of (productIDs, variationIDs) containing only non-zero IDs
+    func extractProductAndVariationIDs() -> (productIDs: Set<Int64>, variationIDs: Set<Int64>) {
+        var productIDs = Set<Int64>()
+        var variationIDs = Set<Int64>()
+
+        for missingProduct in self {
+            // If variationID is non-zero, it's a variation
+            if missingProduct.variationID != 0 {
+                variationIDs.insert(missingProduct.variationID)
+            }
+            // If productID is non-zero (and variationID is zero), it's a simple product
+            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)
+        }
+
+        return (productIDs, variationIDs)
+    }
+}