connect_database

Instructions

Implementation Reference

• index.js:245-329 (handler)

  The core handler function for the 'connect_database' tool. It merges user-provided config with environment variables, disconnects any existing connection, initializes a connection pool for PostgreSQL or MySQL, tests the connection, and returns a success message.

  async connectDatabase(config) {
    // Merge with environment variables if config is partial
    let finalConfig;
    
    if (!config.type || !config.host || !config.port || !config.database || !config.user || !config.password) {
      // Try to get missing values from env
      const envConfig = this.getConfigFromEnv();
      if (!envConfig) {
        throw new Error(
          'Incomplete database configuration. Provide all parameters or set environment variables:\n' +
          'For PostgreSQL: DB_TYPE=postgresql, DB_HOST, DB_PORT, DB_DATABASE, DB_USER, DB_PASSWORD\n' +
          'For MySQL: DB_TYPE=mysql, MYSQL_HOST, MYSQL_PORT, MYSQL_DATABASE, MYSQL_USER, MYSQL_PASSWORD'
        );
      }
      
      // Merge provided config with env config (provided values take precedence)
      finalConfig = {
        type: config.type || envConfig.type,
        host: config.host || envConfig.host,
        port: config.port || envConfig.port,
        database: config.database || envConfig.database,
        user: config.user || envConfig.user,
        password: config.password || envConfig.password,
        ssl: config.ssl !== undefined ? config.ssl : envConfig.ssl,
      };
    } else {
      finalConfig = config;
    }
  
    // Disconnect existing connections
    await this.disconnectDatabase();
  
    this.currentConfig = finalConfig;
  
    if (finalConfig.type === 'postgresql') {
      this.postgresPool = new Pool({
        host: finalConfig.host,
        port: finalConfig.port,
        database: finalConfig.database,
        user: finalConfig.user,
        password: finalConfig.password,
        ssl: finalConfig.ssl ? { rejectUnauthorized: false } : false,
        max: 10,
      });
  
      // Test connection
      const client = await this.postgresPool.connect();
      await client.query('SELECT NOW()');
      client.release();
  
      return {
        content: [
          {
            type: 'text',
            text: `Successfully connected to PostgreSQL database: ${finalConfig.database}@${finalConfig.host}:${finalConfig.port}`,
          },
        ],
      };
    } else if (finalConfig.type === 'mysql') {
      this.mysqlConnection = mysql.createPool({
        host: finalConfig.host,
        port: finalConfig.port,
        database: finalConfig.database,
        user: finalConfig.user,
        password: finalConfig.password,
        ssl: finalConfig.ssl ? {} : undefined,
        waitForConnections: true,
        connectionLimit: 10,
      });
  
      // Test connection
      await this.mysqlConnection.query('SELECT NOW()');
  
      return {
        content: [
          {
            type: 'text',
            text: `Successfully connected to MySQL database: ${finalConfig.database}@${finalConfig.host}:${finalConfig.port}`,
          },
        ],
      };
    } else {
      throw new Error(`Unsupported database type: ${finalConfig.type}`);
    }
  }

• index.js:116-151 (schema)

  Input schema defining the parameters for connecting to a database: type (postgresql/mysql), host, port, database, user, password, ssl.

  inputSchema: {
    type: 'object',
    properties: {
      type: {
        type: 'string',
        enum: ['postgresql', 'mysql'],
        description: 'Database type (optional if using env vars)',
      },
      host: {
        type: 'string',
        description: 'Database host (optional if using env vars)',
      },
      port: {
        type: 'number',
        description: 'Database port (optional if using env vars)',
      },
      database: {
        type: 'string',
        description: 'Database name (optional if using env vars)',
      },
      user: {
        type: 'string',
        description: 'Database user (optional if using env vars)',
      },
      password: {
        type: 'string',
        description: 'Database password (optional if using env vars)',
      },
      ssl: {
        type: 'boolean',
        description: 'Use SSL connection (optional)',
        default: false,
      },
    },
    required: [],
  },

• index.js:112-152 (registration)

  Tool registration in the ListToolsRequestSchema handler, including name, description, and input schema.

  {
    name: 'connect_database',
    description:
      'Connect to a PostgreSQL or MySQL database. Parameters can be provided directly or loaded from environment variables. If no parameters are provided, will use environment variables (DB_TYPE, DB_HOST, DB_PORT, DB_DATABASE, DB_USER, DB_PASSWORD, DB_SSL). For PostgreSQL: POSTGRES_HOST, POSTGRES_PORT, etc. For MySQL: MYSQL_HOST, MYSQL_PORT, etc.',
    inputSchema: {
      type: 'object',
      properties: {
        type: {
          type: 'string',
          enum: ['postgresql', 'mysql'],
          description: 'Database type (optional if using env vars)',
        },
        host: {
          type: 'string',
          description: 'Database host (optional if using env vars)',
        },
        port: {
          type: 'number',
          description: 'Database port (optional if using env vars)',
        },
        database: {
          type: 'string',
          description: 'Database name (optional if using env vars)',
        },
        user: {
          type: 'string',
          description: 'Database user (optional if using env vars)',
        },
        password: {
          type: 'string',
          description: 'Database password (optional if using env vars)',
        },
        ssl: {
          type: 'boolean',
          description: 'Use SSL connection (optional)',
          default: false,
        },
      },
      required: [],
    },
  },

• index.js:213-214 (registration)

  Dispatch logic in the CallToolRequestSchema handler that routes 'connect_database' calls to the connectDatabase method.

  case 'connect_database':
    return await this.connectDatabase(args);

• index.js:38-95 (helper)

  Supporting utility to extract and validate database configuration from various environment variable formats for both PostgreSQL and MySQL.

  getConfigFromEnv() {
    // Check for PostgreSQL env vars
    const pgHost = process.env.DB_HOST || process.env.POSTGRES_HOST;
    const pgPort = process.env.DB_PORT || process.env.POSTGRES_PORT;
    const pgDatabase = process.env.DB_DATABASE || process.env.POSTGRES_DATABASE;
    const pgUser = process.env.DB_USER || process.env.POSTGRES_USER;
    const pgPassword = process.env.DB_PASSWORD || process.env.POSTGRES_PASSWORD;
    const dbType = process.env.DB_TYPE || process.env.DATABASE_TYPE;
  
    // Check for MySQL env vars
    const mysqlHost = process.env.MYSQL_HOST;
    const mysqlPort = process.env.MYSQL_PORT;
    const mysqlDatabase = process.env.MYSQL_DATABASE;
    const mysqlUser = process.env.MYSQL_USER;
    const mysqlPassword = process.env.MYSQL_PASSWORD;
  
    // Determine database type
    let type = null;
    if (dbType) {
      type = dbType.toLowerCase() === 'mysql' ? 'mysql' : 'postgresql';
    } else if (mysqlHost || mysqlDatabase) {
      type = 'mysql';
    } else if (pgHost || pgDatabase) {
      type = 'postgresql';
    }
  
    if (!type) {
      return null;
    }
  
    if (type === 'postgresql') {
      if (!pgHost || !pgPort || !pgDatabase || !pgUser || !pgPassword) {
        return null;
      }
      return {
        type: 'postgresql',
        host: pgHost,
        port: parseInt(pgPort, 10),
        database: pgDatabase,
        user: pgUser,
        password: pgPassword,
        ssl: process.env.DB_SSL === 'true' || process.env.POSTGRES_SSL === 'true',
      };
    } else {
      if (!mysqlHost || !mysqlPort || !mysqlDatabase || !mysqlUser || !mysqlPassword) {
        return null;
      }
      return {
        type: 'mysql',
        host: mysqlHost,
        port: parseInt(mysqlPort, 10),
        database: mysqlDatabase,
        user: mysqlUser,
        password: mysqlPassword,
        ssl: process.env.DB_SSL === 'true' || process.env.MYSQL_SSL === 'true',
      };
    }
  }