Merge pull request #10063 from nextcloud/i2h3/10054-inheritance

New remote items inherit content policy

Author: i2h3

shell_integration/MacOSX/NextcloudFileProviderKit/Sources/NextcloudFileProviderKit/Database/FilesDatabaseManager.swift

@@ -212,6 +212,36 @@ public final class FilesDatabaseManager: Sendable {
             .toUnmanagedResults()
     }
 
+    ///
+    /// Resolve the parent's "Always keep downloaded" flag for a metadata
+    /// that is about to be persisted as a fresh row.
+    ///
+    /// Mirrors the inheritance applied to locally-created items in
+    /// `Item+Create.swift` so a sibling appearing via remote enumeration
+    /// acquires the same `contentPolicy` and Finder overlay without the user
+    /// having to re-toggle the parent (#10054).
+    ///
+    /// Checking only the immediate parent is sufficient: the recursive
+    /// enable in `Item.set(keepDownloaded:domain:)` sets the flag on every
+    /// then-known descendant of the pinned ancestor, so every intermediate
+    /// directory between the pin root and this new item is itself pinned.
+    ///
+    /// Falls back to the root container when no parent row exists at the
+    /// item's `serverUrl` — items directly under the user's home are stored
+    /// against a synthesised root keyed by ocId, not by serverUrl/fileName.
+    ///
+    func inheritedKeepDownloaded(for metadata: SendableItemMetadata) -> Bool {
+        if let parent = parentDirectoryMetadataForItem(metadata) {
+            return parent.keepDownloaded
+        }
+
+        if let root = itemMetadata(ocId: NSFileProviderItemIdentifier.rootContainer.rawValue) {
+            return root.keepDownloaded
+        }
+
+        return false
+    }
+
     private func processItemMetadatasToDelete(
         existingMetadatas: Results<RealmItemMetadata>,
         updatedMetadatas: [SendableItemMetadata]
@@ -272,6 +302,9 @@ public final class FilesDatabaseManager: Sendable {
                 }
 
             } else { // This is a new metadata
+                // Inherit the parent's "Always keep downloaded" flag so a file surfacing here via remote enumeration acquires the same pin as its already-pinned siblings (#10054).
+                updatedMetadata.keepDownloaded = inheritedKeepDownloaded(for: updatedMetadata)
+
                 returningNewMetadatas.append(updatedMetadata)
 
                 logger.debug("Created new item metadata during update.", [.item: updatedMetadata.ocId])
@@ -374,6 +407,8 @@ public final class FilesDatabaseManager: Sendable {
                     }
                 } else {
                     logger.info("Depth 1 read target is new: \(readTargetMetadata.ocId)")
+                    // Inherit from the parent so a directory appearing here via remote enumeration (e.g. created on the server while the user already pinned its parent) picks up the same pin as siblings (#10054).
+                    readTargetMetadata.keepDownloaded = inheritedKeepDownloaded(for: readTargetMetadata)
                     metadatasToCreate.insert(readTargetMetadata, at: 0)
                 }
             }
@@ -522,6 +557,7 @@ public final class FilesDatabaseManager: Sendable {
                     && !$0.deleted
                     && !$0.isLockFileOfLocalOrigin
             }
+
             if logicalCandidates.count == 1, let existing = logicalCandidates.first {
                 toWrite.downloaded = existing.downloaded
                 toWrite.keepDownloaded = existing.keepDownloaded
@@ -531,6 +567,13 @@ public final class FilesDatabaseManager: Sendable {
                 }
 
                 toWrite.lockToken = existing.lockToken
+            } else {
+                // No prior row at this ocId or logical address: this is a
+                // genuinely new item. Inherit the parent's "Always keep
+                // downloaded" flag so a file surfacing here via remote
+                // enumeration acquires the same pin as its already-pinned
+                // siblings (#10054).
+                toWrite.keepDownloaded = inheritedKeepDownloaded(for: metadata)
             }
         }
 

shell_integration/MacOSX/NextcloudFileProviderKit/Sources/NextcloudFileProviderKit/Enumeration/Enumerator+SyncEngine.swift

@@ -212,7 +212,15 @@ extension Enumerator {
                 metadata.lockToken = existing?.lockToken
                 let updatedItems: [SendableItemMetadata] = isNew ? [] : [metadata]
                 metadata.downloaded = existing?.downloaded == true
-                metadata.keepDownloaded = existing?.keepDownloaded == true
+
+                if let existing {
+                    metadata.keepDownloaded = existing.keepDownloaded
+                } else {
+                    // Genuinely new item: inherit the parent's pin so the
+                    // overlay and `contentPolicy` match its siblings (#10054).
+                    metadata.keepDownloaded = dbManager.inheritedKeepDownloaded(for: metadata)
+                }
+
                 dbManager.addItemMetadata(metadata)
                 return ([metadata], newItems, updatedItems, [], nextPage, nil)
             }
@@ -228,7 +236,15 @@ extension Enumerator {
             metadata.lockToken = existing?.lockToken
             metadata.visitedDirectory = existing?.visitedDirectory == true
             metadata.downloaded = existing?.downloaded == true
-            metadata.keepDownloaded = existing?.keepDownloaded == true
+
+            if let existing {
+                metadata.keepDownloaded = existing.keepDownloaded
+            } else {
+                // Genuinely new item: inherit the parent's pin so the
+                // overlay and `contentPolicy` match its siblings (#10054).
+                metadata.keepDownloaded = dbManager.inheritedKeepDownloaded(for: metadata)
+            }
+
             dbManager.addItemMetadata(metadata)
 
             return ([metadata], newMetadatas, updatedMetadatas, [], nextPage, nil)

shell_integration/MacOSX/NextcloudFileProviderKit/Tests/NextcloudFileProviderKitTests/FilesDatabaseManagerTests.swift

@@ -978,13 +978,14 @@ final class FilesDatabaseManagerTests: NextcloudFileProviderKitTestCase {
         XCTAssertTrue(updatedMetadata.downloaded, "downloaded should be retained when keepExistingDownloadState is true")
     }
 
-    func testKeepDownloadedNotSetForNewMetadata() throws {
+    func testKeepDownloadedNotInheritedWhenNoPinnedAncestor() throws {
         let account = Account(user: "test", id: "t", serverUrl: "https://example.com", password: "")
 
-        // Create completely new metadata (not existing in database)
+        // Create completely new metadata (not existing in database) with no
+        // pinned ancestor: neither a parent row nor a pinned root container.
         var newMetadata = SendableItemMetadata(ocId: "new-item", fileName: "new.txt", account: account)
         newMetadata.etag = "initial-etag"
-        newMetadata.keepDownloaded = false // Should remain false for new items
+        newMetadata.keepDownloaded = false
 
         let result = Self.dbManager.depth1ReadUpdateItemMetadatas(
             account: account.ncKitAccount,
@@ -997,11 +998,94 @@ final class FilesDatabaseManagerTests: NextcloudFileProviderKitTestCase {
         XCTAssertEqual(result.updatedMetadatas?.isEmpty, true, "Should not update any metadata")
 
         let createdMetadata = try XCTUnwrap(result.newMetadatas?.first)
-        XCTAssertFalse(createdMetadata.keepDownloaded, "keepDownloaded should remain false for new items")
+        XCTAssertFalse(createdMetadata.keepDownloaded, "keepDownloaded should remain false when no pinned ancestor exists")
 
         // Verify in database
         let dbMetadata = try XCTUnwrap(Self.dbManager.itemMetadata(ocId: "new-item"))
-        XCTAssertFalse(dbMetadata.keepDownloaded, "keepDownloaded should be false in database for new items")
+        XCTAssertFalse(dbMetadata.keepDownloaded, "keepDownloaded should be false in database when no pinned ancestor exists")
+    }
+
+    func testKeepDownloadedInheritedFromPinnedParentForNewMetadata() throws {
+        let account = Account(user: "test", id: "t", serverUrl: "https://example.com", password: "")
+
+        // Parent folder under the user's home, pinned.
+        var parentFolder = SendableItemMetadata(ocId: "pinned-parent", fileName: "pinned", account: account)
+        parentFolder.directory = true
+        parentFolder.uploaded = true
+        parentFolder.keepDownloaded = true
+        parentFolder.etag = "parent-etag"
+
+        Self.dbManager.addItemMetadata(parentFolder)
+
+        // New child appearing remotely inside the pinned folder. Its
+        // `serverUrl` is the parent's full path. `keepDownloaded` starts
+        // `false`, mirroring what `NKFile.toItemMetadata()` produces.
+        let parentRemotePath = account.davFilesUrl + "/pinned"
+        var newChild = SendableItemMetadata(ocId: "fresh-child", fileName: "child.txt", account: account)
+        newChild.serverUrl = parentRemotePath
+        newChild.etag = "child-etag"
+        newChild.keepDownloaded = false
+
+        let result = Self.dbManager.depth1ReadUpdateItemMetadatas(
+            account: account.ncKitAccount,
+            serverUrl: parentRemotePath,
+            updatedMetadatas: [parentFolder, newChild],
+            keepExistingDownloadState: true
+        )
+
+        let createdChild = try XCTUnwrap(result.newMetadatas?.first(where: { $0.ocId == "fresh-child" }))
+        XCTAssertTrue(createdChild.keepDownloaded, "keepDownloaded should be inherited from pinned parent for new items")
+
+        let dbChild = try XCTUnwrap(Self.dbManager.itemMetadata(ocId: "fresh-child"))
+        XCTAssertTrue(dbChild.keepDownloaded, "Inherited keepDownloaded should be persisted to the database")
+    }
+
+    func testAddItemMetadataPreservingLocalState_InheritsPinnedParentForNewItem() throws {
+        let account = Account(user: "test", id: "t", serverUrl: "https://example.com", password: "")
+
+        // Pinned parent folder.
+        var parentFolder = SendableItemMetadata(ocId: "preserving-parent", fileName: "pinned", account: account)
+        parentFolder.directory = true
+        parentFolder.uploaded = true
+        parentFolder.keepDownloaded = true
+
+        Self.dbManager.addItemMetadata(parentFolder)
+
+        // Fresh child inside the pinned folder, exactly as it would arrive
+        // from `NKFile.toItemMetadata()` (keepDownloaded = false).
+        var freshChild = SendableItemMetadata(ocId: "preserving-child", fileName: "child.txt", account: account)
+        freshChild.serverUrl = account.davFilesUrl + "/pinned"
+        freshChild.keepDownloaded = false
+
+        let written = Self.dbManager.addItemMetadataPreservingLocalState(freshChild)
+
+        XCTAssertTrue(written.keepDownloaded, "keepDownloaded should be inherited from pinned parent on first insert")
+
+        let dbChild = try XCTUnwrap(Self.dbManager.itemMetadata(ocId: "preserving-child"))
+        XCTAssertTrue(dbChild.keepDownloaded, "Inherited keepDownloaded should be persisted to the database")
+    }
+
+    func testAddItemMetadataPreservingLocalState_DoesNotInheritFromUnpinnedParent() throws {
+        let account = Account(user: "test", id: "t", serverUrl: "https://example.com", password: "")
+
+        // Unpinned parent folder.
+        var parentFolder = SendableItemMetadata(ocId: "unpinned-parent", fileName: "regular", account: account)
+        parentFolder.directory = true
+        parentFolder.uploaded = true
+        parentFolder.keepDownloaded = false
+
+        Self.dbManager.addItemMetadata(parentFolder)
+
+        var freshChild = SendableItemMetadata(ocId: "unpinned-child", fileName: "child.txt", account: account)
+        freshChild.serverUrl = account.davFilesUrl + "/regular"
+        freshChild.keepDownloaded = false
+
+        let written = Self.dbManager.addItemMetadataPreservingLocalState(freshChild)
+
+        XCTAssertFalse(written.keepDownloaded, "keepDownloaded should remain false when parent is not pinned")
+
+        let dbChild = try XCTUnwrap(Self.dbManager.itemMetadata(ocId: "unpinned-child"))
+        XCTAssertFalse(dbChild.keepDownloaded, "Unpinned parent must not flip the child's keepDownloaded in the database")
     }
 
     func testKeepDownloadedRetainedWithMultipleItems() throws {