feat: add TableProCore cross-platform Swift Package

Author: datlechin

Packages/TableProCore/Package.swift

@@ -0,0 +1,54 @@
+// 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"])
+    ],
+    targets: [
+        .target(
+            name: "TableProPluginKit",
+            dependencies: [],
+            path: "Sources/TableProPluginKit"
+        ),
+        .target(
+            name: "TableProModels",
+            dependencies: ["TableProPluginKit"],
+            path: "Sources/TableProModels"
+        ),
+        .target(
+            name: "TableProDatabase",
+            dependencies: ["TableProModels", "TableProPluginKit"],
+            path: "Sources/TableProDatabase"
+        ),
+        .target(
+            name: "TableProQuery",
+            dependencies: ["TableProModels", "TableProPluginKit"],
+            path: "Sources/TableProQuery"
+        ),
+        .testTarget(
+            name: "TableProModelsTests",
+            dependencies: ["TableProModels", "TableProPluginKit"],
+            path: "Tests/TableProModelsTests"
+        ),
+        .testTarget(
+            name: "TableProDatabaseTests",
+            dependencies: ["TableProDatabase", "TableProModels", "TableProPluginKit"],
+            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 pluginNotFound(String)
+    case notConnected
+    case sshNotSupported
+
+    public var errorDescription: String? {
+        switch self {
+        case .pluginNotFound(let type):
+            return "No driver plugin 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,120 @@
+import Foundation
+import TableProModels
+import TableProPluginKit
+
+public final class ConnectionManager: @unchecked Sendable {
+    private let pluginLoader: PluginLoader
+    private let secureStore: SecureStore
+    private let sshProvider: SSHProvider?
+
+    private let lock = NSLock()
+    private var sessions: [UUID: ConnectionSession] = [:]
+
+    public init(
+        pluginLoader: PluginLoader,
+        secureStore: SecureStore,
+        sshProvider: SSHProvider? = nil
+    ) {
+        self.pluginLoader = pluginLoader
+        self.secureStore = secureStore
+        self.sshProvider = sshProvider
+    }
+
+    public func connect(_ connection: DatabaseConnection) async throws -> ConnectionSession {
+        let password = try secureStore.retrieve(forKey: connection.id.uuidString)
+
+        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 {
+            guard let plugin = pluginLoader.driverPlugin(for: connection.type.pluginTypeId) else {
+                throw ConnectionError.pluginNotFound(connection.type.rawValue)
+            }
+
+            let config = DriverConnectionConfig(
+                host: effectiveHost,
+                port: effectivePort,
+                username: connection.username,
+                password: password ?? "",
+                database: connection.database,
+                additionalFields: connection.additionalFields
+            )
+            let pluginDriver = plugin.createDriver(config: config)
+
+            let driver = PluginDriverAdapter(pluginDriver: pluginDriver)
+            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 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 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 }
+    }
+
+    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
+    }
+
+    public func session(for connectionId: UUID) -> ConnectionSession? {
+        lock.lock()
+        defer { lock.unlock() }
+        return sessions[connectionId]
+    }
+}

Packages/TableProCore/Sources/TableProDatabase/ConnectionSession.swift

@@ -0,0 +1,27 @@
+import Foundation
+import TableProModels
+
+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/PluginDriverAdapter.swift

@@ -0,0 +1,102 @@
+import Foundation
+import TableProModels
+import TableProPluginKit
+
+public final class PluginDriverAdapter: DatabaseDriver, @unchecked Sendable {
+    private let pluginDriver: any PluginDatabaseDriver
+
+    public init(pluginDriver: any PluginDatabaseDriver) {
+        self.pluginDriver = pluginDriver
+    }
+
+    public func connect() async throws {
+        try await pluginDriver.connect()
+    }
+
+    // PluginDatabaseDriver.disconnect() is sync and non-throwing, while
+    // DatabaseDriver.disconnect() is async throws. A non-throwing call
+    // satisfies the throwing requirement, so no try is needed here.
+    public func disconnect() async throws {
+        pluginDriver.disconnect()
+    }
+
+    public func ping() async throws -> Bool {
+        do {
+            try await pluginDriver.ping()
+            return true
+        } catch {
+            return false
+        }
+    }
+
+    public func execute(query: String) async throws -> QueryResult {
+        let pluginResult = try await pluginDriver.execute(query: query)
+        return QueryResult(from: pluginResult)
+    }
+
+    public func cancelCurrentQuery() async throws {
+        try pluginDriver.cancelQuery()
+    }
+
+    public func fetchTables(schema: String?) async throws -> [TableInfo] {
+        let pluginTables = try await pluginDriver.fetchTables(schema: schema)
+        return pluginTables.map { TableInfo(from: $0) }
+    }
+
+    public func fetchColumns(table: String, schema: String?) async throws -> [ColumnInfo] {
+        let pluginColumns = try await pluginDriver.fetchColumns(table: table, schema: schema)
+        return pluginColumns.enumerated().map { index, col in
+            ColumnInfo(from: col, ordinalPosition: index)
+        }
+    }
+
+    public func fetchIndexes(table: String, schema: String?) async throws -> [IndexInfo] {
+        let pluginIndexes = try await pluginDriver.fetchIndexes(table: table, schema: schema)
+        return pluginIndexes.map { IndexInfo(from: $0) }
+    }
+
+    public func fetchForeignKeys(table: String, schema: String?) async throws -> [ForeignKeyInfo] {
+        let pluginFKs = try await pluginDriver.fetchForeignKeys(table: table, schema: schema)
+        return pluginFKs.map { ForeignKeyInfo(from: $0) }
+    }
+
+    public func fetchDatabases() async throws -> [String] {
+        try await pluginDriver.fetchDatabases()
+    }
+
+    public func switchDatabase(to name: String) async throws {
+        try await pluginDriver.switchDatabase(to: name)
+    }
+
+    public var supportsSchemas: Bool {
+        pluginDriver.supportsSchemas
+    }
+
+    public func switchSchema(to name: String) async throws {
+        try await pluginDriver.switchSchema(to: name)
+    }
+
+    public var currentSchema: String? {
+        pluginDriver.currentSchema
+    }
+
+    public var supportsTransactions: Bool {
+        pluginDriver.supportsTransactions
+    }
+
+    public func beginTransaction() async throws {
+        try await pluginDriver.beginTransaction()
+    }
+
+    public func commitTransaction() async throws {
+        try await pluginDriver.commitTransaction()
+    }
+
+    public func rollbackTransaction() async throws {
+        try await pluginDriver.rollbackTransaction()
+    }
+
+    public var serverVersion: String? {
+        pluginDriver.serverVersion
+    }
+}