feat: share public link - WPB-20915

WireFoundation/Sources/WireFoundationSupport/Sourcery/AutoMockable.manual.swift

@@ -20,6 +20,10 @@ public import WireFoundation
 
 public actor KeychainProtocolMock: KeychainProtocol {
 
+    // MARK: - Init
+
+    public init() {}
+
     // MARK: - addItem
 
     public var addItemQuery_Invocations: [Set<KeychainQueryItem>] = []

WireMessaging/Package.swift

@@ -78,6 +78,7 @@ let package = Package(
                 "WireMessagingUI",
                 "WireMessagingDomainSupport",
                 .product(name: "WireDesign", package: "WireUI"),
+                .product(name: "WireFoundationSupport", package: "WireFoundation"),
                 "WireFoundation"
             ],
             resources: [

WireMessaging/Sources/WireMessagingAssembly/WireMessagingFactory.swift

@@ -17,7 +17,7 @@
 //
 
 public import Foundation
 public import UIKit
 public import SwiftUI
 public import WireData
 public import WireFoundation
@@ -200,7 +200,12 @@
                         getAssetUseCase: WireCellsGetAssetUseCase(
                             localAssetRepository: localAssetRepository,
                             fileCache: fileCache
-                        )
+                        ),
+                        getPublicLinkData: WireCellsGetPublicLinkDataUseCase(nodesAPI: nodesAPI),
+                        createPublicLink: WireCellsCreatePublicLinkUseCase(nodesAPI: nodesAPI),
+                        deletePublicLink: WireCellsDeletePublicLinkUseCase(nodesAPI: nodesAPI),
+                        updatePublicLinkExpiration: WireCellsUpdatePublicLinkExpirationUseCase(nodesAPI: nodesAPI),
+                        updatePublicLinkPassword: WireCellsUpdatePublicLinkPasswordUseCase(nodesAPI: nodesAPI)
                     ),
                     isCellsStatePending: false,
                     localAssetRepository: localAssetRepository,

WireMessaging/Sources/WireMessagingData/WireCells/Model/WireCellsNodeNetworkModel.swift

@@ -39,7 +39,7 @@ package struct WireCellsNodeNetworkModel: Equatable, Hashable, Sendable {
     package let ownerUserId: String?
     package let ownerUserName: String?
     package let conversationId: String?
-    package let publicLinkId: String?
+    package let publicLinkID: String?
     package let downloadURL: URL?
     package let tags: [String]
 
@@ -60,7 +60,7 @@ package struct WireCellsNodeNetworkModel: Equatable, Hashable, Sendable {
         ownerUserId: String? = nil,
         ownerUserName: String?,
         conversationId: String? = nil,
-        publicLinkId: String? = nil,
+        publicLinkID: String? = nil,
         downloadURL: URL? = nil,
         tags: [String] = []
     ) {
@@ -80,7 +80,7 @@ package struct WireCellsNodeNetworkModel: Equatable, Hashable, Sendable {
         self.ownerUserId = ownerUserId
         self.ownerUserName = ownerUserName
         self.conversationId = conversationId
-        self.publicLinkId = publicLinkId
+        self.publicLinkID = publicLinkID
         self.downloadURL = downloadURL
         self.tags = tags
     }
@@ -105,7 +105,7 @@ package extension WireCellsNodeNetworkModel {
             ownerUserID: ownerUserId.flatMap { QualifiedID(string: $0) },
             ownerUserName: ownerUserName,
             conversationID: conversationId.flatMap(QualifiedID.init(string:)),
-            publicLinkID: publicLinkId.map(WireCellsPublicLinkID.init(string:)),
+            publicLinkID: publicLinkID.map(WireCellsPublicLinkID.init(string:)),
             downloadURL: downloadURL,
             tags: tags
         )
@@ -130,7 +130,7 @@ package extension WireCellsNode {
             ownerUserId: ownerUserID?.transportString,
             ownerUserName: ownerUserName,
             conversationId: conversationID?.transportString,
-            publicLinkId: publicLinkID?.string,
+            publicLinkID: publicLinkID?.string,
             tags: tags
         )
     }
@@ -159,7 +159,7 @@ package extension RestNode {
             ownerUserId: metadataString("usermeta-owner-uuid"),
             ownerUserName: metadataString("usermeta-owner"),
             conversationId: contextWorkspace?.uuid,
-            publicLinkId: shares?.first?.uuid,
+            publicLinkID: shares?.first?.uuid,
             downloadURL: preSignedGET?.url.flatMap(URL.init(string:)),
             tags: metadataString("usermeta-tags")?
                 .split(separator: ",").map { String($0) } ?? []

WireMessaging/Sources/WireMessagingData/WireCells/NodesAPI/NodesAPI.swift

@@ -121,7 +121,7 @@
         out: URL,
         cellPath: String,
         onProgressUpdate: @escaping @Sendable (UInt64) -> Void
     ) async throws {
         guard let stream = OutputStream(url: out, append: true) else {
             throw NodesAPIError.failedToCreateWriteStream
         }
@@ -169,16 +169,39 @@
         try await restAPI.getEditorURL(id: id)
     }
 
-    package func createPublicLink(nodeID: UUID, fileName: String) async throws -> WireCellsPublicLink {
-        try await restAPI.createPublicLink(uuid: nodeID, fileName: fileName)
+    package func createPublicLink(nodeID: UUID, label: String) async throws -> WireCellsPublicLink {
+        try await restAPI.createPublicLink(
+            uuid: nodeID,
+            label: label
+        )
+    }
+
+    package func getPublicLink(linkID: String) async throws -> WireCellsPublicLink {
+        try await restAPI.getPublicLink(linkID: linkID)
     }
 
-    package func getPublicLink(linkUUID: UUID) async throws -> URL {
-        try await restAPI.getPublicLink(uuid: linkUUID)
+    package func deletePublicLink(linkID: String) async throws {
+        try await restAPI.deletePublicLink(linkID: linkID)
     }
 
-    package func deletePublicLink(linkUUID: UUID) async throws {
-        try await restAPI.deletePublicLink(uuid: linkUUID)
+    package func updatePublicLinkExpiration(
+        linkID: String,
+        expiration: Date?
+    ) async throws -> WireCellsPublicLink {
+        try await restAPI.updatePublicLinkExpiration(
+            linkID: linkID,
+            expiration: expiration
+        )
+    }
+
+    package func updatePublicLinkPassword(
+        linkID: String,
+        password: String?
+    ) async throws -> WireCellsPublicLink {
+        try await restAPI.updatePublicLinkPassword(
+            linkID: linkID,
+            password: password
+        )
     }
 
     package func updateTags(nodeID: UUID, tags: [String]) async throws {

WireMessaging/Sources/WireMessagingData/WireCells/NodesAPI/RestAPI.swift

@@ -25,6 +25,7 @@ enum WireCellsNodesAPIError: Error {
     case failedToDecodeNode
     case failedToDecodeNodeVersions
     case missingData(String)
+    case invalidParameters(String)
 }
 
 final class RestAPI: Sendable {
@@ -274,28 +275,18 @@ final class RestAPI: Sendable {
         }
     }
 
-    func getPublicLink(uuid: UUID) async throws -> URL {
+    func getPublicLink(linkID: String) async throws -> WireCellsPublicLink {
         let response = try await NodeServiceAPI.getPublicLink(
-            linkUuid: uuid.transportString(),
+            linkUuid: linkID,
             apiConfiguration: makeConfiguration()
         )
 
-        guard let urlString = response.linkUrl else {
-            throw WireCellsNodesAPIError.missingData("Link URL not found")
-        }
-        guard let url = URL(string: urlString) else {
-            throw WireCellsNodesAPIError.missingData("Link URL is invalid")
-        }
-
-        return url
+        return try WireCellsPublicLink(response, serverURL: serverURLResolver())
     }
 
-    func createPublicLink(uuid: UUID, fileName: String) async throws -> WireCellsPublicLink {
+    func createPublicLink(uuid: UUID, label: String) async throws -> WireCellsPublicLink {
         let request = RestPublicLinkRequest(
-            link: RestShareLink(
-                label: fileName,
-                permissions: [.preview, .download]
-            )
+            link: RestShareLink(label: label, permissions: [.preview, .download])
         )
 
         let response = try await NodeServiceAPI.createPublicLink(
@@ -304,28 +295,59 @@ final class RestAPI: Sendable {
             apiConfiguration: makeConfiguration()
         )
 
-        guard let idString = response.uuid else {
-            throw WireCellsNodesAPIError.missingData("UUID is null")
-        }
-        guard let id = UUID(uuidString: idString) else {
-            throw WireCellsNodesAPIError.missingData("UUID is invalid")
-        }
+        return try WireCellsPublicLink(response, serverURL: serverURLResolver())
+    }
 
-        guard let urlString = response.linkUrl else {
-            throw WireCellsNodesAPIError.missingData("Link URL not found")
-        }
-        guard let url = URL(string: urlString) else {
-            throw WireCellsNodesAPIError.missingData("Link URL is invalid")
-        }
+    func deletePublicLink(linkID: String) async throws {
+        _ = try await NodeServiceAPI.deletePublicLink(
+            linkUuid: linkID,
+            apiConfiguration: makeConfiguration()
+        )
+    }
+
+    func updatePublicLinkExpiration(linkID: String, expiration: Date?) async throws -> WireCellsPublicLink {
+        var currentLink = try await NodeServiceAPI.getPublicLink(
+            linkUuid: linkID,
+            apiConfiguration: makeConfiguration()
+        )
+        currentLink.accessEnd = expiration.map { String(Int($0.timeIntervalSince1970)) }
+
+        let updatedLink = try await NodeServiceAPI.updatePublicLink(
+            linkUuid: linkID,
+            publicLinkRequest: RestPublicLinkRequest(
+                link: currentLink,
+                passwordEnabled: currentLink.passwordRequired
+            ),
+            apiConfiguration: makeConfiguration()
+        )
 
-        return WireCellsPublicLink(uuid: id, url: url)
+        return try WireCellsPublicLink(updatedLink, serverURL: serverURLResolver())
     }
 
-    func deletePublicLink(uuid: UUID) async throws {
-        _ = try await NodeServiceAPI.deletePublicLink(
-            linkUuid: uuid.transportString(),
+    func updatePublicLinkPassword(
+        linkID: String,
+        password: String?
+    ) async throws -> WireCellsPublicLink {
+        var currentLink = try await NodeServiceAPI.getPublicLink(
+            linkUuid: linkID,
+            apiConfiguration: makeConfiguration()
+        )
+
+        let hasExistingPassword = currentLink.passwordRequired == true
+        currentLink.passwordRequired = password != nil
+
+        let updatedLink = try await NodeServiceAPI.updatePublicLink(
+            linkUuid: linkID,
+            publicLinkRequest: RestPublicLinkRequest(
+                createPassword: !hasExistingPassword ? password : nil,
+                link: currentLink,
+                passwordEnabled: password != nil,
+                updatePassword: hasExistingPassword ? password : nil,
+            ),
             apiConfiguration: makeConfiguration()
         )
+
+        return try WireCellsPublicLink(updatedLink, serverURL: serverURLResolver())
     }
 
     func updateTags(uuid: UUID, tags: [String]) async throws {
@@ -349,9 +371,15 @@ final class RestAPI: Sendable {
         return response.values ?? []
     }
 
+    private var apiURL: URL {
+        get throws {
+            try serverURLResolver().appendingPathComponent("/v2")
+        }
+    }
+
     private func makeConfiguration() async throws -> CellsSDKAPIConfiguration {
         let config = CellsSDKAPIConfiguration()
-        config.basePath = try serverURLResolver().appendingPathComponent("/v2").absoluteString
+        config.basePath = try apiURL.absoluteString
         config.customHeaders = ["Authorization": "Bearer \(try await accessTokenProvider.accessToken().token)"]
         config.interceptor = LoggingIntercepter()
 
@@ -513,4 +541,22 @@ private extension RestPreSignedURL {
         }
         return (url: url, date: Date(timeIntervalSinceNow: expiresAtTimeInterval))
     }
+
+}
+
+private extension WireCellsPublicLink {
+
+    init(_ value: RestShareLink, serverURL: URL) throws {
+        guard let linkID = value.uuid, let url = value.linkUrl else {
+            throw WireCellsNodesAPIError.missingData("Missing link ID or URL")
+        }
+
+        self.init(
+            linkID: linkID,
+            url: serverURL.appendingPathComponent(url),
+            requiresPassword: value.passwordRequired ?? false,
+            expirationDate: value.accessEnd.flatMap { TimeInterval($0) }.map { Date(timeIntervalSince1970: $0) }
+        )
+    }
+
 }

WireMessaging/Sources/WireMessagingDomain/WireCells/Model/WireCellsPublicLink.swift

@@ -19,11 +19,15 @@
 public import Foundation
 
 public struct WireCellsPublicLink: Equatable, Hashable, Sendable {
-    public let uuid: UUID
+    public let linkID: String
     public let url: URL
+    public let requiresPassword: Bool
+    public let expirationDate: Date?
 
-    package init(uuid: UUID, url: URL) {
-        self.uuid = uuid
+    package init(linkID: String, url: URL, requiresPassword: Bool, expirationDate: Date?) {
+        self.linkID = linkID
         self.url = url
+        self.requiresPassword = requiresPassword
+        self.expirationDate = expirationDate
     }
 }

WireMessaging/Sources/WireMessagingDomain/WireCells/Protocols/NodesAPIProtocol.swift

@@ -40,11 +40,22 @@ package protocol NodesAPIProtocol: Sendable {
 
     func deleteNodes(nodeIDs: [UUID], permanently: Bool) async throws -> Bool
 
-    func createPublicLink(nodeID: UUID, fileName: String) async throws -> WireCellsPublicLink
+    func createPublicLink(nodeID: UUID, label: String) async throws
+        -> WireCellsPublicLink
 
-    func getPublicLink(linkUUID: UUID) async throws -> URL
+    func getPublicLink(linkID: String) async throws -> WireCellsPublicLink
 
-    func deletePublicLink(linkUUID: UUID) async throws
+    func deletePublicLink(linkID: String) async throws
+
+    func updatePublicLinkExpiration(
+        linkID: String,
+        expiration: Date?
+    ) async throws -> WireCellsPublicLink
+
+    func updatePublicLinkPassword(
+        linkID: String,
+        password: String?
+    ) async throws -> WireCellsPublicLink
 
     func updateTags(nodeID: UUID, tags: [String]) async throws
 

WireMessaging/Sources/WireMessagingDomain/WireCells/Protocols/WireCellsGetPublicLinkDataUseCaseProtocol.swift

@@ -0,0 +1,21 @@
+//
+// Wire
+// Copyright (C) 2026 Wire Swiss GmbH
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see http://www.gnu.org/licenses/.
+//
+
+public protocol WireCellsGetPublicLinkDataUseCaseProtocol: Sendable {
+    func invoke(linkID: String) async throws -> WireCellsPublicLink
+}

WireMessaging/Sources/WireMessagingDomain/WireCells/UseCases/Keychain/Helpers/Keychain+WireCellsService.swift

@@ -0,0 +1,23 @@
+//
+// Wire
+// Copyright (C) 2026 Wire Swiss GmbH
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see http://www.gnu.org/licenses/.
+//
+
+import WireFoundation
+
+extension Keychain {
+    static let wireDriveSharedLinkPasswordService = "wire-drive-shared-link-password"
+}