feat(sidebar): recent tables section (opt-in)

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Recent section at the top of the Tables sidebar tracks the last 10 tables you opened per connection and database, in-memory for the session. Off by default, turn it on in Settings > General > Sidebar. (#1352)
+
 ### Changed
 
 - Data grid now serves the row count from its existing cache instead of recomputing it on every layout pass, reducing CPU churn while scrolling large result sets.

TablePro/Core/Storage/RecentTablesStore.swift

@@ -0,0 +1,45 @@
+import Foundation
+
+extension Notification.Name {
+    static let recentTablesDidChange = Notification.Name("RecentTablesDidChange")
+}
+
+@MainActor
+final class RecentTablesStore {
+    static let shared = RecentTablesStore()
+
+    struct Key: Hashable {
+        let connectionID: UUID
+        let database: String?
+    }
+
+    struct Entry: Hashable, Identifiable {
+        let name: String
+        let schema: String?
+        let type: TableInfo.TableType
+
+        var id: String { schema.map { "\($0).\(name)" } ?? name }
+    }
+
+    private var entriesByKey: [Key: [Entry]] = [:]
+    private let cap = 10
+
+    init() {}
+
+    func push(connectionID: UUID, database: String?, table: TableInfo) {
+        let key = Key(connectionID: connectionID, database: database)
+        let entry = Entry(name: table.name, schema: table.schema, type: table.type)
+        var list = entriesByKey[key] ?? []
+        list.removeAll { $0.id == entry.id }
+        list.insert(entry, at: 0)
+        if list.count > cap {
+            list = Array(list.prefix(cap))
+        }
+        entriesByKey[key] = list
+        NotificationCenter.default.post(name: .recentTablesDidChange, object: nil)
+    }
+
+    func entries(connectionID: UUID, database: String?) -> [Entry] {
+        entriesByKey[Key(connectionID: connectionID, database: database)] ?? []
+    }
+}

TablePro/Models/Settings/GeneralSettings.swift

@@ -63,26 +63,32 @@ struct GeneralSettings: Codable, Equatable {
     /// Whether to share anonymous usage analytics
     var shareAnalytics: Bool
 
+    /// Whether the sidebar shows a Recent section with recently opened tables
+    var showRecentTables: Bool
+
     static let `default` = GeneralSettings(
         startupBehavior: .reopenLast,
         language: .system,
         automaticallyCheckForUpdates: true,
         queryTimeoutSeconds: 60,
-        shareAnalytics: true
+        shareAnalytics: true,
+        showRecentTables: false
     )
 
     init(
         startupBehavior: StartupBehavior = .reopenLast,
         language: AppLanguage = .system,
         automaticallyCheckForUpdates: Bool = true,
         queryTimeoutSeconds: Int = 60,
-        shareAnalytics: Bool = true
+        shareAnalytics: Bool = true,
+        showRecentTables: Bool = false
     ) {
         self.startupBehavior = startupBehavior
         self.language = language
         self.automaticallyCheckForUpdates = automaticallyCheckForUpdates
         self.queryTimeoutSeconds = queryTimeoutSeconds
         self.shareAnalytics = shareAnalytics
+        self.showRecentTables = showRecentTables
     }
 
     init(from decoder: Decoder) throws {
@@ -92,5 +98,6 @@ struct GeneralSettings: Codable, Equatable {
         automaticallyCheckForUpdates = try container.decodeIfPresent(Bool.self, forKey: .automaticallyCheckForUpdates) ?? true
         queryTimeoutSeconds = try container.decodeIfPresent(Int.self, forKey: .queryTimeoutSeconds) ?? 60
         shareAnalytics = try container.decodeIfPresent(Bool.self, forKey: .shareAnalytics) ?? true
+        showRecentTables = try container.decodeIfPresent(Bool.self, forKey: .showRecentTables) ?? false
     }
 }

TablePro/ViewModels/SidebarViewModel.swift

@@ -99,6 +99,14 @@ final class SidebarViewModel {
             )
         }
     }
+    var isRecentsExpanded: Bool {
+        didSet {
+            UserDefaults.standard.set(
+                isRecentsExpanded,
+                forKey: SidebarPersistenceKey.recentsExpanded(connectionId: connectionId)
+            )
+        }
+    }
     var redisKeyTreeViewModel: RedisKeyTreeViewModel?
     var showOperationDialog = false
     var pendingOperationType: TableOperationType?
@@ -165,6 +173,10 @@ final class SidebarViewModel {
             legacyKey: SidebarPersistenceKey.legacyRedisKeysExpanded,
             defaultValue: true
         )
+        let recentsKey = SidebarPersistenceKey.recentsExpanded(connectionId: connectionId)
+        self.isRecentsExpanded = UserDefaults.standard.object(forKey: recentsKey) != nil
+            ? UserDefaults.standard.bool(forKey: recentsKey)
+            : true
     }
 
     private static func loadInitialExpansion(connectionId: UUID) -> ExpansionState {

TablePro/Views/Main/Extensions/MainContentCoordinator+Navigation.swift

@@ -21,6 +21,13 @@ extension MainContentCoordinator {
         forceNonPreview: Bool = false,
         activateGridFocus: Bool = false
     ) {
+        if AppSettingsManager.shared.general.showRecentTables {
+            RecentTablesStore.shared.push(
+                connectionID: connection.id,
+                database: activeDatabaseName.isEmpty ? nil : activeDatabaseName,
+                table: table
+            )
+        }
         openTableTab(
             table.name,
             schema: table.schema,

TablePro/Views/Settings/GeneralSettingsView.swift

@@ -56,6 +56,9 @@ struct GeneralSettingsView: View {
             }
 
             Section("Sidebar") {
+                Toggle("Show recent tables", isOn: $settings.showRecentTables)
+                    .help("Adds a Recent section at the top of the Tables sidebar with the last tables you opened per connection and database.")
+
                 Picker("Default layout for new connections:", selection: $defaultSidebarLayout) {
                     Text("List").tag(SidebarLayout.flat)
                     Text("Tree").tag(SidebarLayout.tree)

TablePro/Views/Sidebar/SidebarPersistenceKey.swift

@@ -12,6 +12,10 @@ enum SidebarPersistenceKey {
         "sidebar.\(connectionId.uuidString).redisKeys.expanded"
     }
 
+    static func recentsExpanded(connectionId: UUID) -> String {
+        "sidebar.\(connectionId.uuidString).recents.expanded"
+    }
+
     static func selectedTab(connectionId: UUID) -> String {
         "sidebar.selectedTab.\(connectionId.uuidString)"
     }

TablePro/Views/Sidebar/SidebarView.swift

@@ -11,6 +11,8 @@ import TableProPluginKit
 struct SidebarView: View {
     @State private var viewModel: SidebarViewModel
     @State private var favoriteTables: Set<FavoriteTablesStorage.FavoriteEntry> = []
+    @State private var recentTables: [RecentTablesStore.Entry] = []
+    @State private var settingsManager = AppSettingsManager.shared
     @State private var showDatabaseFilter: Bool = false
 
     private var schemaService: SchemaService { SchemaService.shared }
@@ -329,6 +331,19 @@ struct SidebarView: View {
 
     // MARK: - Table List
 
+    private var recentTableInfos: [TableInfo] {
+        let search = viewModel.searchText
+        return recentTables.compactMap { entry in
+            guard let match = tables.first(where: { $0.name == entry.name && $0.schema == entry.schema }) else {
+                return nil
+            }
+            if !search.isEmpty, !match.name.localizedCaseInsensitiveContains(search) {
+                return nil
+            }
+            return match
+        }
+    }
+
     private var activeDatabase: String? {
         let name = coordinator?.activeDatabaseName ?? ""
         return name.isEmpty ? nil : name
@@ -352,8 +367,56 @@ struct SidebarView: View {
         )
     }
 
+    private func reloadRecentTables() {
+        guard settingsManager.general.showRecentTables else {
+            recentTables = []
+            return
+        }
+        recentTables = RecentTablesStore.shared.entries(
+            connectionID: connectionId,
+            database: activeDatabase
+        )
+    }
+
+    @ViewBuilder
+    private var recentSection: some View {
+        let recents = recentTableInfos
+        if settingsManager.general.showRecentTables, !recents.isEmpty {
+            Section(isExpanded: $viewModel.isRecentsExpanded) {
+                ForEach(recents) { info in
+                    TableRow(
+                        table: info,
+                        isPendingTruncate: pendingTruncates.contains(info.name),
+                        isPendingDelete: pendingDeletes.contains(info.name),
+                        isFavorite: isFavorite(info),
+                        onToggleFavorite: { toggleFavorite(info) }
+                    )
+                    .selectionDisabled()
+                    .contentShape(Rectangle())
+                    .onTapGesture(count: 2) {
+                        onDoubleClick?(info)
+                    }
+                    .contextMenu {
+                        SidebarContextMenu(
+                            clickedTable: info,
+                            selectedTables: windowState.selectedTables,
+                            isReadOnly: coordinator?.safeModeLevel.blocksAllWrites ?? false,
+                            onBatchToggleTruncate: { viewModel.batchToggleTruncate(tableNames: $0) },
+                            onBatchToggleDelete: { viewModel.batchToggleDelete(tableNames: $0) },
+                            coordinator: coordinator
+                        )
+                    }
+                }
+            } header: {
+                Text(String(localized: "Recent"))
+            }
+        }
+    }
+
     private var tableList: some View {
         List(selection: selectedTablesBinding) {
+            recentSection
+
             ForEach(SidebarObjectKind.allCases, id: \.self) { kind in
                 sectionView(for: kind)
             }
@@ -397,8 +460,15 @@ struct SidebarView: View {
         .onReceive(NotificationCenter.default.publisher(for: .favoriteTablesDidChange)) { _ in
             favoriteTables = FavoriteTablesStorage.shared.favorites(for: connectionId)
         }
+        .onReceive(NotificationCenter.default.publisher(for: .recentTablesDidChange)) { _ in
+            reloadRecentTables()
+        }
+        .onChange(of: settingsManager.general.showRecentTables) { _, _ in
+            reloadRecentTables()
+        }
         .onAppear {
             favoriteTables = FavoriteTablesStorage.shared.favorites(for: connectionId)
+            reloadRecentTables()
         }
     }
 

TableProTests/Models/GeneralSettingsTests.swift

@@ -0,0 +1,28 @@
+import Foundation
+@testable import TablePro
+import Testing
+
+@Suite("GeneralSettings.showRecentTables")
+struct GeneralSettingsTests {
+    @Test("Defaults to off")
+    func defaultsOff() {
+        #expect(GeneralSettings.default.showRecentTables == false)
+        #expect(GeneralSettings().showRecentTables == false)
+    }
+
+    @Test("Decoding settings without the key keeps recent tables off")
+    func decodesMissingKeyAsOff() throws {
+        let json = Data(#"{"startupBehavior":"showWelcome"}"#.utf8)
+        let decoded = try JSONDecoder().decode(GeneralSettings.self, from: json)
+        #expect(decoded.showRecentTables == false)
+    }
+
+    @Test("Round-trips when enabled")
+    func roundTripsEnabled() throws {
+        var settings = GeneralSettings()
+        settings.showRecentTables = true
+        let data = try JSONEncoder().encode(settings)
+        let decoded = try JSONDecoder().decode(GeneralSettings.self, from: data)
+        #expect(decoded.showRecentTables == true)
+    }
+}

TableProTests/Storage/RecentTablesStoreTests.swift

@@ -0,0 +1,84 @@
+import Foundation
+import Testing
+
+@testable import TablePro
+
+@Suite("RecentTablesStore")
+@MainActor
+struct RecentTablesStoreTests {
+    private func makeStore() -> RecentTablesStore {
+        RecentTablesStore()
+    }
+
+    private func makeTable(_ name: String, schema: String? = nil) -> TableInfo {
+        TableInfo(name: name, type: .table, rowCount: nil, schema: schema)
+    }
+
+    @Test("Push inserts entry at the front")
+    func pushInsertsAtFront() {
+        let store = makeStore()
+        let conn = UUID()
+        store.push(connectionID: conn, database: "db", table: makeTable("a"))
+        store.push(connectionID: conn, database: "db", table: makeTable("b"))
+        let entries = store.entries(connectionID: conn, database: "db")
+        #expect(entries.map(\.name) == ["b", "a"])
+    }
+
+    @Test("Push dedupes by table id and bumps to front")
+    func pushDedupes() {
+        let store = makeStore()
+        let conn = UUID()
+        store.push(connectionID: conn, database: "db", table: makeTable("a"))
+        store.push(connectionID: conn, database: "db", table: makeTable("b"))
+        store.push(connectionID: conn, database: "db", table: makeTable("a"))
+        let entries = store.entries(connectionID: conn, database: "db")
+        #expect(entries.map(\.name) == ["a", "b"])
+    }
+
+    @Test("Push caps list at 10 entries")
+    func pushCaps() {
+        let store = makeStore()
+        let conn = UUID()
+        for index in 0..<15 {
+            store.push(connectionID: conn, database: "db", table: makeTable("t\(index)"))
+        }
+        let entries = store.entries(connectionID: conn, database: "db")
+        #expect(entries.count == 10)
+        #expect(entries.first?.name == "t14")
+        #expect(entries.last?.name == "t5")
+    }
+
+    @Test("Entries isolated per (connection, database) key")
+    func entriesIsolated() {
+        let store = makeStore()
+        let connA = UUID()
+        let connB = UUID()
+        store.push(connectionID: connA, database: "db", table: makeTable("alpha"))
+        store.push(connectionID: connB, database: "db", table: makeTable("beta"))
+        store.push(connectionID: connA, database: "other", table: makeTable("gamma"))
+
+        #expect(store.entries(connectionID: connA, database: "db").map(\.name) == ["alpha"])
+        #expect(store.entries(connectionID: connB, database: "db").map(\.name) == ["beta"])
+        #expect(store.entries(connectionID: connA, database: "other").map(\.name) == ["gamma"])
+    }
+
+    @Test("Schema-qualified table is distinct from same-name unqualified")
+    func schemaDistinct() {
+        let store = makeStore()
+        let conn = UUID()
+        store.push(connectionID: conn, database: "db", table: makeTable("users", schema: "public"))
+        store.push(connectionID: conn, database: "db", table: makeTable("users", schema: nil))
+        let entries = store.entries(connectionID: conn, database: "db")
+        #expect(entries.count == 2)
+    }
+
+    @Test("Nil database key is distinct from empty-string database")
+    func nilDatabaseDistinctFromEmpty() {
+        let store = makeStore()
+        let conn = UUID()
+        store.push(connectionID: conn, database: nil, table: makeTable("sqlite_table"))
+        store.push(connectionID: conn, database: "postgres", table: makeTable("pg_table"))
+        #expect(store.entries(connectionID: conn, database: nil).map(\.name) == ["sqlite_table"])
+        #expect(store.entries(connectionID: conn, database: "postgres").map(\.name) == ["pg_table"])
+    }
+}