Realm file as UIDocument

Question

I've been trying to use a Realm file as a document in a Document-based iOS app. The goal is to select the Realm file from the file picker so the user can switch between Realm databases, or send a database that they've worked with to another user. Similar to a text editor creating a new text file for each new document the user creates, but with a Realm db instead of a text file.

I have the file picker showing as the initial view just fine (so I think the DocumentBrowswerViewController isn't the root of the issue), but the "+" button to create a new file doesn't actually create a new file. What am I missing to get a blank file created (with the default.realm file I included in the app bundle) or open an existing file?

My DocumentBrowserViewController class:

class DocumentBrowserViewController: UIDocumentBrowserViewController, UIDocumentBrowserViewControllerDelegate {

    override func viewDidLoad() {
        super.viewDidLoad()

        delegate = self

        allowsDocumentCreation = true
        allowsPickingMultipleItems = false
    }

    func documentBrowser(_ controller: UIDocumentBrowserViewController, didRequestDocumentCreationWithHandler importHandler: @escaping (URL?, UIDocumentBrowserViewController.ImportMode) -> Void) {
        let newDocumentURL: URL? = Bundle.main.url(forResource: "default", withExtension: "realm")

        if newDocumentURL != nil {
            importHandler(newDocumentURL, .copy)
        } else {
            importHandler(nil, .none)
        }
    }

    func documentBrowser(_ controller: UIDocumentBrowserViewController, didPickDocumentsAt documentURLs: [URL]) {
        guard let sourceURL = documentURLs.first else { return }

        presentDocument(at: sourceURL)
    }

    func documentBrowser(_ controller: UIDocumentBrowserViewController, didImportDocumentAt sourceURL: URL, toDestinationURL destinationURL: URL) {
        presentDocument(at: destinationURL)
    }

    func documentBrowser(_ controller: UIDocumentBrowserViewController, failedToImportDocumentAt documentURL: URL, error: Error?) {
        // Make sure to handle the failed import appropriately, e.g., by presenting an error message to the user.
    }

    // MARK: Document Presentation

    func presentDocument(at documentURL: URL) {
        let document = try! Document(contentsOf: documentURL, ofType: "RealmDocument")

        // Access the document
        document.open(completionHandler: { success in
            if success {
                // Display the content of the document:
                let view = RootView(realmDocument: document) 

                let documentViewController = UIHostingController(rootView: view)
                self.present(documentViewController, animated: true, completion: nil)
            } else {
                // Make sure to handle the failed import appropriately, e.g., by presenting an error message to the user.
            }
        })
    }

    func closeDocument(_ document: Document) {
        dismiss(animated: true) {
            document.close(completionHandler: nil)
        }
    }
}

and the Document class (wrapping the Realm database file):

enum RealmDocumentError: Error {
    case FailedToConvertURLToFilePath
}

class Document: UIDocument {

    var representedRealm: Realm = {
        var config = Realm.Configuration()
        config.inMemoryIdentifier = NSUUID().uuidString
        do {
            return try Realm(configuration:config)
        } catch {
            fatalError("Realm init failed")
        }
    }()


    private static func realmURL(url: URL) -> URL {
        return url.appendingPathComponent(NSUUID().uuidString)
    }


    convenience init(contentsOf url: URL, ofType typeName: String) throws {
        self.init()

        do {
            try representedRealm = Realm(fileURL: url)
        } catch {
            fatalError("Something went wrong creating the realm for \(url)")
        }
    }


    convenience init(for urlOrNil: URL?, withContentsOfURL contentsURL: URL, ofType typeName: String) throws {
        self.init()

        var config = Realm.Configuration()
        config.fileURL = contentsURL
        config.readOnly = true
        let originalRealm = try Realm(configuration: config)

        if let url = urlOrNil {
            try originalRealm.writeCopy(toFile: url)
            representedRealm = try Realm(fileURL: url)
        } else {
            var temporaryInMemoryRealmURL = URL(fileURLWithPath:NSTemporaryDirectory())
            temporaryInMemoryRealmURL.appendPathComponent(NSUUID().uuidString)

            try originalRealm.writeCopy(toFile: temporaryInMemoryRealmURL)
            representedRealm = try Realm(fileURL: temporaryInMemoryRealmURL)
        }
    }

    deinit {
        // This is a workaround — ideally Realm would allow initialising an in-memory Realm based on an on-disk representation and this cleanup code would be unnecessary
        guard let url = representedRealm.configuration.fileURL else {
            return
        }
        if url.path.hasPrefix(NSTemporaryDirectory()) {
            do {
                let fileManager = FileManager.default
                try fileManager.removeItem(at: url)
            }   catch let error as NSError {
                Swift.print("Error while deleting temporary Realm: \(error.localizedDescription)")
            }
        }
    }

    override func load(fromContents contents: Any, ofType typeName: String?) throws {
        let url = fileURL
        let proposedRealmPath = url.path
        if let currentRealmPath = representedRealm.configuration.fileURL?.path {

            if currentRealmPath != proposedRealmPath {
                try! representedRealm.writeCopy(toFile: url)
                var config = Realm.Configuration()
                config.fileURL = url
                representedRealm = try! Realm(configuration: config)

                let fileManager = FileManager.default
                try! fileManager.removeItem(atPath: currentRealmPath)
            }
        } else {
            throw RealmDocumentError.FailedToConvertURLToFilePath
        }
    }


    override func writeContents(_ contents: Any, to url: URL, for saveOperation: UIDocument.SaveOperation, originalContentsURL: URL?) throws {
        try representedRealm.writeCopy(toFile: url)
    }


    override var hasUnsavedChanges: Bool {
        return representedRealm.isInWriteTransaction
    }

}