update data deletes and tests to match LeStorage changes

PadelClubData/Data/Club.swift

@@ -29,15 +29,9 @@ final public class Club: BaseClub {
         DataStore.shared.courts.filter { $0.club == self.id }.sorted(by: \.index)
     }
 
-    public override func deleteDependencies(store: Store, shouldBeSynchronized: Bool) {
+    public override func deleteDependencies(store: Store, actionOption: ActionOption) {
         
-        store.deleteDependencies(type: Court.self, shouldBeSynchronized: shouldBeSynchronized) { $0.club == self.id }
+        store.deleteDependencies(type: Court.self, actionOption: actionOption) { ($0 as? Court)?.club == self.id }
-
-//        let customizedCourts = self.customizedCourts
-//        for customizedCourt in customizedCourts {
-//            customizedCourt.deleteDependencies(store: store, shouldBeSynchronized: shouldBeSynchronized)
-//        }
-//        DataStore.shared.courts.deleteDependencies(customizedCourts, shouldBeSynchronized: shouldBeSynchronized)
     }
 
     public override func deleteUnusedSharedDependencies(store: Store) {

PadelClubData/Data/Court.swift

@@ -52,7 +52,7 @@ final public class Court: BaseCourt {
         Store.main.findById(club)
     }
     
-    public override func deleteDependencies(store: Store, shouldBeSynchronized: Bool) {
+    public override func deleteDependencies(store: Store, actionOption: ActionOption) {
     }
     
 }

PadelClubData/Data/DateInterval.swift

@@ -57,7 +57,7 @@ final public class DateInterval: BaseDateInterval {
         date <= startDate && date <= endDate && date >= startDate && date >= endDate
     }
     
-    public override func deleteDependencies(store: Store, shouldBeSynchronized: Bool) {
+    public override func deleteDependencies(store: Store, actionOption: ActionOption) {
     }
     
 //    enum CodingKeys: String, CodingKey {

PadelClubData/Data/DrawLog.swift

@@ -74,7 +74,7 @@ final public class DrawLog: BaseDrawLog, SideStorable {
         return TournamentLibrary.shared.store(tournamentId: self.tournament)
     }
 
-    public override func deleteDependencies(store: Store, shouldBeSynchronized: Bool) {
+    public override func deleteDependencies(store: Store, actionOption: ActionOption) {
     }
     
 }

PadelClubData/Data/Event.swift

@@ -30,10 +30,12 @@ final public class Event: BaseEvent {
         store.deleteUnusedSharedDependencies(type: DateInterval.self, shouldBeSynchronized: false) { $0.event == self.id }
     }
     
-    public override func deleteDependencies(store: Store, shouldBeSynchronized: Bool) {
+    public override func deleteDependencies(store: Store, actionOption: ActionOption) {
         
-        store.deleteDependencies(type: Tournament.self, shouldBeSynchronized: shouldBeSynchronized) { $0.event == self.id && $0.isDeleted == false }
+        store.deleteDependencies(type: Tournament.self, actionOption: actionOption) { storable in
-        store.deleteDependencies(type: DateInterval.self, shouldBeSynchronized: shouldBeSynchronized) { $0.event == self.id }
+            guard let tournament = storable as? Tournament else { return false }
+            return tournament.event == self.id && tournament.isDeleted == false }
+        store.deleteDependencies(type: DateInterval.self, actionOption: actionOption) { ($0 as? DateInterval)?.event == self.id }
 
         
 //        let tournaments = self.tournaments

PadelClubData/Data/GroupStage.swift

@@ -607,9 +607,9 @@ final public class GroupStage: BaseGroupStage, SideStorable {
         return teams(true).firstIndex(of: team)
     }
 
-    public override func deleteDependencies(store: Store, shouldBeSynchronized: Bool) {
+    public override func deleteDependencies(store: Store, actionOption: ActionOption) {
         
-        store.deleteDependencies(type: Match.self, shouldBeSynchronized: shouldBeSynchronized) { $0.groupStage == self.id }
+        store.deleteDependencies(type: Match.self, actionOption: actionOption) { ($0 as? Match)?.groupStage == self.id }
 
 //        
 //        let matches = self._matches()

PadelClubData/Data/Match.swift

@@ -82,9 +82,9 @@ final public class Match: BaseMatch, SideStorable {
     
     // MARK: -
     
-    public override func deleteDependencies(store: Store, shouldBeSynchronized: Bool) {
+    public override func deleteDependencies(store: Store, actionOption: ActionOption) {
         
-        store.deleteDependencies(type: TeamScore.self, shouldBeSynchronized: shouldBeSynchronized) { $0.match == self.id }
+        store.deleteDependencies(type: TeamScore.self, actionOption: actionOption) { ($0 as? TeamScore)?.match == self.id }
         
 //        let teamScores = self.teamScores
 //        for teamScore in teamScores {

PadelClubData/Data/Round.swift

@@ -903,25 +903,11 @@ defer {
         _cachedLoserRoundsAndChildren = nil
     }
     
-    public override func deleteDependencies(store: Store, shouldBeSynchronized: Bool) {
+    public override func deleteDependencies(store: Store, actionOption: ActionOption) {
 
-        store.deleteDependencies(type: Match.self, shouldBeSynchronized: shouldBeSynchronized) { $0.round == self.id }
+        store.deleteDependencies(type: Match.self, actionOption: actionOption) { ($0 as? Match)?.round == self.id }
-        store.deleteDependencies(type: Round.self, shouldBeSynchronized: shouldBeSynchronized) { $0.parent == self.id }
+        store.deleteDependencies(type: Round.self, actionOption: actionOption) { ($0 as? Round)?.parent == self.id }
 
-        
-//        let matches = self._matches()
-//        for match in matches {
-//            match.deleteDependencies(store: store, shouldBeSynchronized: shouldBeSynchronized)
-//        }
-//        
-//        self.tournamentStore?.matches.deleteDependencies(matches, shouldBeSynchronized: shouldBeSynchronized)
-//        
-//        let loserRounds = self.loserRounds()
-//        for round in loserRounds {
-//            round.deleteDependencies(store: store, shouldBeSynchronized: shouldBeSynchronized)
-//        }
-//        
-//        self.tournamentStore?.rounds.deleteDependencies(loserRounds, shouldBeSynchronized: shouldBeSynchronized)
     }
 
     

PadelClubData/Data/TeamRegistration.swift

@@ -101,10 +101,10 @@ final public class TeamRegistration: BaseTeamRegistration, SideStorable {
         tournamentStore.teamScores.delete(contentOfs: ts)
     }
 
-    public override func deleteDependencies(store: Store, shouldBeSynchronized: Bool) {
+    public override func deleteDependencies(store: Store, actionOption: ActionOption) {
         
-        store.deleteDependencies(type: TeamScore.self, shouldBeSynchronized: shouldBeSynchronized) { $0.teamRegistration == self.id }
+        store.deleteDependencies(type: TeamScore.self, actionOption: actionOption) { ($0 as? TeamScore)?.teamRegistration == self.id }
-        store.deleteDependencies(type: PlayerRegistration.self, shouldBeSynchronized: shouldBeSynchronized) { $0.teamRegistration == self.id }
+        store.deleteDependencies(type: PlayerRegistration.self, actionOption: actionOption) { ($0 as? PlayerRegistration)?.teamRegistration == self.id }
 
         //        let unsortedPlayers = unsortedPlayers()
 //        for player in unsortedPlayers {

PadelClubData/Data/Tournament.swift

@@ -32,16 +32,16 @@ final public class Tournament: BaseTournament {
         return TournamentLibrary.shared.store(tournamentId: self.id)
     }
 
-    public override func deleteDependencies(store: Store, shouldBeSynchronized: Bool) {
+    public override func deleteDependencies(store: Store, actionOption: ActionOption) {
         
         do {
             let tournamentStore = try store.alternateStore(identifier: self.id)
             
-            tournamentStore.deleteAllDependencies(type: DrawLog.self, shouldBeSynchronized: shouldBeSynchronized)
+            tournamentStore.deleteAllDependencies(type: DrawLog.self, actionOption: actionOption)
-            tournamentStore.deleteAllDependencies(type: TeamRegistration.self, shouldBeSynchronized: shouldBeSynchronized)
+            tournamentStore.deleteAllDependencies(type: TeamRegistration.self, actionOption: actionOption)
-            tournamentStore.deleteAllDependencies(type: GroupStage.self, shouldBeSynchronized: shouldBeSynchronized)
+            tournamentStore.deleteAllDependencies(type: GroupStage.self, actionOption: actionOption)
-            tournamentStore.deleteAllDependencies(type: Round.self, shouldBeSynchronized: shouldBeSynchronized)
+            tournamentStore.deleteAllDependencies(type: Round.self, actionOption: actionOption)
-            tournamentStore.deleteAllDependencies(type: MatchScheduler.self, shouldBeSynchronized: shouldBeSynchronized)
+            tournamentStore.deleteAllDependencies(type: MatchScheduler.self, actionOption: actionOption)
         } catch {
             Logger.error(error)
         }

PadelClubData/Subscriptions/Guard.swift

@@ -48,7 +48,7 @@ import Combine
     }
     
     @objc func collectionDidLoad(notification: Notification) {
-        if let _ = notification.object as? BaseCollection<Purchase> {
+        if let _ = notification.object as? StoredCollection<Purchase> {
             self._updateBestPlan()
         }
     }

PadelClubDataTests/DeletionTests.swift

@@ -279,7 +279,7 @@ actor BoolChecker {
                 return
             }
             
-            print("sleep...")
+//            print("sleep...")
             
             // Wait for 100ms before next check
             try? await Task.sleep(for: .milliseconds(100))

PadelClubDataTests/PadelClubDataTests.swift

@@ -41,29 +41,33 @@ struct PadelClubDataTests {
         }
         
         // Cleanup
-        let events = DataStore.shared.events
-        try await DataStore.shared.events.deleteAsync(contentOfs: Array(events))
-
-        try await DataStore.shared.events.loadDataFromServerIfAllowed(clear: true)
-        #expect(DataStore.shared.events.count == 0)
         
-        try await DataStore.shared.tournaments.loadDataFromServerIfAllowed(clear: true)
+        let eventCol: SyncedCollection<Event> = await  StoreCenter.main.mainStore.asyncLoadingSynchronizedCollection()
-        #expect(DataStore.shared.tournaments.count == 0)
+        eventCol.reset()
+        let events: [Event] = try await StoreCenter.main.service().get()
+        try await eventCol.deleteAsync(contentOfs: Array(events))
+        #expect(eventCol.count == 0)
+        
+        let tournamentCol: SyncedCollection<Tournament> = await  StoreCenter.main.mainStore.asyncLoadingSynchronizedCollection()
+        tournamentCol.reset()
+        let tournaments: [Tournament] = try await StoreCenter.main.service().get()
+        try await tournamentCol.deleteAsync(contentOfs: Array(tournaments))
+        #expect(tournamentCol.count == 0)
 
         // Create
         let event: Event = Event(creator: userId, club: nil, name: "test")
-        try await DataStore.shared.events.addOrUpdateAsync(instance: event)
+        try await eventCol.addOrUpdateAsync(instance: event)
         
         let tournament: Tournament = Tournament.fake()
         tournament.event = event.id
-        try await DataStore.shared.tournaments.addOrUpdateAsync(instance: tournament)
+        try await tournamentCol.addOrUpdateAsync(instance: tournament)
 
         // Test server content
-        try await DataStore.shared.events.loadDataFromServerIfAllowed(clear: true)
+        try await eventCol.loadDataFromServerIfAllowed(clear: true)
-        #expect(DataStore.shared.events.count == 1)
+        #expect(eventCol.count == 1)
         
-        try await DataStore.shared.tournaments.loadDataFromServerIfAllowed(clear: true)
+        try await tournamentCol.loadDataFromServerIfAllowed(clear: true)
-        #expect(DataStore.shared.tournaments.count == 1)
+        #expect(tournamentCol.count == 1)
 
     }
     

PadelClubDataTests/SyncDataAccessTests.swift

@@ -9,15 +9,6 @@ import Testing
 @testable import PadelClubData
 @testable import LeStorage
 
-extension String {
-    
-    static func random(length: Int = 10) -> String {
-        let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
-        return String((0..<length).map{ _ in letters.randomElement()! })
-    }
-    
-}
-
 struct SyncDataAccessTests {
     
     let username1: String = "UserDataTests"

PadelClubDataTests/SynchronizationTests.swift

@@ -80,7 +80,7 @@ struct SynchronizationTests {
         
         let eventCollection2: SyncedCollection<Event> = await  self.secondStoreCenter.mainStore.asyncLoadingSynchronizedCollection()
         #expect(eventCollection2.hasLoaded == true)
-        eventCollection2.clear()
+        eventCollection2.reset()
 
         // cleanup sync residues
         let _ = try await self.secondStoreCenter.testSynchronizeOnceAsync()
@@ -121,13 +121,13 @@ struct SynchronizationTests {
         let eventCollectionA: SyncedCollection<Event> = await StoreCenter.main.mainStore.asyncLoadingSynchronizedCollection()
         try await eventCollectionA.deleteAsync(contentOfs: Array(eventCollectionA))
         let eventCollectionB: SyncedCollection<Event> = await  self.secondStoreCenter.mainStore.asyncLoadingSynchronizedCollection()
-        eventCollectionB.clear()
+        eventCollectionB.reset()
         
         // Setup clubs collections
         let clubCollectionA: SyncedCollection<Club> = await StoreCenter.main.mainStore.asyncLoadingSynchronizedCollection()
         try await clubCollectionA.deleteAsync(contentOfs: Array(clubCollectionA))
         let clubCollectionB: SyncedCollection<Club> = await  self.secondStoreCenter.mainStore.asyncLoadingSynchronizedCollection()
-        clubCollectionB.clear()
+        clubCollectionB.reset()
 
         // cleanup sync residues
         let _ = try await self.secondStoreCenter.testSynchronizeOnceAsync()
@@ -185,7 +185,7 @@ struct SynchronizationTests {
         let teamRegColA: SyncedCollection<TeamRegistration> = await StoreCenter.main.mainStore.asyncLoadingSynchronizedCollection()
         try await teamRegColA.deleteAsync(contentOfs: Array(teamRegColA))
         let teamRegColB: SyncedCollection<TeamRegistration> = await  self.secondStoreCenter.mainStore.asyncLoadingSynchronizedCollection()
-        teamRegColB.clear()
+        teamRegColB.reset()
         
         // cleanup sync residues
         let _ = try await self.secondStoreCenter.testSynchronizeOnceAsync()
@@ -213,7 +213,7 @@ struct SynchronizationTests {
         
         try await eventCollectionA.deleteAsync(contentOfs: Array(eventCollectionA))
         let eventCollectionB: SyncedCollection<Event> = await  self.secondStoreCenter.mainStore.asyncLoadingSynchronizedCollection()
-        eventCollectionB.clear()
+        eventCollectionB.reset()
         
         // cleanup sync residues
         let _ = try await self.secondStoreCenter.testSynchronizeOnceAsync()