@slates-integrations/postgresql 0.2.0-rc.6 → 0.2.0-rc.9

package/src/tools/describe-table.ts

@@ -1,231 +0,0 @@
-import { SlateTool } from '@slates/provider';
-import { spec } from '../spec';
-import { createClient, escapeIdentifier } from '../lib/helpers';
-import { z } from 'zod';
-
-export let describeTable = SlateTool.create(spec, {
-  name: 'Describe Table',
-  key: 'describe_table',
-  description: `Get detailed schema information for a specific table, including columns, data types, constraints, indexes, and foreign keys.
-Useful for understanding table structure before building queries or modifying schemas.`,
-  tags: {
-    readOnly: true
-  }
-})
-  .input(
-    z.object({
-      tableName: z.string().describe('Name of the table to describe'),
-      schemaName: z
-        .string()
-        .optional()
-        .describe('Schema containing the table. Defaults to the configured default schema.')
-    })
-  )
-  .output(
-    z.object({
-      tableName: z.string().describe('Name of the described table'),
-      schemaName: z.string().describe('Schema of the described table'),
-      columns: z
-        .array(
-          z.object({
-            columnName: z.string().describe('Column name'),
-            dataType: z.string().describe('PostgreSQL data type'),
-            isNullable: z.boolean().describe('Whether the column allows NULL values'),
-            defaultValue: z.string().nullable().describe('Default value expression'),
-            maxLength: z
-              .number()
-              .nullable()
-              .describe('Maximum character length for character types'),
-            isPrimaryKey: z
-              .boolean()
-              .describe('Whether this column is part of the primary key'),
-            ordinalPosition: z.number().describe('Column position in the table')
-          })
-        )
-        .describe('Column definitions'),
-      indexes: z
-        .array(
-          z.object({
-            indexName: z.string().describe('Name of the index'),
-            isUnique: z.boolean().describe('Whether this is a unique index'),
-            isPrimary: z.boolean().describe('Whether this is the primary key index'),
-            indexColumns: z.array(z.string()).describe('Columns included in the index'),
-            indexType: z
-              .string()
-              .describe('Index access method (btree, hash, gin, gist, etc.)')
-          })
-        )
-        .describe('Indexes on the table'),
-      foreignKeys: z
-        .array(
-          z.object({
-            constraintName: z.string().describe('Name of the foreign key constraint'),
-            columnName: z.string().describe('Local column name'),
-            referencedTable: z.string().describe('Referenced table (schema.table)'),
-            referencedColumn: z.string().describe('Referenced column name')
-          })
-        )
-        .describe('Foreign key relationships'),
-      estimatedRowCount: z.number().nullable().describe('Estimated number of rows'),
-      sizeFormatted: z.string().nullable().describe('Human-readable table size')
-    })
-  )
-  .handleInvocation(async ctx => {
-    let client = createClient(ctx.auth, ctx.config);
-    let schema = ctx.input.schemaName || ctx.config.defaultSchema;
-    let table = ctx.input.tableName;
-
-    ctx.info(`Describing table: ${schema}.${table}`);
-
-    // Fetch columns
-    let columnsResult = await client.query(
-      `
-      SELECT
-        c.column_name,
-        c.data_type,
-        c.udt_name,
-        c.is_nullable,
-        c.column_default,
-        c.character_maximum_length,
-        c.ordinal_position,
-        COALESCE(
-          (SELECT true FROM information_schema.key_column_usage kcu
-           JOIN information_schema.table_constraints tc
-             ON tc.constraint_name = kcu.constraint_name
-             AND tc.table_schema = kcu.table_schema
-           WHERE tc.constraint_type = 'PRIMARY KEY'
-             AND kcu.table_schema = c.table_schema
-             AND kcu.table_name = c.table_name
-             AND kcu.column_name = c.column_name
-           LIMIT 1),
-          false
-        ) AS is_primary_key
-      FROM information_schema.columns c
-      WHERE c.table_schema = '${schema.replace(/'/g, "''")}'
-        AND c.table_name = '${table.replace(/'/g, "''")}'
-      ORDER BY c.ordinal_position
-    `,
-      ctx.config.queryTimeout
-    );
-
-    // Fetch indexes
-    let indexesResult = await client.query(
-      `
-      SELECT
-        i.relname AS index_name,
-        ix.indisunique AS is_unique,
-        ix.indisprimary AS is_primary,
-        am.amname AS index_type,
-        array_agg(a.attname ORDER BY array_position(ix.indkey, a.attnum)) AS index_columns
-      FROM pg_index ix
-      JOIN pg_class t ON t.oid = ix.indrelid
-      JOIN pg_class i ON i.oid = ix.indexrelid
-      JOIN pg_namespace n ON n.oid = t.relnamespace
-      JOIN pg_am am ON am.oid = i.relam
-      JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
-      WHERE t.relname = '${table.replace(/'/g, "''")}'
-        AND n.nspname = '${schema.replace(/'/g, "''")}'
-      GROUP BY i.relname, ix.indisunique, ix.indisprimary, am.amname
-      ORDER BY i.relname
-    `,
-      ctx.config.queryTimeout
-    );
-
-    // Fetch foreign keys
-    let fkResult = await client.query(
-      `
-      SELECT
-        tc.constraint_name,
-        kcu.column_name,
-        ccu.table_schema || '.' || ccu.table_name AS referenced_table,
-        ccu.column_name AS referenced_column
-      FROM information_schema.table_constraints tc
-      JOIN information_schema.key_column_usage kcu
-        ON tc.constraint_name = kcu.constraint_name
-        AND tc.table_schema = kcu.table_schema
-      JOIN information_schema.constraint_column_usage ccu
-        ON ccu.constraint_name = tc.constraint_name
-        AND ccu.table_schema = tc.table_schema
-      WHERE tc.constraint_type = 'FOREIGN KEY'
-        AND tc.table_schema = '${schema.replace(/'/g, "''")}'
-        AND tc.table_name = '${table.replace(/'/g, "''")}'
-      ORDER BY tc.constraint_name
-    `,
-      ctx.config.queryTimeout
-    );
-
-    // Fetch size info
-    let sizeResult = await client.query(
-      `
-      SELECT
-        c.reltuples::bigint AS estimated_row_count,
-        pg_size_pretty(pg_total_relation_size(c.oid)) AS size_formatted
-      FROM pg_class c
-      JOIN pg_namespace n ON n.oid = c.relnamespace
-      WHERE c.relname = '${table.replace(/'/g, "''")}'
-        AND n.nspname = '${schema.replace(/'/g, "''")}'
-      LIMIT 1
-    `,
-      ctx.config.queryTimeout
-    );
-
-    let columns = columnsResult.rows.map((row: any) => ({
-      columnName: row.column_name as string,
-      dataType:
-        row.udt_name === 'int4'
-          ? 'integer'
-          : row.udt_name === 'int8'
-            ? 'bigint'
-            : row.udt_name === 'int2'
-              ? 'smallint'
-              : row.udt_name === 'float4'
-                ? 'real'
-                : row.udt_name === 'float8'
-                  ? 'double precision'
-                  : row.udt_name === 'bool'
-                    ? 'boolean'
-                    : (row.data_type as string),
-      isNullable: row.is_nullable === 'YES',
-      defaultValue: row.column_default as string | null,
-      maxLength:
-        row.character_maximum_length != null ? Number(row.character_maximum_length) : null,
-      isPrimaryKey: row.is_primary_key === true,
-      ordinalPosition: Number(row.ordinal_position)
-    }));
-
-    let indexes = indexesResult.rows.map((row: any) => ({
-      indexName: row.index_name as string,
-      isUnique: row.is_unique === true,
-      isPrimary: row.is_primary === true,
-      indexColumns: Array.isArray(row.index_columns)
-        ? row.index_columns
-        : typeof row.index_columns === 'string'
-          ? row.index_columns.replace(/[{}]/g, '').split(',')
-          : [],
-      indexType: row.index_type as string
-    }));
-
-    let foreignKeys = fkResult.rows.map((row: any) => ({
-      constraintName: row.constraint_name as string,
-      columnName: row.column_name as string,
-      referencedTable: row.referenced_table as string,
-      referencedColumn: row.referenced_column as string
-    }));
-
-    let sizeRow = sizeResult.rows[0] as any;
-
-    return {
-      output: {
-        tableName: table,
-        schemaName: schema,
-        columns,
-        indexes,
-        foreignKeys,
-        estimatedRowCount:
-          sizeRow?.estimated_row_count != null ? Number(sizeRow.estimated_row_count) : null,
-        sizeFormatted: (sizeRow?.size_formatted as string) ?? null
-      },
-      message: `Table \`${schema}.${table}\` has **${columns.length}** column(s), **${indexes.length}** index(es), and **${foreignKeys.length}** foreign key(s).`
-    };
-  })
-  .build();

package/src/tools/execute-query.ts

@@ -1,95 +0,0 @@
-import { SlateTool } from '@slates/provider';
-import { spec } from '../spec';
-import { createClient } from '../lib/helpers';
-import { z } from 'zod';
-
-export let executeQuery = SlateTool.create(spec, {
-  name: 'Execute SQL Query',
-  key: 'execute_query',
-  description: `Execute an arbitrary SQL query against the PostgreSQL database. Supports all SQL operations including SELECT, INSERT, UPDATE, DELETE, CREATE, ALTER, DROP, and more.
-Returns column metadata and result rows for SELECT queries, or affected row counts for DML statements.
-Supports complex queries with joins, subqueries, CTEs, window functions, and aggregations.`,
-  instructions: [
-    'Always validate SQL syntax before executing to avoid errors.',
-    'Use parameterized-style quoting for user-provided values to prevent SQL injection.',
-    'For large result sets, use LIMIT to control the number of returned rows.'
-  ],
-  constraints: [
-    'Query execution is subject to the configured timeout.',
-    'Results are limited by the configured maxRows setting when no explicit LIMIT is provided.'
-  ],
-  tags: {
-    destructive: false,
-    readOnly: false
-  }
-})
-  .input(
-    z.object({
-      sql: z.string().describe('The SQL query to execute'),
-      maxRows: z
-        .number()
-        .optional()
-        .describe(
-          'Maximum number of rows to return. Overrides the default maxRows config. Only applicable for SELECT queries.'
-        )
-    })
-  )
-  .output(
-    z.object({
-      columns: z
-        .array(
-          z.object({
-            name: z.string().describe('Column name'),
-            type: z.string().describe('PostgreSQL data type')
-          })
-        )
-        .describe('Column metadata for the result set'),
-      rows: z
-        .array(z.record(z.string(), z.any()))
-        .describe('Result rows as key-value objects'),
-      rowCount: z
-        .number()
-        .nullable()
-        .describe('Number of rows affected (for DML) or returned'),
-      command: z
-        .string()
-        .describe('The SQL command that was executed (e.g., SELECT, INSERT, UPDATE)')
-    })
-  )
-  .handleInvocation(async ctx => {
-    let client = createClient(ctx.auth, ctx.config);
-    let sql = ctx.input.sql.trim();
-    let maxRows = ctx.input.maxRows ?? ctx.config.maxRows;
-
-    // If it's a SELECT query without LIMIT, add one
-    let isSelect = /^\s*(SELECT|WITH)\b/i.test(sql);
-    let hasLimit = /\bLIMIT\s+\d+/i.test(sql);
-
-    let querySql = sql;
-    if (isSelect && !hasLimit && maxRows > 0) {
-      // Remove trailing semicolon if present before adding LIMIT
-      querySql = querySql.replace(/;\s*$/, '');
-      querySql = `${querySql} LIMIT ${maxRows}`;
-    }
-
-    ctx.info(
-      `Executing SQL query: ${querySql.substring(0, 200)}${querySql.length > 200 ? '...' : ''}`
-    );
-
-    let result = await client.query(querySql, ctx.config.queryTimeout);
-
-    let displayColumns = result.columns.map(c => ({ name: c.name, type: c.type }));
-
-    return {
-      output: {
-        columns: displayColumns,
-        rows: result.rows,
-        rowCount: result.rowCount,
-        command: result.command
-      },
-      message: isSelect
-        ? `Query returned **${result.rows.length}** row(s) with **${result.columns.length}** column(s).`
-        : `\`${result.command}\` completed. **${result.rowCount ?? 0}** row(s) affected.`
-    };
-  })
-  .build();

package/src/tools/index.ts

@@ -1,12 +0,0 @@
-export { executeQuery } from './execute-query';
-export { listTables } from './list-tables';
-export { describeTable } from './describe-table';
-export { insertRows } from './insert-rows';
-export { updateRows } from './update-rows';
-export { deleteRows } from './delete-rows';
-export { manageTable } from './manage-table';
-export { manageIndexes } from './manage-indexes';
-export { listSchemas } from './list-schemas';
-export { manageRoles } from './manage-roles';
-export { manageSchemas } from './manage-schemas';
-export { manageViews } from './manage-views';

package/src/tools/insert-rows.ts

@@ -1,133 +0,0 @@
-import { SlateTool } from '@slates/provider';
-import { spec } from '../spec';
-import {
-  createClient,
-  escapeIdentifier,
-  escapeLiteral,
-  qualifiedTableName
-} from '../lib/helpers';
-import { postgresServiceError } from '../lib/errors';
-import { z } from 'zod';
-
-export let insertRows = SlateTool.create(spec, {
-  name: 'Insert Rows',
-  key: 'insert_rows',
-  description: `Insert one or more rows into a PostgreSQL table. Provide the data as an array of objects where keys are column names and values are the data to insert.
-Supports inserting multiple rows in a single operation and can optionally return the inserted rows.`,
-  instructions: [
-    'Column names in the row objects must exactly match the table column names.',
-    'Values are automatically escaped to prevent SQL injection.',
-    'Use null for NULL values.'
-  ],
-  tags: {
-    destructive: false
-  }
-})
-  .input(
-    z.object({
-      tableName: z.string().describe('Name of the table to insert into'),
-      schemaName: z.string().optional().describe('Schema containing the table'),
-      rows: z
-        .array(z.record(z.string(), z.any()))
-        .min(1)
-        .describe('Array of row objects to insert, where keys are column names'),
-      returning: z
-        .boolean()
-        .optional()
-        .default(true)
-        .describe('Whether to return the inserted rows using RETURNING *'),
-      onConflict: z
-        .enum(['error', 'ignore', 'update'])
-        .optional()
-        .default('error')
-        .describe(
-          'Behavior on unique constraint conflict: error (default), ignore (DO NOTHING), or update (DO UPDATE SET)'
-        ),
-      conflictColumns: z
-        .array(z.string())
-        .optional()
-        .describe(
-          'Columns that define the conflict target (required when onConflict is "ignore" or "update")'
-        )
-    })
-  )
-  .output(
-    z.object({
-      insertedCount: z.number().describe('Number of rows inserted'),
-      returnedRows: z
-        .array(z.record(z.string(), z.any()))
-        .describe('Inserted rows (if returning was enabled)')
-    })
-  )
-  .handleInvocation(async ctx => {
-    let client = createClient(ctx.auth, ctx.config);
-    let schema = ctx.input.schemaName || ctx.config.defaultSchema;
-    let fullTableName = qualifiedTableName(ctx.input.tableName, schema);
-
-    // Collect all unique column names from all rows
-    let columnSet = new Set<string>();
-    for (let row of ctx.input.rows) {
-      for (let key of Object.keys(row)) {
-        columnSet.add(key);
-      }
-    }
-    let columns = Array.from(columnSet);
-
-    // Build values list
-    let valueClauses: string[] = [];
-    for (let row of ctx.input.rows) {
-      let values = columns.map(col => {
-        let val = row[col];
-        if (val === null || val === undefined) return 'NULL';
-        if (typeof val === 'number') return String(val);
-        if (typeof val === 'boolean') return val ? 'TRUE' : 'FALSE';
-        if (typeof val === 'object') return escapeLiteral(JSON.stringify(val));
-        return escapeLiteral(String(val));
-      });
-      valueClauses.push(`(${values.join(', ')})`);
-    }
-
-    let columnList = columns.map(escapeIdentifier).join(', ');
-    let sql = `INSERT INTO ${fullTableName} (${columnList}) VALUES ${valueClauses.join(', ')}`;
-
-    // Handle conflict
-    if (ctx.input.onConflict === 'ignore') {
-      let conflictTarget = ctx.input.conflictColumns?.length
-        ? `(${ctx.input.conflictColumns.map(escapeIdentifier).join(', ')})`
-        : '';
-      sql += ` ON CONFLICT ${conflictTarget} DO NOTHING`;
-    } else if (ctx.input.onConflict === 'update') {
-      let conflictCols = ctx.input.conflictColumns;
-      if (!conflictCols?.length) {
-        throw postgresServiceError(
-          'conflictColumns must be specified when onConflict is "update"'
-        );
-      }
-      let conflictTarget = `(${conflictCols.map(escapeIdentifier).join(', ')})`;
-      let updateCols = columns.filter(c => !conflictCols.includes(c));
-      let setClauses = updateCols.map(
-        c => `${escapeIdentifier(c)} = EXCLUDED.${escapeIdentifier(c)}`
-      );
-      if (setClauses.length > 0) {
-        sql += ` ON CONFLICT ${conflictTarget} DO UPDATE SET ${setClauses.join(', ')}`;
-      } else {
-        sql += ` ON CONFLICT ${conflictTarget} DO NOTHING`;
-      }
-    }
-
-    if (ctx.input.returning) {
-      sql += ' RETURNING *';
-    }
-
-    ctx.info(`Inserting ${ctx.input.rows.length} row(s) into ${fullTableName}`);
-    let result = await client.query(sql, ctx.config.queryTimeout);
-
-    return {
-      output: {
-        insertedCount: result.rowCount ?? ctx.input.rows.length,
-        returnedRows: result.rows
-      },
-      message: `Inserted **${result.rowCount ?? ctx.input.rows.length}** row(s) into \`${ctx.input.tableName}\`.`
-    };
-  })
-  .build();

package/src/tools/list-schemas.ts

@@ -1,80 +0,0 @@
-import { SlateTool } from '@slates/provider';
-import { spec } from '../spec';
-import { createClient } from '../lib/helpers';
-import { z } from 'zod';
-
-export let listSchemas = SlateTool.create(spec, {
-  name: 'List Schemas',
-  key: 'list_schemas',
-  description: `List all schemas in the PostgreSQL database with their table counts and sizes.
-Useful for exploring the database structure and understanding the organization of tables across schemas.`,
-  tags: {
-    readOnly: true
-  }
-})
-  .input(
-    z.object({
-      includeSystemSchemas: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('Include system schemas (pg_catalog, information_schema, pg_toast)')
-    })
-  )
-  .output(
-    z.object({
-      schemas: z
-        .array(
-          z.object({
-            schemaName: z.string().describe('Name of the schema'),
-            schemaOwner: z.string().describe('Owner of the schema'),
-            tableCount: z.number().describe('Number of tables in the schema'),
-            sizeFormatted: z
-              .string()
-              .nullable()
-              .describe('Total size of all tables in the schema')
-          })
-        )
-        .describe('List of schemas in the database'),
-      totalCount: z.number().describe('Total number of schemas found')
-    })
-  )
-  .handleInvocation(async ctx => {
-    let client = createClient(ctx.auth, ctx.config);
-
-    let systemFilter = ctx.input.includeSystemSchemas
-      ? ''
-      : `WHERE n.nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast') AND n.nspname NOT LIKE 'pg_temp_%' AND n.nspname NOT LIKE 'pg_toast_temp_%'`;
-
-    let sql = `
-      SELECT
-        n.nspname AS schema_name,
-        pg_catalog.pg_get_userbyid(n.nspowner) AS schema_owner,
-        COUNT(c.oid) FILTER (WHERE c.relkind IN ('r', 'p')) AS table_count,
-        pg_size_pretty(COALESCE(SUM(pg_total_relation_size(c.oid)) FILTER (WHERE c.relkind IN ('r', 'p', 'm')), 0)) AS size_formatted
-      FROM pg_catalog.pg_namespace n
-      LEFT JOIN pg_catalog.pg_class c ON c.relnamespace = n.oid AND c.relkind IN ('r', 'p', 'm')
-      ${systemFilter}
-      GROUP BY n.nspname, n.nspowner
-      ORDER BY n.nspname
-    `;
-
-    ctx.info('Listing database schemas');
-    let result = await client.query(sql, ctx.config.queryTimeout);
-
-    let schemas = result.rows.map((row: any) => ({
-      schemaName: row.schema_name as string,
-      schemaOwner: row.schema_owner as string,
-      tableCount: Number(row.table_count),
-      sizeFormatted: row.size_formatted as string | null
-    }));
-
-    return {
-      output: {
-        schemas,
-        totalCount: schemas.length
-      },
-      message: `Found **${schemas.length}** schema(s) in the database.`
-    };
-  })
-  .build();

package/src/tools/list-tables.ts

@@ -1,119 +0,0 @@
-import { SlateTool } from '@slates/provider';
-import { spec } from '../spec';
-import { createClient } from '../lib/helpers';
-import { z } from 'zod';
-
-export let listTables = SlateTool.create(spec, {
-  name: 'List Tables',
-  key: 'list_tables',
-  description: `List all tables in the PostgreSQL database, optionally filtered by schema. Returns table names, schemas, row estimates, and size information.
-Also supports listing views and materialized views.`,
-  tags: {
-    readOnly: true
-  }
-})
-  .input(
-    z.object({
-      schemaName: z
-        .string()
-        .optional()
-        .describe(
-          'Filter tables by schema name. If not specified, uses the default schema from config.'
-        ),
-      includeViews: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('Include views and materialized views in the results'),
-      includeSystemTables: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('Include system tables from pg_catalog and information_schema')
-    })
-  )
-  .output(
-    z.object({
-      tables: z
-        .array(
-          z.object({
-            tableName: z.string().describe('Name of the table'),
-            schemaName: z.string().describe('Schema containing the table'),
-            tableType: z
-              .string()
-              .describe('Type of table (BASE TABLE, VIEW, MATERIALIZED VIEW)'),
-            estimatedRowCount: z
-              .number()
-              .nullable()
-              .describe('Estimated number of rows from pg_stat'),
-            sizeBytes: z
-              .number()
-              .nullable()
-              .describe('Table size in bytes including indexes and TOAST'),
-            sizeFormatted: z.string().nullable().describe('Human-readable table size')
-          })
-        )
-        .describe('List of tables in the database'),
-      totalCount: z.number().describe('Total number of tables found')
-    })
-  )
-  .handleInvocation(async ctx => {
-    let client = createClient(ctx.auth, ctx.config);
-    let schema = ctx.input.schemaName || ctx.config.defaultSchema;
-
-    let typeFilter = `'BASE TABLE'`;
-    if (ctx.input.includeViews) {
-      typeFilter = `'BASE TABLE', 'VIEW'`;
-    }
-
-    let schemaFilter = ctx.input.includeSystemTables
-      ? ''
-      : `AND n.nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')`;
-
-    if (schema && !ctx.input.includeSystemTables) {
-      schemaFilter = `AND n.nspname = '${schema.replace(/'/g, "''")}'`;
-    }
-
-    let sql = `
-      SELECT
-        c.relname AS table_name,
-        n.nspname AS schema_name,
-        CASE c.relkind
-          WHEN 'r' THEN 'BASE TABLE'
-          WHEN 'v' THEN 'VIEW'
-          WHEN 'm' THEN 'MATERIALIZED VIEW'
-          WHEN 'f' THEN 'FOREIGN TABLE'
-          WHEN 'p' THEN 'PARTITIONED TABLE'
-        END AS table_type,
-        c.reltuples::bigint AS estimated_row_count,
-        pg_total_relation_size(c.oid) AS size_bytes,
-        pg_size_pretty(pg_total_relation_size(c.oid)) AS size_formatted
-      FROM pg_class c
-      JOIN pg_namespace n ON n.oid = c.relnamespace
-      WHERE c.relkind IN (${ctx.input.includeViews ? "'r','v','m','p'" : "'r','p'"})
-        ${schemaFilter}
-      ORDER BY n.nspname, c.relname
-    `;
-
-    ctx.info(`Listing tables in schema: ${schema || '(all schemas)'}`);
-    let result = await client.query(sql, ctx.config.queryTimeout);
-
-    let tables = result.rows.map((row: any) => ({
-      tableName: row.table_name as string,
-      schemaName: row.schema_name as string,
-      tableType: row.table_type as string,
-      estimatedRowCount:
-        row.estimated_row_count != null ? Number(row.estimated_row_count) : null,
-      sizeBytes: row.size_bytes != null ? Number(row.size_bytes) : null,
-      sizeFormatted: row.size_formatted as string | null
-    }));
-
-    return {
-      output: {
-        tables,
-        totalCount: tables.length
-      },
-      message: `Found **${tables.length}** table(s) in ${schema ? `schema \`${schema}\`` : 'the database'}.`
-    };
-  })
-  .build();