Resend records that were sent but never saved when signing in

Signing in clears CKSyncEngine's pending changes, so `.signIn` re-enqueues
the records CloudKit does not know about: `enqueueUnknownRecordsForCloudKit`
touches every row without a last known server record. A record that was sent
but never saved has one, though, because a record is stored as its own last
known server record when it is built for sending. With pointfreeco#548 a save rejected
with `quotaExceeded` is retried, but if the user signs out of iCloud, keeps
their local data and signs back in, the retry is dropped with the other
pending changes, and the record is never uploaded unless it is edited again.

Also enqueue live rows whose last known server record has not been saved to
the server. Their archives are decoded from a metadatabase cursor before the
write, and the updates are batched to stay under SQLite's bound parameter
limit. Covered by `saveWhileQuotaExceededThenSignOutAndIn`, which fails
without this change.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: binaryunary

Sources/SQLiteData/CloudKit/SyncEngine.swift

@@ -664,13 +664,48 @@
     }
 
     private func enqueueUnknownRecordsForCloudKit() async throws {
+      let unsavedRecordIDs = try await unsavedRecordIDs()
       try await userDatabase.write { db in
         try $_isSynchronizingChanges.withValue(false) {
           try SyncMetadata
             .where { !$0.hasLastKnownServerRecord }
             .update { $0.recordPrimaryKey = $0.recordPrimaryKey }
             .execute(db)
+          // NB: Batched to stay well under SQLite's bound parameter limit.
+          for start in stride(from: 0, to: unsavedRecordIDs.count, by: 500) {
+            try SyncMetadata
+              .findAll(unsavedRecordIDs[start..<min(start + 500, unsavedRecordIDs.count)])
+              .update { $0.recordPrimaryKey = $0.recordPrimaryKey }
+              .execute(db)
+          }
+        }
+      }
+    }
+
+    /// Records that were sent to CloudKit but never saved there, for example because the user's
+    /// iCloud storage was full.
+    ///
+    /// A record is stored as its own last known server record when it is built for sending, so
+    /// unlike a record that was never sent it is not caught by `!hasLastKnownServerRecord`. Signing
+    /// in clears the sync engine's pending changes, so these records must be enqueued again.
+    private func unsavedRecordIDs() async throws -> [CKRecord.ID] {
+      try await metadatabase.read { db in
+        var recordIDs: [CKRecord.ID] = []
+        let rows = try SyncMetadata
+          .where { $0.hasLastKnownServerRecord && !$0._isDeleted }
+          .select { ($0.recordName, $0.zoneName, $0.ownerName, $0.lastKnownServerRecord) }
+          .fetchCursor(db)
+        while let (recordName, zoneName, ownerName, lastKnownServerRecord) = try rows.next() {
+          guard lastKnownServerRecord?.hasBeenSavedToServer != true
+          else { continue }
+          recordIDs.append(
+            CKRecord.ID(
+              recordName: recordName,
+              zoneID: CKRecordZone.ID(zoneName: zoneName, ownerName: ownerName)
+            )
+          )
         }
+        return recordIDs
       }
     }
 

Tests/SQLiteDataTests/CloudKitTests/QuotaExceededTests.swift

@@ -6,6 +6,7 @@
   import SQLiteData
   import SQLiteDataTestSupport
   import SnapshotTestingCustomDump
+  import TestLocals
   import Testing
 
   extension BaseCloudKitTests {
@@ -69,6 +70,71 @@
           """
         }
       }
+
+      // * Local client saves records while the user's iCloud storage is full.
+      // * User signs out of iCloud, keeps local data, and signs back in.
+      // * User frees up iCloud storage.
+      // => Records are uploaded.
+      @available(iOS 17, macOS 14, tvOS 17, watchOS 10, *)
+      @Test(.taskLocal($syncEngineDelegate, MyDelegate()))
+      func saveWhileQuotaExceededThenSignOutAndIn() async throws {
+        setQuotaExceeded(true)
+        try await userDatabase.userWrite { db in
+          try db.seed {
+            RemindersList(id: 1, title: "Personal")
+            Reminder(id: 1, title: "Get milk", remindersListID: 1)
+          }
+        }
+        try await syncEngine.processPendingRecordZoneChanges(scope: .private)
+
+        await signOut()
+        await signIn()
+        try await syncEngine.processPendingDatabaseChanges(scope: .private)
+
+        #expect(
+          Set(syncEngine.private.state.pendingRecordZoneChanges) == [
+            .saveRecord(RemindersList.recordID(for: 1)),
+            .saveRecord(Reminder.recordID(for: 1)),
+          ]
+        )
+
+        setQuotaExceeded(false)
+        try await syncEngine.processPendingRecordZoneChanges(scope: .private)
+
+        assertInlineSnapshot(of: container, as: .customDump) {
+          """
+          MockCloudContainer(
+            privateCloudDatabase: MockCloudDatabase(
+              databaseScope: .private,
+              storage: [
+                [0]: CKRecord(
+                  recordID: CKRecord.ID(1:reminders/zone/__defaultOwner__),
+                  recordType: "reminders",
+                  parent: CKReference(recordID: CKRecord.ID(1:remindersLists/zone/__defaultOwner__)),
+                  share: nil,
+                  id: 1,
+                  isCompleted: 0,
+                  remindersListID: 1,
+                  title: "Get milk"
+                ),
+                [1]: CKRecord(
+                  recordID: CKRecord.ID(1:remindersLists/zone/__defaultOwner__),
+                  recordType: "remindersLists",
+                  parent: nil,
+                  share: nil,
+                  id: 1,
+                  title: "Personal"
+                )
+              ]
+            ),
+            sharedCloudDatabase: MockCloudDatabase(
+              databaseScope: .shared,
+              storage: []
+            )
+          )
+          """
+        }
+      }
     }
   }
 #endif