@bytebase/dbhub 0.1.0 → 0.1.2

package/dist/connectors/sqlserver/index.js

@@ -1,186 +0,0 @@
-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/prompts/db-explainer.js

@@ -1,201 +0,0 @@
-import { z } from "zod";
-import { ConnectorManager } from '../connectors/manager.js';
-import { formatPromptSuccessResponse, formatPromptErrorResponse } from '../utils/response-formatter.js';
-// Schema for database explainer prompt
-export const dbExplainerSchema = {
-    target: z.string().describe("Name of the table, column, or database to explain")
-};
-/**
- * Database Explainer Prompt Handler
- * Provides explanations about database elements
- */
-export async function dbExplainerPromptHandler({ target }, _extra) {
-    try {
-        const connector = ConnectorManager.getCurrentConnector();
-        // First check if this is a table name
-        const tables = await connector.getTables();
-        const normalizedTarget = target.toLowerCase();
-        // Check if target matches a table
-        const matchingTable = tables.find(t => t.toLowerCase() === normalizedTarget);
-        if (matchingTable) {
-            // Explain the table
-            const columns = await connector.getTableSchema(matchingTable);
-            // Create a table structure description
-            const tableDescription = `Table: ${matchingTable}
-      
-Structure:
-${columns.map(col => `- ${col.column_name} (${col.data_type})${col.is_nullable === 'YES' ? ', nullable' : ''}${col.column_default ? `, default: ${col.column_default}` : ''}`).join('\n')}
-
-Purpose:
-This table appears to store ${determineTablePurpose(matchingTable, columns)}
-
-Relationships:
-${determineRelationships(matchingTable, columns)}`;
-            return formatPromptSuccessResponse(tableDescription);
-        }
-        // Check if target is a table.column format
-        if (target.includes('.')) {
-            const [tableName, columnName] = target.split('.');
-            if (tables.find(t => t.toLowerCase() === tableName.toLowerCase())) {
-                // Get column info
-                const columns = await connector.getTableSchema(tableName);
-                const column = columns.find(c => c.column_name.toLowerCase() === columnName.toLowerCase());
-                if (column) {
-                    const columnDescription = `Column: ${tableName}.${column.column_name}
-          
-Type: ${column.data_type}
-Nullable: ${column.is_nullable === 'YES' ? 'Yes' : 'No'}
-Default: ${column.column_default || 'None'}
-
-Purpose:
-${determineColumnPurpose(column.column_name, column.data_type)}`;
-                    return formatPromptSuccessResponse(columnDescription);
-                }
-            }
-        }
-        // If target is not a specific table or column, provide database overview
-        // Determine if 'database' or similar term is in the target
-        if (['database', 'db', 'schema', 'overview', 'all'].includes(normalizedTarget)) {
-            let dbOverview = `Database Overview
-
-Tables: ${tables.length}
-${tables.map(t => `- ${t}`).join('\n')}
-
-This database ${describeDatabasePurpose(tables)}`;
-            return formatPromptSuccessResponse(dbOverview);
-        }
-        // If no match is found but the target could be a partial match
-        const possibleTableMatches = tables.filter(t => t.toLowerCase().includes(normalizedTarget) ||
-            normalizedTarget.includes(t.toLowerCase()));
-        if (possibleTableMatches.length > 0) {
-            return formatPromptSuccessResponse(`Could not find exact match for "${target}". Did you mean one of these tables?\n\n${possibleTableMatches.join('\n')}`);
-        }
-        // No match found
-        return formatPromptErrorResponse(`Could not find a table, column, or database feature matching "${target}"`, "NOT_FOUND");
-    }
-    catch (error) {
-        return formatPromptErrorResponse(`Error explaining database: ${error.message}`, "EXPLANATION_ERROR");
-    }
-}
-/**
- * Helper function to make an educated guess about the purpose of a table
- * based on its name and columns
- */
-function determineTablePurpose(tableName, columns) {
-    const lowerTableName = tableName.toLowerCase();
-    const columnNames = columns.map(c => c.column_name.toLowerCase());
-    // Check for common patterns
-    if (lowerTableName.includes('user') || columnNames.includes('username') || columnNames.includes('email')) {
-        return 'user information and profiles';
-    }
-    if (lowerTableName.includes('order') || lowerTableName.includes('purchase')) {
-        return 'order or purchase transactions';
-    }
-    if (lowerTableName.includes('product') || lowerTableName.includes('item')) {
-        return 'product or item information';
-    }
-    if (lowerTableName.includes('log') || columnNames.includes('timestamp')) {
-        return 'event or activity logs';
-    }
-    if (columnNames.includes('created_at') && columnNames.includes('updated_at')) {
-        return 'tracking timestamped data records';
-    }
-    // Default
-    return 'data related to ' + tableName;
-}
-/**
- * Helper function to determine potential relationships based on column names
- */
-function determineRelationships(tableName, columns) {
-    const potentialRelationships = [];
-    // Look for _id columns which often indicate foreign keys
-    const idColumns = columns.filter(c => c.column_name.toLowerCase().endsWith('_id') &&
-        !c.column_name.toLowerCase().startsWith(tableName.toLowerCase()));
-    if (idColumns.length > 0) {
-        idColumns.forEach(col => {
-            const referencedTable = col.column_name.toLowerCase().replace('_id', '');
-            potentialRelationships.push(`May have a relationship with the "${referencedTable}" table (via ${col.column_name})`);
-        });
-    }
-    // Check if the table itself might be referenced by others
-    if (columns.some(c => c.column_name.toLowerCase() === 'id')) {
-        potentialRelationships.push(`May be referenced by other tables as "${tableName.toLowerCase()}_id"`);
-    }
-    return potentialRelationships.length > 0
-        ? potentialRelationships.join('\n')
-        : 'No obvious relationships identified based on column names';
-}
-/**
- * Helper function to determine the purpose of a column based on naming patterns
- */
-function determineColumnPurpose(columnName, dataType) {
-    const lowerColumnName = columnName.toLowerCase();
-    if (lowerColumnName === 'id') {
-        return 'Primary identifier for records in this table';
-    }
-    if (lowerColumnName.endsWith('_id')) {
-        const referencedTable = lowerColumnName.replace('_id', '');
-        return `Foreign key reference to the "${referencedTable}" table`;
-    }
-    if (lowerColumnName.includes('name')) {
-        return 'Stores name information';
-    }
-    if (lowerColumnName.includes('email')) {
-        return 'Stores email address information';
-    }
-    if (lowerColumnName.includes('password') || lowerColumnName.includes('hash')) {
-        return 'Stores security credential information (likely hashed)';
-    }
-    if (lowerColumnName === 'created_at' || lowerColumnName === 'created_on') {
-        return 'Timestamp for when the record was created';
-    }
-    if (lowerColumnName === 'updated_at' || lowerColumnName === 'modified_at') {
-        return 'Timestamp for when the record was last updated';
-    }
-    if (lowerColumnName.includes('date') || lowerColumnName.includes('time')) {
-        return 'Stores date or time information';
-    }
-    if (lowerColumnName.includes('price') || lowerColumnName.includes('cost') || lowerColumnName.includes('amount')) {
-        return 'Stores monetary value information';
-    }
-    // Data type specific purposes
-    if (dataType.includes('boolean')) {
-        return 'Stores a true/false flag';
-    }
-    if (dataType.includes('json')) {
-        return 'Stores structured JSON data';
-    }
-    if (dataType.includes('text') || dataType.includes('varchar') || dataType.includes('char')) {
-        return 'Stores text information';
-    }
-    // Default
-    return `Stores ${dataType} data`;
-}
-/**
- * Helper function to describe the overall database purpose based on tables
- */
-function describeDatabasePurpose(tables) {
-    const tableNames = tables.map(t => t.toLowerCase());
-    if (tableNames.some(t => t.includes('user')) &&
-        tableNames.some(t => t.includes('order'))) {
-        return 'appears to be an e-commerce or customer order management system';
-    }
-    if (tableNames.some(t => t.includes('patient')) ||
-        tableNames.some(t => t.includes('medical'))) {
-        return 'appears to be related to healthcare or medical record management';
-    }
-    if (tableNames.some(t => t.includes('student')) ||
-        tableNames.some(t => t.includes('course'))) {
-        return 'appears to be related to education or student management';
-    }
-    if (tableNames.some(t => t.includes('employee')) ||
-        tableNames.some(t => t.includes('payroll'))) {
-        return 'appears to be related to HR or employee management';
-    }
-    if (tableNames.some(t => t.includes('inventory')) ||
-        tableNames.some(t => t.includes('stock'))) {
-        return 'appears to be related to inventory or stock management';
-    }
-    // Default
-    return 'contains multiple tables that store related information';
-}

package/dist/prompts/index.js

@@ -1,11 +0,0 @@
-import { sqlGeneratorPromptHandler, sqlGeneratorSchema } from './sql-generator.js';
-import { dbExplainerPromptHandler, dbExplainerSchema } from './db-explainer.js';
-/**
- * Register all prompt handlers with the MCP server
- */
-export function registerPrompts(server) {
-    // Register SQL Generator prompt
-    server.prompt("generate_sql", "Generate SQL queries from natural language descriptions", sqlGeneratorSchema, sqlGeneratorPromptHandler);
-    // Register Database Explainer prompt
-    server.prompt("explain_db", "Get explanations about database tables, columns, and structures", dbExplainerSchema, dbExplainerPromptHandler);
-}

package/dist/prompts/sql-generator.js

@@ -1,114 +0,0 @@
-import { z } from "zod";
-import { ConnectorManager } from '../connectors/manager.js';
-import { formatPromptSuccessResponse, formatPromptErrorResponse } from '../utils/response-formatter.js';
-// Schema for SQL generator prompt
-export const sqlGeneratorSchema = {
-    description: z.string().describe("Natural language description of the SQL query to generate"),
-    dialect: z.enum(["postgres", "sqlite"]).optional().describe("SQL dialect to use (optional)")
-};
-/**
- * SQL Generator Prompt Handler
- * Generates SQL queries from natural language descriptions
- */
-export async function sqlGeneratorPromptHandler({ description, dialect }, _extra) {
-    try {
-        // Get current connector to determine dialect if not specified
-        const connector = ConnectorManager.getCurrentConnector();
-        // Determine SQL dialect from connector if not explicitly provided
-        const sqlDialect = dialect ||
-            (connector.id === 'postgres' ? 'postgres' :
-                (connector.id === 'sqlite' ? 'sqlite' : 'postgres'));
-        // Get schema information to help with table/column references
-        const tables = await connector.getTables();
-        const tableSchemas = await Promise.all(tables.map(async (table) => {
-            try {
-                const columns = await connector.getTableSchema(table);
-                return {
-                    table,
-                    columns: columns.map(col => ({
-                        name: col.column_name,
-                        type: col.data_type
-                    }))
-                };
-            }
-            catch (error) {
-                // Skip tables we can't access
-                return null;
-            }
-        }));
-        // Filter out null entries (tables we couldn't access)
-        const accessibleSchemas = tableSchemas.filter(schema => schema !== null);
-        // Generate a schema description for context
-        const schemaContext = accessibleSchemas.length > 0
-            ? `Available tables and their columns:\n${accessibleSchemas.map(schema => `- ${schema.table}: ${schema.columns.map(col => `${col.name} (${col.type})`).join(', ')}`).join('\n')}`
-            : 'No schema information available.';
-        // Example queries for the given dialect to use as reference
-        const dialectExamples = {
-            postgres: [
-                "SELECT * FROM users WHERE created_at > NOW() - INTERVAL '1 day'",
-                "SELECT u.name, COUNT(o.id) FROM users u JOIN orders o ON u.id = o.user_id GROUP BY u.name HAVING COUNT(o.id) > 5",
-                "SELECT product_name, price FROM products WHERE price > (SELECT AVG(price) FROM products)"
-            ],
-            sqlite: [
-                "SELECT * FROM users WHERE created_at > datetime('now', '-1 day')",
-                "SELECT u.name, COUNT(o.id) FROM users u JOIN orders o ON u.id = o.user_id GROUP BY u.name HAVING COUNT(o.id) > 5",
-                "SELECT product_name, price FROM products WHERE price > (SELECT AVG(price) FROM products)"
-            ]
-        };
-        // Build a prompt that would help generate the SQL
-        // In a real implementation, this would call an AI model
-        const prompt = `
-Generate a ${sqlDialect} SQL query based on this description: "${description}"
-
-${schemaContext}
-
-The query should:
-1. Be written for ${sqlDialect} dialect
-2. Use only the available tables and columns
-3. Prioritize readability
-4. Include appropriate comments
-5. Be compatible with ${sqlDialect} syntax
-`;
-        // In a real implementation, this would be the result from an AI model call
-        // For this demo, we'll generate a simple SQL query based on the description
-        let generatedSQL;
-        // Very simple pattern matching for demo purposes
-        // In a real implementation, this would use a language model
-        if (description.toLowerCase().includes('count')) {
-            generatedSQL = `-- Count query generated from: "${description}"
-SELECT COUNT(*) AS count 
-FROM ${accessibleSchemas.length > 0 ? accessibleSchemas[0].table : 'table_name'};`;
-        }
-        else if (description.toLowerCase().includes('average') || description.toLowerCase().includes('avg')) {
-            const table = accessibleSchemas.length > 0 ? accessibleSchemas[0].table : 'table_name';
-            const numericColumn = accessibleSchemas.length > 0
-                ? accessibleSchemas[0].columns.find(col => ['int', 'numeric', 'decimal', 'float', 'real', 'double'].some(t => col.type.includes(t)))?.name || 'numeric_column'
-                : 'numeric_column';
-            generatedSQL = `-- Average query generated from: "${description}"
-SELECT AVG(${numericColumn}) AS average
-FROM ${table};`;
-        }
-        else if (description.toLowerCase().includes('join')) {
-            generatedSQL = `-- Join query generated from: "${description}"
-SELECT t1.*, t2.*
-FROM ${accessibleSchemas.length > 0 ? accessibleSchemas[0]?.table : 'table1'} t1
-JOIN ${accessibleSchemas.length > 1 ? accessibleSchemas[1]?.table : 'table2'} t2
-  ON t1.id = t2.${accessibleSchemas.length > 0 ? accessibleSchemas[0]?.table : 'table1'}_id;`;
-        }
-        else {
-            // Default to a simple SELECT
-            const table = accessibleSchemas.length > 0 ? accessibleSchemas[0].table : 'table_name';
-            generatedSQL = `-- Query generated from: "${description}"
-SELECT * 
-FROM ${table}
-LIMIT 10;`;
-        }
-        // Return the generated SQL with explanations
-        return formatPromptSuccessResponse(generatedSQL, 
-        // Add references to example queries that could help
-        dialectExamples[sqlDialect]);
-    }
-    catch (error) {
-        return formatPromptErrorResponse(`Failed to generate SQL: ${error.message}`, "SQL_GENERATION_ERROR");
-    }
-}

package/dist/resources/index.js

@@ -1,12 +0,0 @@
-import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { tablesResourceHandler } from './tables.js';
-import { schemaResourceHandler } from './schema.js';
-/**
- * Register all resource handlers with the MCP server
- */
-export function registerResources(server) {
-    // Resource for listing all tables
-    server.resource("tables", "db://tables", tablesResourceHandler);
-    // Resource for getting table schema
-    server.resource("schema", new ResourceTemplate("db://schema/{tableName}", { list: undefined }), schemaResourceHandler);
-}

package/dist/resources/schema.js

@@ -1,36 +0,0 @@
-import { ConnectorManager } from '../connectors/manager.js';
-import { createResourceSuccessResponse, createResourceErrorResponse } from '../utils/response-formatter.js';
-/**
- * Schema resource handler
- * Returns schema information for a specific table
- */
-export async function schemaResourceHandler(uri, variables, _extra) {
-    const connector = ConnectorManager.getCurrentConnector();
-    // Handle tableName which could be a string or string array from URL template
-    const tableName = Array.isArray(variables.tableName)
-        ? variables.tableName[0]
-        : variables.tableName;
-    try {
-        // If table doesn't exist, getTableSchema will throw an error
-        const columns = await connector.getTableSchema(tableName);
-        // Create a more structured response
-        const formattedColumns = columns.map(col => ({
-            name: col.column_name,
-            type: col.data_type,
-            nullable: col.is_nullable === 'YES',
-            default: col.column_default
-        }));
-        // Prepare response data
-        const responseData = {
-            table: tableName,
-            columns: formattedColumns,
-            count: formattedColumns.length
-        };
-        // Use the utility to create a standardized response
-        return createResourceSuccessResponse(uri.href, responseData);
-    }
-    catch (error) {
-        // Use the utility to create a standardized error response
-        return createResourceErrorResponse(uri.href, `Table '${tableName}' does not exist or cannot be accessed`, "TABLE_NOT_FOUND");
-    }
-}

package/dist/resources/tables.js

@@ -1,17 +0,0 @@
-import { ConnectorManager } from '../connectors/manager.js';
-import { createResourceSuccessResponse } from '../utils/response-formatter.js';
-/**
- * Tables resource handler
- * Returns a list of all tables in the database
- */
-export async function tablesResourceHandler(uri, _extra) {
-    const connector = ConnectorManager.getCurrentConnector();
-    const tableNames = await connector.getTables();
-    // Prepare response data
-    const responseData = {
-        tables: tableNames,
-        count: tableNames.length
-    };
-    // Use the utility to create a standardized response
-    return createResourceSuccessResponse(uri.href, responseData);
-}