@bytebase/dbhub 0.1.0 → 0.1.1

package/dist/connectors/mysql/index.js

@@ -1,169 +0,0 @@
-import mysql from 'mysql2/promise';
-import { ConnectorRegistry } from '../interface.js';
-/**
- * MySQL DSN Parser
- * Handles DSN strings like: mysql://user:password@localhost:3306/dbname
- */
-class MySQLDSNParser {
-    parse(dsn) {
-        // Basic validation
-        if (!this.isValidDSN(dsn)) {
-            throw new Error(`Invalid MySQL DSN: ${dsn}`);
-        }
-        try {
-            const url = new URL(dsn);
-            const config = {
-                host: url.hostname,
-                port: url.port ? parseInt(url.port) : 3306,
-                database: url.pathname.substring(1), // Remove leading '/'
-                user: url.username,
-                password: url.password,
-            };
-            // Handle query parameters
-            url.searchParams.forEach((value, key) => {
-                if (key === 'ssl') {
-                    config.ssl = value === 'true' ? {} : undefined;
-                }
-                // Add other parameters as needed
-            });
-            return config;
-        }
-        catch (error) {
-            throw new Error(`Failed to parse MySQL DSN: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    getSampleDSN() {
-        return 'mysql://root:password@localhost:3306/mysql';
-    }
-    isValidDSN(dsn) {
-        try {
-            const url = new URL(dsn);
-            return url.protocol === 'mysql:';
-        }
-        catch (error) {
-            return false;
-        }
-    }
-}
-/**
- * MySQL Connector Implementation
- */
-export class MySQLConnector {
-    constructor() {
-        this.id = 'mysql';
-        this.name = 'MySQL';
-        this.dsnParser = new MySQLDSNParser();
-        this.pool = null;
-    }
-    async connect(dsn) {
-        try {
-            const config = this.dsnParser.parse(dsn);
-            this.pool = mysql.createPool(config);
-            // Test the connection
-            const [rows] = await this.pool.query('SELECT 1');
-            console.error("Successfully connected to MySQL database");
-        }
-        catch (err) {
-            console.error("Failed to connect to MySQL database:", err);
-            throw err;
-        }
-    }
-    async disconnect() {
-        if (this.pool) {
-            await this.pool.end();
-            this.pool = null;
-        }
-    }
-    async getTables() {
-        if (!this.pool) {
-            throw new Error('Not connected to database');
-        }
-        try {
-            // Get all tables from the current database
-            const [rows] = await this.pool.query(`
-        SELECT table_name 
-        FROM information_schema.tables 
-        WHERE table_schema = DATABASE()
-        ORDER BY table_name
-      `);
-            return rows.map(row => row.table_name);
-        }
-        catch (error) {
-            console.error("Error getting tables:", error);
-            throw error;
-        }
-    }
-    async tableExists(tableName) {
-        if (!this.pool) {
-            throw new Error('Not connected to database');
-        }
-        try {
-            const [rows] = await this.pool.query(`
-        SELECT COUNT(*) as count
-        FROM information_schema.tables 
-        WHERE table_schema = DATABASE() 
-        AND table_name = ?
-      `, [tableName]);
-            return rows[0].count > 0;
-        }
-        catch (error) {
-            console.error("Error checking if table exists:", error);
-            throw error;
-        }
-    }
-    async getTableSchema(tableName) {
-        if (!this.pool) {
-            throw new Error('Not connected to database');
-        }
-        try {
-            // Get table columns
-            const [rows] = await this.pool.query(`
-        SELECT 
-          column_name, 
-          data_type, 
-          is_nullable,
-          column_default
-        FROM information_schema.columns
-        WHERE table_schema = DATABASE()
-        AND table_name = ?
-        ORDER BY ordinal_position
-      `, [tableName]);
-            return rows;
-        }
-        catch (error) {
-            console.error("Error getting table schema:", error);
-            throw error;
-        }
-    }
-    async executeQuery(query) {
-        if (!this.pool) {
-            throw new Error('Not connected to database');
-        }
-        const safetyCheck = this.validateQuery(query);
-        if (!safetyCheck.isValid) {
-            throw new Error(safetyCheck.message || "Query validation failed");
-        }
-        try {
-            const [rows, fields] = await this.pool.query(query);
-            return { rows, fields };
-        }
-        catch (error) {
-            console.error("Error executing query:", error);
-            throw error;
-        }
-    }
-    validateQuery(query) {
-        // Basic check to prevent non-SELECT queries
-        const normalizedQuery = query.trim().toLowerCase();
-        if (!normalizedQuery.startsWith('select')) {
-            return {
-                isValid: false,
-                message: "Only SELECT queries are allowed for security reasons."
-            };
-        }
-        return { isValid: true };
-    }
-}
-// Create and register the connector
-const mysqlConnector = new MySQLConnector();
-ConnectorRegistry.register(mysqlConnector);

package/dist/connectors/postgres/index.js

@@ -1,172 +0,0 @@
-import pg from 'pg';
-const { Pool } = pg;
-import { ConnectorRegistry } from '../interface.js';
-/**
- * PostgreSQL DSN Parser
- * Handles DSN strings like: postgres://user:password@localhost:5432/dbname?sslmode=disable
- */
-class PostgresDSNParser {
-    parse(dsn) {
-        // Basic validation
-        if (!this.isValidDSN(dsn)) {
-            throw new Error(`Invalid PostgreSQL DSN: ${dsn}`);
-        }
-        try {
-            // For PostgreSQL, we can actually pass the DSN directly to the Pool constructor
-            // But we'll parse it here for consistency and to extract components if needed
-            const url = new URL(dsn);
-            const config = {
-                host: url.hostname,
-                port: url.port ? parseInt(url.port) : 5432,
-                database: url.pathname.substring(1), // Remove leading '/'
-                user: url.username,
-                password: url.password,
-            };
-            // Handle query parameters (like sslmode, etc.)
-            url.searchParams.forEach((value, key) => {
-                if (key === 'sslmode') {
-                    config.ssl = value !== 'disable';
-                }
-                // Add other parameters as needed
-            });
-            return config;
-        }
-        catch (error) {
-            throw new Error(`Failed to parse PostgreSQL DSN: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    getSampleDSN() {
-        return 'postgres://postgres:password@localhost:5432/postgres?sslmode=disable';
-    }
-    isValidDSN(dsn) {
-        try {
-            const url = new URL(dsn);
-            return url.protocol === 'postgres:' || url.protocol === 'postgresql:';
-        }
-        catch (error) {
-            return false;
-        }
-    }
-}
-/**
- * PostgreSQL Connector Implementation
- */
-export class PostgresConnector {
-    constructor() {
-        this.id = 'postgres';
-        this.name = 'PostgreSQL';
-        this.dsnParser = new PostgresDSNParser();
-        this.pool = null;
-    }
-    async connect(dsn) {
-        try {
-            const config = this.dsnParser.parse(dsn);
-            this.pool = new Pool(config);
-            // Test the connection
-            const client = await this.pool.connect();
-            console.error("Successfully connected to PostgreSQL database");
-            client.release();
-        }
-        catch (err) {
-            console.error("Failed to connect to PostgreSQL database:", err);
-            throw err;
-        }
-    }
-    async disconnect() {
-        if (this.pool) {
-            await this.pool.end();
-            this.pool = null;
-        }
-    }
-    async getTables() {
-        if (!this.pool) {
-            throw new Error('Not connected to database');
-        }
-        const client = await this.pool.connect();
-        try {
-            const result = await client.query(`
-        SELECT table_name 
-        FROM information_schema.tables 
-        WHERE table_schema = 'public'
-        ORDER BY table_name
-      `);
-            return result.rows.map(row => row.table_name);
-        }
-        finally {
-            client.release();
-        }
-    }
-    async tableExists(tableName) {
-        if (!this.pool) {
-            throw new Error('Not connected to database');
-        }
-        const client = await this.pool.connect();
-        try {
-            const result = await client.query(`
-        SELECT EXISTS (
-          SELECT FROM information_schema.tables 
-          WHERE table_schema = 'public' 
-          AND table_name = $1
-        )
-      `, [tableName]);
-            return result.rows[0].exists;
-        }
-        finally {
-            client.release();
-        }
-    }
-    async getTableSchema(tableName) {
-        if (!this.pool) {
-            throw new Error('Not connected to database');
-        }
-        const client = await this.pool.connect();
-        try {
-            // Get table columns
-            const result = await client.query(`
-        SELECT 
-          column_name, 
-          data_type, 
-          is_nullable,
-          column_default
-        FROM information_schema.columns
-        WHERE table_schema = 'public'
-        AND table_name = $1
-        ORDER BY ordinal_position
-      `, [tableName]);
-            return result.rows;
-        }
-        finally {
-            client.release();
-        }
-    }
-    async executeQuery(query) {
-        if (!this.pool) {
-            throw new Error('Not connected to database');
-        }
-        const safetyCheck = this.validateQuery(query);
-        if (!safetyCheck.isValid) {
-            throw new Error(safetyCheck.message || "Query validation failed");
-        }
-        const client = await this.pool.connect();
-        try {
-            return await client.query(query);
-        }
-        finally {
-            client.release();
-        }
-    }
-    validateQuery(query) {
-        // Basic check to prevent non-SELECT queries
-        const normalizedQuery = query.trim().toLowerCase();
-        if (!normalizedQuery.startsWith('select')) {
-            return {
-                isValid: false,
-                message: "Only SELECT queries are allowed for security reasons."
-            };
-        }
-        return { isValid: true };
-    }
-}
-// Create and register the connector
-const postgresConnector = new PostgresConnector();
-ConnectorRegistry.register(postgresConnector);

package/dist/connectors/sqlite/index.js

@@ -1,208 +0,0 @@
-/**
- * SQLite Connector Implementation
- *
- * Implements SQLite database connectivity for DBHub
- * To use this connector:
- * 1. Set DSN=sqlite:///path/to/database.db in your .env file
- * 2. Or set DB_CONNECTOR_TYPE=sqlite for default in-memory database
- */
-import { ConnectorRegistry } from '../interface.js';
-import sqlite3 from 'sqlite3';
-/**
- * SQLite DSN Parser
- * Handles DSN strings like:
- * - sqlite:///path/to/database.db (absolute path)
- * - sqlite://./relative/path/to/database.db (relative path)
- * - sqlite::memory: (in-memory database)
- */
-class SQLiteDSNParser {
-    parse(dsn) {
-        // Basic validation
-        if (!this.isValidDSN(dsn)) {
-            throw new Error(`Invalid SQLite DSN: ${dsn}`);
-        }
-        try {
-            const url = new URL(dsn);
-            let dbPath;
-            // Handle in-memory database
-            if (url.hostname === '' && url.pathname === ':memory:') {
-                dbPath = ':memory:';
-            }
-            // Handle file paths
-            else {
-                // Get the path part, handling both relative and absolute paths
-                if (url.pathname.startsWith('//')) {
-                    // Absolute path: sqlite:///path/to/db.sqlite
-                    dbPath = url.pathname.substring(2); // Remove leading //
-                }
-                else {
-                    // Relative path: sqlite://./path/to/db.sqlite
-                    dbPath = url.pathname;
-                }
-            }
-            return { dbPath };
-        }
-        catch (error) {
-            throw new Error(`Failed to parse SQLite DSN: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    getSampleDSN() {
-        return 'sqlite:///path/to/database.db';
-    }
-    isValidDSN(dsn) {
-        try {
-            const url = new URL(dsn);
-            return url.protocol === 'sqlite:';
-        }
-        catch (error) {
-            return false;
-        }
-    }
-}
-export class SQLiteConnector {
-    constructor() {
-        this.id = 'sqlite';
-        this.name = 'SQLite';
-        this.dsnParser = new SQLiteDSNParser();
-        this.db = null;
-        this.dbPath = ':memory:'; // Default to in-memory database
-    }
-    async connect(dsn, initScript) {
-        const config = this.dsnParser.parse(dsn);
-        this.dbPath = config.dbPath;
-        return new Promise((resolve, reject) => {
-            this.db = new sqlite3.Database(this.dbPath, (err) => {
-                if (err) {
-                    console.error("Failed to connect to SQLite database:", err);
-                    reject(err);
-                }
-                else {
-                    // Can't use console.log here because it will break the stdio transport
-                    console.error("Successfully connected to SQLite database");
-                    // If an initialization script is provided, run it
-                    if (initScript) {
-                        this.db.exec(initScript, (err) => {
-                            if (err) {
-                                console.error("Failed to initialize database with script:", err);
-                                reject(err);
-                            }
-                            else {
-                                console.error("Successfully initialized database with script");
-                                resolve();
-                            }
-                        });
-                    }
-                    else {
-                        resolve();
-                    }
-                }
-            });
-        });
-    }
-    async disconnect() {
-        // Close the SQLite connection
-        if (this.db) {
-            return new Promise((resolve, reject) => {
-                this.db.close((err) => {
-                    if (err) {
-                        reject(err);
-                    }
-                    else {
-                        this.db = null;
-                        resolve();
-                    }
-                });
-            });
-        }
-        return Promise.resolve();
-    }
-    async getTables() {
-        if (!this.db) {
-            throw new Error("Not connected to SQLite database");
-        }
-        return new Promise((resolve, reject) => {
-            this.db.all(`SELECT name FROM sqlite_master 
-         WHERE type='table' AND name NOT LIKE 'sqlite_%'
-         ORDER BY name`, (err, rows) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(rows.map(row => row.name));
-                }
-            });
-        });
-    }
-    async tableExists(tableName) {
-        if (!this.db) {
-            throw new Error("Not connected to SQLite database");
-        }
-        return new Promise((resolve, reject) => {
-            this.db.get(`SELECT name FROM sqlite_master 
-         WHERE type='table' AND name = ?`, [tableName], (err, row) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(!!row);
-                }
-            });
-        });
-    }
-    async getTableSchema(tableName) {
-        if (!this.db) {
-            throw new Error("Not connected to SQLite database");
-        }
-        return new Promise((resolve, reject) => {
-            this.db.all(`PRAGMA table_info(${tableName})`, (err, rows) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    // Convert SQLite schema format to our standard TableColumn format
-                    const columns = rows.map(row => ({
-                        column_name: row.name,
-                        data_type: row.type,
-                        is_nullable: row.notnull === 0 ? 'YES' : 'NO', // In SQLite, 0 means nullable
-                        column_default: row.dflt_value
-                    }));
-                    resolve(columns);
-                }
-            });
-        });
-    }
-    async executeQuery(query) {
-        if (!this.db) {
-            throw new Error("Not connected to SQLite database");
-        }
-        // Validate query for safety
-        const safetyCheck = this.validateQuery(query);
-        if (!safetyCheck.isValid) {
-            throw new Error(safetyCheck.message || "Query validation failed");
-        }
-        return new Promise((resolve, reject) => {
-            this.db.all(query, (err, rows) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve({ rows });
-                }
-            });
-        });
-    }
-    validateQuery(query) {
-        // Basic check to prevent non-SELECT queries
-        const normalizedQuery = query.trim().toLowerCase();
-        if (!normalizedQuery.startsWith('select')) {
-            return {
-                isValid: false,
-                message: "Only SELECT queries are allowed for security reasons."
-            };
-        }
-        return { isValid: true };
-    }
-}
-// Register the SQLite connector
-const sqliteConnector = new SQLiteConnector();
-ConnectorRegistry.register(sqliteConnector);