Merge branch 'main' into improved-mock-cloud-database

Author: stephencelis

Examples/Reminders/Schema.swift

@@ -229,6 +229,30 @@ func appDatabase() throws -> any DatabaseWriter {
     .execute(db)
   }
 
+  migrator.registerMigration("Create foreign key indexes") { db in
+    try #sql(
+      """
+      CREATE INDEX IF NOT EXISTS "idx_reminders_remindersListID"
+      ON "reminders"("remindersListID")
+      """
+    )
+    .execute(db)
+    try #sql(
+      """
+      CREATE INDEX IF NOT EXISTS "idx_remindersTags_reminderID"
+      ON "remindersTags"("reminderID")
+      """
+    )
+    .execute(db)
+    try #sql(
+      """
+      CREATE INDEX IF NOT EXISTS "idx_remindersTags_tagID"
+      ON "remindersTags"("tagID")
+      """
+    )
+    .execute(db)
+  }
+  
   try migrator.migrate(database)
 
   try database.write { db in
@@ -515,3 +539,4 @@ nonisolated private let logger = Logger(subsystem: "Reminders", category: "Datab
     }
   }
 #endif
+

Examples/SyncUps/Schema.swift

@@ -123,6 +123,22 @@ extension DependencyValues {
       )
       .execute(db)
     }
+    migrator.registerMigration("Create foreign key indexes") { db in
+      try #sql(
+        """
+        CREATE INDEX IF NOT EXISTS "idx_attendees_syncUpID"
+        ON "attendees"("syncUpID")
+        """
+      )
+      .execute(db)
+      try #sql(
+        """
+        CREATE INDEX IF NOT EXISTS "idx_meetings_syncUpID"
+        ON "meetings"("syncUpID")
+        """
+      )
+      .execute(db)
+    }
     try migrator.migrate(database)
     defaultDatabase = database
     defaultSyncEngine = try SyncEngine(

Sources/SQLiteData/CloudKit/SyncEngine.swift

@@ -1227,7 +1227,7 @@
                               recordName: metadata.recordName,
                               lastKnownServerRecord: metadata.lastKnownServerRecord,
                               rootRecordName: tree.rootRecordName,
-                              rootLastKnownServerRecord: tree.lastKnownServerRecord
+                              rootLastKnownServerRecord: tree.rootLastKnownServerRecord
                             )
                           }
                       )

Sources/SQLiteData/Documentation.docc/Articles/CloudKitSharing.md

@@ -401,7 +401,7 @@ let share = try await database.read { db in
 }
 guard
   share?.currentUserParticipant?.permission == .readWrite
-    || share?.permission == .readWrite
+    || share?.publicPermission == .readWrite
 else {
   // User does not have permissions to write to record.
   return

Tests/SQLiteDataTests/CloudKitTests/SharingTests.swift

@@ -1369,6 +1369,114 @@
         }
       }
 
+      /// Deleting a root shared record that is not owned by current user should only delete
+      /// the CKShare but not the actual records, including associated records.
+      @available(iOS 17, macOS 14, tvOS 17, watchOS 10, *)
+      @Test func deleteRootSharedRecord_CurrentUserNotOwner_DoNotCascade() async throws {
+        let externalZone = CKRecordZone(
+          zoneID: CKRecordZone.ID(
+            zoneName: "external.zone",
+            ownerName: "external.owner"
+          )
+        )
+        try await syncEngine.modifyRecordZones(scope: .shared, saving: [externalZone]).notify()
+
+        let modelARecord = CKRecord(
+          recordType: ModelA.tableName,
+          recordID: ModelA.recordID(for: 1, zoneID: externalZone.zoneID)
+        )
+        modelARecord.setValue(42, forKey: "count", at: now)
+
+        let share = CKShare(
+          rootRecord: modelARecord,
+          shareID: CKRecord.ID(
+            recordName: "share-\(modelARecord.recordID.recordName)",
+            zoneID: modelARecord.recordID.zoneID
+          )
+        )
+
+        try await syncEngine
+          .acceptShare(
+            metadata: ShareMetadata(
+              containerIdentifier: container.containerIdentifier!,
+              hierarchicalRootRecordID: modelARecord.recordID,
+              rootRecord: modelARecord,
+              share: share
+            )
+          )
+
+        try await userDatabase.userWrite { db in
+          try db.seed {
+            ModelB(id: 1, isOn: true, modelAID: 1)
+            ModelC(id: 1, title: "Hello world!", modelBID: 1)
+          }
+        }
+
+        try await syncEngine.processPendingRecordZoneChanges(scope: .shared)
+
+        try await userDatabase.userWrite { db in
+          try ModelA.find(1).delete().execute(db)
+        }
+
+        try await syncEngine.processPendingRecordZoneChanges(scope: .shared)
+
+        assertQuery(Reminder.all, database: userDatabase.database) {
+          """
+          (No results)
+          """
+        }
+        assertQuery(RemindersList.all, database: userDatabase.database) {
+          """
+          (No results)
+          """
+        }
+        assertQuery(SyncMetadata.all, database: syncEngine.metadatabase) {
+          """
+          (No results)
+          """
+        }
+        assertInlineSnapshot(of: container, as: .customDump) {
+          """
+          MockCloudContainer(
+            privateCloudDatabase: MockCloudDatabase(
+              databaseScope: .private,
+              storage: []
+            ),
+            sharedCloudDatabase: MockCloudDatabase(
+              databaseScope: .shared,
+              storage: [
+                [0]: CKRecord(
+                  recordID: CKRecord.ID(1:modelAs/external.zone/external.owner),
+                  recordType: "modelAs",
+                  parent: nil,
+                  share: CKReference(recordID: CKRecord.ID(share-1:modelAs/external.zone/external.owner)),
+                  count: 42
+                ),
+                [1]: CKRecord(
+                  recordID: CKRecord.ID(1:modelBs/external.zone/external.owner),
+                  recordType: "modelBs",
+                  parent: CKReference(recordID: CKRecord.ID(1:modelAs/external.zone/external.owner)),
+                  share: nil,
+                  id: 1,
+                  isOn: 1,
+                  modelAID: 1
+                ),
+                [2]: CKRecord(
+                  recordID: CKRecord.ID(1:modelCs/external.zone/external.owner),
+                  recordType: "modelCs",
+                  parent: CKReference(recordID: CKRecord.ID(1:modelBs/external.zone/external.owner)),
+                  share: nil,
+                  id: 1,
+                  modelBID: 1,
+                  title: "Hello world!"
+                )
+              ]
+            )
+          )
+          """
+        }
+      }
+
       /// Syncing deletion of a root shared record that is not owned by current user should delete
       /// entire zone.
       @available(iOS 17, macOS 14, tvOS 17, watchOS 10, *)