Merge branch 'trunk' into test/local-catalog-v-23.8-for-testing

Author: joshheald

.buildkite/commands/build-for-testing.sh

@@ -18,5 +18,5 @@ echo "--- :hammer_and_wrench: Building"
 bundle exec fastlane build_for_testing
 
 echo "--- :arrow_up: Upload Build Products"
-tar -cf build-products.tar DerivedData/Build/Products/ DerivedData/Index.noindex/DataStore/
+tar -cf build-products.tar DerivedData/Build/Products/
 buildkite-agent artifact upload build-products.tar

.buildkite/pipeline.yml

@@ -79,13 +79,6 @@ steps:
         agents:
           queue: linter
 
-      - label: "🧟 Detect unused code"
-        command: ".buildkite/commands/run-periphery.sh"
-        depends_on: build
-        plugins: [$CI_TOOLKIT]
-        notify:
-          - github_commit_status:
-              context: Periphery - Detect unused code
 
       - label: 🧹 Lint Translations
         command: gplint /workdir/WooCommerce/Resources/AppStoreStrings.pot

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

@@ -160,9 +160,47 @@ public final class GRDBObservableDataSource: POSObservableDataSourceProtocol {
 
     private func setupVariationObservation(parentProduct: POSVariableParentProduct) {
         let currentPage = currentVariationPage
+        let parentProductID = parentProduct.productID
+
+        struct ObservationResult {
+            let variations: [POSProductVariation]
+            let parentProduct: POSVariableParentProduct
+        }
+
         let observation = ValueObservation
-            .tracking { [weak self] database -> [POSProductVariation] in
-                guard let self else { return [] }
+            .tracking { [weak self] database -> ObservationResult in
+                guard let self else { return ObservationResult(variations: [], parentProduct: parentProduct) }
+
+                // Fetch parent product with updated attributes
+                struct ParentProductWithAttributes: Decodable, FetchableRecord {
+                    let product: PersistedProduct
+                    let attributes: [PersistedProductAttribute]
+                }
+
+                let parentWithAttributes = try PersistedProduct
+                    .filter(PersistedProduct.Columns.siteID == self.siteID)
+                    .filter(PersistedProduct.Columns.id == parentProductID)
+                    .including(all: PersistedProduct.attributes)
+                    .asRequest(of: ParentProductWithAttributes.self)
+                    .fetchOne(database)
+
+                // Create updated parent product with fresh attributes
+                let updatedParentProduct: POSVariableParentProduct
+                if let parentWithAttributes {
+                    let attributes = (parentWithAttributes.attributes).map {
+                        $0.toProductAttribute(siteID: parentWithAttributes.product.siteID)
+                    }
+                    let product = parentWithAttributes.product
+                    updatedParentProduct = POSVariableParentProduct(
+                        id: parentProduct.id,
+                        name: product.name,
+                        productImageSource: nil, // Image not needed for variation name generation
+                        productID: product.id,
+                        allAttributes: attributes
+                    )
+                } else {
+                    updatedParentProduct = parentProduct
+                }
 
                 struct VariationWithRelations: Decodable, FetchableRecord {
                     let persistedProductVariation: PersistedProductVariation
@@ -171,36 +209,42 @@ public final class GRDBObservableDataSource: POSObservableDataSourceProtocol {
                 }
 
                 let variationsWithRelations = try PersistedProductVariation
-                    .posVariationsRequest(siteID: self.siteID, parentProductID: parentProduct.productID)
+                    .posVariationsRequest(siteID: self.siteID, parentProductID: parentProductID)
                     .limit(self.pageSize * currentPage)
                     .including(all: PersistedProductVariation.attributes)
                     .including(optional: PersistedProductVariation.image)
                     .asRequest(of: VariationWithRelations.self)
                     .fetchAll(database)
 
-                return variationsWithRelations.map { record in
+                let variations = variationsWithRelations.map { record in
                     record.persistedProductVariation.toPOSProductVariation(
                         attributes: (record.attributes ?? []).map { $0.toProductVariationAttribute() },
                         image: record.image?.toProductImage()
                     )
                 }
+
+                return ObservationResult(variations: variations, parentProduct: updatedParentProduct)
             }
 
         variationObservationCancellable = observation
             .publisher(in: grdbManager.databaseConnection)
             .receive(on: DispatchQueue.main)
             .sink(
-                receiveCompletion: { [weak self] completion in
+                receiveCompletion: { [weak self] (completion: Subscribers.Completion<Error>) in
                     if case .failure(let error) = completion {
                         self?.variationError = error
                         self?.isLoadingVariations = false
                     }
                 },
-                receiveValue: { [weak self] observedVariations in
+                receiveValue: { [weak self] (result: ObservationResult) in
                     guard let self else { return }
+
+                    // Update current parent product with fresh attributes
+                    self.currentParentProduct = result.parentProduct
+
                     let posItems = itemMapper.mapVariationsToPOSItems(
-                        variations: observedVariations,
-                        parentProduct: parentProduct
+                        variations: result.variations,
+                        parentProduct: result.parentProduct
                     )
                     variationItems = posItems
                     variationError = nil

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

@@ -95,6 +95,11 @@ final class POSCatalogPersistenceService: POSCatalogPersistenceServiceProtocol {
 
         try await grdbManager.databaseConnection.write { db in
             for product in catalog.products {
+                // Delete attributes for updated products, the remaining set will be recreated later in the save
+                try PersistedProductAttribute
+                    .filter(PersistedProductAttribute.Columns.productID == product.productID)
+                    .deleteAll(db)
+
                 try PersistedProduct(from: product).save(db)
 
                 // Delete variations that are no longer associated with this product
@@ -111,6 +116,11 @@ final class POSCatalogPersistenceService: POSCatalogPersistenceServiceProtocol {
             }
 
             for variation in catalog.variationsToPersist {
+                // Delete attributes for updated variations, the remaining set will be recreated later in the save
+                try PersistedProductVariationAttribute
+                    .filter(PersistedProductVariationAttribute.Columns.productVariationID == variation.id)
+                    .deleteAll(db)
+
                 try variation.save(db)
             }
 
@@ -129,7 +139,7 @@ final class POSCatalogPersistenceService: POSCatalogPersistenceServiceProtocol {
             }
 
             for var attribute in catalog.productAttributesToPersist {
-                try attribute.save(db)
+                try attribute.insert(db)
             }
 
             for var attribute in catalog.variationAttributesToPersist {

Modules/Tests/YosemiteTests/Tools/POS/POSCatalogPersistenceServiceTests.swift

@@ -275,7 +275,7 @@ struct POSCatalogPersistenceServiceTests {
         }
     }
 
-    @Test func persistIncrementalCatalogData_upserts_attributes_for_updated_product() async throws {
+    @Test func persistIncrementalCatalogData_replaces_attributes_for_updated_product() async throws {
         // Given
         let attribute1 = Yosemite.ProductAttribute.fake().copy(name: "Color", options: ["Indigo", "Blue"])
         let attribute2 = Yosemite.ProductAttribute.fake().copy(name: "Size")
@@ -291,17 +291,40 @@ struct POSCatalogPersistenceServiceTests {
 
         // Then
         try await grdbManager.databaseConnection.read { db in
-            // Should have 4 attributes: original 2 + updated 2 (upsert adds new ones, keeps old ones)
+            // Should have 2 attributes - old ones deleted, new ones added (no duplicates)
             let attributeCount = try PersistedProductAttribute.fetchCount(db)
-            #expect(attributeCount == 4)
+            #expect(attributeCount == 2)
 
             let attributes = try PersistedProductAttribute.fetchAll(db).sorted(by: { $0.name < $1.name })
             #expect(attributes[0].name == "Color")
-            #expect(attributes[0].options == ["Indigo", "Blue"]) // Original unchanged
-            #expect(attributes[1].name == "Color")
-            #expect(attributes[1].options == ["Cardinal", "Blue"]) // Updated version
-            #expect(attributes[2].name == "Material") // New attribute
-            #expect(attributes[3].name == "Size") // Original unchanged
+            #expect(attributes[0].options == ["Cardinal", "Blue"]) // Updated version
+            #expect(attributes[1].name == "Material") // New attribute
+        }
+    }
+
+    @Test func persistIncrementalCatalogData_prevents_duplicate_attributes_on_multiple_syncs() async throws {
+        // Given - product with attributes
+        let attribute1 = Yosemite.ProductAttribute.fake().copy(name: "Color", options: ["Red", "Blue"])
+        let attribute2 = Yosemite.ProductAttribute.fake().copy(name: "Size", options: ["S", "M", "L"])
+        let product = POSProduct.fake().copy(siteID: sampleSiteID, productID: 1, attributes: [attribute1, attribute2])
+        try await insertProduct(product)
+
+        // When - perform multiple incremental syncs with the same product/attributes
+        let catalog = POSCatalog(products: [product], variations: [], syncDate: .now)
+        try await sut.persistIncrementalCatalogData(catalog, siteID: sampleSiteID)
+        try await sut.persistIncrementalCatalogData(catalog, siteID: sampleSiteID)
+        try await sut.persistIncrementalCatalogData(catalog, siteID: sampleSiteID)
+
+        // Then - should have exactly 2 attributes, not duplicates
+        try await grdbManager.databaseConnection.read { db in
+            let attributeCount = try PersistedProductAttribute.fetchCount(db)
+            #expect(attributeCount == 2)
+
+            let attributes = try PersistedProductAttribute.fetchAll(db).sorted(by: { $0.name < $1.name })
+            #expect(attributes[0].name == "Color")
+            #expect(attributes[0].options == ["Red", "Blue"])
+            #expect(attributes[1].name == "Size")
+            #expect(attributes[1].options == ["S", "M", "L"])
         }
     }
 
@@ -449,6 +472,36 @@ struct POSCatalogPersistenceServiceTests {
         }
     }
 
+    @Test func persistIncrementalCatalogData_prevents_duplicate_variation_attributes_on_multiple_syncs() async throws {
+        // Given - variation with attributes
+        let parentProduct = POSProduct.fake().copy(siteID: sampleSiteID, productID: 10)
+        let attribute1 = Yosemite.ProductVariationAttribute.fake().copy(name: "Color", option: "Red")
+        let attribute2 = Yosemite.ProductVariationAttribute.fake().copy(name: "Size", option: "L")
+        let variation = POSProductVariation.fake().copy(siteID: sampleSiteID, productID: 10, productVariationID: 1, attributes: [attribute1, attribute2])
+        try await insertProduct(parentProduct)
+        try await insertVariation(variation)
+
+        // When - perform multiple incremental syncs with the same variation/attributes
+        let catalog = POSCatalog(products: [parentProduct], variations: [variation], syncDate: .now)
+        try await sut.persistIncrementalCatalogData(catalog, siteID: sampleSiteID)
+        try await sut.persistIncrementalCatalogData(catalog, siteID: sampleSiteID)
+        try await sut.persistIncrementalCatalogData(catalog, siteID: sampleSiteID)
+
+        // Then - should have exactly 2 attributes, not duplicates
+        try await grdbManager.databaseConnection.read { db in
+            let attributeCount = try PersistedProductVariationAttribute.fetchCount(db)
+            #expect(attributeCount == 2)
+
+            let attributes = try PersistedProductVariationAttribute.fetchAll(db).sorted(by: { $0.name < $1.name })
+            #expect(attributes[0].name == "Color")
+            #expect(attributes[0].option == "Red")
+            #expect(attributes[0].productVariationID == 1)
+            #expect(attributes[1].name == "Size")
+            #expect(attributes[1].option == "L")
+            #expect(attributes[1].productVariationID == 1)
+        }
+    }
+
     @Test func persistIncrementalCatalogData_replaces_image_for_updated_variation() async throws {
         // Given
         let parentProduct = POSProduct.fake().copy(siteID: sampleSiteID, productID: 10)

RELEASE-NOTES.txt

@@ -8,6 +8,7 @@
 - [*] Update products on the Top Performers card when there are changes made to displayed products [https://github.com/woocommerce/woocommerce-ios/pull/16380]
 - [*] Fixed issue unregistering device from push notifications [https://github.com/woocommerce/woocommerce-ios/pull/16386]
 - [Internal] Fix broken navigation to a variable product selector [https://github.com/woocommerce/woocommerce-ios/pull/16363]
+-[***] POS uses a local on-device product catalog for fast barcode scanning, search, and product selection [https://github.com/woocommerce/woocommerce-ios/pull/16395]
 
 23.7
 -----

fastlane/metadata/default/name.txt

@@ -1 +1 @@
-WooCommerce
+WooCommerce: Store Management & POS

fastlane/metadata/default/subtitle.txt

@@ -1 +1 @@
-Your store in your pocket
+All-in-one mobile ecommerce