How to enable files and folders permission on iOS

After some research, I stumbled onto this Apple documentation page (which wasn't found after my hours of google searching when I posted this question)

https://developer.apple.com/documentation/uikit/view_controllers/providing_access_to_directories

Navigate to the Save the URL as a Bookmark part of the article.

Utilizing a SwiftUI fileImporter gives one-time read/write access to the user-selected directory. To persist this read/write access, I had to make a bookmark and store it somewhere to access later.

Since I only needed one bookmark for the user's downloads directory, I saved it in UserDefaults (a bookmark is very small in terms of size).

When saving a bookmark, the app is added into the Files and folders in the user's settings, so the user can revoke file permissions for the app immediately (hence all the guard statements in my code snippet).

Here's the code snippet which I used and with testing, downloading does persist across app launches and multiple downloads.

import SwiftUI
import UniformTypeIdentifiers
import Alamofire

struct ContentView: View {
    @AppStorage("bookmarkData") var downloadsBookmark: Data?
    
    @State private var showFileImporter = false
    
    var body: some View {
        VStack {
            Button("Set downloads directory") {
                showFileImporter.toggle()
            }
            
            Button("Save to downloads directory") {
                Task {
                    do {
                        let destination: DownloadRequest.Destination = { _, response in
                            // Save to a temp directory in app documents
                            let documentsURL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0].appendingPathComponent("Downloads")
                            let suggestedName = response.suggestedFilename ?? "unknown"

                            let fileURL = documentsURL.appendingPathComponent(suggestedName)

                            return (fileURL, [.removePreviousFile, .createIntermediateDirectories])
                        }

                        let tempUrl = try await AF.download(URL(string: "https://i.imgur.com/zaVQDFJ.png")!, to: destination).serializingDownloadedFileURL().value
                        
                        // Get the bookmark data from the AppStorage call
                        guard let bookmarkData = downloadsBookmark else {
                            return
                        }
                        var isStale = false
                        let downloadsUrl = try URL(resolvingBookmarkData: bookmarkData, bookmarkDataIsStale: &isStale)
                        
                        guard !isStale else {
                            // Log that the bookmark is stale
                            
                            return
                        }
                        
                        // Securely access the URL from the bookmark data
                        guard downloadsUrl.startAccessingSecurityScopedResource() else {
                            print("Can't access security scoped resource")
                            
                            return
                        }
                        
                        // We have to stop accessing the resource no matter what
                        defer { downloadsUrl.stopAccessingSecurityScopedResource() }
                        
                        do {
                            try FileManager.default.moveItem(at: tempUrl, to: downloadsUrl.appendingPathComponent(tempUrl.lastPathComponent))
                        } catch {
                            print("Move error: \(error)")
                        }
                    } catch {
                        print("Downloading error!: \(error)")
                    }
                }
            }
        }
        .fileImporter(isPresented: $showFileImporter, allowedContentTypes: [UTType.folder]) { result in
            switch result {
            case .success(let url):
                // Securely access the URL to save a bookmark
                guard url.startAccessingSecurityScopedResource() else {
                    // Handle the failure here.
                    return
                }
                
                // We have to stop accessing the resource no matter what
                defer { url.stopAccessingSecurityScopedResource() }
                
                do {
                    // Make sure the bookmark is minimal!
                    downloadsBookmark = try url.bookmarkData(options: .minimalBookmark, includingResourceValuesForKeys: nil, relativeTo: nil)
                } catch {
                    print("Bookmark error \(error)")
                }
            case .failure(let error):
                print("Importer error: \(error)")
            }
        }
    }
}