!tables

Implementation Reference

• src/index.ts:125-154 (registration)

  Registration of the '!tables' MCP tool, including the inline handler function that checks database connection and retrieves tables via dbService.getTables(), returning JSON or error.

  server.tool(
    "!tables",
    {},
    async () => {
      if (!dbService) {
        return {
          content: [{ type: "text", text: "You must connect to a database first!" }],
          isError: true,
        };
      }
  
      try {
        const tables = await dbService.getTables();
        return {
          content: [
            {
              type: "text",
              text: JSON.stringify(tables, null, 2),
            },
          ],
        };
      } catch (error: unknown) {
        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
        return {
          content: [{ type: "text", text: `Failed to get table information: ${errorMessage}` }],
          isError: true,
        };
      }
    }
  );

• src/services/database.ts:37-89 (handler)

  The core handler logic in DatabaseService.getTables() that queries the database-specific information_schema or equivalent to fetch table names and column metadata (name, type, nullable). Supports PostgreSQL, MySQL, and Firestore.

  async getTables(): Promise<TableInfo[]> {
      switch (this.config.type) {
          case 'postgres': {
              const query = `
        SELECT 
          table_name,
          json_agg(json_build_object(
            'name', column_name,
            'type', data_type,
            'nullable', is_nullable = 'YES'
          )) as columns
        FROM information_schema.columns
        WHERE table_schema = 'public'
        GROUP BY table_name;
      `;
              const result = await this.postgresClient!.query(query);
              return result.rows.map(row => ({
                  name: row.table_name,
                  columns: row.columns
              }));
          }
          case 'mysql': {
              const [rows] = await this.mysqlConnection!.query(`
        SELECT 
          TABLE_NAME as tableName,
          GROUP_CONCAT(
            JSON_OBJECT(
              'name', COLUMN_NAME,
              'type', DATA_TYPE,
              'nullable', IS_NULLABLE = 'YES'
            )
          ) as columns
        FROM information_schema.columns
        WHERE table_schema = DATABASE()
        GROUP BY TABLE_NAME;
      `);
              return rows.map((row: any) => ({
                  name: row.tableName,
                  columns: JSON.parse(`[${row.columns}]`)
              }));
          }
          case 'firestore': {
              // Firestore'da tablo yapısı olmadığı için koleksiyonları listeleyeceğiz
              const collections = await this.firestoreClient!.listCollections();
              return collections.map(collection => ({
                  name: collection.id,
                  columns: [] // Firestore şemasız olduğu için boş bırakıyoruz
              }));
          }
          default:
              return [];
      }
  }

• src/types/database.ts:20-29 (schema)

  TypeScript interface definitions for TableInfo (table name and columns array) and ColumnInfo (column name, type, nullable flag), which structure the output data from !tables tool.

  export interface TableInfo {
      name: string;
      columns: ColumnInfo[];
  }
  
  export interface ColumnInfo {
      name: string;
      type: string;
      nullable: boolean;
  }