Sync form factor specific favorites

Core/BookmarksCachingSearch.swift

@@ -70,8 +70,8 @@ public class CoreDataBookmarksSearchStore: BookmarksSearchStore {
         fetchRequest.resultType = .dictionaryResultType
         fetchRequest.propertiesToFetch = [#keyPath(BookmarkEntity.title),
                                           #keyPath(BookmarkEntity.url),
-                                          #keyPath(BookmarkEntity.favoriteFolder),
                                           #keyPath(BookmarkEntity.objectID)]
+        fetchRequest.relationshipKeyPathsForPrefetching = [#keyPath(BookmarkEntity.favoriteFolders)]
 
         context.perform {
             let result = try? context.fetch(fetchRequest) as? [Dictionary<String, Any>]
@@ -131,7 +131,7 @@ public class BookmarksCachingSearch: BookmarksStringSearch {
             self.init(objectID: objectID,
                       title: title,
                       url: url,
-                      isFavorite: bookmark[#keyPath(BookmarkEntity.favoriteFolder)] != nil)
+                      isFavorite: (bookmark[#keyPath(BookmarkEntity.favoriteFolders)] as? Set<NSManagedObject>)?.isEmpty != true)
         }
 
         public func togglingFavorite() -> BookmarksStringSearchResult {

Core/BookmarksExporter.swift

@@ -29,9 +29,11 @@ public enum BookmarksExporterError: Error {
 public struct BookmarksExporter {
 
     private(set) var coreDataStorage: CoreDataDatabase
+    private let favoritesDisplayMode: FavoritesDisplayMode
 
-    public init(coreDataStore: CoreDataDatabase) {
+    public init(coreDataStore: CoreDataDatabase, favoritesDisplayMode: FavoritesDisplayMode) {
         coreDataStorage = coreDataStore
+        self.favoritesDisplayMode = favoritesDisplayMode
     }
 
     public func exportBookmarksTo(url: URL) throws {
@@ -64,7 +66,7 @@ public struct BookmarksExporter {
                 content.append(Template.bookmark(level: level,
                                                  title: entity.title!.escapedForHTML,
                                                  url: entity.url!,
-                                                 isFavorite: entity.isFavorite))
+                                                 isFavorite: entity.isFavorite(on: favoritesDisplayMode.displayedFolder)))
             }
         }
         return content

Core/BookmarksImporter.swift

@@ -42,8 +42,8 @@ final public class BookmarksImporter {
     private(set) var importedBookmarks: [BookmarkOrFolder] = []
     private(set) var coreDataStorage: BookmarkCoreDataImporter
 
-    public init(coreDataStore: CoreDataDatabase) {
-        coreDataStorage = BookmarkCoreDataImporter(database: coreDataStore)
+    public init(coreDataStore: CoreDataDatabase, favoritesDisplayMode: FavoritesDisplayMode) {
+        coreDataStorage = BookmarkCoreDataImporter(database: coreDataStore, favoritesDisplayMode: favoritesDisplayMode)
     }
 
     func isDocumentInSafariFormat(_ document: Document) -> Bool {

Core/BookmarksModelsErrorHandling.swift

@@ -82,18 +82,22 @@ public extension BookmarkEditorViewModel {
 
     convenience init(editingEntityID: NSManagedObjectID,
                      bookmarksDatabase: CoreDataDatabase,
+                     favoritesDisplayMode: FavoritesDisplayMode,
                      syncService: DDGSyncing?) {
         self.init(editingEntityID: editingEntityID,
                   bookmarksDatabase: bookmarksDatabase,
+                  favoritesDisplayMode: favoritesDisplayMode,
                   errorEvents: BookmarksModelsErrorHandling(syncService: syncService))
 
     }
 
     convenience init(creatingFolderWithParentID parentFolderID: NSManagedObjectID?,
                      bookmarksDatabase: CoreDataDatabase,
+                     favoritesDisplayMode: FavoritesDisplayMode,
                      syncService: DDGSyncing?) {
         self.init(creatingFolderWithParentID: parentFolderID,
                   bookmarksDatabase: bookmarksDatabase,
+                  favoritesDisplayMode: favoritesDisplayMode,
                   errorEvents: BookmarksModelsErrorHandling(syncService: syncService))
     }
 }
@@ -102,25 +106,25 @@ public extension BookmarkListViewModel {
 
     convenience init(bookmarksDatabase: CoreDataDatabase,
                      parentID: NSManagedObjectID?,
+                     favoritesDisplayMode: FavoritesDisplayMode,
                      syncService: DDGSyncing?) {
         self.init(bookmarksDatabase: bookmarksDatabase,
                   parentID: parentID,
+                  favoritesDisplayMode: favoritesDisplayMode,
                   errorEvents: BookmarksModelsErrorHandling(syncService: syncService))
     }
 }
 
 public extension FavoritesListViewModel {
 
-    convenience init(bookmarksDatabase: CoreDataDatabase) {
-        self.init(bookmarksDatabase: bookmarksDatabase,
-                  errorEvents: BookmarksModelsErrorHandling())
+    convenience init(bookmarksDatabase: CoreDataDatabase, favoritesDisplayMode: FavoritesDisplayMode) {
+        self.init(bookmarksDatabase: bookmarksDatabase, errorEvents: BookmarksModelsErrorHandling(), favoritesDisplayMode: favoritesDisplayMode)
     }
 }
 
 public extension MenuBookmarksViewModel {
 
     convenience init(bookmarksDatabase: CoreDataDatabase, syncService: DDGSyncing?) {
-        self.init(bookmarksDatabase: bookmarksDatabase,
-                  errorEvents: BookmarksModelsErrorHandling(syncService: syncService))
+        self.init(bookmarksDatabase: bookmarksDatabase, errorEvents: BookmarksModelsErrorHandling(syncService: syncService))
     }
 }

Core/LegacyBookmarksStoreMigration.swift

@@ -39,7 +39,7 @@ public class LegacyBookmarksStoreMigration {
             }
         } else {
             // Initialize structure if needed
-            BookmarkUtils.prepareFoldersStructure(in: context)
+            BookmarkUtils.prepareLegacyFoldersStructure(in: context)
             if context.hasChanges {
                 do {
                     try context.save(onErrorFire: .bookmarksCouldNotPrepareDatabase)
@@ -82,7 +82,8 @@ public class LegacyBookmarksStoreMigration {
         BookmarkUtils.prepareFoldersStructure(in: destination)
 
         guard let newRoot = BookmarkUtils.fetchRootFolder(destination),
-              let newFavoritesRoot = BookmarkUtils.fetchFavoritesFolder(destination) else {
+              let newFavoritesRoot = BookmarkUtils.fetchFavoritesFolder(withUUID: FavoritesFolderID.unified.rawValue, in: destination),
+              let newMobileFavoritesRoot = BookmarkUtils.fetchFavoritesFolder(withUUID: FavoritesFolderID.mobile.rawValue, in: destination) else {
             Pixel.fire(pixel: .bookmarksMigrationCouldNotPrepareDatabase)
             Thread.sleep(forTimeInterval: 2)
             fatalError("Could not write to Bookmarks DB")
@@ -169,14 +170,16 @@ public class LegacyBookmarksStoreMigration {
             }()
             bookmark.addToFavorites(insertAt: 0,
                                     favoritesRoot: newFavoritesRoot)
+            bookmark.addToFavorites(insertAt: 0,
+                                    favoritesRoot: newMobileFavoritesRoot)
         }
 
         do {
             try destination.save(onErrorFire: .bookmarksMigrationFailed)
         } catch {
             destination.reset()
 
-            BookmarkUtils.prepareFoldersStructure(in: destination)
+            BookmarkUtils.prepareLegacyFoldersStructure(in: destination)
             do {
                 try destination.save(onErrorFire: .bookmarksMigrationCouldNotPrepareDatabaseOnFailedMigration)
             } catch {

Core/PixelEvent.swift

@@ -473,10 +473,15 @@ extension Pixel {
         case bookmarksMigrationCouldNotPrepareDatabaseOnFailedMigration
         case bookmarksMigrationCouldNotValidateDatabase
         case bookmarksMigrationCouldNotRemoveOldStore
+        case bookmarksMigrationCouldNotPrepareMultipleFavoriteFolders
 
         case syncFailedToMigrate
         case syncFailedToLoadAccount
         case syncFailedToSetupEngine
+        case syncBookmarksCountLimitExceededDaily
+        case syncCredentialsCountLimitExceededDaily
+        case syncBookmarksRequestSizeLimitExceededDaily
+        case syncCredentialsRequestSizeLimitExceededDaily
 
         case syncSentUnauthenticatedRequest
         case syncMetadataCouldNotLoadDatabase
@@ -489,6 +494,7 @@ extension Pixel {
 
         case bookmarksCleanupFailed
         case bookmarksCleanupAttemptedWhileSyncWasEnabled
+        case favoritesCleanupFailed
 
         case credentialsDatabaseCleanupFailed
         case credentialsCleanupAttemptedWhileSyncWasEnabled
@@ -951,10 +957,15 @@ extension Pixel.Event {
             return "m_d_bookmarks_migration_could_not_prepare_database_on_failed_migration"
         case .bookmarksMigrationCouldNotValidateDatabase: return "m_d_bookmarks_migration_could_not_validate_database"
         case .bookmarksMigrationCouldNotRemoveOldStore: return "m_d_bookmarks_migration_could_not_remove_old_store"
+        case .bookmarksMigrationCouldNotPrepareMultipleFavoriteFolders: return "m_d_bookmarks_migration_could_not_prepare_multiple_favorite_folders"
 
         case .syncFailedToMigrate: return "m_d_sync_failed_to_migrate"
         case .syncFailedToLoadAccount: return "m_d_sync_failed_to_load_account"
         case .syncFailedToSetupEngine: return "m_d_sync_failed_to_setup_engine"
+        case .syncBookmarksCountLimitExceededDaily: return "m_d_sync_bookmarks_count_limit_exceeded_daily"
+        case .syncCredentialsCountLimitExceededDaily: return "m_d_sync_credentials_count_limit_exceeded_daily"
+        case .syncBookmarksRequestSizeLimitExceededDaily: return "m_d_sync_bookmarks_request_size_limit_exceeded_daily"
+        case .syncCredentialsRequestSizeLimitExceededDaily: return "m_d_sync_credentials_request_size_limit_exceeded_daily"
 
         case .syncSentUnauthenticatedRequest: return "m_d_sync_sent_unauthenticated_request"
         case .syncMetadataCouldNotLoadDatabase: return "m_d_sync_metadata_could_not_load_database"
@@ -968,6 +979,7 @@ extension Pixel.Event {
 
         case .bookmarksCleanupFailed: return "m_d_bookmarks_cleanup_failed"
         case .bookmarksCleanupAttemptedWhileSyncWasEnabled: return "m_d_bookmarks_cleanup_attempted_while_sync_was_enabled"
+        case .favoritesCleanupFailed: return "m_d_favorites_cleanup_failed"
 
         case .credentialsDatabaseCleanupFailed: return "m_d_credentials_database_cleanup_failed_2"
         case .credentialsCleanupAttemptedWhileSyncWasEnabled: return "m_d_credentials_cleanup_attempted_while_sync_was_enabled"

Core/SyncBookmarksAdapter.swift

@@ -26,14 +26,38 @@ import Persistence
 import SyncDataProviders
 import WidgetKit
 
+public protocol FavoritesDisplayModeStoring: AnyObject {
+    var favoritesDisplayMode: FavoritesDisplayMode { get set }
+}
+
 public final class SyncBookmarksAdapter {
 
     public private(set) var provider: BookmarksProvider?
     public let databaseCleaner: BookmarkDatabaseCleaner
     public let syncDidCompletePublisher: AnyPublisher<Void, Never>
     public let widgetRefreshCancellable: AnyCancellable
+    public static let syncBookmarksPausedStateChanged = Notification.Name("com.duckduckgo.app.SyncPausedStateChanged")
+    public static let bookmarksSyncLimitReached = Notification.Name("com.duckduckgo.app.SyncBookmarksLimitReached")
+
+    public var shouldResetBookmarksSyncTimestamp: Bool = false {
+        willSet {
+            assert(provider == nil, "Setting this value has no effect after provider has been instantiated")
+        }
+    }
 
-    public init(database: CoreDataDatabase) {
+    @UserDefaultsWrapper(key: .syncBookmarksPaused, defaultValue: false)
+    static public var isSyncBookmarksPaused: Bool {
+        didSet {
+            NotificationCenter.default.post(name: syncBookmarksPausedStateChanged, object: nil)
+        }
+    }
+
+    @UserDefaultsWrapper(key: .syncBookmarksPausedErrorDisplayed, defaultValue: false)
+    static private var didShowBookmarksSyncPausedError: Bool
+
+    public init(database: CoreDataDatabase, favoritesDisplayModeStorage: FavoritesDisplayModeStoring) {
+        self.database = database
+        self.favoritesDisplayModeStorage = favoritesDisplayModeStorage
         syncDidCompletePublisher = syncDidCompleteSubject.eraseToAnyPublisher()
         databaseCleaner = BookmarkDatabaseCleaner(
             bookmarkDatabase: database,
@@ -49,6 +73,7 @@ public final class SyncBookmarksAdapter {
         databaseCleaner.cleanUpDatabaseNow()
         if shouldEnable {
             databaseCleaner.scheduleRegularCleaning()
+            handleFavoritesAfterDisablingSync()
         } else {
             databaseCleaner.cancelCleaningSchedule()
         }
@@ -64,14 +89,33 @@ public final class SyncBookmarksAdapter {
             metadataStore: metadataStore,
             syncDidUpdateData: { [syncDidCompleteSubject] in
                 syncDidCompleteSubject.send()
+                Self.isSyncBookmarksPaused = false
+                Self.didShowBookmarksSyncPausedError = false
             }
         )
+        if shouldResetBookmarksSyncTimestamp {
+            provider.lastSyncTimestamp = nil
+        }
 
         syncErrorCancellable = provider.syncErrorPublisher
             .sink { error in
                 switch error {
                 case let syncError as SyncError:
                     Pixel.fire(pixel: .syncBookmarksFailed, error: syncError)
+                    switch syncError {
+                    case .unexpectedStatusCode(409):
+                        // If bookmarks count limit has been exceeded
+                        Self.isSyncBookmarksPaused = true
+                        DailyPixel.fire(pixel: .syncBookmarksCountLimitExceededDaily)
+                        Self.notifyBookmarksSyncLimitReached()
+                    case .unexpectedStatusCode(413):
+                        // If bookmarks request size limit has been exceeded
+                        Self.isSyncBookmarksPaused = true
+                        DailyPixel.fire(pixel: .syncBookmarksRequestSizeLimitExceededDaily)
+                        Self.notifyBookmarksSyncLimitReached()
+                    default:
+                        break
+                    }
                 default:
                     let nsError = error as NSError
                     if nsError.domain != NSURLErrorDomain {
@@ -86,6 +130,36 @@ public final class SyncBookmarksAdapter {
         self.provider = provider
     }
 
+    static private func notifyBookmarksSyncLimitReached() {
+        if !Self.didShowBookmarksSyncPausedError {
+            NotificationCenter.default.post(name: Self.bookmarksSyncLimitReached, object: nil)
+            Self.didShowBookmarksSyncPausedError = true
+        }
+    }
+
+    private func handleFavoritesAfterDisablingSync() {
+        let context = database.makeContext(concurrencyType: .privateQueueConcurrencyType)
+
+        context.performAndWait {
+            do {
+                if favoritesDisplayModeStorage.favoritesDisplayMode.isDisplayUnified {
+                    BookmarkUtils.copyFavorites(from: .unified, to: .mobile, clearingNonNativeFavoritesFolder: .desktop, in: context)
+                    favoritesDisplayModeStorage.favoritesDisplayMode = .displayNative(.mobile)
+                } else {
+                    BookmarkUtils.copyFavorites(from: .mobile, to: .unified, clearingNonNativeFavoritesFolder: .desktop, in: context)
+                }
+                try context.save()
+            } catch {
+                let nsError = error as NSError
+                let processedErrors = CoreDataErrorsParser.parse(error: nsError)
+                let params = processedErrors.errorPixelParameters
+                Pixel.fire(pixel: .favoritesCleanupFailed, error: error, withAdditionalParameters: params)
+            }
+        }
+    }
+
     private var syncDidCompleteSubject = PassthroughSubject<Void, Never>()
     private var syncErrorCancellable: AnyCancellable?
+    private let database: CoreDataDatabase
+    private let favoritesDisplayModeStorage: FavoritesDisplayModeStoring
 }

Core/SyncCredentialsAdapter.swift

@@ -30,6 +30,17 @@ public final class SyncCredentialsAdapter {
     public private(set) var provider: CredentialsProvider?
     public let databaseCleaner: CredentialsDatabaseCleaner
     public let syncDidCompletePublisher: AnyPublisher<Void, Never>
+    public static let syncCredentialsPausedStateChanged = SyncBookmarksAdapter.syncBookmarksPausedStateChanged
+    public static let credentialsSyncLimitReached = Notification.Name("com.duckduckgo.app.SyncCredentialsLimitReached")
+
+    @UserDefaultsWrapper(key: .syncCredentialsPaused, defaultValue: false)
+    static public var isSyncCredentialsPaused: Bool {
+        didSet {
+            NotificationCenter.default.post(name: syncCredentialsPausedStateChanged, object: nil)
+        }
+    }
+    @UserDefaultsWrapper(key: .syncCredentialsPausedErrorDisplayed, defaultValue: false)
+    static private var didShowCredentialsSyncPausedError: Bool
 
     public init(secureVaultFactory: AutofillVaultFactory = AutofillSecureVaultFactory, secureVaultErrorReporter: SecureVaultErrorReporting) {
         syncDidCompletePublisher = syncDidCompleteSubject.eraseToAnyPublisher()
@@ -63,6 +74,8 @@ public final class SyncCredentialsAdapter {
                 metadataStore: metadataStore,
                 syncDidUpdateData: { [weak self] in
                     self?.syncDidCompleteSubject.send()
+                    Self.isSyncCredentialsPaused = false
+                    Self.didShowCredentialsSyncPausedError = false
                 }
             )
 
@@ -71,6 +84,21 @@ public final class SyncCredentialsAdapter {
                     switch error {
                     case let syncError as SyncError:
                         Pixel.fire(pixel: .syncCredentialsFailed, error: syncError)
+
+                        switch syncError {
+                        case .unexpectedStatusCode(409):
+                            // If credentials count limit has been exceeded
+                            Self.isSyncCredentialsPaused = true
+                            DailyPixel.fire(pixel: .syncCredentialsCountLimitExceededDaily)
+                            Self.notifyCredentialsSyncLimitReached()
+                        case .unexpectedStatusCode(413):
+                            // If credentials request size limit has been exceeded
+                            Self.isSyncCredentialsPaused = true
+                            DailyPixel.fire(pixel: .syncCredentialsRequestSizeLimitExceededDaily)
+                            Self.notifyCredentialsSyncLimitReached()
+                        default:
+                            break
+                        }
                     default:
                         let nsError = error as NSError
                         if nsError.domain != NSURLErrorDomain {
@@ -91,6 +119,13 @@ public final class SyncCredentialsAdapter {
        }
     }
 
+    static private func notifyCredentialsSyncLimitReached() {
+        if !Self.didShowCredentialsSyncPausedError {
+            NotificationCenter.default.post(name: Self.credentialsSyncLimitReached, object: nil)
+            Self.didShowCredentialsSyncPausedError = true
+        }
+    }
+
     private var syncDidCompleteSubject = PassthroughSubject<Void, Never>()
     private var syncErrorCancellable: AnyCancellable?
     private let secureVaultErrorReporter: SecureVaultErrorReporting