@neverinfamous/postgres-mcp 1.2.0 → 2.0.0

package/dist/adapters/postgresql/tools/citext.js

@@ -11,6 +11,7 @@
  */
 import { z } from "zod";
 import { readOnly, write } from "../../../utils/annotations.js";
+import { parsePostgresError } from "./core/error-helpers.js";
 import { getToolIcons } from "../../../utils/icons.js";
 import { CitextConvertColumnSchema, CitextConvertColumnSchemaBase, CitextListColumnsSchema, CitextListColumnsSchemaBase, CitextAnalyzeCandidatesSchema, CitextAnalyzeCandidatesSchemaBase, CitextSchemaAdvisorSchema, CitextSchemaAdvisorSchemaBase, 
 // Output schemas
@@ -42,12 +43,19 @@ citext is ideal for emails, usernames, and other identifiers where case shouldn'
         annotations: write("Create Citext Extension"),
         icons: getToolIcons("citext", write("Create Citext Extension")),
         handler: async (_params, _context) => {
-            await adapter.executeQuery("CREATE EXTENSION IF NOT EXISTS citext");
-            return {
-                success: true,
-                message: "citext extension enabled",
-                usage: "Create columns with type CITEXT instead of TEXT for case-insensitive comparisons",
-            };
+            try {
+                await adapter.executeQuery("CREATE EXTENSION IF NOT EXISTS citext");
+                return {
+                    success: true,
+                    message: "citext extension enabled",
+                    usage: "Create columns with type CITEXT instead of TEXT for case-insensitive comparisons",
+                };
+            }
+            catch (error) {
+                throw parsePostgresError(error, {
+                    tool: "pg_citext_create_extension",
+                });
+            }
         },
     };
 }
@@ -66,61 +74,79 @@ Note: If views depend on this column, you must drop and recreate them manually b
         annotations: write("Convert to Citext"),
         icons: getToolIcons("citext", write("Convert to Citext")),
         handler: async (params, _context) => {
-            const parsed = CitextConvertColumnSchema.parse(params ?? {});
-            const { table, column, schema: schemaOpt } = parsed;
-            const schemaName = schemaOpt ?? "public";
-            const qualifiedTable = `"${schemaName}"."${table}"`;
-            const extCheck = await adapter.executeQuery(`
+            try {
+                const parsed = CitextConvertColumnSchema.parse(params ?? {});
+                const { table, column, schema: schemaOpt } = parsed;
+                const schemaName = schemaOpt ?? "public";
+                const qualifiedTable = `"${schemaName}"."${table}"`;
+                const extCheck = await adapter.executeQuery(`
                 SELECT EXISTS(
                     SELECT 1 FROM pg_extension WHERE extname = 'citext'
                 ) as installed
             `);
-            const hasExt = extCheck.rows?.[0]?.["installed"] ?? false;
-            if (!hasExt) {
-                throw new Error("citext extension is not installed. Run pg_citext_create_extension first.");
-            }
-            const colCheck = await adapter.executeQuery(`
+                const hasExt = extCheck.rows?.[0]?.["installed"] ?? false;
+                if (!hasExt) {
+                    return {
+                        success: false,
+                        error: "citext extension is not installed. Run pg_citext_create_extension first.",
+                    };
+                }
+                // Check if table exists before checking column
+                const tableCheck = await adapter.executeQuery(`
+                SELECT 1 FROM information_schema.tables
+                WHERE table_schema = $1 AND table_name = $2
+            `, [schemaName, table]);
+                if (!tableCheck.rows || tableCheck.rows.length === 0) {
+                    return {
+                        success: false,
+                        error: `Table ${qualifiedTable} does not exist. Verify the table name and schema.`,
+                    };
+                }
+                const colCheck = await adapter.executeQuery(`
                 SELECT data_type, udt_name
-                FROM information_schema.columns 
-                WHERE table_schema = $1 
-                  AND table_name = $2 
+                FROM information_schema.columns
+                WHERE table_schema = $1
+                  AND table_name = $2
                   AND column_name = $3
             `, [schemaName, table, column]);
-            if (!colCheck.rows || colCheck.rows.length === 0) {
-                throw new Error(`Column "${column}" not found in table ${qualifiedTable}. Verify the table and column names.`);
-            }
-            const dataType = colCheck.rows[0]?.["data_type"];
-            const udtName = colCheck.rows[0]?.["udt_name"];
-            // Normalize type: use udt_name for user-defined types (like citext)
-            const currentType = dataType === "USER-DEFINED" ? udtName : dataType;
-            if (udtName === "citext") {
-                return {
-                    success: true,
-                    message: `Column ${column} is already citext`,
-                    wasAlreadyCitext: true,
-                };
-            }
-            // Validate that the column is a text-based type
-            const allowedTypes = [
-                "text",
-                "character varying",
-                "character",
-                "char",
-                "varchar",
-            ];
-            const normalizedType = dataType.toLowerCase();
-            if (!allowedTypes.includes(normalizedType)) {
-                return {
-                    success: false,
-                    error: `Column "${column}" is type "${currentType}", not a text-based type`,
-                    currentType,
-                    allowedTypes: ["text", "varchar", "character varying"],
-                    suggestion: `citext conversion only works for text-based columns. Column "${column}" is "${currentType}" which cannot be converted.`,
-                };
-            }
-            // Check for dependent views before attempting the conversion
-            const depCheck = await adapter.executeQuery(`
-                SELECT DISTINCT 
+                if (!colCheck.rows || colCheck.rows.length === 0) {
+                    return {
+                        success: false,
+                        error: `Column "${column}" not found in table ${qualifiedTable}. Verify the column name.`,
+                    };
+                }
+                const dataType = colCheck.rows[0]?.["data_type"];
+                const udtName = colCheck.rows[0]?.["udt_name"];
+                // Normalize type: use udt_name for user-defined types (like citext)
+                const currentType = dataType === "USER-DEFINED" ? udtName : dataType;
+                if (udtName === "citext") {
+                    return {
+                        success: true,
+                        message: `Column ${column} is already citext`,
+                        wasAlreadyCitext: true,
+                    };
+                }
+                // Validate that the column is a text-based type
+                const allowedTypes = [
+                    "text",
+                    "character varying",
+                    "character",
+                    "char",
+                    "varchar",
+                ];
+                const normalizedType = dataType.toLowerCase();
+                if (!allowedTypes.includes(normalizedType)) {
+                    return {
+                        success: false,
+                        error: `Column "${column}" is type "${currentType}", not a text-based type`,
+                        currentType,
+                        allowedTypes: ["text", "varchar", "character varying"],
+                        suggestion: `citext conversion only works for text-based columns. Column "${column}" is "${currentType}" which cannot be converted.`,
+                    };
+                }
+                // Check for dependent views before attempting the conversion
+                const depCheck = await adapter.executeQuery(`
+                SELECT DISTINCT
                     c.relname as dependent_view,
                     n.nspname as view_schema
                 FROM pg_depend d
@@ -135,40 +161,46 @@ Note: If views depend on this column, you must drop and recreate them manually b
                   AND t.relname = $2
                   AND a.attname = $3
             `, [schemaName, table, column]);
-            const dependentViews = depCheck.rows ?? [];
-            if (dependentViews.length > 0) {
-                return {
-                    success: false,
-                    error: "Column has dependent views that must be dropped before conversion",
-                    dependentViews: dependentViews.map((v) => `${v["view_schema"]}.${v["dependent_view"]}`),
-                    hint: "Drop the listed views, run this conversion, then recreate the views. PostgreSQL cannot ALTER COLUMN TYPE when views depend on it.",
-                };
-            }
-            try {
-                await adapter.executeQuery(`
+                const dependentViews = depCheck.rows ?? [];
+                if (dependentViews.length > 0) {
+                    return {
+                        success: false,
+                        error: "Column has dependent views that must be dropped before conversion",
+                        dependentViews: dependentViews.map((v) => `${v["view_schema"]}.${v["dependent_view"]}`),
+                        hint: "Drop the listed views, run this conversion, then recreate the views. PostgreSQL cannot ALTER COLUMN TYPE when views depend on it.",
+                    };
+                }
+                try {
+                    await adapter.executeQuery(`
                     ALTER TABLE ${qualifiedTable}
                     ALTER COLUMN "${column}" TYPE citext USING "${column}"::citext
                 `);
-                return {
-                    success: true,
-                    message: `Column ${column} converted from ${currentType} to citext`,
-                    table: qualifiedTable,
-                    previousType: currentType,
-                    affectedViews: dependentViews.length > 0
-                        ? dependentViews.map((v) => `${v["view_schema"]}.${v["dependent_view"]}`)
-                        : undefined,
-                };
+                    return {
+                        success: true,
+                        message: `Column ${column} converted from ${currentType} to citext`,
+                        table: qualifiedTable,
+                        previousType: currentType,
+                        affectedViews: dependentViews.length > 0
+                            ? dependentViews.map((v) => `${v["view_schema"]}.${v["dependent_view"]}`)
+                            : undefined,
+                    };
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    return {
+                        success: false,
+                        error: `Failed to convert column: ${errorMessage}`,
+                        hint: "If views depend on this column, they may need to be dropped and recreated",
+                        dependentViews: dependentViews.length > 0
+                            ? dependentViews.map((v) => `${v["view_schema"]}.${v["dependent_view"]}`)
+                            : undefined,
+                    };
+                }
             }
             catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                return {
-                    success: false,
-                    error: `Failed to convert column: ${errorMessage}`,
-                    hint: "If views depend on this column, they may need to be dropped and recreated",
-                    dependentViews: dependentViews.length > 0
-                        ? dependentViews.map((v) => `${v["view_schema"]}.${v["dependent_view"]}`)
-                        : undefined,
-                };
+                throw parsePostgresError(error, {
+                    tool: "pg_citext_convert_column",
+                });
             }
         },
     };
@@ -187,34 +219,46 @@ Useful for auditing case-insensitive columns.`,
         annotations: readOnly("List Citext Columns"),
         icons: getToolIcons("citext", readOnly("List Citext Columns")),
         handler: async (params, _context) => {
-            const parsed = CitextListColumnsSchema.parse(params);
-            const { schema, limit: userLimit } = parsed;
-            // Default limit of 100 to prevent large payloads
-            const DEFAULT_LIMIT = 100;
-            const effectiveLimit = userLimit === 0 ? undefined : (userLimit ?? DEFAULT_LIMIT);
-            const conditions = [
-                "udt_name = 'citext'",
-                "table_schema NOT IN ('pg_catalog', 'information_schema')",
-            ];
-            const queryParams = [];
-            let paramIndex = 1;
-            if (schema !== undefined) {
-                conditions.push(`table_schema = $${String(paramIndex++)}`);
-                queryParams.push(schema);
-            }
-            const whereClause = conditions.join(" AND ");
-            // Count total columns first
-            const countSql = `
+            try {
+                const parsed = CitextListColumnsSchema.parse(params);
+                const { schema, limit: userLimit } = parsed;
+                // Validate schema existence when specified
+                if (schema !== undefined) {
+                    const schemaCheck = await adapter.executeQuery(`SELECT 1 FROM information_schema.schemata
+             WHERE schema_name = $1`, [schema]);
+                    if (!schemaCheck.rows || schemaCheck.rows.length === 0) {
+                        return {
+                            success: false,
+                            error: `Schema '${schema}' does not exist. Verify the schema name.`,
+                        };
+                    }
+                }
+                // Default limit of 100 to prevent large payloads
+                const DEFAULT_LIMIT = 100;
+                const effectiveLimit = userLimit === 0 ? undefined : (userLimit ?? DEFAULT_LIMIT);
+                const conditions = [
+                    "udt_name = 'citext'",
+                    "table_schema NOT IN ('pg_catalog', 'information_schema')",
+                ];
+                const queryParams = [];
+                let paramIndex = 1;
+                if (schema !== undefined) {
+                    conditions.push(`table_schema = $${String(paramIndex++)}`);
+                    queryParams.push(schema);
+                }
+                const whereClause = conditions.join(" AND ");
+                // Count total columns first
+                const countSql = `
                 SELECT COUNT(*) as total
                 FROM information_schema.columns
                 WHERE ${whereClause}
             `;
-            const countResult = await adapter.executeQuery(countSql, queryParams);
-            const totalCount = Number(countResult.rows?.[0]?.["total"] ?? 0);
-            // Add LIMIT clause
-            const limitClause = effectiveLimit !== undefined ? `LIMIT ${String(effectiveLimit)}` : "";
-            const sql = `
-                SELECT 
+                const countResult = await adapter.executeQuery(countSql, queryParams);
+                const totalCount = Number(countResult.rows?.[0]?.["total"] ?? 0);
+                // Add LIMIT clause
+                const limitClause = effectiveLimit !== undefined ? `LIMIT ${String(effectiveLimit)}` : "";
+                const sql = `
+                SELECT
                     table_schema,
                     table_name,
                     column_name,
@@ -225,18 +269,24 @@ Useful for auditing case-insensitive columns.`,
                 ORDER BY table_schema, table_name, ordinal_position
                 ${limitClause}
             `;
-            const result = await adapter.executeQuery(sql, queryParams);
-            const columns = result.rows ?? [];
-            // Determine if results were truncated
-            const truncated = effectiveLimit !== undefined && columns.length < totalCount;
-            return {
-                columns,
-                count: columns.length,
-                totalCount,
-                truncated,
-                ...(effectiveLimit !== undefined && { limit: effectiveLimit }),
-                ...(schema !== undefined && { schema }),
-            };
+                const result = await adapter.executeQuery(sql, queryParams);
+                const columns = result.rows ?? [];
+                // Determine if results were truncated
+                const truncated = effectiveLimit !== undefined && columns.length < totalCount;
+                return {
+                    columns,
+                    count: columns.length,
+                    totalCount,
+                    truncated,
+                    ...(effectiveLimit !== undefined && { limit: effectiveLimit }),
+                    ...(schema !== undefined && { schema }),
+                };
+            }
+            catch (error) {
+                throw parsePostgresError(error, {
+                    tool: "pg_citext_list_columns",
+                });
+            }
         },
     };
 }
@@ -255,6 +305,29 @@ Looks for common patterns like email, username, name, slug, etc.`,
         icons: getToolIcons("citext", readOnly("Analyze Citext Candidates")),
         handler: async (params, _context) => {
             const { patterns, schema, table, limit: userLimit, excludeSystemSchemas: userExcludeSystemSchemas, } = CitextAnalyzeCandidatesSchema.parse(params);
+            // Validate table/schema existence before querying
+            if (table !== undefined) {
+                const schemaName = schema ?? "public";
+                const qualifiedTable = `"${schemaName}"."${table}"`;
+                const tableCheck = await adapter.executeQuery(`SELECT 1 FROM information_schema.tables
+           WHERE table_schema = $1 AND table_name = $2`, [schemaName, table]);
+                if (!tableCheck.rows || tableCheck.rows.length === 0) {
+                    return {
+                        success: false,
+                        error: `Table ${qualifiedTable} does not exist. Verify the table name and schema.`,
+                    };
+                }
+            }
+            else if (schema !== undefined) {
+                const schemaCheck = await adapter.executeQuery(`SELECT 1 FROM information_schema.schemata
+           WHERE schema_name = $1`, [schema]);
+                if (!schemaCheck.rows || schemaCheck.rows.length === 0) {
+                    return {
+                        success: false,
+                        error: `Schema '${schema}' does not exist. Verify the schema name.`,
+                    };
+                }
+            }
             // Default limit of 50 to prevent large payloads and transport truncation
             const DEFAULT_LIMIT = 50;
             const effectiveLimit = userLimit === 0 ? undefined : (userLimit ?? DEFAULT_LIMIT);
@@ -328,7 +401,7 @@ Looks for common patterns like email, username, name, slug, etc.`,
             // Add LIMIT clause
             const limitClause = effectiveLimit !== undefined ? `LIMIT ${String(effectiveLimit)}` : "";
             const sql = `
-                SELECT 
+                SELECT
                     table_schema,
                     table_name,
                     column_name,
@@ -402,50 +475,57 @@ Useful for testing citext behavior before converting columns.`,
         annotations: readOnly("Compare Citext Values"),
         icons: getToolIcons("citext", readOnly("Compare Citext Values")),
         handler: async (params, _context) => {
-            // Use the schema for proper validation
-            const schema = z.object({
-                value1: z.string(),
-                value2: z.string(),
-            });
-            const { value1, value2 } = schema.parse(params);
-            const extCheck = await adapter.executeQuery(`
+            try {
+                // Use the schema for proper validation
+                const schema = z.object({
+                    value1: z.string(),
+                    value2: z.string(),
+                });
+                const { value1, value2 } = schema.parse(params);
+                const extCheck = await adapter.executeQuery(`
                 SELECT EXISTS(
                     SELECT 1 FROM pg_extension WHERE extname = 'citext'
                 ) as installed
             `);
-            const hasExt = extCheck.rows?.[0]?.["installed"] ?? false;
-            if (hasExt) {
-                const result = await adapter.executeQuery(`
-                    SELECT 
+                const hasExt = extCheck.rows?.[0]?.["installed"] ?? false;
+                if (hasExt) {
+                    const result = await adapter.executeQuery(`
+                    SELECT
                         $1::citext = $2::citext as citext_equal,
                         $1::text = $2::text as text_equal,
                         LOWER($1) = LOWER($2) as lower_equal
                 `, [value1, value2]);
-                const row = result.rows?.[0];
-                return {
-                    value1,
-                    value2,
-                    citextEqual: row?.["citext_equal"],
-                    textEqual: row?.["text_equal"],
-                    lowerEqual: row?.["lower_equal"],
-                    extensionInstalled: true,
-                };
-            }
-            else {
-                const result = await adapter.executeQuery(`
-                    SELECT 
+                    const row = result.rows?.[0];
+                    return {
+                        value1,
+                        value2,
+                        citextEqual: row?.["citext_equal"],
+                        textEqual: row?.["text_equal"],
+                        lowerEqual: row?.["lower_equal"],
+                        extensionInstalled: true,
+                    };
+                }
+                else {
+                    const result = await adapter.executeQuery(`
+                    SELECT
                         $1::text = $2::text as text_equal,
                         LOWER($1) = LOWER($2) as lower_equal
                 `, [value1, value2]);
-                const row = result.rows?.[0];
-                return {
-                    value1,
-                    value2,
-                    textEqual: row?.["text_equal"],
-                    lowerEqual: row?.["lower_equal"],
-                    extensionInstalled: false,
-                    hint: "Install citext extension for native case-insensitive comparisons",
-                };
+                    const row = result.rows?.[0];
+                    return {
+                        value1,
+                        value2,
+                        textEqual: row?.["text_equal"],
+                        lowerEqual: row?.["lower_equal"],
+                        extensionInstalled: false,
+                        hint: "Install citext extension for native case-insensitive comparisons",
+                    };
+                }
+            }
+            catch (error) {
+                throw parsePostgresError(error, {
+                    tool: "pg_citext_compare",
+                });
             }
         },
     };
@@ -465,111 +545,121 @@ Requires the 'table' parameter to specify which table to analyze.`,
         annotations: readOnly("Citext Schema Advisor"),
         icons: getToolIcons("citext", readOnly("Citext Schema Advisor")),
         handler: async (params, _context) => {
-            const { table, schema } = CitextSchemaAdvisorSchema.parse(params);
-            const schemaName = schema ?? "public";
-            const qualifiedTable = `"${schemaName}"."${table}"`;
-            // First check if table exists
-            const tableCheck = await adapter.executeQuery(`
+            try {
+                const { table, schema } = CitextSchemaAdvisorSchema.parse(params);
+                const schemaName = schema ?? "public";
+                const qualifiedTable = `"${schemaName}"."${table}"`;
+                // First check if table exists
+                const tableCheck = await adapter.executeQuery(`
                 SELECT 1 FROM information_schema.tables
                 WHERE table_schema = $1 AND table_name = $2
             `, [schemaName, table]);
-            if (!tableCheck.rows || tableCheck.rows.length === 0) {
-                throw new Error(`Table ${qualifiedTable} not found. Verify the table name and schema.`);
-            }
-            const colResult = await adapter.executeQuery(`
-                SELECT 
+                if (!tableCheck.rows || tableCheck.rows.length === 0) {
+                    return {
+                        success: false,
+                        error: `Table ${qualifiedTable} not found. Verify the table name and schema.`,
+                    };
+                }
+                const colResult = await adapter.executeQuery(`
+                SELECT
                     column_name,
                     data_type,
                     udt_name,
                     is_nullable,
                     character_maximum_length
                 FROM information_schema.columns
-                WHERE table_schema = $1 
+                WHERE table_schema = $1
                   AND table_name = $2
                   AND data_type IN ('text', 'character varying', 'USER-DEFINED')
                 ORDER BY ordinal_position
             `, [schemaName, table]);
-            const columns = colResult.rows ?? [];
-            const recommendations = [];
-            const highConfidencePatterns = [
-                "email",
-                "username",
-                "login",
-                "user_name",
-            ];
-            const mediumConfidencePatterns = [
-                "name",
-                "slug",
-                "handle",
-                "code",
-                "sku",
-                "identifier",
-                "nickname",
-            ];
-            for (const col of columns) {
-                const colName = col["column_name"].toLowerCase();
-                const dataType = col["data_type"];
-                const udtName = col["udt_name"];
-                if (udtName === "citext") {
-                    recommendations.push({
-                        column: col["column_name"],
-                        currentType: "citext",
-                        previousType: "text or varchar (converted)",
-                        recommendation: "already_citext",
-                        confidence: "high",
-                        reason: "Column is already using citext",
-                    });
-                    continue;
-                }
-                const isHighConfidence = highConfidencePatterns.some((p) => colName.includes(p));
-                const isMediumConfidence = mediumConfidencePatterns.some((p) => colName.includes(p));
-                if (isHighConfidence) {
-                    recommendations.push({
-                        column: col["column_name"],
-                        currentType: dataType,
-                        recommendation: "convert",
-                        confidence: "high",
-                        reason: `Column name suggests case-insensitive data (${colName} matches common identifier patterns)`,
-                    });
-                }
-                else if (isMediumConfidence) {
-                    recommendations.push({
-                        column: col["column_name"],
-                        currentType: dataType,
-                        recommendation: "convert",
-                        confidence: "medium",
-                        reason: `Column name may benefit from case-insensitivity (${colName})`,
-                    });
-                }
-                else {
-                    recommendations.push({
-                        column: col["column_name"],
-                        currentType: dataType,
-                        recommendation: "keep",
-                        confidence: "low",
-                        reason: "No obvious case-insensitivity pattern detected",
-                    });
+                const columns = colResult.rows ?? [];
+                const recommendations = [];
+                const highConfidencePatterns = [
+                    "email",
+                    "username",
+                    "login",
+                    "user_name",
+                ];
+                const mediumConfidencePatterns = [
+                    "name",
+                    "slug",
+                    "handle",
+                    "code",
+                    "sku",
+                    "identifier",
+                    "nickname",
+                ];
+                for (const col of columns) {
+                    const colName = col["column_name"].toLowerCase();
+                    const dataType = col["data_type"];
+                    const udtName = col["udt_name"];
+                    if (udtName === "citext") {
+                        recommendations.push({
+                            column: col["column_name"],
+                            currentType: "citext",
+                            previousType: "text or varchar (converted)",
+                            recommendation: "already_citext",
+                            confidence: "high",
+                            reason: "Column is already using citext",
+                        });
+                        continue;
+                    }
+                    const isHighConfidence = highConfidencePatterns.some((p) => colName.includes(p));
+                    const isMediumConfidence = mediumConfidencePatterns.some((p) => colName.includes(p));
+                    if (isHighConfidence) {
+                        recommendations.push({
+                            column: col["column_name"],
+                            currentType: dataType,
+                            recommendation: "convert",
+                            confidence: "high",
+                            reason: `Column name suggests case-insensitive data (${colName} matches common identifier patterns)`,
+                        });
+                    }
+                    else if (isMediumConfidence) {
+                        recommendations.push({
+                            column: col["column_name"],
+                            currentType: dataType,
+                            recommendation: "convert",
+                            confidence: "medium",
+                            reason: `Column name may benefit from case-insensitivity (${colName})`,
+                        });
+                    }
+                    else {
+                        recommendations.push({
+                            column: col["column_name"],
+                            currentType: dataType,
+                            recommendation: "keep",
+                            confidence: "low",
+                            reason: "No obvious case-insensitivity pattern detected",
+                        });
+                    }
                 }
+                const convertCount = recommendations.filter((r) => r.recommendation === "convert").length;
+                const highCount = recommendations.filter((r) => r.recommendation === "convert" && r.confidence === "high").length;
+                return {
+                    table: `${schemaName}.${table}`,
+                    recommendations,
+                    summary: {
+                        totalTextColumns: columns.length,
+                        recommendConvert: convertCount,
+                        highConfidence: highCount,
+                        alreadyCitext: recommendations.filter((r) => r.recommendation === "already_citext").length,
+                    },
+                    nextSteps: convertCount > 0
+                        ? [
+                            "Review recommendations above",
+                            `Use pg_citext_convert_column to convert recommended columns`,
+                            "Update application queries if they rely on case-sensitive comparisons",
+                        ]
+                        : ["No columns require conversion"],
+                };
+            }
+            catch (error) {
+                throw parsePostgresError(error, {
+                    tool: "pg_citext_schema_advisor",
+                });
             }
-            const convertCount = recommendations.filter((r) => r.recommendation === "convert").length;
-            const highCount = recommendations.filter((r) => r.recommendation === "convert" && r.confidence === "high").length;
-            return {
-                table: `${schemaName}.${table}`,
-                recommendations,
-                summary: {
-                    totalTextColumns: columns.length,
-                    recommendConvert: convertCount,
-                    highConfidence: highCount,
-                    alreadyCitext: recommendations.filter((r) => r.recommendation === "already_citext").length,
-                },
-                nextSteps: convertCount > 0
-                    ? [
-                        "Review recommendations above",
-                        `Use pg_citext_convert_column to convert recommended columns`,
-                        "Update application queries if they rely on case-sensitive comparisons",
-                    ]
-                    : ["No columns require conversion"],
-            };
         },
     };
 }