[Woo POS][Local Catalog] Add incremental sync triggers

Modules/Sources/PointOfSale/Controllers/PointOfSaleObservableItemsController.swift

@@ -6,19 +6,24 @@ import protocol Yosemite.POSObservableDataSourceProtocol
 import struct Yosemite.POSVariableParentProduct
 import class Yosemite.GRDBObservableDataSource
 import protocol Storage.GRDBManagerProtocol
+import protocol Yosemite.POSCatalogSyncCoordinatorProtocol
+import enum Yosemite.POSCatalogSyncError
 
 /// Controller that wraps an observable data source for POS items
 /// Uses computed state based on data source observations for automatic UI updates
 @Observable
 final class PointOfSaleObservableItemsController: PointOfSaleItemsControllerProtocol {
     private let dataSource: POSObservableDataSourceProtocol
+    private let catalogSyncCoordinator: POSCatalogSyncCoordinatorProtocol
+    private let siteID: Int64
 
     // Track which items have been loaded at least once
     private var hasLoadedProducts = false
     private var hasLoadedVariationsForCurrentParent = false
 
     // Track current parent for variation state mapping
     private var currentParentItem: POSItem?
+    private var refreshState: RefreshState = .idle
 
     var itemsViewState: ItemsViewState {
         ItemsViewState(
@@ -32,22 +37,41 @@ final class PointOfSaleObservableItemsController: PointOfSaleItemsControllerProt
 
     init(siteID: Int64,
          grdbManager: GRDBManagerProtocol,
-         currencySettings: CurrencySettings) {
+         currencySettings: CurrencySettings,
+         catalogSyncCoordinator: POSCatalogSyncCoordinatorProtocol) {
+        self.siteID = siteID
         self.dataSource = GRDBObservableDataSource(
             siteID: siteID,
             grdbManager: grdbManager,
             currencySettings: currencySettings
         )
+        self.catalogSyncCoordinator = catalogSyncCoordinator
     }
 
     // periphery:ignore - used by tests
-    init(dataSource: POSObservableDataSourceProtocol) {
+    init(siteID: Int64,
+         dataSource: POSObservableDataSourceProtocol,
+         catalogSyncCoordinator: POSCatalogSyncCoordinatorProtocol) {
+        self.siteID = siteID
         self.dataSource = dataSource
+        self.catalogSyncCoordinator = catalogSyncCoordinator
     }
 
     func loadItems(base: ItemListBaseItem) async {
         switch base {
         case .root:
+            // Refresh if there's an error or if items are empty after initial load
+            let shouldRefresh = {
+                if case .error = refreshState {
+                    return true
+                }
+                return hasLoadedProducts && dataSource.productItems.isEmpty
+            }()
+
+            if shouldRefresh {
+                await refreshItems(base: base)
+            }
+
             dataSource.loadProducts()
             hasLoadedProducts = true
         case .parent(let parent):
@@ -62,21 +86,38 @@ final class PointOfSaleObservableItemsController: PointOfSaleItemsControllerProt
                 hasLoadedVariationsForCurrentParent = false
             }
 
+            // Refresh if there's an error or if variations are empty after initial load
+            let shouldRefresh = {
+                if case .error = refreshState {
+                    return true
+                }
+                return hasLoadedVariationsForCurrentParent && dataSource.variationItems.isEmpty
+            }()
+
+            if shouldRefresh {
+                await refreshItems(base: base)
+            }
+
             dataSource.loadVariations(for: parentProduct)
             hasLoadedVariationsForCurrentParent = true
         }
     }
 
     func refreshItems(base: ItemListBaseItem) async {
-        switch base {
-        case .root:
-            dataSource.refresh()
-        case .parent(let parent):
-            guard case .variableParentProduct(let parentProduct) = parent else {
-                assertionFailure("Unsupported parent type for refreshing items: \(parent)")
-                return
+        refreshState = .loading
+
+        do {
+            try await catalogSyncCoordinator.performIncrementalSync(for: siteID)
+            refreshState = .idle
+        } catch let error as POSCatalogSyncError {
+            switch error {
+            case .syncAlreadyInProgress:
+                refreshState = .idle
+            default:
+                refreshState = .error(error)
             }
-            dataSource.loadVariations(for: parentProduct)
+        } catch {
+            refreshState = .error(error)
         }
     }
 
@@ -108,12 +149,21 @@ private extension PointOfSaleObservableItemsController {
             return .initial
         }
 
-        // Loading state - preserve existing items
-        if dataSource.isLoadingProducts {
+        // Loading state - preserve existing items (both for data loading and refresh)
+        if dataSource.isLoadingProducts || refreshState == .loading {
             return .loading(items)
         }
 
-        // Error state
+        // Error state for refresh
+        if case .error(let error) = refreshState {
+            if items.isEmpty {
+                return .error(.errorOnLoadingProducts(error: error))
+            } else {
+                return .inlineError(items, error: .errorOnLoadingProducts(error: error), context: .refresh)
+            }
+        }
+
+        // Error state for data source observation
         if let error = dataSource.productError, items.isEmpty {
             return .error(.errorOnLoadingProducts(error: error))
         }
@@ -139,12 +189,21 @@ private extension PointOfSaleObservableItemsController {
             return [parentItem: .initial]
         }
 
-        // Loading state - preserve existing items
-        if dataSource.isLoadingVariations {
+        // Loading state - preserve existing items (both for data loading and refresh)
+        if dataSource.isLoadingVariations || refreshState == .loading {
             return [parentItem: .loading(items)]
         }
 
-        // Error state
+        // Error state for refresh
+        if case .error(let error) = refreshState {
+            if items.isEmpty {
+                return [parentItem: .error(.errorOnLoadingVariations(error: error))]
+            } else {
+                return [parentItem: .inlineError(items, error: .errorOnLoadingVariations(error: error), context: .refresh)]
+            }
+        }
+
+        // Error state for data source observation
         if let error = dataSource.variationError, items.isEmpty {
             return [parentItem: .error(.errorOnLoadingVariations(error: error))]
         }
@@ -158,3 +217,25 @@ private extension PointOfSaleObservableItemsController {
         return [parentItem: .loaded(items, hasMoreItems: dataSource.hasMoreVariations)]
     }
 }
+
+private extension PointOfSaleObservableItemsController {
+    /// Represents the state of a refresh operation
+    enum RefreshState: Equatable {
+        case idle
+        case loading
+        case error(Error)
+
+        static func == (lhs: RefreshState, rhs: RefreshState) -> Bool {
+            switch (lhs, rhs) {
+            case (.idle, .idle):
+                return true
+            case (.loading, .loading):
+                return true
+            case (.error(let lhsError), .error(let rhsError)):
+                return lhsError.localizedDescription == rhsError.localizedDescription
+            default:
+                return false
+            }
+        }
+    }
+}

Modules/Sources/PointOfSale/Extensions/Observation+WithObservationTrackingOf.swift

@@ -0,0 +1,14 @@
+import Foundation
+import Observation
+
+/// A helper method for continuously tracking observations on a value.
+///
+func withObservationTracking<T: Sendable>(of value: @Sendable @escaping @autoclosure () -> T, execute: @Sendable @escaping (T) -> Void) {
+    Observation.withObservationTracking {
+        execute(value())
+    } onChange: {
+        DispatchQueue.main.async {
+            withObservationTracking(of: value(), execute: execute)
+        }
+    }
+}

Modules/Sources/PointOfSale/Models/PointOfSaleAggregateModel.swift

@@ -14,6 +14,7 @@ import protocol Yosemite.POSSearchHistoryProviding
 import enum Yosemite.POSItemType
 import protocol Yosemite.PointOfSaleBarcodeScanServiceProtocol
 import enum Yosemite.PointOfSaleBarcodeScanError
+import protocol Yosemite.POSCatalogSyncCoordinatorProtocol
 
 protocol PointOfSaleAggregateModelProtocol {
     var cart: Cart { get }
@@ -51,6 +52,8 @@ protocol PointOfSaleAggregateModelProtocol {
     private let collectOrderPaymentAnalyticsTracker: POSCollectOrderPaymentAnalyticsTracking
     let searchHistoryService: POSSearchHistoryProviding
     private let barcodeScanService: PointOfSaleBarcodeScanServiceProtocol
+    private let siteID: Int64
+    private let catalogSyncCoordinator: POSCatalogSyncCoordinatorProtocol?
 
     private var startPaymentOnCardReaderConnection: AnyCancellable?
     private var cardReaderDisconnection: AnyCancellable?
@@ -86,7 +89,9 @@ protocol PointOfSaleAggregateModelProtocol {
          popularPurchasableItemsController: PointOfSaleItemsControllerProtocol,
          barcodeScanService: PointOfSaleBarcodeScanServiceProtocol,
          soundPlayer: PointOfSaleSoundPlayerProtocol = PointOfSaleSoundPlayer(),
-         paymentState: PointOfSalePaymentState = .idle) {
+         paymentState: PointOfSalePaymentState = .idle,
+         siteID: Int64,
+         catalogSyncCoordinator: POSCatalogSyncCoordinatorProtocol? = nil) {
         self.entryPointController = entryPointController
         self.purchasableItemsController = itemsController
         self.purchasableItemsSearchController = purchasableItemsSearchController
@@ -102,10 +107,14 @@ protocol PointOfSaleAggregateModelProtocol {
         self.popularPurchasableItemsController = popularPurchasableItemsController
         self.barcodeScanService = barcodeScanService
         self.soundPlayer = soundPlayer
+        self.siteID = siteID
+        self.catalogSyncCoordinator = catalogSyncCoordinator
 
         publishCardReaderConnectionStatus()
         publishPaymentMessages()
         setupReaderReconnectionObservation()
+        setupPaymentSuccessObservation()
+        performIncrementalSync()
     }
 }
 
@@ -592,6 +601,25 @@ extension PointOfSaleAggregateModel {
     }
 }
 
+// MARK: - Incremental catalog sync on payment success
+
+private extension PointOfSaleAggregateModel {
+    private func setupPaymentSuccessObservation() {
+        withObservationTracking(of: self.paymentState.isSuccess) { [weak self] success in
+            if success {
+                self?.performIncrementalSync()
+            }
+        }
+    }
+
+    private func performIncrementalSync() {
+        guard let catalogSyncCoordinator else { return }
+        Task {
+            try? await catalogSyncCoordinator.performIncrementalSync(for: siteID)
+        }
+    }
+}
+
 #if DEBUG
 extension PointOfSaleAggregateModel {
     func setPreviewState(paymentState: PointOfSalePaymentState, inlineMessage: PointOfSaleCardPresentPaymentMessageType?) {

Modules/Sources/PointOfSale/Models/PointOfSalePaymentState.swift

@@ -28,6 +28,17 @@ struct PointOfSalePaymentState: Equatable {
             return card.shownFullScreen
         }
     }
+
+    var isSuccess: Bool {
+        switch (card, cash) {
+        case (.cardPaymentSuccessful, _):
+            return true
+        case (_, .paymentSuccess):
+            return true
+        default:
+            return false
+        }
+    }
 }
 
 enum PointOfSaleCardPaymentState: Equatable {

Modules/Sources/PointOfSale/Presentation/Item Selector/ChildItemList.swift

@@ -78,7 +78,9 @@ private extension ChildItemList {
             .transition(.opacity)
             .refreshable {
                 analyticsTracker.trackRefresh()
-                await itemsController.refreshItems(base: node)
+                await Task {
+                    await itemsController.refreshItems(base: node)
+                }.value
             }
         }
     }

Modules/Sources/PointOfSale/Presentation/PointOfSaleEntryPointView.swift

@@ -40,6 +40,8 @@ public struct PointOfSaleEntryPointView: View {
     private let barcodeScanService: PointOfSaleBarcodeScanServiceProtocol
     private let siteTimezone: TimeZone
     private let services: POSDependencyProviding
+    private let siteID: Int64
+    private let catalogSyncCoordinator: POSCatalogSyncCoordinatorProtocol?
 
     /// periphery: ignore - public in preparation of move to POS module
     public init(siteID: Int64,
@@ -70,11 +72,12 @@ public struct PointOfSaleEntryPointView: View {
         // Note: We check feature flag here for eligibility. Once eligibility checking is
         // refactored to be more centralized, this check can be simplified.
         let isGRDBEnabled = services.featureFlags.isFeatureFlagEnabled(.pointOfSaleLocalCatalogi1)
-        if let grdbManager = grdbManager, catalogSyncCoordinator != nil, isGRDBEnabled {
+        if let grdbManager = grdbManager, let catalogSyncCoordinator, isGRDBEnabled {
             self.itemsController = PointOfSaleObservableItemsController(
                 siteID: siteID,
                 grdbManager: grdbManager,
-                currencySettings: services.currency.currencySettings
+                currencySettings: services.currency.currencySettings,
+                catalogSyncCoordinator: catalogSyncCoordinator
             )
         } else {
             self.itemsController = PointOfSaleItemsController(
@@ -127,6 +130,8 @@ public struct PointOfSaleEntryPointView: View {
         self.orderListModel = POSOrderListModel(ordersController: ordersController, receiptSender: receiptSender)
         self.siteTimezone = siteTimezone
         self.services = services
+        self.siteID = siteID
+        self.catalogSyncCoordinator = catalogSyncCoordinator
     }
 
     public var body: some View {
@@ -155,7 +160,9 @@ public struct PointOfSaleEntryPointView: View {
                 collectOrderPaymentAnalyticsTracker: collectOrderPaymentAnalyticsTracker,
                 searchHistoryService: searchHistoryService,
                 popularPurchasableItemsController: popularPurchasableItemsController,
-                barcodeScanService: barcodeScanService)
+                barcodeScanService: barcodeScanService,
+                siteID: siteID,
+                catalogSyncCoordinator: catalogSyncCoordinator)
         }
         .environment(\.posAnalytics, services.analytics)
         .environment(\.posCurrencyProvider, services.currency)

Modules/Sources/PointOfSale/Utils/PreviewHelpers.swift

@@ -213,7 +213,9 @@ struct POSPreviewHelpers {
         searchHistoryService: POSSearchHistoryProviding = PointOfSalePreviewHistoryService(),
         popularItemsController: PointOfSaleItemsControllerProtocol = PointOfSalePreviewItemsController(),
         barcodeScanService: PointOfSaleBarcodeScanServiceProtocol = PointOfSalePreviewBarcodeScanService(),
-        analytics: POSAnalyticsProviding = EmptyPOSAnalytics()
+        analytics: POSAnalyticsProviding = EmptyPOSAnalytics(),
+        siteID: Int64 = 1,
+        catalogSyncCoordinator: POSCatalogSyncCoordinatorProtocol? = nil
     ) -> PointOfSaleAggregateModel {
         return PointOfSaleAggregateModel(
             entryPointController: POSEntryPointController(eligibilityChecker: PointOfSalePreviewTabEligibilityChecker()),
@@ -228,7 +230,9 @@ struct POSPreviewHelpers {
             collectOrderPaymentAnalyticsTracker: collectOrderPaymentAnalyticsTracker,
             searchHistoryService: searchHistoryService,
             popularPurchasableItemsController: popularItemsController,
-            barcodeScanService: barcodeScanService
+            barcodeScanService: barcodeScanService,
+            siteID: siteID,
+            catalogSyncCoordinator: catalogSyncCoordinator
         )
     }
 
@@ -619,7 +623,7 @@ final class POSPreviewCatalogSyncCoordinator: POSCatalogSyncCoordinatorProtocol
         try await Task.sleep(nanoseconds: 500_000_000)
     }
 
-    func performSmartSync(for siteID: Int64, fullSyncMaxAge: TimeInterval) async throws {
+    func performSmartSync(for siteID: Int64, fullSyncMaxAge: TimeInterval, incrementalSyncMaxAge: TimeInterval) async throws {
         // Simulates a smart sync operation with a 1 second delay.
         try await Task.sleep(nanoseconds: 1_000_000_000)
     }

Modules/Sources/Yosemite/PointOfSale/Items/GRDBObservableDataSource.swift

@@ -108,10 +108,6 @@ public final class GRDBObservableDataSource: POSObservableDataSourceProtocol {
         setupVariationObservation(parentProduct: parentProduct)
     }
 
-    public func refresh() {
-        // No-op: database observation automatically updates when data changes during incremental sync
-    }
-
     // MARK: - ValueObservation Setup
 
     private func setupProductObservation() {