mysql_connect

Instructions

Implementation Reference

• src/index.ts:281-304 (handler)

  The handleConnect method that executes the mysql_connect tool logic: parses and validates connection parameters using ConfigSchema, closes any existing pool, creates a new MySQL connection pool using createConnection, tests it implicitly, and returns a success message.

  private async handleConnect(args: any) {
    try {
      const config = ConfigSchema.parse(args);
      this.config = config;
      
      // Close existing connection if any
      if (this.pool) {
        await this.pool.end();
      }
  
      this.pool = await this.createConnection(config);
      
      return {
        content: [
          {
            type: "text",
            text: `Successfully connected to MySQL server at ${config.host}:${config.port}${config.database ? ` (database: ${config.database})` : ""}`,
          },
        ],
      };
    } catch (error) {
      throw new Error(`Connection failed: ${error instanceof Error ? error.message : String(error)}`);
    }
  }

• src/index.ts:15-25 (schema)

  Zod schema (ConfigSchema) used to validate input parameters for the mysql_connect tool, matching the tool's inputSchema definition.

  const ConfigSchema = z.object({
    host: z.string(),
    port: z.number().optional().default(3306),
    user: z.string(),
    password: z.string(),
    database: z.string().optional(),
    ssl: z.boolean().optional().default(false),
    connectionLimit: z.number().optional().default(10),
  });
  
  type Config = z.infer<typeof ConfigSchema>;

• src/index.ts:100-135 (registration)

  Registration of the mysql_connect tool in the ListTools response, including name, description, and input schema specification.

  {
    name: "mysql_connect",
    description: "Connect to a MySQL database with provided connection parameters",
    inputSchema: {
      type: "object",
      properties: {
        host: {
          type: "string",
          description: "MySQL server hostname or IP address",
        },
        port: {
          type: "number",
          description: "MySQL server port (default: 3306)",
          default: 3306,
        },
        user: {
          type: "string",
          description: "Database username",
        },
        password: {
          type: "string",
          description: "Database password",
        },
        database: {
          type: "string",
          description: "Database name (optional)",
        },
        ssl: {
          type: "boolean",
          description: "Use SSL connection (default: false)",
          default: false,
        },
      },
      required: ["host", "user", "password"],
    },
  },

• src/index.ts:67-94 (helper)

  Supporting method createConnection that actually sets up the mysql2/promise Pool with config options, applies SSL if needed, and tests the connection with ping before returning the pool.

  private async createConnection(config: Config): Promise<mysql.Pool> {
    try {
      const poolConfig: mysql.PoolOptions = {
        host: config.host,
        port: config.port,
        user: config.user,
        password: config.password,
        database: config.database,
        connectionLimit: config.connectionLimit,
        multipleStatements: false,
      };
  
      if (config.ssl) {
        poolConfig.ssl = {};
      }
  
      this.pool = mysql.createPool(poolConfig);
  
      // Test the connection
      const connection = await this.pool.getConnection();
      await connection.ping();
      connection.release();
  
      return this.pool;
    } catch (error) {
      throw new Error(`Failed to connect to MySQL: ${error instanceof Error ? error.message : String(error)}`);
    }
  }

• src/index.ts:248-251 (registration)

  Tool dispatch registration in the CallToolRequest handler switch statement, routing 'mysql_connect' calls to the handleConnect method.

  switch (name) {
    case "mysql_connect":
      return await this.handleConnect(args);
    case "mysql_query":