fix(tabs): notice any change to or deletion of an open SQL file, and report a failed move to Trash (#3088)

Author: datlechin

CHANGELOG.md

@@ -103,10 +103,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Garbled name and ISO-8859-1 label on a UTF-8, UTF-16 or UTF-32 linked SQL file, and garbled big-endian UTF-32 files.
 - Cleared keyword, folder or **Global** on a saved query or its folder never reaching another device.
 - Renaming a folder putting back the scope another window had just set.
+- No changed-on-disk notice for an SQL file outside a linked folder or replaced by an older copy, and Save overwriting it.
 - Saved queries and their folders deleted at launch when their connection had not arrived from iCloud.
 - Saved queries left naming a deleted folder on other devices after that folder was deleted.
 - A keyword two linked SQL files both declared reaching a different file on each launch.
 - A keyword a saved query shared with a global one reaching either query, depending on the connection.
+- Silent failure moving a linked SQL file to the Trash, and an open tab recreating a deleted file on save.
 - AI chat's saved query mentions missing a query saved earlier in the same session.
 - **File > Import > Import Data…** importing every file as SQL. (#3047)
 - A file the import panel dimmed still opening, and reaching the wrong importer.

TablePro/Core/Coordinators/SourceFileDiskChangeMonitor.swift

@@ -0,0 +1,86 @@
+//
+//  SourceFileDiskChangeMonitor.swift
+//  TablePro
+//
+
+import Foundation
+
+@MainActor
+internal final class SourceFileDiskChangeMonitor {
+    typealias StampReader = @Sendable ([URL]) async -> [FileStamp?]
+
+    private struct Probe {
+        let tabId: UUID
+        let url: URL
+        let recordedStamp: FileStamp?
+    }
+
+    private weak var tabManager: QueryTabManager?
+    private let readStamps: StampReader
+    private var inFlight: Task<Void, Never>?
+    private var needsAnotherPass = false
+
+    init(tabManager: QueryTabManager, readStamps: @escaping StampReader = SourceFileDiskChangeMonitor.readStampsOffMainActor) {
+        self.tabManager = tabManager
+        self.readStamps = readStamps
+    }
+
+    func refresh() {
+        guard inFlight == nil else {
+            needsAnotherPass = true
+            return
+        }
+        inFlight = Task { await self.runPasses() }
+    }
+
+    func waitUntilIdle() async {
+        await inFlight?.value
+    }
+
+    func cancel() {
+        needsAnotherPass = false
+        inFlight?.cancel()
+    }
+
+    @concurrent
+    nonisolated static func readStampsOffMainActor(_ urls: [URL]) async -> [FileStamp?] {
+        urls.map(FileStamp.read)
+    }
+
+    private func runPasses() async {
+        repeat {
+            needsAnotherPass = false
+            await runPass()
+        } while needsAnotherPass && !Task.isCancelled
+        inFlight = nil
+    }
+
+    private func runPass() async {
+        guard let tabManager else { return }
+        let probes = tabManager.tabs.compactMap { tab -> Probe? in
+            guard let url = tab.content.sourceFileURL else { return nil }
+            return Probe(tabId: tab.id, url: url, recordedStamp: tab.content.savedFileStamp)
+        }
+        guard !probes.isEmpty else { return }
+        let stamps = await readStamps(probes.map(\.url))
+        guard !Task.isCancelled else { return }
+        for (probe, stamp) in zip(probes, stamps) {
+            apply(stamp, to: probe)
+        }
+    }
+
+    private func apply(_ stamp: FileStamp?, to probe: Probe) {
+        guard let tabManager,
+              let tab = tabManager.tabs.first(where: { $0.id == probe.tabId }),
+              tab.content.sourceFileURL == probe.url,
+              tab.content.savedFileStamp == probe.recordedStamp else { return }
+        var settled = tab.content
+        FileTabBaseline.settle(FileTabBaseline.diskChange(in: settled, current: stamp), in: &settled)
+        guard settled.diskChange != tab.content.diskChange
+            || settled.dismissedDiskChange != tab.content.dismissedDiskChange else { return }
+        tabManager.mutate(tabId: probe.tabId) { mutable in
+            mutable.content.diskChange = settled.diskChange
+            mutable.content.dismissedDiskChange = settled.dismissedDiskChange
+        }
+    }
+}

TablePro/Core/Services/Infrastructure/EditorTabOpener.swift

@@ -69,6 +69,7 @@ internal enum EditorTabOpener {
                 title: payload.tabTitle,
                 databaseName: payload.databaseName ?? browseDatabaseName,
                 sourceFileURL: payload.sourceFileURL,
+                sourceFileStamp: payload.sourceFileStamp,
                 claimFocus: true
             )
         case .createTable:

TablePro/Core/Services/Infrastructure/TabRouter.swift

@@ -486,18 +486,21 @@ internal final class TabRouter {
         }
 
         if let session = DatabaseManager.shared.lastActiveSession {
-            let content = await Task.detached(priority: .userInitiated) { () -> String? in
-                try? String(contentsOf: url, encoding: .utf8)
+            let read = await Task.detached(priority: .userInitiated) { () -> (content: String, stamp: FileStamp?)? in
+                let stamp = FileStamp.read(url)
+                guard let content = try? String(contentsOf: url, encoding: .utf8) else { return nil }
+                return (content, stamp)
             }.value
-            guard let content else {
+            guard let read else {
                 Self.logger.error("Failed to read SQL file: \(url.lastPathComponent, privacy: .private(mask: .hash))")
                 return
             }
             let payload = EditorTabPayload(
                 connectionId: session.connection.id,
                 tabType: .query,
-                initialQuery: content,
-                sourceFileURL: url
+                initialQuery: read.content,
+                sourceFileURL: url,
+                sourceFileStamp: read.stamp
             )
             WindowManager.shared.openTab(payload: payload)
             AppActivationPolicyController.shared.activate(ignoringOtherApps: true)

TablePro/Core/Utilities/File/FileStamp.swift

@@ -0,0 +1,32 @@
+//
+//  FileStamp.swift
+//  TablePro
+//
+
+import Foundation
+
+internal struct FileStamp: Codable, Hashable, Sendable {
+    let modificationSeconds: Int
+    let modificationNanoseconds: Int
+    let size: Int64
+    let fileNumber: UInt64
+
+    var modificationDate: Date {
+        Date(timeIntervalSince1970: TimeInterval(modificationSeconds) + TimeInterval(modificationNanoseconds) / 1_000_000_000)
+    }
+
+    static func read(_ url: URL) -> FileStamp? {
+        var status = stat()
+        let succeeded = url.withUnsafeFileSystemRepresentation { path -> Bool in
+            guard let path else { return false }
+            return stat(path, &status) == 0
+        }
+        guard succeeded else { return nil }
+        return FileStamp(
+            modificationSeconds: status.st_mtimespec.tv_sec,
+            modificationNanoseconds: status.st_mtimespec.tv_nsec,
+            size: status.st_size,
+            fileNumber: status.st_ino
+        )
+    }
+}

TablePro/Core/Utilities/File/FileTextLoader.swift

@@ -6,34 +6,34 @@
 import Foundation
 
 internal enum FileTextLoader {
-    struct LoadedText {
+    struct LoadedText: Sendable {
         let content: String
         let encoding: String.Encoding
-        /// When the file was last written, as of just before this text was read.
+        /// What the file was, as of just before this text was read.
         ///
         /// Read here rather than by the caller, because a caller that stats afterwards records a
-        /// date newer than the text it is holding, and a write that lands in between is then
-        /// invisible: the tab looks up to date against a file it never read. Taking the date first
+        /// stamp newer than the text it is holding, and a write that lands in between is then
+        /// invisible: the tab looks up to date against a file it never read. Taking the stamp first
         /// fails the other way, leaving the baseline older than the text, so the changed-on-disk
         /// notice can fire once too often but never go missing.
-        let modifiedAt: Date?
+        let stamp: FileStamp?
         var isUTF8: Bool { encoding == .utf8 }
     }
 
     static func load(_ url: URL) -> LoadedText? {
-        let modifiedAt = modificationDate(of: url)
+        let stamp = FileStamp.read(url)
         if startsWithByteOrderMark(url) {
-            return loadByteOrderMarked(url, modifiedAt: modifiedAt)
+            return loadByteOrderMarked(url, stamp: stamp)
         }
         var detected: String.Encoding = .utf8
         if let content = try? String(contentsOf: url, usedEncoding: &detected) {
-            return LoadedText(content: content, encoding: detected, modifiedAt: modifiedAt)
+            return LoadedText(content: content, encoding: detected, stamp: stamp)
         }
         if let content = try? String(contentsOf: url, encoding: .utf8) {
-            return LoadedText(content: content, encoding: .utf8, modifiedAt: modifiedAt)
+            return LoadedText(content: content, encoding: .utf8, stamp: stamp)
         }
         if let content = try? String(contentsOf: url, encoding: .isoLatin1) {
-            return LoadedText(content: content, encoding: .isoLatin1, modifiedAt: modifiedAt)
+            return LoadedText(content: content, encoding: .isoLatin1, stamp: stamp)
         }
         return nil
     }
@@ -43,17 +43,13 @@ internal enum FileTextLoader {
         return TextPrefixDecoder.decode(data, prefixLength: data.count)?.content
     }
 
-    static func modificationDate(of url: URL) -> Date? {
-        (try? FileManager.default.attributesOfItem(atPath: url.path)[.modificationDate]) as? Date
-    }
-
     static func loadHeader(_ url: URL, maxBytes: Int = 4_096) -> LoadedText? {
+        let stamp = FileStamp.read(url)
         guard let handle = try? FileHandle(forReadingFrom: url) else { return nil }
         defer { try? handle.close() }
         guard let bytes = try? handle.read(upToCount: maxBytes + TextPrefixDecoder.lookaheadLength),
               let decoded = TextPrefixDecoder.decode(bytes, prefixLength: maxBytes) else { return nil }
-        let modifiedAt = modificationDate(of: url)
-        return LoadedText(content: decoded.content, encoding: decoded.encoding, modifiedAt: modifiedAt)
+        return LoadedText(content: decoded.content, encoding: decoded.encoding, stamp: stamp)
     }
 
     private static func startsWithByteOrderMark(_ url: URL) -> Bool {
@@ -63,10 +59,10 @@ internal enum FileTextLoader {
         return ByteOrderMark.leading(bytes) != nil
     }
 
-    private static func loadByteOrderMarked(_ url: URL, modifiedAt: Date?) -> LoadedText? {
+    private static func loadByteOrderMarked(_ url: URL, stamp: FileStamp?) -> LoadedText? {
         guard let bytes = try? Data(contentsOf: url),
               let decoded = TextPrefixDecoder.decode(bytes, prefixLength: bytes.count) else { return nil }
-        return LoadedText(content: decoded.content, encoding: decoded.encoding, modifiedAt: modifiedAt)
+        return LoadedText(content: decoded.content, encoding: decoded.encoding, stamp: stamp)
     }
 }
 

TablePro/Core/VersionHistory/LinkedFileVersionHistoryProvider.swift

@@ -31,7 +31,7 @@ internal struct LinkedFileVersionHistoryProvider: VersionHistoryProvider {
         let records = try await gitCall { try await client.status(in: directory, pathspec: fileURL.lastPathComponent) }
         let current = VersionHistoryEntry(
             reference: .current,
-            date: FileTextLoader.modificationDate(of: fileURL),
+            date: FileStamp.read(fileURL)?.modificationDate,
             hasUncommittedChanges: !records.isEmpty
         )
         guard try await gitCall({ try await client.hasCommits(in: directory) }) else {

TablePro/Models/Query/EditorTabPayload.swift

@@ -54,6 +54,7 @@ internal struct EditorTabPayload: Codable, Hashable {
     internal let initialFilterState: TabFilterState?
     /// Source file URL for .sql files opened from disk (used for deduplication)
     internal let sourceFileURL: URL?
+    internal let sourceFileStamp: FileStamp?
     /// Schema key for ER diagram tabs
     internal let erDiagramSchemaKey: String?
     /// The routine or trigger a .objectSource tab shows
@@ -69,7 +70,7 @@ internal struct EditorTabPayload: Codable, Hashable {
         case initialQuery, isView, objectType, showStructure, skipAutoExecute, isPreview
         case forcesNewTab
         case tabTitle
-        case initialFilterState, sourceFileURL, erDiagramSchemaKey, objectRef, versionHistorySubject, intent
+        case initialFilterState, sourceFileURL, sourceFileStamp, erDiagramSchemaKey, objectRef, versionHistorySubject, intent
         // Legacy key for backward decoding only
         case isNewTab
     }
@@ -90,6 +91,7 @@ internal struct EditorTabPayload: Codable, Hashable {
         forcesNewTab: Bool = false,
         initialFilterState: TabFilterState? = nil,
         sourceFileURL: URL? = nil,
+        sourceFileStamp: FileStamp? = nil,
         erDiagramSchemaKey: String? = nil,
         objectRef: DatabaseObjectRef? = nil,
         versionHistorySubject: VersionHistorySubject? = nil,
@@ -111,6 +113,7 @@ internal struct EditorTabPayload: Codable, Hashable {
         self.forcesNewTab = forcesNewTab
         self.initialFilterState = initialFilterState
         self.sourceFileURL = sourceFileURL
+        self.sourceFileStamp = sourceFileStamp
         self.erDiagramSchemaKey = erDiagramSchemaKey
         self.objectRef = objectRef
         self.versionHistorySubject = versionHistorySubject
@@ -138,6 +141,7 @@ internal struct EditorTabPayload: Codable, Hashable {
         forcesNewTab = try container.decodeIfPresent(Bool.self, forKey: .forcesNewTab) ?? false
         initialFilterState = try container.decodeIfPresent(TabFilterState.self, forKey: .initialFilterState)
         sourceFileURL = try container.decodeIfPresent(URL.self, forKey: .sourceFileURL)
+        sourceFileStamp = try container.decodeIfPresent(FileStamp.self, forKey: .sourceFileStamp)
         erDiagramSchemaKey = try container.decodeIfPresent(String.self, forKey: .erDiagramSchemaKey)
         objectRef = try container.decodeIfPresent(DatabaseObjectRef.self, forKey: .objectRef)
         versionHistorySubject = try container.decodeIfPresent(VersionHistorySubject.self, forKey: .versionHistorySubject)
@@ -167,6 +171,7 @@ internal struct EditorTabPayload: Codable, Hashable {
         try container.encode(forcesNewTab, forKey: .forcesNewTab)
         try container.encodeIfPresent(initialFilterState, forKey: .initialFilterState)
         try container.encodeIfPresent(sourceFileURL, forKey: .sourceFileURL)
+        try container.encodeIfPresent(sourceFileStamp, forKey: .sourceFileStamp)
         try container.encodeIfPresent(erDiagramSchemaKey, forKey: .erDiagramSchemaKey)
         try container.encodeIfPresent(objectRef, forKey: .objectRef)
         try container.encodeIfPresent(versionHistorySubject, forKey: .versionHistorySubject)
@@ -191,6 +196,7 @@ internal struct EditorTabPayload: Codable, Hashable {
         self.forcesNewTab = false
         self.initialFilterState = nil
         self.sourceFileURL = tab.content.sourceFileURL
+        self.sourceFileStamp = nil
         self.erDiagramSchemaKey = tab.display.erDiagramSchemaKey
         self.objectRef = tab.display.objectRef
         self.versionHistorySubject = tab.display.versionHistorySubject

TablePro/Models/Query/FileTabBaseline.swift

@@ -18,13 +18,61 @@ import Foundation
 internal enum FileTabBaseline {
     internal static func hydrate(_ tab: inout QueryTab) {
         guard let url = tab.content.sourceFileURL, let loaded = FileTextLoader.load(url) else { return }
-        tab.content.savedFileContent = loaded.content
-        tab.content.loadMtime = loaded.modifiedAt
+        record(loaded.content, stamp: loaded.stamp, in: &tab.content)
     }
 
     internal static func hydrate(_ tabs: inout [QueryTab]) {
         for index in tabs.indices {
             hydrate(&tabs[index])
         }
     }
+
+    internal static func adopt(_ loaded: FileTextLoader.LoadedText, into content: inout TabQueryContent) {
+        adopt(text: loaded.content, stamp: loaded.stamp, into: &content)
+    }
+
+    internal static func adopt(text: String, stamp: FileStamp?, into content: inout TabQueryContent) {
+        content.query = text
+        record(text, stamp: stamp, in: &content)
+    }
+
+    internal static func recordWrite(of text: String, to url: URL, in content: inout TabQueryContent) {
+        record(text, stamp: FileStamp.read(url), in: &content)
+    }
+
+    internal static func diskChange(in content: TabQueryContent) -> SourceFileDiskChange? {
+        guard let url = content.sourceFileURL else { return nil }
+        return diskChange(in: content, current: FileStamp.read(url))
+    }
+
+    internal static func diskChange(in content: TabQueryContent, current: FileStamp?) -> SourceFileDiskChange? {
+        guard content.sourceFileURL != nil else { return nil }
+        return SourceFileDiskChange.detect(recorded: content.savedFileStamp, current: current)
+    }
+
+    internal static func settle(_ detected: SourceFileDiskChange?, in content: inout TabQueryContent) {
+        guard detected != content.dismissedDiskChange else {
+            content.diskChange = nil
+            return
+        }
+        content.dismissedDiskChange = nil
+        content.diskChange = detected
+    }
+
+    internal static func showDiskChange(_ change: SourceFileDiskChange, in content: inout TabQueryContent) {
+        content.diskChange = change
+        content.dismissedDiskChange = nil
+    }
+
+    internal static func dismissDiskChange(in content: inout TabQueryContent) {
+        content.dismissedDiskChange = content.diskChange
+        content.diskChange = nil
+    }
+
+    private static func record(_ text: String, stamp: FileStamp?, in content: inout TabQueryContent) {
+        content.savedFileContent = text
+        content.savedFileStamp = stamp
+        content.diskChange = nil
+        content.dismissedDiskChange = nil
+    }
 }