postgres-scout-mcp 1.0.0

package/dist/tools/query.js

@@ -0,0 +1,138 @@
+import { z } from 'zod';
+import { executeQuery } from '../utils/database.js';
+import { formatQueryResult } from '../utils/result-formatter.js';
+import { assertNoSensitiveCatalogAccess } from '../utils/sanitize.js';
+const ExecuteQuerySchema = z.object({
+    query: z.string(),
+    params: z.array(z.any()).optional().default([]),
+    timeout: z.number().optional(),
+    maxRows: z.number().optional()
+});
+const ExplainQuerySchema = z.object({
+    query: z.string(),
+    params: z.array(z.any()).optional().default([]),
+    analyze: z.boolean().optional().default(true),
+    verbose: z.boolean().optional().default(false),
+    buffers: z.boolean().optional().default(true)
+});
+export async function executeQueryTool(connection, logger, args) {
+    const { query, params, timeout, maxRows } = args;
+    logger.info('executeQuery', 'Executing user query', {
+        queryLength: query.length,
+        paramCount: params.length
+    });
+    assertNoSensitiveCatalogAccess(query);
+    const startTime = Date.now();
+    const result = await executeQuery(connection, logger, {
+        query,
+        params,
+        options: { timeout, maxRows }
+    });
+    const executionTimeMs = Date.now() - startTime;
+    return formatQueryResult(result, executionTimeMs);
+}
+export async function explainQueryTool(connection, logger, args) {
+    const { query, params, verbose, buffers } = args;
+    const isReadOnly = connection.config.mode === 'read-only';
+    const requestedAnalyze = args.analyze;
+    const analyze = isReadOnly ? false : requestedAnalyze;
+    if (isReadOnly && requestedAnalyze) {
+        logger.warn('explainQuery', 'Read-only mode forces analyze=false for safety', {
+            queryLength: query.length
+        });
+    }
+    logger.info('explainQuery', 'Analyzing query performance', {
+        queryLength: query.length,
+        analyze,
+        verbose,
+        buffers
+    });
+    assertNoSensitiveCatalogAccess(query);
+    const explainOptions = ['FORMAT JSON'];
+    if (analyze)
+        explainOptions.push('ANALYZE');
+    if (verbose)
+        explainOptions.push('VERBOSE');
+    if (analyze && buffers)
+        explainOptions.push('BUFFERS');
+    const explainQuery = `EXPLAIN (${explainOptions.join(', ')}) ${query}`;
+    const startTime = Date.now();
+    const result = await executeQuery(connection, logger, {
+        query: explainQuery,
+        params
+    });
+    const executionTimeMs = Date.now() - startTime;
+    const planData = result.rows[0]?.['QUERY PLAN'] || result.rows[0];
+    let plan;
+    let planningTime = 0;
+    let executionTime = 0;
+    if (Array.isArray(planData)) {
+        plan = planData[0]?.Plan;
+        planningTime = planData[0]?.['Planning Time'] || 0;
+        executionTime = planData[0]?.['Execution Time'] || 0;
+    }
+    else {
+        plan = planData;
+    }
+    const recommendations = generateRecommendations(plan);
+    return {
+        query,
+        plan,
+        executionTimeMs: executionTime || executionTimeMs,
+        planningTimeMs: planningTime,
+        recommendations
+    };
+}
+function generateRecommendations(plan) {
+    const recommendations = [];
+    if (!plan)
+        return recommendations;
+    const nodeType = plan['Node Type'];
+    const relationName = plan['Relation Name'];
+    if (nodeType === 'Seq Scan') {
+        recommendations.push(`⚠ Sequential scan on table "${relationName}" - consider adding an index`);
+    }
+    if (nodeType === 'Index Scan' || nodeType === 'Index Only Scan') {
+        recommendations.push(`✓ Using index: ${plan['Index Name']}`);
+    }
+    if (plan['Actual Rows'] && plan['Plan Rows']) {
+        const ratio = plan['Actual Rows'] / plan['Plan Rows'];
+        if (ratio > 10 || ratio < 0.1) {
+            recommendations.push(`⚠ Poor row estimate (planned: ${plan['Plan Rows']}, actual: ${plan['Actual Rows']}) - run ANALYZE`);
+        }
+    }
+    if (plan['Buffers']) {
+        const shared = plan['Buffers']['Shared'];
+        if (shared) {
+            const hit = shared['Hit'] || 0;
+            const read = shared['Read'] || 0;
+            const total = hit + read;
+            if (total > 0) {
+                const hitRatio = hit / total;
+                if (hitRatio < 0.9) {
+                    recommendations.push(`⚠ Low cache hit ratio (${(hitRatio * 100).toFixed(1)}%) - data mostly from disk`);
+                }
+                else {
+                    recommendations.push(`✓ Excellent cache hit ratio (${(hitRatio * 100).toFixed(1)}%)`);
+                }
+            }
+        }
+    }
+    if (plan.Plans && Array.isArray(plan.Plans)) {
+        for (const subPlan of plan.Plans) {
+            recommendations.push(...generateRecommendations(subPlan));
+        }
+    }
+    return recommendations;
+}
+export const queryTools = {
+    executeQuery: {
+        schema: ExecuteQuerySchema,
+        handler: executeQueryTool
+    },
+    explainQuery: {
+        schema: ExplainQuerySchema,
+        handler: explainQueryTool
+    }
+};
+//# sourceMappingURL=query.js.map

package/dist/tools/relationships.js

@@ -0,0 +1,261 @@
+import { z } from 'zod';
+import { executeInternalQuery } from '../utils/database.js';
+import { escapeIdentifier, sanitizeIdentifier } from '../utils/sanitize.js';
+const ExploreRelationshipsSchema = z.object({
+    table: z.string(),
+    recordId: z.union([z.string(), z.number()]),
+    schema: z.string().optional().default('public'),
+    depth: z.number().optional().default(1),
+    includeReverse: z.boolean().optional().default(true)
+});
+const AnalyzeForeignKeysSchema = z.object({
+    schema: z.string().optional().default('public'),
+    checkOrphans: z.boolean().optional().default(false),
+    checkIndexes: z.boolean().optional().default(true)
+});
+export async function exploreRelationships(connection, logger, args) {
+    const { table, recordId, schema, depth, includeReverse } = args;
+    logger.info('exploreRelationships', 'Exploring relationships', { table, recordId, depth });
+    const sanitizedSchema = sanitizeIdentifier(schema);
+    const sanitizedTable = sanitizeIdentifier(table);
+    const pkQuery = `
+    SELECT a.attname as column_name
+    FROM pg_index i
+    JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
+    WHERE i.indrelid = $1::regclass
+      AND i.indisprimary
+    LIMIT 1
+  `;
+    const pkResult = await executeInternalQuery(connection, logger, {
+        query: pkQuery,
+        params: [`${sanitizedSchema}.${sanitizedTable}`]
+    });
+    if (pkResult.rows.length === 0) {
+        throw new Error(`No primary key found for table ${schema}.${table}`);
+    }
+    const pkColumn = pkResult.rows[0].column_name;
+    const recordQuery = `
+    SELECT *
+    FROM ${escapeIdentifier(sanitizedSchema)}.${escapeIdentifier(sanitizedTable)}
+    WHERE ${escapeIdentifier(sanitizeIdentifier(pkColumn))} = $1
+  `;
+    const recordResult = await executeInternalQuery(connection, logger, {
+        query: recordQuery,
+        params: [recordId]
+    });
+    if (recordResult.rows.length === 0) {
+        throw new Error(`Record not found: ${schema}.${table} where ${pkColumn} = ${recordId}`);
+    }
+    const record = recordResult.rows[0];
+    const fkQuery = `
+    SELECT
+      c.conname as constraint_name,
+      a.attname as column_name,
+      ref_ns.nspname as ref_schema,
+      ref_tbl.relname as ref_table,
+      ref_attr.attname as ref_column
+    FROM pg_constraint c
+    JOIN pg_attribute a ON a.attrelid = c.conrelid AND a.attnum = ANY(c.conkey)
+    JOIN pg_class ref_tbl ON ref_tbl.oid = c.confrelid
+    JOIN pg_namespace ref_ns ON ref_ns.oid = ref_tbl.relnamespace
+    JOIN pg_attribute ref_attr ON ref_attr.attrelid = c.confrelid AND ref_attr.attnum = ANY(c.confkey)
+    WHERE c.conrelid = $1::regclass
+      AND c.contype = 'f'
+  `;
+    const fkResult = await executeInternalQuery(connection, logger, {
+        query: fkQuery,
+        params: [`${sanitizedSchema}.${sanitizedTable}`]
+    });
+    const related = {};
+    for (const fk of fkResult.rows) {
+        const fkValue = record[fk.column_name];
+        if (fkValue) {
+            const relatedQuery = `
+        SELECT *
+        FROM ${escapeIdentifier(fk.ref_schema)}.${escapeIdentifier(fk.ref_table)}
+        WHERE ${escapeIdentifier(fk.ref_column)} = $1
+      `;
+            const relatedResult = await executeInternalQuery(connection, logger, {
+                query: relatedQuery,
+                params: [fkValue]
+            });
+            if (relatedResult.rows.length > 0) {
+                related[fk.ref_table] = {
+                    via: `${fk.column_name} -> ${fk.ref_table}.${fk.ref_column}`,
+                    record: relatedResult.rows[0]
+                };
+            }
+        }
+    }
+    const reverseReferences = {};
+    if (includeReverse) {
+        const reverseFkQuery = `
+      SELECT
+        ns.nspname as schema,
+        tbl.relname as table,
+        a.attname as column_name,
+        c.conname as constraint_name
+      FROM pg_constraint c
+      JOIN pg_class tbl ON tbl.oid = c.conrelid
+      JOIN pg_namespace ns ON ns.oid = tbl.relnamespace
+      JOIN pg_attribute a ON a.attrelid = c.conrelid AND a.attnum = ANY(c.conkey)
+      WHERE c.confrelid = $1::regclass
+        AND c.contype = 'f'
+    `;
+        const reverseFkResult = await executeInternalQuery(connection, logger, {
+            query: reverseFkQuery,
+            params: [`${sanitizedSchema}.${sanitizedTable}`]
+        });
+        for (const revFk of reverseFkResult.rows) {
+            const reverseQuery = `
+        SELECT *
+        FROM ${escapeIdentifier(revFk.schema)}.${escapeIdentifier(revFk.table)}
+        WHERE ${escapeIdentifier(revFk.column_name)} = $1
+        LIMIT 10
+      `;
+            const reverseResult = await executeInternalQuery(connection, logger, {
+                query: reverseQuery,
+                params: [recordId]
+            });
+            if (reverseResult.rows.length > 0) {
+                reverseReferences[revFk.table] = reverseResult.rows;
+            }
+        }
+    }
+    return {
+        table,
+        schema,
+        primaryKey: pkColumn,
+        recordId,
+        record,
+        related,
+        ...(includeReverse && { reverseReferences })
+    };
+}
+export async function analyzeForeignKeys(connection, logger, args) {
+    const { schema, checkOrphans, checkIndexes } = args;
+    logger.info('analyzeForeignKeys', 'Analyzing foreign keys', { schema });
+    const sanitizedSchema = sanitizeIdentifier(schema);
+    const fkQuery = `
+    SELECT
+      c.conname as constraint_name,
+      ns.nspname as schema,
+      tbl.relname as table,
+      a.attname as column,
+      ref_ns.nspname as ref_schema,
+      ref_tbl.relname as ref_table,
+      ref_attr.attname as ref_column,
+      c.confupdtype as on_update,
+      c.confdeltype as on_delete
+    FROM pg_constraint c
+    JOIN pg_class tbl ON tbl.oid = c.conrelid
+    JOIN pg_namespace ns ON ns.oid = tbl.relnamespace
+    JOIN pg_attribute a ON a.attrelid = c.conrelid AND a.attnum = ANY(c.conkey)
+    JOIN pg_class ref_tbl ON ref_tbl.oid = c.confrelid
+    JOIN pg_namespace ref_ns ON ref_ns.oid = ref_tbl.relnamespace
+    JOIN pg_attribute ref_attr ON ref_attr.attrelid = c.confrelid AND ref_attr.attnum = ANY(c.confkey)
+    WHERE ns.nspname = $1
+      AND c.contype = 'f'
+    ORDER BY tbl.relname, c.conname
+  `;
+    const fkResult = await executeInternalQuery(connection, logger, {
+        query: fkQuery,
+        params: [sanitizedSchema]
+    });
+    const issues = [];
+    for (const fk of fkResult.rows) {
+        const fkIssues = [];
+        if (checkIndexes) {
+            const indexQuery = `
+        SELECT COUNT(*) as index_count
+        FROM pg_index i
+        JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
+        WHERE i.indrelid = $1::regclass
+          AND a.attname = $2
+      `;
+            const indexResult = await executeInternalQuery(connection, logger, {
+                query: indexQuery,
+                params: [`${fk.schema}.${fk.table}`, fk.column]
+            });
+            const indexCount = parseInt(indexResult.rows[0]?.index_count || '0', 10);
+            if (indexCount === 0) {
+                fkIssues.push({
+                    type: 'missing_index',
+                    severity: 'warning',
+                    message: 'Foreign key column not indexed',
+                    impact: `Slow DELETE/UPDATE on ${fk.ref_table} table`,
+                    recommendation: `CREATE INDEX CONCURRENTLY idx_${fk.table}_${fk.column} ON ${fk.schema}.${fk.table}(${fk.column});`,
+                    estimatedImpact: 'Will speed up CASCADE operations and JOIN queries'
+                });
+            }
+        }
+        if (checkOrphans) {
+            const orphanQuery = `
+        SELECT COUNT(*) as orphan_count
+        FROM ${escapeIdentifier(fk.schema)}.${escapeIdentifier(fk.table)} t
+        LEFT JOIN ${escapeIdentifier(fk.ref_schema)}.${escapeIdentifier(fk.ref_table)} r
+          ON t.${escapeIdentifier(fk.column)} = r.${escapeIdentifier(fk.ref_column)}
+        WHERE t.${escapeIdentifier(fk.column)} IS NOT NULL
+          AND r.${escapeIdentifier(fk.ref_column)} IS NULL
+      `;
+            const orphanResult = await executeInternalQuery(connection, logger, {
+                query: orphanQuery
+            });
+            const orphanCount = parseInt(orphanResult.rows[0]?.orphan_count || '0', 10);
+            if (orphanCount > 0) {
+                fkIssues.push({
+                    type: 'orphans',
+                    severity: 'error',
+                    message: `${orphanCount} orphaned records found`,
+                    orphanCount,
+                    recommendation: 'Clean up orphans before enforcing constraint',
+                    cleanupQuery: `DELETE FROM ${fk.schema}.${fk.table} WHERE ${fk.column} NOT IN (SELECT ${fk.ref_column} FROM ${fk.ref_schema}.${fk.ref_table});`
+                });
+            }
+        }
+        if (fkIssues.length > 0) {
+            issues.push({
+                constraint: fk.constraint_name,
+                table: fk.table,
+                schema: fk.schema,
+                column: fk.column,
+                referencesTable: fk.ref_table,
+                referencesSchema: fk.ref_schema,
+                referencesColumn: fk.ref_column,
+                issues: fkIssues
+            });
+        }
+    }
+    const recommendations = [];
+    const missingIndexes = issues.filter(i => i.issues.some((issue) => issue.type === 'missing_index')).length;
+    const orphanedRecords = issues.filter(i => i.issues.some((issue) => issue.type === 'orphans')).length;
+    if (missingIndexes > 0) {
+        recommendations.push(`⚠ ${missingIndexes} foreign key columns missing indexes - significant performance impact`);
+        recommendations.push('Add missing indexes during low-traffic period (use CONCURRENTLY)');
+    }
+    if (orphanedRecords > 0) {
+        recommendations.push(`⚠ ${orphanedRecords} foreign keys have orphaned records - data integrity issue`);
+        recommendations.push('Clean up orphaned records before enforcing constraints');
+    }
+    if (issues.length === 0) {
+        recommendations.push('✓ All foreign keys are properly indexed and have no orphaned records');
+    }
+    return {
+        schema,
+        totalForeignKeys: fkResult.rows.length,
+        issuesFound: issues.length,
+        issues,
+        recommendations
+    };
+}
+export const relationshipTools = {
+    exploreRelationships: {
+        schema: ExploreRelationshipsSchema,
+        handler: exploreRelationships
+    },
+    analyzeForeignKeys: {
+        schema: AnalyzeForeignKeysSchema,
+        handler: analyzeForeignKeys
+    }
+};
+//# sourceMappingURL=relationships.js.map

package/dist/tools/schema.js

@@ -0,0 +1,253 @@
+import { z } from 'zod';
+import { executeInternalQuery } from '../utils/database.js';
+const ListTablesSchema = z.object({
+    schema: z.string().optional().default('public'),
+    includeSystemTables: z.boolean().optional().default(false)
+});
+const DescribeTableSchema = z.object({
+    table: z.string(),
+    schema: z.string().optional().default('public')
+});
+const ListSchemasSchema = z.object({});
+export async function listSchemas(connection, logger, args) {
+    logger.info('listSchemas', 'Listing database schemas');
+    const query = `
+    SELECT
+      n.nspname as name,
+      pg_catalog.pg_get_userbyid(n.nspowner) as owner,
+      (SELECT COUNT(*) FROM pg_catalog.pg_class c WHERE c.relnamespace = n.oid AND c.relkind = 'r') as table_count
+    FROM pg_catalog.pg_namespace n
+    WHERE n.nspname !~ '^pg_' AND n.nspname <> 'information_schema'
+    ORDER BY n.nspname;
+  `;
+    const result = await executeInternalQuery(connection, logger, { query });
+    return {
+        schemas: result.rows.map(row => ({
+            name: row.name,
+            owner: row.owner,
+            tableCount: parseInt(row.table_count, 10)
+        }))
+    };
+}
+export async function listTables(connection, logger, args) {
+    const { schema, includeSystemTables } = args;
+    logger.info('listTables', 'Listing tables', { schema, includeSystemTables });
+    const systemTableFilter = includeSystemTables ? '' : "AND c.relname NOT LIKE 'pg_%'";
+    const query = `
+    SELECT
+      c.relname as name,
+      n.nspname as schema,
+      CASE c.relkind
+        WHEN 'r' THEN 'BASE TABLE'
+        WHEN 'v' THEN 'VIEW'
+        WHEN 'm' THEN 'MATERIALIZED VIEW'
+        WHEN 'p' THEN 'PARTITIONED TABLE'
+      END as type,
+      CASE
+        WHEN c.reltuples < 0 THEN NULL
+        ELSE c.reltuples::bigint
+      END as row_estimate,
+      pg_stat_get_live_tuples(c.oid) as live_tuples,
+      c.reltuples < 0 as needs_analyze,
+      pg_total_relation_size(c.oid) as total_size,
+      pg_table_size(c.oid) as table_size,
+      pg_indexes_size(c.oid) as index_size,
+      pg_stat_get_last_vacuum_time(c.oid) as last_vacuum,
+      pg_stat_get_last_analyze_time(c.oid) as last_analyze,
+      c.relkind = 'p' as is_partitioned
+    FROM pg_catalog.pg_class c
+    LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+    WHERE c.relkind IN ('r', 'v', 'm', 'p')
+      AND n.nspname = $1
+      ${systemTableFilter}
+    ORDER BY c.relname;
+  `;
+    const result = await executeInternalQuery(connection, logger, {
+        query,
+        params: [schema]
+    });
+    const tables = result.rows.map(row => {
+        const rowEstimate = row.row_estimate === null
+            ? parseInt(row.live_tuples || '0', 10)
+            : parseInt(row.row_estimate, 10);
+        return {
+            name: row.name,
+            schema: row.schema,
+            type: row.type,
+            rowEstimate,
+            ...(row.needs_analyze && { needsAnalyze: true }),
+            sizeBytes: parseInt(row.table_size, 10),
+            indexSize: parseInt(row.index_size, 10),
+            totalSize: parseInt(row.total_size, 10),
+            lastVacuum: row.last_vacuum,
+            lastAnalyze: row.last_analyze,
+            isPartitioned: row.is_partitioned
+        };
+    });
+    return {
+        schema,
+        tableCount: tables.length,
+        tables: tables.map(t => ({
+            ...t,
+            sizeMB: (t.sizeBytes / 1024 / 1024).toFixed(2),
+            indexSizeMB: (t.indexSize / 1024 / 1024).toFixed(2),
+            totalSizeMB: (t.totalSize / 1024 / 1024).toFixed(2)
+        }))
+    };
+}
+export async function describeTable(connection, logger, args) {
+    const { table, schema } = args;
+    logger.info('describeTable', 'Describing table', { table, schema });
+    const [columns, constraints, indexes, stats] = await Promise.all([
+        getColumns(connection, logger, schema, table),
+        getConstraints(connection, logger, schema, table),
+        getIndexes(connection, logger, schema, table),
+        getTableStats(connection, logger, schema, table)
+    ]);
+    return {
+        table,
+        schema,
+        columns,
+        constraints,
+        indexes,
+        ...stats
+    };
+}
+async function getColumns(connection, logger, schema, table) {
+    const query = `
+    SELECT
+      a.attname as name,
+      pg_catalog.format_type(a.atttypid, a.atttypmod) as type,
+      NOT a.attnotnull as nullable,
+      pg_catalog.pg_get_expr(d.adbin, d.adrelid) as default_value,
+      EXISTS(
+        SELECT 1 FROM pg_catalog.pg_constraint c
+        WHERE c.conrelid = a.attrelid
+          AND a.attnum = ANY(c.conkey)
+          AND c.contype = 'p'
+      ) as is_primary_key,
+      EXISTS(
+        SELECT 1 FROM pg_catalog.pg_constraint c
+        WHERE c.conrelid = a.attrelid
+          AND a.attnum = ANY(c.conkey)
+          AND c.contype = 'f'
+      ) as is_foreign_key
+    FROM pg_catalog.pg_attribute a
+    LEFT JOIN pg_catalog.pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+    WHERE a.attrelid = $1::regclass
+      AND a.attnum > 0
+      AND NOT a.attisdropped
+    ORDER BY a.attnum;
+  `;
+    const result = await executeInternalQuery(connection, logger, {
+        query,
+        params: [`${schema}.${table}`]
+    });
+    return result.rows.map(row => ({
+        name: row.name,
+        type: row.type,
+        nullable: row.nullable,
+        default: row.default_value,
+        isPrimaryKey: row.is_primary_key,
+        isForeignKey: row.is_foreign_key
+    }));
+}
+async function getConstraints(connection, logger, schema, table) {
+    const query = `
+    SELECT
+      c.conname as name,
+      c.contype as type,
+      pg_catalog.pg_get_constraintdef(c.oid, true) as definition,
+      ARRAY(
+        SELECT a.attname
+        FROM unnest(c.conkey) k(n)
+        JOIN pg_catalog.pg_attribute a ON a.attrelid = c.conrelid AND a.attnum = k.n
+      ) as columns
+    FROM pg_catalog.pg_constraint c
+    WHERE c.conrelid = $1::regclass
+    ORDER BY c.conname;
+  `;
+    const result = await executeInternalQuery(connection, logger, {
+        query,
+        params: [`${schema}.${table}`]
+    });
+    return result.rows.map(row => {
+        const typeMap = {
+            'p': 'PRIMARY KEY',
+            'f': 'FOREIGN KEY',
+            'u': 'UNIQUE',
+            'c': 'CHECK'
+        };
+        return {
+            name: row.name,
+            type: typeMap[row.type] || 'CHECK',
+            columns: row.columns,
+            definition: row.definition
+        };
+    });
+}
+async function getIndexes(connection, logger, schema, table) {
+    const query = `
+    SELECT
+      i.relname as name,
+      ARRAY(
+        SELECT a.attname
+        FROM pg_catalog.pg_attribute a
+        WHERE a.attrelid = i.oid
+          AND a.attnum > 0
+        ORDER BY a.attnum
+      ) as columns,
+      am.amname as type,
+      ix.indisunique as unique,
+      ix.indisprimary as primary,
+      pg_size_pretty(pg_relation_size(i.oid)) as size
+    FROM pg_catalog.pg_index ix
+    JOIN pg_catalog.pg_class i ON i.oid = ix.indexrelid
+    JOIN pg_catalog.pg_am am ON am.oid = i.relam
+    WHERE ix.indrelid = $1::regclass
+    ORDER BY i.relname;
+  `;
+    const result = await executeInternalQuery(connection, logger, {
+        query,
+        params: [`${schema}.${table}`]
+    });
+    return result.rows.map(row => ({
+        name: row.name,
+        columns: row.columns,
+        type: row.type,
+        unique: row.unique,
+        primary: row.primary,
+        size: row.size
+    }));
+}
+async function getTableStats(connection, logger, schema, table) {
+    const query = `
+    SELECT
+      c.reltuples::bigint as estimated_row_count,
+      pg_size_pretty(pg_table_size(c.oid)) as disk_size,
+      pg_size_pretty(pg_indexes_size(c.oid)) as index_size,
+      pg_size_pretty(pg_total_relation_size(c.oid)) as total_size
+    FROM pg_catalog.pg_class c
+    WHERE c.oid = $1::regclass;
+  `;
+    const result = await executeInternalQuery(connection, logger, {
+        query,
+        params: [`${schema}.${table}`]
+    });
+    return result.rows[0] || {};
+}
+export const schemaTools = {
+    listSchemas: {
+        schema: ListSchemasSchema,
+        handler: listSchemas
+    },
+    listTables: {
+        schema: ListTablesSchema,
+        handler: listTables
+    },
+    describeTable: {
+        schema: DescribeTableSchema,
+        handler: describeTable
+    }
+};
+//# sourceMappingURL=schema.js.map