list_tables.ts•4.45 kB
import { BaseTool } from '../base';
import { QuickbaseClient } from '../../client/quickbase';
import { createLogger } from '../../utils/logger';
const logger = createLogger('ListTablesTool');
/**
* Table information returned by list_tables
*/
export interface TableInfo {
/**
* The ID of the table
*/
id: string;
/**
* The name of the table
*/
name: string;
/**
* The description of the table
*/
description?: string;
/**
* The singular noun for records in this table
*/
singleRecordName?: string;
/**
* The plural noun for records in this table
*/
pluralRecordName?: string;
/**
* The date the table was created
*/
created?: string;
/**
* The date the table was last updated
*/
updated?: string;
/**
* Additional details about the table
*/
[key: string]: any;
}
/**
* Parameters for list_tables tool
*/
export interface ListTablesParams {
/**
* The ID of the application (optional, uses the configured one if not provided)
*/
app_id?: string;
/**
* Whether to include hidden tables in the results
*/
include_hidden?: boolean;
/**
* Filter tables by pattern (case-insensitive substring match)
*/
filter?: string;
}
/**
* Response from listing tables
*/
export interface ListTablesResult {
/**
* Array of table information
*/
tables: TableInfo[];
/**
* The application ID that was queried
*/
appId: string;
}
/**
* Tool for listing tables in a Quickbase application
*/
export class ListTablesTool extends BaseTool<ListTablesParams, ListTablesResult> {
public name = 'list_tables';
public description = 'Lists all tables in the Quickbase application';
/**
* Parameter schema for list_tables
*/
public paramSchema = {
type: 'object',
properties: {
app_id: {
type: 'string',
description: 'The ID of the application'
},
include_hidden: {
type: 'boolean',
description: 'Whether to include hidden tables'
},
filter: {
type: 'string',
description: 'Filter tables by name (case-insensitive substring match)'
}
},
required: []
};
/**
* Constructor
* @param client Quickbase client
*/
constructor(client: QuickbaseClient) {
super(client);
}
/**
* Run the list_tables tool
* @param params Tool parameters
* @returns List of tables in the application
*/
protected async run(params: ListTablesParams): Promise<ListTablesResult> {
const { app_id, include_hidden, filter } = params;
// Use provided app_id or fall back to the one from config
const appId = app_id || this.client.getConfig().appId;
if (!appId) {
throw new Error('Application ID is required but not provided in parameters or configuration');
}
logger.info('Listing tables in Quickbase application', {
appId,
includeHidden: include_hidden
});
// Prepare query parameters
const queryParams: Record<string, string> = {};
if (include_hidden !== undefined) {
queryParams.includeHidden = include_hidden.toString();
}
// List tables in the application
const response = await this.client.request({
method: 'GET',
path: `/tables?appId=${appId}`,
params: queryParams
});
if (!response.success || !response.data) {
logger.error('Failed to list tables', {
error: response.error,
appId
});
throw new Error(response.error?.message || 'Failed to list tables');
}
// Cast data to array of tables
let tables = (response.data as Record<string, any>[]).map(table => ({
id: table.id,
name: table.name,
description: table.description,
singleRecordName: table.singleRecordName,
pluralRecordName: table.pluralRecordName,
created: table.created,
updated: table.updated,
...table
}));
// Filter tables if requested
if (filter && filter.trim() !== '') {
const filterLower = filter.toLowerCase();
tables = tables.filter(table =>
table.name.toLowerCase().includes(filterLower) ||
(table.description && table.description.toLowerCase().includes(filterLower))
);
}
logger.info(`Found ${tables.length} tables in application`, { appId });
return {
tables,
appId
};
}
}