@bytebase/dbhub 0.0.5 → 0.0.6

package/dist/connectors/sqlserver/index.js

@@ -0,0 +1,186 @@
+import sql from 'mssql';
+import { ConnectorRegistry } from '../interface.js';
+/**
+ * SQL Server DSN parser
+ * Expected format: mssql://username:password@host:port/database
+ */
+export class SQLServerDSNParser {
+    parse(dsn) {
+        // Remove the protocol prefix
+        if (!this.isValidDSN(dsn)) {
+            throw new Error('Invalid SQL Server DSN format. Expected: mssql://username:password@host:port/database');
+        }
+        // Parse the DSN
+        const url = new URL(dsn);
+        const host = url.hostname;
+        const port = url.port ? parseInt(url.port, 10) : 1433; // Default SQL Server port
+        const database = url.pathname.substring(1); // Remove leading slash
+        const user = url.username;
+        const password = url.password;
+        // Parse additional options from query parameters
+        const options = {};
+        for (const [key, value] of url.searchParams.entries()) {
+            if (key === 'encrypt') {
+                options.encrypt = value;
+            }
+            else if (key === 'trustServerCertificate') {
+                options.trustServerCertificate = value === 'true';
+            }
+            else if (key === 'connectTimeout') {
+                options.connectTimeout = parseInt(value, 10);
+            }
+            else if (key === 'requestTimeout') {
+                options.requestTimeout = parseInt(value, 10);
+            }
+        }
+        // Construct and return the config
+        return {
+            user,
+            password,
+            server: host,
+            port,
+            database,
+            options: {
+                encrypt: options.encrypt ?? true, // Default to encrypted connection
+                trustServerCertificate: options.trustServerCertificate === true, // Need explicit conversion to boolean
+                connectTimeout: options.connectTimeout ?? 15000,
+                requestTimeout: options.requestTimeout ?? 15000,
+            },
+        };
+    }
+    getSampleDSN() {
+        return 'mssql://username:password@localhost:1433/database?encrypt=true';
+    }
+    isValidDSN(dsn) {
+        try {
+            const url = new URL(dsn);
+            return url.protocol === 'mssql:';
+        }
+        catch (e) {
+            return false;
+        }
+    }
+}
+/**
+ * SQL Server connector
+ */
+export class SQLServerConnector {
+    constructor() {
+        this.id = 'sqlserver';
+        this.name = 'SQL Server';
+        this.dsnParser = new SQLServerDSNParser();
+    }
+    async connect(dsn) {
+        try {
+            this.config = this.dsnParser.parse(dsn);
+            if (!this.config.options) {
+                this.config.options = {};
+            }
+            this.connection = await new sql.ConnectionPool(this.config).connect();
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async disconnect() {
+        if (this.connection) {
+            await this.connection.close();
+            this.connection = undefined;
+        }
+    }
+    async getTables() {
+        if (!this.connection) {
+            throw new Error('Not connected to SQL Server database');
+        }
+        try {
+            const result = await this.connection.request().query(`
+        SELECT TABLE_NAME 
+        FROM INFORMATION_SCHEMA.TABLES 
+        ORDER BY TABLE_NAME
+      `);
+            return result.recordset.map((row) => row.TABLE_NAME);
+        }
+        catch (error) {
+            throw new Error(`Failed to get tables: ${error.message}`);
+        }
+    }
+    async tableExists(tableName) {
+        if (!this.connection) {
+            throw new Error('Not connected to SQL Server database');
+        }
+        try {
+            const result = await this.connection.request()
+                .input('tableName', sql.VarChar, tableName)
+                .query(`
+          SELECT COUNT(*) as count
+          FROM INFORMATION_SCHEMA.TABLES
+          WHERE TABLE_NAME = @tableName
+        `);
+            return result.recordset[0].count > 0;
+        }
+        catch (error) {
+            throw new Error(`Failed to check if table exists: ${error.message}`);
+        }
+    }
+    async getTableSchema(tableName) {
+        if (!this.connection) {
+            throw new Error('Not connected to SQL Server database');
+        }
+        try {
+            const result = await this.connection.request()
+                .input('tableName', sql.VarChar, tableName)
+                .query(`
+          SELECT 
+            COLUMN_NAME as column_name,
+            DATA_TYPE as data_type,
+            IS_NULLABLE as is_nullable,
+            COLUMN_DEFAULT as column_default
+          FROM INFORMATION_SCHEMA.COLUMNS
+          WHERE TABLE_NAME = @tableName
+          ORDER BY ORDINAL_POSITION
+        `);
+            return result.recordset;
+        }
+        catch (error) {
+            throw new Error(`Failed to get schema for table ${tableName}: ${error.message}`);
+        }
+    }
+    async executeQuery(query) {
+        if (!this.connection) {
+            throw new Error('Not connected to SQL Server database');
+        }
+        const safetyCheck = this.validateQuery(query);
+        if (!safetyCheck.isValid) {
+            throw new Error(safetyCheck.message || "Query validation failed");
+        }
+        try {
+            const result = await this.connection.request().query(query);
+            return {
+                rows: result.recordset || [],
+                fields: result.recordset && result.recordset.length > 0
+                    ? Object.keys(result.recordset[0]).map(key => ({
+                        name: key,
+                    }))
+                    : [],
+                rowCount: result.rowsAffected[0] || 0,
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to execute query: ${error.message}`);
+        }
+    }
+    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 sqlServerConnector = new SQLServerConnector();
+ConnectorRegistry.register(sqlServerConnector);

package/dist/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 // Import connector modules to register them
 import './connectors/postgres/index.js'; // Register PostgreSQL connector
+import './connectors/sqlserver/index.js'; // Register SQL Server connector
 // import './connectors/sqlite/index.js';  // Uncomment to enable SQLite
 // Import main function from server.ts
 import { main } from './server.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytebase/dbhub",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "Universal Database MCP Server",
   "main": "dist/index.js",
   "type": "module",
@@ -19,13 +19,16 @@
     "@modelcontextprotocol/sdk": "^1.6.1",
     "dotenv": "^16.4.7",
     "express": "^4.18.2",
+    "mssql": "^11.0.1",
     "pg": "^8.13.3",
     "zod": "^3.24.2"
   },
   "devDependencies": {
     "@types/express": "^4.17.21",
+    "@types/mssql": "^9.1.7",
     "@types/node": "^22.13.10",
     "@types/pg": "^8.11.11",
+    "cross-env": "^7.0.3",
     "ts-node": "^10.9.2",
     "tsx": "^4.19.3",
     "typescript": "^5.8.2"
@@ -45,6 +48,7 @@
   "scripts": {
     "build": "tsc",
     "start": "node dist/index.js",
-    "dev": "NODE_ENV=development tsx src/index.ts"
+    "dev": "NODE_ENV=development tsx src/index.ts",
+    "crossdev": "cross-env NODE_ENV=development tsx src/index.ts"
   }
 }