fix(datagrid): edit date cells inline and add date presets to Set Value (#1233)

* fix(datagrid): edit date cells inline and add date presets to Set Value

* refactor(datagrid): consolidate isTimeOnly and tighten Set Value DATE presets

* fix(datagrid): isolate inline editor undo, dismiss editor on row mutations, follow FK preview on row changes

* fix(datagrid): route Cmd+Z through first responder and track FK popover by focused row

Author: datlechin

CHANGELOG.md

@@ -7,13 +7,28 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Right-click Set Value submenu on date, datetime, and timestamp cells now offers current-value SQL function presets (`CURRENT_DATE` for date columns, `CURRENT_TIME` for time columns, `NOW()` and `CURRENT_TIMESTAMP` for datetime and timestamp columns).
+
 ### Changed
 
 - The connection window shows the connecting state inline with a Cancel button instead of an empty sidebar.
+- Date, datetime, and timestamp cells use the same inline text editor as other columns; the popover date picker is removed.
+- The foreign key preview popover now follows the selected row when you arrow up or down, refreshing both the anchor and the displayed reference row. Arrow left or right (column change) and row mutations dismiss the popover.
 
 ### Fixed
 
 - Closing the connection window during a slow connect no longer leaves a stuck "Connecting…" window or a stray failure alert (#1185).
+- Editing a NULL cell and dismissing without typing no longer flips the value to an empty string or marks the row as modified.
+- Data grid cells with a chevron accessory (enum, boolean, JSON, blob) no longer truncate short values that fit the full cell width.
+- Double-clicking an enum, set, or boolean cell now opens the inline text editor; the chevron still opens the picker popover.
+- Double-clicking another cell while editing no longer delays the new editor or silently drops pending changes on the previous cell.
+- DATE columns no longer render a phantom `00:00:00` time suffix; the display now matches the stored value and the editor.
+- Editing a cell, dismissing the editor, then pressing Cmd+Z multiple times no longer crashes. The inline editor now keeps its typing-undo stack private instead of pushing entries onto the window's undo manager.
+- Pressing Cmd+Z right after Add Row no longer leaves a stranded cell editor floating over the removed row; the editor now dismisses whenever rows are inserted, removed, or replaced.
+- Adding a new row no longer renders the new row view on top of the auto-opened cell editor mid-animation; the editor is kept at the front of the table view's subview list whenever a sibling is added.
+- Cmd+Z and Cmd+Shift+Z while editing a cell now undo and redo typing in the editor instead of jumping straight to data-grid changes; the menu commands route through the first responder before falling back to the window's undo manager.
 
 ## [0.40.1] - 2026-05-12
 

TablePro/Core/Services/ColumnType.swift

@@ -76,6 +76,14 @@ enum ColumnType: Equatable {
         }
     }
 
+    var isTimeOnly: Bool {
+        guard isDateType, let raw = rawType?.uppercased() else { return false }
+        return raw == "TIME"
+            || raw == "TIMETZ"
+            || raw == "TIME WITHOUT TIME ZONE"
+            || raw == "TIME WITH TIME ZONE"
+    }
+
     /// Whether this type represents long text that should use multi-line editor
     /// Checks for TEXT, LONGTEXT, MEDIUMTEXT, TINYTEXT, CLOB types
     var isLongText: Bool {

TablePro/Core/Services/Formatting/CellDisplayFormatter.swift

@@ -26,7 +26,10 @@ enum CellDisplayFormatter {
                 displayValue = ValueDisplayFormatService.applyFormat(value, format: displayFormat)
             } else if let columnType {
                 if columnType.isDateType {
-                    if let formatted = DateFormattingService.shared.format(dateString: displayValue) {
+                    if let formatted = DateFormattingService.shared.format(
+                        dateString: displayValue,
+                        columnType: columnType
+                    ) {
                         displayValue = formatted
                     }
                 } else if BlobFormattingService.shared.requiresFormatting(columnType: columnType) {

TablePro/Core/Services/Formatting/DateFormattingService.swift

@@ -17,6 +17,8 @@ final class DateFormattingService {
 
     /// Cached formatter for current user-selected format
     private var formatter: DateFormatter
+    private var dateOnlyFormatter: DateFormatter
+    private var timeOnlyFormatter: DateFormatter
 
     /// Current date format option
     private(set) var currentFormat: DateFormatOption
@@ -37,7 +39,9 @@ final class DateFormattingService {
         // Initialize with default format (ISO 8601)
         // Will be updated by AppSettingsManager after it completes initialization
         self.currentFormat = .iso8601
-        self.formatter = Self.createFormatter(for: .iso8601)
+        self.formatter = Self.createFormatter(format: DateFormatOption.iso8601.formatString)
+        self.dateOnlyFormatter = Self.createFormatter(format: DateFormatOption.iso8601.dateOnlyFormatString)
+        self.timeOnlyFormatter = Self.createFormatter(format: DateFormatOption.iso8601.timeOnlyFormatString)
         self.parsers = Self.createParsers()
         formatCache.countLimit = 100_000
     }
@@ -48,7 +52,9 @@ final class DateFormattingService {
     func updateFormat(_ format: DateFormatOption) {
         guard format != currentFormat else { return }
         currentFormat = format
-        formatter = Self.createFormatter(for: format)
+        formatter = Self.createFormatter(format: format.formatString)
+        dateOnlyFormatter = Self.createFormatter(format: format.dateOnlyFormatString)
+        timeOnlyFormatter = Self.createFormatter(format: format.timeOnlyFormatString)
         // Clear cache when format changes since all cached values are now stale
         formatCache.removeAllObjects()
     }
@@ -62,44 +68,59 @@ final class DateFormattingService {
 
     /// Format a string date value (parse then format)
     /// - Parameter dateString: Date string from database (ISO 8601, MySQL timestamp, etc.)
+    /// - Parameter columnType: Column type, used to pick date-only / time-only / datetime variant
     /// - Returns: Formatted date string, or nil if unparseable
-    func format(dateString: String) -> String? {
-        // Check cache first
-        let cacheKey = dateString as NSString
+    func format(dateString: String, columnType: ColumnType? = nil) -> String? {
+        let targetFormatter = formatter(for: columnType)
+        let cacheKey = "\(formatBucket(for: columnType))|\(dateString)" as NSString
         if let cached = formatCache.object(forKey: cacheKey) {
-            // Empty string in cache means unparseable
             return cached.length == 0 ? nil : cached as String
         }
 
         if let date = parsers[lastSuccessfulParserIndex].date(from: dateString) {
-            let result = format(date)
+            let result = targetFormatter.string(from: date)
             formatCache.setObject(result as NSString, forKey: cacheKey)
             return result
         }
         for index in parsers.indices where index != lastSuccessfulParserIndex {
             if let date = parsers[index].date(from: dateString) {
                 lastSuccessfulParserIndex = index
-                let result = format(date)
+                let result = targetFormatter.string(from: date)
                 formatCache.setObject(result as NSString, forKey: cacheKey)
                 return result
             }
         }
 
-        // Could not parse - cache empty string to avoid re-parsing
         formatCache.setObject("" as NSString, forKey: cacheKey)
         return nil
     }
 
+    private func formatter(for columnType: ColumnType?) -> DateFormatter {
+        switch columnType {
+        case .date:
+            return dateOnlyFormatter
+        case .timestamp, .datetime:
+            return columnType?.isTimeOnly == true ? timeOnlyFormatter : formatter
+        default:
+            return formatter
+        }
+    }
+
+    private func formatBucket(for columnType: ColumnType?) -> String {
+        switch columnType {
+        case .date: return "d"
+        case .timestamp, .datetime: return columnType?.isTimeOnly == true ? "t" : "dt"
+        default: return "dt"
+        }
+    }
+
     // MARK: - Private Helper Methods
 
-    /// Create formatter for a specific format option
-    /// - Parameter option: The date format option
-    /// - Returns: Configured DateFormatter
-    private static func createFormatter(for option: DateFormatOption) -> DateFormatter {
+    private static func createFormatter(format: String) -> DateFormatter {
         let formatter = DateFormatter()
-        formatter.dateFormat = option.formatString
-        formatter.locale = Locale.current  // Use user's locale for localized formatting
-        formatter.timeZone = TimeZone.current  // Use user's timezone
+        formatter.dateFormat = format
+        formatter.locale = Locale.current
+        formatter.timeZone = TimeZone.current
         return formatter
     }
 

TablePro/Models/Settings/AppSettings.swift

@@ -109,6 +109,21 @@ enum DateFormatOption: String, Codable, CaseIterable, Identifiable {
     }
 
     var formatString: String { rawValue }
+
+    var dateOnlyFormatString: String {
+        switch self {
+        case .iso8601, .iso8601Date: return "yyyy-MM-dd"
+        case .usLong, .usShort: return "MM/dd/yyyy"
+        case .euLong, .euShort: return "dd/MM/yyyy"
+        }
+    }
+
+    var timeOnlyFormatString: String {
+        switch self {
+        case .usLong: return "hh:mm:ss a"
+        default: return "HH:mm:ss"
+        }
+    }
 }
 
 /// Data grid settings

TablePro/Views/Main/MainContentCommandActions.swift

@@ -800,17 +800,23 @@ final class MainContentCommandActions {
     func undoChange() {
         if coordinator?.tabManager.selectedTab?.display.resultsViewMode == .structure {
             coordinator?.structureActions?.undo?()
-        } else {
-            coordinator?.contentWindow?.undoManager?.undo()
+            return
+        }
+        if NSApp.sendAction(NSSelectorFromString("undo:"), to: nil, from: nil) {
+            return
         }
+        coordinator?.contentWindow?.undoManager?.undo()
     }
 
     func redoChange() {
         if coordinator?.tabManager.selectedTab?.display.resultsViewMode == .structure {
             coordinator?.structureActions?.redo?()
-        } else {
-            coordinator?.contentWindow?.undoManager?.redo()
+            return
+        }
+        if NSApp.sendAction(NSSelectorFromString("redo:"), to: nil, from: nil) {
+            return
         }
+        coordinator?.contentWindow?.undoManager?.redo()
     }
 
     // MARK: - Group B Broadcast Subscribers

TablePro/Views/Results/CellOverlayEditor.swift

@@ -19,12 +19,21 @@ final class CellOverlayEditor: NSObject, NSTextViewDelegate {
     private(set) var row: Int = -1
     private(set) var column: Int = -1
     private(set) var columnIndex: Int = -1
+    private var initialValue: String = ""
 
     var onCommit: ((_ row: Int, _ columnIndex: Int, _ newValue: String) -> Void)?
     var onTabNavigation: ((_ row: Int, _ column: Int, _ forward: Bool) -> Void)?
 
     var isActive: Bool { container != nil }
 
+    var containerView: NSView? { container }
+
+    func raiseToFront() {
+        guard let container, let tableView, container.superview === tableView else { return }
+        guard tableView.subviews.last !== container else { return }
+        tableView.addSubview(container)
+    }
+
     // MARK: - Show / Dismiss
 
     func show(
@@ -34,12 +43,13 @@ final class CellOverlayEditor: NSObject, NSTextViewDelegate {
         columnIndex: Int,
         value: String
     ) {
-        dismiss(commit: false)
+        dismiss(commit: true)
 
         self.tableView = tableView
         self.row = row
         self.column = column
         self.columnIndex = columnIndex
+        self.initialValue = value
 
         let cellFrame = tableView.frameOfCell(atColumn: column, row: row)
         guard !cellFrame.isEmpty else { return }
@@ -112,18 +122,20 @@ final class CellOverlayEditor: NSObject, NSTextViewDelegate {
         guard let activeContainer = container, let activeTextView = textView else { return }
 
         let newValue = activeTextView.string
+        let originalValue = initialValue
 
         removeDismissObservers()
 
         activeContainer.removeFromSuperview()
         container = nil
         textView = nil
+        initialValue = ""
 
         if let tableView {
             tableView.window?.makeFirstResponder(tableView)
         }
 
-        if commit {
+        if commit, newValue != originalValue {
             onCommit?(row, columnIndex, newValue)
         }
     }
@@ -139,7 +151,7 @@ final class CellOverlayEditor: NSObject, NSTextViewDelegate {
                 object: clipView,
                 queue: .main
             ) { [weak self] _ in
-                Task { @MainActor [weak self] in
+                MainActor.assumeIsolated {
                     self?.dismiss(commit: true)
                 }
             }
@@ -150,7 +162,7 @@ final class CellOverlayEditor: NSObject, NSTextViewDelegate {
             object: tableView,
             queue: .main
         ) { [weak self] _ in
-            Task { @MainActor [weak self] in
+            MainActor.assumeIsolated {
                 self?.dismiss(commit: false)
             }
         }
@@ -160,7 +172,7 @@ final class CellOverlayEditor: NSObject, NSTextViewDelegate {
             object: nil,
             queue: .main
         ) { [weak self] _ in
-            Task { @MainActor [weak self] in
+            MainActor.assumeIsolated {
                 self?.dismiss(commit: true)
             }
         }
@@ -171,15 +183,14 @@ final class CellOverlayEditor: NSObject, NSTextViewDelegate {
                 object: editorWindow,
                 queue: .main
             ) { [weak self] _ in
-                Task { @MainActor [weak self] in
+                MainActor.assumeIsolated {
                     self?.dismiss(commit: true)
                 }
             }
         }
 
         outsideClickMonitor = NSEvent.addLocalMonitorForEvents(matching: [.leftMouseDown, .rightMouseDown]) { [weak self] event in
-            guard let self else { return event }
-            Task { @MainActor [weak self] in
+            MainActor.assumeIsolated {
                 self?.handleOutsideClick(event: event)
             }
             return event
@@ -263,10 +274,14 @@ private final class OverlayContainerView: NSView {
 // MARK: - Overlay Text View
 
 private final class OverlayTextView: NSTextView {
+    private let storedUndoManager = UndoManager()
+
     weak var overlayEditor: CellOverlayEditor?
 
     private static let menuKeyEquivalents: Set<String> = ["s"]
 
+    override var undoManager: UndoManager? { storedUndoManager }
+
     override func performKeyEquivalent(with event: NSEvent) -> Bool {
         if event.modifierFlags.contains(.command),
            let chars = event.charactersIgnoringModifiers,

TablePro/Views/Results/Cells/DataGridCellKind.swift

@@ -10,7 +10,6 @@ enum DataGridCellKind: Equatable {
     case foreignKey
     case dropdown
     case boolean
-    case date
     case json
     case blob
 }

TablePro/Views/Results/Cells/DataGridCellRegistry.swift

@@ -43,7 +43,6 @@ final class DataGridCellRegistry {
         if isDropdownColumn { return .dropdown }
         if let type = columnType {
             if type.isBooleanType { return .boolean }
-            if type.isDateType { return .date }
             if type.isJsonType { return .json }
             if type.isBlobType { return .blob }
         }

TablePro/Views/Results/Cells/DataGridCellView.swift

@@ -215,13 +215,18 @@ final class DataGridCellView: NSView {
 
     private func drawText(reservingTrailingWidth trailing: CGFloat) {
         guard !displayText.isEmpty else { return }
-        let availableWidth = bounds.width - 2 * DataGridMetrics.cellHorizontalInset - trailing
-        guard availableWidth > 0 else { return }
+        let totalAvailable = bounds.width - 2 * DataGridMetrics.cellHorizontalInset
+        guard totalAvailable > 0 else { return }
         guard let context = NSGraphicsContext.current?.cgContext else { return }
 
         let fullLine = cachedCTLine()
-        let lineToDraw: CTLine
         let typographicWidth = CTLineGetTypographicBounds(fullLine, nil, nil, nil)
+
+        let availableWidth: CGFloat = typographicWidth > Double(totalAvailable)
+            ? totalAvailable - trailing
+            : totalAvailable
+
+        let lineToDraw: CTLine
         if typographicWidth > Double(availableWidth) {
             let ellipsis = makeEllipsisLine()
             lineToDraw = CTLineCreateTruncatedLine(fullLine, Double(availableWidth), .end, ellipsis) ?? fullLine
@@ -284,7 +289,7 @@ final class DataGridCellView: NSView {
             let x = bounds.maxX - DataGridMetrics.cellHorizontalInset - size.width
             let y = (bounds.height - size.height) / 2
             return NSRect(x: x, y: y, width: size.width, height: size.height)
-        case .dropdown, .boolean, .date, .json, .blob:
+        case .dropdown, .boolean, .json, .blob:
             guard isEditableCell else { return .zero }
             let size = NSSize(width: 12, height: 14)
             let x = bounds.maxX - DataGridMetrics.cellHorizontalInset - size.width
@@ -301,7 +306,7 @@ final class DataGridCellView: NSView {
             return
         case .foreignKey:
             image = onEmphasizedSelection ? Self.fkArrowEmphasized : Self.fkArrowNormal
-        case .dropdown, .boolean, .date, .json, .blob:
+        case .dropdown, .boolean, .json, .blob:
             if visualState.isDeleted {
                 image = Self.chevronDisabled
             } else if onEmphasizedSelection {
@@ -332,7 +337,7 @@ final class DataGridCellView: NSView {
             case .foreignKey:
                 accessoryDelegate?.dataGridCellDidClickFKArrow(row: cellRow, columnIndex: cellColumnIndex)
                 return
-            case .dropdown, .boolean, .date, .json, .blob:
+            case .dropdown, .boolean, .json, .blob:
                 guard !visualState.isDeleted else {
                     super.mouseDown(with: event)
                     return