fix: Oracle view crash caused by LONG column type in OracleNIO decoder

Packages/TableProCore/Package.swift

@@ -0,0 +1,60 @@
+// swift-tools-version: 5.9
+
+import PackageDescription
+
+let package = Package(
+    name: "TableProCore",
+    platforms: [
+        .macOS(.v14),
+        .iOS(.v17)
+    ],
+    products: [
+        .library(name: "TableProPluginKit", targets: ["TableProPluginKit"]),
+        .library(name: "TableProModels", targets: ["TableProModels"]),
+        .library(name: "TableProDatabase", targets: ["TableProDatabase"]),
+        .library(name: "TableProQuery", targets: ["TableProQuery"]),
+        .library(name: "TableProSync", targets: ["TableProSync"])
+    ],
+    targets: [
+        .target(
+            name: "TableProPluginKit",
+            dependencies: [],
+            path: "Sources/TableProPluginKit"
+        ),
+        .target(
+            name: "TableProModels",
+            dependencies: ["TableProPluginKit"],
+            path: "Sources/TableProModels"
+        ),
+        .target(
+            name: "TableProDatabase",
+            dependencies: ["TableProModels"],
+            path: "Sources/TableProDatabase"
+        ),
+        .target(
+            name: "TableProQuery",
+            dependencies: ["TableProModels", "TableProPluginKit"],
+            path: "Sources/TableProQuery"
+        ),
+        .target(
+            name: "TableProSync",
+            dependencies: ["TableProModels"],
+            path: "Sources/TableProSync"
+        ),
+        .testTarget(
+            name: "TableProModelsTests",
+            dependencies: ["TableProModels", "TableProPluginKit"],
+            path: "Tests/TableProModelsTests"
+        ),
+        .testTarget(
+            name: "TableProDatabaseTests",
+            dependencies: ["TableProDatabase", "TableProModels"],
+            path: "Tests/TableProDatabaseTests"
+        ),
+        .testTarget(
+            name: "TableProQueryTests",
+            dependencies: ["TableProQuery", "TableProModels", "TableProPluginKit"],
+            path: "Tests/TableProQueryTests"
+        )
+    ]
+)

Packages/TableProCore/Sources/TableProDatabase/ConnectionError.swift

@@ -0,0 +1,18 @@
+import Foundation
+
+public enum ConnectionError: Error, LocalizedError {
+    case driverNotFound(String)
+    case notConnected
+    case sshNotSupported
+
+    public var errorDescription: String? {
+        switch self {
+        case .driverNotFound(let type):
+            return "No driver available for database type: \(type)"
+        case .notConnected:
+            return "Not connected to database"
+        case .sshNotSupported:
+            return "SSH tunneling is not available on this platform"
+        }
+    }
+}

Packages/TableProCore/Sources/TableProDatabase/ConnectionManager.swift

@@ -0,0 +1,132 @@
+import Foundation
+import TableProModels
+
+public final class ConnectionManager: @unchecked Sendable {
+    private let driverFactory: DriverFactory
+    private let secureStore: SecureStore
+    private let sshProvider: SSHProvider?
+
+    private let lock = NSLock()
+    private var sessions: [UUID: ConnectionSession] = [:]
+
+    public init(
+        driverFactory: DriverFactory,
+        secureStore: SecureStore,
+        sshProvider: SSHProvider? = nil
+    ) {
+        self.driverFactory = driverFactory
+        self.secureStore = secureStore
+        self.sshProvider = sshProvider
+    }
+
+    public func connect(_ connection: DatabaseConnection) async throws -> ConnectionSession {
+        let password = try secureStore.retrieve(forKey: Self.passwordKey(for: connection.id))
+
+        var effectiveHost = connection.host
+        var effectivePort = connection.port
+        if connection.sshEnabled, let ssh = connection.sshConfiguration {
+            guard let provider = sshProvider else {
+                throw ConnectionError.sshNotSupported
+            }
+            let tunnel = try await provider.createTunnel(
+                config: ssh,
+                remoteHost: connection.host,
+                remotePort: connection.port
+            )
+            effectiveHost = tunnel.localHost
+            effectivePort = tunnel.localPort
+        }
+
+        do {
+            var effectiveConnection = connection
+            effectiveConnection.host = effectiveHost
+            effectiveConnection.port = effectivePort
+
+            let driver = try driverFactory.createDriver(for: effectiveConnection, password: password)
+            try await driver.connect()
+
+            let session = ConnectionSession(
+                connectionId: connection.id,
+                driver: driver,
+                activeDatabase: connection.database,
+                status: .connected
+            )
+            storeSession(session, for: connection.id)
+            return session
+        } catch {
+            if connection.sshEnabled, let provider = sshProvider {
+                try? await provider.closeTunnel(for: connection.id)
+            }
+            throw error
+        }
+    }
+
+    public func storePassword(_ password: String, for connectionId: UUID) throws {
+        try secureStore.store(password, forKey: Self.passwordKey(for: connectionId))
+    }
+
+    public func deletePassword(for connectionId: UUID) throws {
+        try secureStore.delete(forKey: Self.passwordKey(for: connectionId))
+    }
+
+    private static func passwordKey(for connectionId: UUID) -> String {
+        "com.TablePro.password.\(connectionId.uuidString)"
+    }
+
+    public func disconnect(_ connectionId: UUID) async {
+        let session = removeSession(for: connectionId)
+        guard let session else { return }
+        try? await session.driver.disconnect()
+        if let sshProvider {
+            try? await sshProvider.closeTunnel(for: connectionId)
+        }
+    }
+
+    public func disconnectAll() async {
+        let ids = allSessionIds()
+        for id in ids {
+            await disconnect(id)
+        }
+    }
+
+    private func allSessionIds() -> [UUID] {
+        lock.lock()
+        defer { lock.unlock() }
+        return Array(sessions.keys)
+    }
+
+    public func updateSession(_ connectionId: UUID, _ mutation: (inout ConnectionSession) -> Void) {
+        lock.lock()
+        defer { lock.unlock() }
+        guard var session = sessions[connectionId] else { return }
+        mutation(&session)
+        sessions[connectionId] = session
+    }
+
+    public func switchDatabase(_ connectionId: UUID, to database: String) async throws {
+        guard let session = session(for: connectionId) else {
+            throw ConnectionError.notConnected
+        }
+        try await session.driver.switchDatabase(to: database)
+        updateSession(connectionId) { $0.activeDatabase = database }
+    }
+
+    public func session(for connectionId: UUID) -> ConnectionSession? {
+        lock.lock()
+        defer { lock.unlock() }
+        return sessions[connectionId]
+    }
+
+    private func storeSession(_ session: ConnectionSession, for id: UUID) {
+        lock.lock()
+        sessions[id] = session
+        lock.unlock()
+    }
+
+    private func removeSession(for id: UUID) -> ConnectionSession? {
+        lock.lock()
+        let session = sessions.removeValue(forKey: id)
+        lock.unlock()
+        return session
+    }
+}

Packages/TableProCore/Sources/TableProDatabase/ConnectionSession.swift

@@ -0,0 +1,30 @@
+import Foundation
+import TableProModels
+
+/// Note: Views hold a snapshot of this struct. Mutable fields (activeDatabase, status)
+/// are only updated through ConnectionManager.updateSession and should be re-fetched
+/// from the manager when needed rather than read from a held copy.
+public struct ConnectionSession: Sendable {
+    public let connectionId: UUID
+    public let driver: any DatabaseDriver
+    public internal(set) var activeDatabase: String
+    public internal(set) var currentSchema: String?
+    public internal(set) var status: ConnectionStatus
+    public internal(set) var tables: [TableInfo]
+
+    public init(
+        connectionId: UUID,
+        driver: any DatabaseDriver,
+        activeDatabase: String,
+        currentSchema: String? = nil,
+        status: ConnectionStatus = .connected,
+        tables: [TableInfo] = []
+    ) {
+        self.connectionId = connectionId
+        self.driver = driver
+        self.activeDatabase = activeDatabase
+        self.currentSchema = currentSchema
+        self.status = status
+        self.tables = tables
+    }
+}

Packages/TableProCore/Sources/TableProDatabase/DatabaseDriver.swift

@@ -0,0 +1,29 @@
+import Foundation
+import TableProModels
+
+public protocol DatabaseDriver: AnyObject, Sendable {
+    func connect() async throws
+    func disconnect() async throws
+    func ping() async throws -> Bool
+
+    func execute(query: String) async throws -> QueryResult
+    func cancelCurrentQuery() async throws
+
+    func fetchTables(schema: String?) async throws -> [TableInfo]
+    func fetchColumns(table: String, schema: String?) async throws -> [ColumnInfo]
+    func fetchIndexes(table: String, schema: String?) async throws -> [IndexInfo]
+    func fetchForeignKeys(table: String, schema: String?) async throws -> [ForeignKeyInfo]
+    func fetchDatabases() async throws -> [String]
+
+    func switchDatabase(to name: String) async throws
+    var supportsSchemas: Bool { get }
+    func switchSchema(to name: String) async throws
+    var currentSchema: String? { get }
+
+    var supportsTransactions: Bool { get }
+    func beginTransaction() async throws
+    func commitTransaction() async throws
+    func rollbackTransaction() async throws
+
+    var serverVersion: String? { get }
+}

Packages/TableProCore/Sources/TableProDatabase/Protocols/DriverFactory.swift

@@ -0,0 +1,9 @@
+import Foundation
+import TableProModels
+
+/// Creates database drivers for a given connection.
+/// macOS: plugin-based implementation. iOS: direct driver creation.
+public protocol DriverFactory: Sendable {
+    func createDriver(for connection: DatabaseConnection, password: String?) throws -> any DatabaseDriver
+    func supportedTypes() -> [DatabaseType]
+}

Packages/TableProCore/Sources/TableProDatabase/Protocols/SSHProvider.swift

@@ -0,0 +1,22 @@
+import Foundation
+import TableProModels
+
+public protocol SSHProvider: Sendable {
+    func createTunnel(
+        config: SSHConfiguration,
+        remoteHost: String,
+        remotePort: Int
+    ) async throws -> SSHTunnel
+
+    func closeTunnel(for connectionId: UUID) async throws
+}
+
+public struct SSHTunnel: Sendable {
+    public let localHost: String
+    public let localPort: Int
+
+    public init(localHost: String, localPort: Int) {
+        self.localHost = localHost
+        self.localPort = localPort
+    }
+}

Packages/TableProCore/Sources/TableProDatabase/Protocols/SecureStore.swift

@@ -0,0 +1,7 @@
+import Foundation
+
+public protocol SecureStore: Sendable {
+    func store(_ value: String, forKey key: String) throws
+    func retrieve(forKey key: String) throws -> String?
+    func delete(forKey key: String) throws
+}

Packages/TableProCore/Sources/TableProModels/ConnectionGroup.swift

@@ -0,0 +1,17 @@
+import Foundation
+
+public struct ConnectionGroup: Identifiable, Codable, Sendable {
+    public var id: UUID
+    public var name: String
+    public var sortOrder: Int
+
+    public init(
+        id: UUID = UUID(),
+        name: String = "",
+        sortOrder: Int = 0
+    ) {
+        self.id = id
+        self.name = name
+        self.sortOrder = sortOrder
+    }
+}

Packages/TableProCore/Sources/TableProModels/ConnectionTag.swift

@@ -0,0 +1,17 @@
+import Foundation
+
+public struct ConnectionTag: Identifiable, Codable, Sendable {
+    public var id: UUID
+    public var name: String
+    public var colorHex: String
+
+    public init(
+        id: UUID = UUID(),
+        name: String = "",
+        colorHex: String = "#808080"
+    ) {
+        self.id = id
+        self.name = name
+        self.colorHex = colorHex
+    }
+}