list_tables

Instructions

Implementation Reference

• src/tools/list-tables.ts:5-58 (handler)

  The core handler function 'listTables' that queries INFORMATION_SCHEMA.TABLES for base tables, optionally filtered by schema name, and returns results as JSON.

  export async function listTables(
    db: DatabaseConnection,
    schemaName?: string
  ): Promise<CallToolResult> {
    try {
      const pool = db.getPool()
  
      let query = `
        SELECT 
          TABLE_SCHEMA,
          TABLE_NAME,
          TABLE_TYPE
        FROM INFORMATION_SCHEMA.TABLES
        WHERE TABLE_TYPE = 'BASE TABLE'
      `.trim()
  
      const request = pool.request()
  
      if (schemaName) {
        query += ' AND TABLE_SCHEMA = @schemaName'
        request.input('schemaName', schemaName)
      }
  
      query += ' ORDER BY TABLE_SCHEMA, TABLE_NAME'
  
      const result = await request.query(query)
  
      return {
        content: [
          {
            type: 'text',
            text: JSON.stringify(
              {
                tables: result.recordset,
                count: result.recordset.length,
              },
              null,
              2
            ),
          },
        ],
      }
    } catch (error) {
      return {
        content: [
          {
            type: 'text',
            text: `Erro: ${error instanceof Error ? error.message : 'Erro desconhecido'}`,
          },
        ],
        isError: true,
      }
    }
  }

• src/schemas.ts:20-26 (schema)

  Zod schema definition for 'listTablesInput' with an optional 'schemaName' string parameter.

  export const listTablesInput = z.object({
    schemaName: z
      .string()
      .optional()
      .describe('Schema name to filter tables (default: dbo)')
      .default('dbo'),
  })

• src/schemas.ts:64-74 (schema)

  Registration of 'list_tables' in the toolsSchemas mapping (line 67) and the ListTablesInput type export (line 78).

  export const toolsSchemas = {
    execute_query: executeQueryInput,
    get_table_schema: getTableSchemaInput,
    list_tables: listTablesInput,
    get_database_info: getDatabaseInfoInput,
    list_procedures: listProceduresInput,
    list_functions: listFunctionsInput,
    get_procedure_schema: getProcedureSchemaInput,
    get_function_schema: getFunctionSchemaInput,
    execute_procedure: executeProcedureInput,
  } as const

• src/tools/index.ts:23-41 (registration)

  Re-export of the listTables handler (line 23) and registration of 'list_tables' tool in the toolsList() function (lines 38-41) with description and JSON schema.

  export { listTables } from './list-tables'
  
  export function toolsList() {
    return [
      {
        name: 'execute_query',
        description: 'Executes a SQL query in SQL Server',
        inputSchema: zodToJsonSchema(executeQueryInput),
      },
      {
        name: 'get_table_schema',
        description: 'Gets the schema of a specific table',
        inputSchema: zodToJsonSchema(getTableSchemaInput),
      },
      {
        name: 'list_tables',
        description: 'Lists all the tables in the database',
        inputSchema: zodToJsonSchema(listTablesInput),
      },

• src/services/SqlServerMCPService.ts:98-101 (registration)

  Handler wire-up in the createHandlerMap() method: maps 'list_tables' string to a lambda that parses args and delegates to the imported listTables function.

  handlers.set('list_tables', async (database, args) => {
    const { schemaName } = args as ListTablesInput
    return await listTables(database, schemaName)
  })