[Local catalog] Feature eligibility checker

Modules/Sources/PointOfSale/Models/PointOfSaleSettingsController.swift

@@ -15,6 +15,7 @@ protocol PointOfSaleSettingsControllerProtocol {
     var connectedCardReader: CardPresentPaymentCardReader? { get }
     var storeViewModel: POSSettingsStoreViewModel { get }
     var localCatalogViewModel: POSSettingsLocalCatalogViewModel? { get }
+    var isLocalCatalogEligible: Bool { get }
 }
 
 @Observable final class PointOfSaleSettingsController: PointOfSaleSettingsControllerProtocol {
@@ -23,6 +24,9 @@ protocol PointOfSaleSettingsControllerProtocol {
 
     let storeViewModel: POSSettingsStoreViewModel
     let localCatalogViewModel: POSSettingsLocalCatalogViewModel?
+    private let localCatalogEligibilityService: POSLocalCatalogEligibilityServiceProtocol?
+
+    var isLocalCatalogEligible: Bool = false
 
     init(siteID: Int64,
          settingsService: PointOfSaleSettingsServiceProtocol,
@@ -31,12 +35,15 @@ protocol PointOfSaleSettingsControllerProtocol {
          defaultSiteName: String?,
          siteSettings: [SiteSetting],
          grdbManager: GRDBManagerProtocol?,
-         catalogSyncCoordinator: POSCatalogSyncCoordinatorProtocol?) {
+         catalogSyncCoordinator: POSCatalogSyncCoordinatorProtocol?,
+         localCatalogEligibilityService: POSLocalCatalogEligibilityServiceProtocol?) {
         self.storeViewModel = POSSettingsStoreViewModel(siteID: siteID,
                                                         settingsService: settingsService,
                                                         pluginsService: pluginsService,
                                                         defaultSiteName: defaultSiteName,
                                                         siteSettings: siteSettings)
+        self.localCatalogEligibilityService = localCatalogEligibilityService
+
         if let catalogSyncCoordinator, let grdbManager {
             self.localCatalogViewModel = POSSettingsLocalCatalogViewModel(
                 siteID: siteID,
@@ -48,6 +55,8 @@ protocol PointOfSaleSettingsControllerProtocol {
         }
 
         observeCardReader(from: cardPresentPaymentService)
+
+        checkLocalCatalogEligibility()
     }
 
     private func observeCardReader(from service: CardPresentPaymentFacade) {
@@ -64,6 +73,10 @@ protocol PointOfSaleSettingsControllerProtocol {
                 connectedCardReader = cardReader
             })
     }
+
+    private func checkLocalCatalogEligibility() {
+        isLocalCatalogEligible = localCatalogEligibilityService?.eligibilityState == .eligible
+    }
 }
 
 #if DEBUG
@@ -80,6 +93,10 @@ final class PointOfSaleSettingsPreviewController: PointOfSaleSettingsControllerP
                                                                               siteSettings: [])
 
     var localCatalogViewModel: POSSettingsLocalCatalogViewModel?
+
+    var isLocalCatalogEligible: Bool {
+        localCatalogViewModel != nil
+    }
 }
 
 final class MockPointOfSaleSettingsService: PointOfSaleSettingsServiceProtocol {

Modules/Sources/PointOfSale/Presentation/PointOfSaleEntryPointView.swift

@@ -66,11 +66,10 @@ public struct PointOfSaleEntryPointView: View {
          services: POSDependencyProviding) {
         self.onPointOfSaleModeActiveStateChange = onPointOfSaleModeActiveStateChange
 
-        // Use observable controller with GRDB if available and feature flag is enabled, otherwise fall back to standard controller
-        // 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 {
+        // Use observable controller with GRDB if local catalog is eligible,
+        // otherwise fall back to standard controller.
+        let isLocalCatalogEligible = services.localCatalogEligibility.localCatalogEligibilityService?.eligibilityState == .eligible
+        if isLocalCatalogEligible, let grdbManager = grdbManager {
             self.itemsController = PointOfSaleObservableItemsController(
                 siteID: siteID,
                 grdbManager: grdbManager,
@@ -113,7 +112,8 @@ public struct PointOfSaleEntryPointView: View {
                                                                 defaultSiteName: defaultSiteName,
                                                                 siteSettings: siteSettings,
                                                                 grdbManager: grdbManager,
-                                                                catalogSyncCoordinator: catalogSyncCoordinator)
+                                                                catalogSyncCoordinator: catalogSyncCoordinator,
+                                                                localCatalogEligibilityService: services.localCatalogEligibility.localCatalogEligibilityService)
         self.collectOrderPaymentAnalyticsTracker = collectOrderPaymentAnalyticsTracker
         self.searchHistoryService = searchHistoryService
         self.popularPurchasableItemsController = PointOfSaleItemsController(

Modules/Sources/PointOfSale/Presentation/Settings/PointOfSaleSettingsView.swift

@@ -3,7 +3,6 @@ import SwiftUI
 struct PointOfSaleSettingsView: View {
     @Environment(\.dismiss) private var dismiss
     @Environment(\.posAnalytics) private var analytics
-    @Environment(\.posFeatureFlags) private var featureFlags
     @State private var selection: SidebarNavigation? = .store
 
     let settingsController: PointOfSaleSettingsControllerProtocol
@@ -55,8 +54,7 @@ extension PointOfSaleSettingsView {
                     }
                 )
 
-                // TODO: WOOMOB-1287 - integrate with local catalog feature eligibility
-                if featureFlags.isFeatureFlagEnabled(.pointOfSaleLocalCatalogi1) && settingsController.localCatalogViewModel != nil {
+                if settingsController.isLocalCatalogEligible {
                     PointOfSaleSettingsCard(
                         item: .localCatalog,
                         isSelected: selection == .localCatalog,

Modules/Sources/PointOfSale/Protocols/POSDependencyProviding.swift

@@ -64,6 +64,11 @@ public protocol POSExternalViewProviding {
     func createWCWebView(adminUrl: URL, completion: @escaping () -> Void) -> AnyView
 }
 
+/// Protocol that provides local catalog eligibility service for POS
+public protocol POSLocalCatalogEligibilityProviding {
+    var localCatalogEligibilityService: POSLocalCatalogEligibilityServiceProtocol? { get }
+}
+
 /// Main protocol that combines all POS dependency providers
 /// This enables dependency injection for POS code while maintaining clean separation from ServiceLocator
 public protocol POSDependencyProviding {
@@ -73,4 +78,5 @@ public protocol POSDependencyProviding {
     var connectivity: POSConnectivityProviding { get }
     var externalNavigation: POSExternalNavigationProviding { get }
     var externalViews: POSExternalViewProviding { get }
+    var localCatalogEligibility: POSLocalCatalogEligibilityProviding { get }
 }

Modules/Sources/PointOfSale/Protocols/POSLocalCatalogEligibilityServiceProtocol.swift

@@ -0,0 +1,37 @@
+import Foundation
+
+/// Eligibility state for local catalog feature
+/// Provides diagnostic information for UI display and decision-making
+public enum POSLocalCatalogEligibilityState: Equatable {
+    /// Local catalog is eligible for use
+    case eligible
+
+    /// Local catalog is not eligible
+    case ineligible(reason: POSLocalCatalogIneligibleReason)
+}
+
+/// Reasons why local catalog is ineligible
+public enum POSLocalCatalogIneligibleReason: Equatable {
+    case posTabNotEligible
+    case featureFlagDisabled
+    case catalogSizeTooLarge(totalCount: Int, limit: Int)
+    case catalogSizeCheckFailed(underlyingError: String)
+}
+
+/// Service that provides eligibility information for local catalog feature
+///
+/// Other services can query this for eligibility state and reasons:
+/// - Sync coordinator can check if catalog is eligible
+/// - Settings UI can display eligibility status and reasons
+/// - Analytics can track why stores are ineligible
+///
+/// NOTE: This service checks catalog-related eligibility (size limits) and feature flag state.
+/// The service performs an initial eligibility check during initialization.
+public protocol POSLocalCatalogEligibilityServiceProtocol {
+    /// Current eligibility state (synchronously accessible on main thread)
+    var eligibilityState: POSLocalCatalogEligibilityState { get }
+
+    /// Force refresh eligibility (bypasses cache and updates eligibilityState)
+    /// - Returns: Fresh eligibility state with reason if ineligible
+    @discardableResult func refreshEligibilityState() async -> POSLocalCatalogEligibilityState
+}

Modules/Sources/PointOfSale/Utils/POSEnvironmentKeys.swift

@@ -160,3 +160,8 @@ struct EmptyPOSExternalView: POSExternalViewProviding {
     }
     init() {}
 }
+
+struct EmptyPOSLocalCatalogEligibility: POSLocalCatalogEligibilityProviding {
+    var localCatalogEligibilityService: POSLocalCatalogEligibilityServiceProtocol? = nil
+    init() {}
+}

Modules/Sources/PointOfSale/Utils/PreviewHelpers.swift

@@ -590,6 +590,7 @@ final class POSPreviewServices: POSDependencyProviding {
     var connectivity: POSConnectivityProviding = EmptyPOSConnectivityProvider()
     var externalNavigation: POSExternalNavigationProviding = EmptyPOSExternalNavigation()
     var externalViews: POSExternalViewProviding = EmptyPOSExternalView()
+    var localCatalogEligibility: POSLocalCatalogEligibilityProviding = EmptyPOSLocalCatalogEligibility()
 }
 
 // MARK: - Preview Catalog Services

Modules/Sources/Yosemite/Tools/POS/POSCatalogSizeChecker.swift

@@ -1,5 +1,6 @@
 import Foundation
 import Networking
+import Combine
 
 /// Protocol for checking the size of a remote POS catalog
 public protocol POSCatalogSizeCheckerProtocol {
@@ -18,6 +19,15 @@ public struct POSCatalogSizeChecker: POSCatalogSizeCheckerProtocol {
         self.syncRemote = syncRemote
     }
 
+    public init(credentials: Credentials?,
+                selectedSite: AnyPublisher<JetpackSite?, Never>,
+                appPasswordSupportState: AnyPublisher<Bool, Never>) {
+        let syncRemote = POSCatalogSyncRemote(network: AlamofireNetwork(credentials: credentials,
+                                                                        selectedSite: selectedSite,
+                                                                        appPasswordSupportState: appPasswordSupportState))
+        self.init(syncRemote: syncRemote)
+    }
+
     public func checkCatalogSize(for siteID: Int64) async throws -> POSCatalogSize {
         // Make concurrent requests to get both counts
         async let productCount = syncRemote.getProductCount(siteID: siteID)

Modules/Tests/PointOfSaleTests/Controllers/PointOfSaleSettingsControllerTests.swift

@@ -4,6 +4,7 @@ import Foundation
 @testable import Yosemite
 import Storage
 
+@MainActor
 struct PointOfSaleSettingsControllerTests {
     private let mockSettingsService = MockPointOfSaleSettingsService()
     private let mockCardPresentPaymentService = MockCardPresentPaymentService()
@@ -19,7 +20,8 @@ struct PointOfSaleSettingsControllerTests {
                                                 defaultSiteName: "Test Store",
                                                 siteSettings: [],
                                                 grdbManager: nil,
-                                                catalogSyncCoordinator: nil)
+                                                catalogSyncCoordinator: nil,
+                                                localCatalogEligibilityService: MockPOSLocalCatalogEligibilityService())
 
         // When
         let cardReader = sut.connectedCardReader
@@ -38,7 +40,8 @@ struct PointOfSaleSettingsControllerTests {
                                                 defaultSiteName: "Test Store",
                                                 siteSettings: [],
                                                 grdbManager: nil,
-                                                catalogSyncCoordinator: nil)
+                                                catalogSyncCoordinator: nil,
+                                                localCatalogEligibilityService: MockPOSLocalCatalogEligibilityService())
 
         // Initially nil
         #expect(sut.connectedCardReader == nil)
@@ -80,4 +83,5 @@ final class MockPointOfSaleSettingsController: PointOfSaleSettingsControllerProt
                                                                               defaultSiteName: "Sample Store",
                                                                               siteSettings: [])
     var localCatalogViewModel: POSSettingsLocalCatalogViewModel?
+    var isLocalCatalogEligible = true
 }

Modules/Tests/PointOfSaleTests/Mocks/MockPOSLocalCatalogEligibilityService.swift

@@ -0,0 +1,18 @@
+import Foundation
+@testable import PointOfSale
+
+/// Mock implementation of POSLocalCatalogEligibilityServiceProtocol for testing
+@MainActor
+public final class MockPOSLocalCatalogEligibilityService: POSLocalCatalogEligibilityServiceProtocol {
+    public var eligibilityState: POSLocalCatalogEligibilityState
+    public var refreshCallCount = 0
+
+    public init(eligibilityState: POSLocalCatalogEligibilityState = .eligible) {
+        self.eligibilityState = eligibilityState
+    }
+
+    public func refreshEligibilityState() async -> POSLocalCatalogEligibilityState {
+        refreshCallCount += 1
+        return eligibilityState
+    }
+}

Modules/Tests/YosemiteTests/Mocks/MockPOSCatalogSizeChecker.swift

@@ -2,16 +2,18 @@ import Foundation
 @testable import Yosemite
 
 final class MockPOSCatalogSizeChecker: POSCatalogSizeCheckerProtocol {
-    // MARK: - checkCatalogSize tracking
-    private(set) var checkCatalogSizeCallCount = 0
-    private(set) var lastCheckedSiteID: Int64?
-    var checkCatalogSizeResult: Result<POSCatalogSize, Error> = .success(POSCatalogSize(productCount: 100, variationCount: 50)) // 150 total - well under limit
+    var sizeToReturn: Result<POSCatalogSize, Error>
+    var checkCatalogSizeCallCount = 0
+    var lastCheckedSiteID: Int64?
+
+    init(sizeToReturn: Result<POSCatalogSize, Error> = .success(POSCatalogSize(productCount: 100, variationCount: 50))) {
+        self.sizeToReturn = sizeToReturn
+    }
 
     func checkCatalogSize(for siteID: Int64) async throws -> POSCatalogSize {
         checkCatalogSizeCallCount += 1
         lastCheckedSiteID = siteID
-
-        switch checkCatalogSizeResult {
+        switch sizeToReturn {
         case .success(let size):
             return size
         case .failure(let error):