[Local Catalog] Add GRDB data source for item list

Modules/Sources/Storage/GRDB/Model/PersistedProduct.swift

@@ -89,6 +89,18 @@ extension PersistedProduct: FetchableRecord, PersistableRecord {
                                                              to: primaryKey))
 }
 
+// MARK: - Point of Sale Requests
+public extension PersistedProduct {
+    /// Returns a request for POS-supported products (simple and variable, non-downloadable) for a given site, ordered by name
+    static func posProductsRequest(siteID: Int64) -> QueryInterfaceRequest<PersistedProduct> {
+        return PersistedProduct
+            .filter(Columns.siteID == siteID)
+            .filter([ProductType.simple.rawValue, ProductType.variable.rawValue].contains(Columns.productTypeKey))
+            .filter(Columns.downloadable == false)
+            .order(Columns.name.collating(.localizedCaseInsensitiveCompare))
+    }
+}
+
 // periphery:ignore - TODO: remove ignore when populating database
 private extension PersistedProduct {
     enum CodingKeys: String, CodingKey {
@@ -107,4 +119,9 @@ private extension PersistedProduct {
         case stockQuantity
         case stockStatusKey
     }
+
+    enum ProductType: String {
+        case simple
+        case variable
+    }
 }

Modules/Sources/Storage/GRDB/Model/PersistedProductVariation.swift

@@ -80,6 +80,16 @@ extension PersistedProductVariation: FetchableRecord, PersistableRecord {
                                      key: "image")
 }
 
+// MARK: - Point of Sale Requests
+public extension PersistedProductVariation {
+    /// Returns a request for non-downloadable variations of a parent product, ordered by ID
+    static func posVariationsRequest(siteID: Int64, parentProductID: Int64) -> QueryInterfaceRequest<PersistedProductVariation> {
+        return PersistedProductVariation
+            .filter(Columns.siteID == siteID && Columns.productID == parentProductID)
+            .filter(Columns.downloadable == false)
+            .order(Columns.id)
+    }
+}
 
 // periphery:ignore - TODO: remove ignore when populating database
 private extension PersistedProductVariation {

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

@@ -0,0 +1,232 @@
+// periphery:ignore:all
+import Foundation
+import GRDB
+import Combine
+import Observation
+import Storage
+import WooFoundation
+
+/// Observable data source for GRDB-based POS items using ValueObservation
+/// Provides automatic SwiftUI updates when database changes occur
+@Observable
+public final class GRDBObservableDataSource: POSObservableDataSourceProtocol {
+    // MARK: - Observable Properties
+
+    public private(set) var productItems: [POSItem] = []
+    public private(set) var variationItems: [POSItem] = []
+    public private(set) var isLoadingProducts: Bool = false
+    public private(set) var isLoadingVariations: Bool = false
+    public private(set) var error: Error? = nil
+
+    public var hasMoreProducts: Bool {
+        productItems.count >= (pageSize * currentProductPage) && totalProductCount > productItems.count
+    }
+
+    public var hasMoreVariations: Bool {
+        variationItems.count >= (pageSize * currentVariationPage) && totalVariationCount > variationItems.count
+    }
+
+    // MARK: - Private Properties
+
+    private let siteID: Int64
+    private let grdbManager: GRDBManagerProtocol
+    private let itemMapper: PointOfSaleItemMapperProtocol
+    private let pageSize: Int
+
+    private var currentProductPage: Int = 1
+    private var currentVariationPage: Int = 1
+    private var currentParentProduct: POSVariableParentProduct?
+    private var totalProductCount: Int = 0
+    private var totalVariationCount: Int = 0
+
+    // ValueObservation subscriptions
+    private var productObservationCancellable: AnyCancellable?
+    private var variationObservationCancellable: AnyCancellable?
+    private var statisticsObservationCancellable: AnyCancellable?
+
+    // MARK: - Initialization
+
+    public init(siteID: Int64,
+                grdbManager: GRDBManagerProtocol,
+                currencySettings: CurrencySettings,
+                itemMapper: PointOfSaleItemMapperProtocol? = nil,
+                pageSize: Int = 20) {
+        self.siteID = siteID
+        self.grdbManager = grdbManager
+        self.itemMapper = itemMapper ?? PointOfSaleItemMapper(currencySettings: currencySettings)
+        self.pageSize = pageSize
+
+        setupStatisticsObservation()
+    }
+
+    deinit {
+        productObservationCancellable?.cancel()
+        variationObservationCancellable?.cancel()
+        statisticsObservationCancellable?.cancel()
+    }
+
+    // MARK: - POSObservableDataSourceProtocol
+
+    public func loadProducts() {
+        currentProductPage = 1
+        isLoadingProducts = true
+        setupProductObservation()
+    }
+
+    public func loadMoreProducts() {
+        guard hasMoreProducts && !isLoadingProducts else { return }
+
+        isLoadingProducts = true
+        currentProductPage += 1
+        setupProductObservation()
+    }
+
+    public func loadVariations(for parentProduct: POSVariableParentProduct) {
+        guard currentParentProduct?.productID != parentProduct.productID else {
+            return // Same parent - idempotent
+        }
+
+        currentParentProduct = parentProduct
+        currentVariationPage = 1
+        isLoadingVariations = true
+        variationItems = []
+
+        setupVariationObservation(parentProduct: parentProduct)
+    }
+
+    public func loadMoreVariations() {
+        guard let parentProduct = currentParentProduct,
+              hasMoreVariations && !isLoadingVariations else { return }
+
+        isLoadingVariations = true
+        currentVariationPage += 1
+        setupVariationObservation(parentProduct: parentProduct)
+    }
+
+    public func refresh() {
+        // No-op: database observation automatically updates when data changes during incremental sync
+    }
+
+    // MARK: - ValueObservation Setup
+
+    private func setupProductObservation() {
+        let currentPage = currentProductPage
+        let observation = ValueObservation
+            .tracking { [weak self] database -> [POSProduct] in
+                guard let self else { return [] }
+
+                let persistedProducts = try PersistedProduct
+                    .posProductsRequest(siteID: siteID)
+                    .limit(pageSize * currentPage)
+                    .fetchAll(database)
+
+                return try persistedProducts.map { persistedProduct in
+                    let images = try persistedProduct.request(for: PersistedProduct.images).fetchAll(database)
+                    let attributes = try persistedProduct.request(for: PersistedProduct.attributes).fetchAll(database)
+
+                    return persistedProduct.toPOSProduct(
+                        images: images.map { $0.toProductImage() },
+                        attributes: attributes.map { $0.toProductAttribute(siteID: persistedProduct.siteID) }
+                    )
+                }
+            }
+
+        productObservationCancellable = observation
+            .publisher(in: grdbManager.databaseConnection)
+            .receive(on: DispatchQueue.main)
+            .sink(
+                receiveCompletion: { [weak self] completion in
+                    if case .failure(let error) = completion {
+                        self?.error = error
+                        self?.isLoadingProducts = false
+                    }
+                },
+                receiveValue: { [weak self] observedProducts in
+                    guard let self else { return }
+                    let posItems = itemMapper.mapProductsToPOSItems(products: observedProducts)
+                    productItems = posItems
+                    error = nil
+                    isLoadingProducts = false
+                }
+            )
+    }
+
+    private func setupVariationObservation(parentProduct: POSVariableParentProduct) {
+        variationObservationCancellable?.cancel()
+
+        let currentPage = currentVariationPage
+        let observation = ValueObservation
+            .tracking { [weak self] database -> [POSProductVariation] in
+                guard let self else { return [] }
+
+                let persistedVariations = try PersistedProductVariation
+                    .posVariationsRequest(siteID: self.siteID, parentProductID: parentProduct.productID)
+                    .limit(self.pageSize * currentPage)
+                    .fetchAll(database)
+
+                return try persistedVariations.map { persistedVariation in
+                    let attributes = try persistedVariation.request(for: PersistedProductVariation.attributes).fetchAll(database)
+                    let image = try persistedVariation.request(for: PersistedProductVariation.image).fetchOne(database)
+
+                    return persistedVariation.toPOSProductVariation(
+                        attributes: attributes.map { $0.toProductVariationAttribute() },
+                        image: image?.toProductImage()
+                    )
+                }
+            }
+
+        variationObservationCancellable = observation
+            .publisher(in: grdbManager.databaseConnection)
+            .receive(on: DispatchQueue.main)
+            .sink(
+                receiveCompletion: { [weak self] completion in
+                    if case .failure(let error) = completion {
+                        self?.error = error
+                        self?.isLoadingVariations = false
+                    }
+                },
+                receiveValue: { [weak self] observedVariations in
+                    guard let self else { return }
+                    let posItems = itemMapper.mapVariationsToPOSItems(
+                        variations: observedVariations,
+                        parentProduct: parentProduct
+                    )
+                    variationItems = posItems
+                    error = nil
+                    isLoadingVariations = false
+                }
+            )
+    }
+
+    private func setupStatisticsObservation() {
+        let observation = ValueObservation
+            .tracking { [weak self] database in
+                guard let self else { return (0, 0) }
+
+                let productCount = try PersistedProduct
+                    .posProductsRequest(siteID: siteID)
+                    .fetchCount(database)
+
+                let variationCount = try PersistedProductVariation
+                    .filter(PersistedProductVariation.Columns.siteID == siteID)
+                    .fetchCount(database)
+
+                return (productCount, variationCount)
+            }
+
+        statisticsObservationCancellable = observation
+            .publisher(in: grdbManager.databaseConnection)
+            .receive(on: DispatchQueue.main)
+            .sink(
+                receiveCompletion: { completion in
+                    if case .failure = completion {
+                        // Silently ignore - statistics are not critical
+                    }
+                },
+                receiveValue: { [weak self] (productCount, variationCount) in
+                    self?.totalProductCount = productCount
+                    self?.totalVariationCount = variationCount
+                }
+            )
+    }
+}

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

@@ -0,0 +1,43 @@
+// periphery:ignore:all
+import Foundation
+
+/// Protocol for observable data sources that provide POS items with automatic updates
+public protocol POSObservableDataSourceProtocol {
+    /// Current products mapped to POSItems
+    var productItems: [POSItem] { get }
+
+    /// Current variations for the selected parent product mapped to POSItems
+    var variationItems: [POSItem] { get }
+
+    /// Loading state for products
+    var isLoadingProducts: Bool { get }
+
+    /// Loading state for variations
+    var isLoadingVariations: Bool { get }
+
+    /// Whether more products are available to load
+    var hasMoreProducts: Bool { get }
+
+    /// Whether more variations are available for current parent
+    var hasMoreVariations: Bool { get }
+
+    /// Current error, if any
+    var error: Error? { get }
+
+    /// Loads the first page of products
+    func loadProducts()
+
+    /// Loads the next page of products
+    func loadMoreProducts()
+
+    /// Loads variations for a specific parent product
+    func loadVariations(for parentProduct: POSVariableParentProduct)
+
+    /// Loads more variations for the current parent product
+    func loadMoreVariations()
+
+    /// Refreshes all data
+    /// Note: For GRDB implementations, this is a no-op as the database observation
+    /// automatically updates when data changes during incremental sync
+    func refresh()
+}

Modules/Tests/PointOfSaleTests/Mocks/MockPOSObservableDataSource.swift

@@ -0,0 +1,37 @@
+import Foundation
+import Observation
+import Yosemite
+
+/// Mock implementation for testing and development
+@Observable
+final class MockPOSObservableDataSource: POSObservableDataSourceProtocol {
+    var productItems: [POSItem] = []
+    var variationItems: [POSItem] = []
+    var isLoadingProducts: Bool = false
+    var isLoadingVariations: Bool = false
+    var hasMoreProducts: Bool = false
+    var hasMoreVariations: Bool = false
+    var error: Error? = nil
+
+    init() {}
+
+    func loadProducts() {
+        // Tests set properties directly - no async behavior needed
+    }
+
+    func loadMoreProducts() {
+        // Tests set properties directly - no async behavior needed
+    }
+
+    func loadVariations(for parentProduct: POSVariableParentProduct) {
+        // Tests set properties directly - no async behavior needed
+    }
+
+    func loadMoreVariations() {
+        // Tests set properties directly - no async behavior needed
+    }
+
+    func refresh() {
+        // No-op for mock
+    }
+}