@calebmabry/postgres-mcp-server 0.1.0

package/dist/tools/query.js

@@ -0,0 +1,318 @@
+import { getPool } from "../db.js";
+import { config } from "../config.js";
+import { QueryInputSchema, validateInput, } from "../validation.js";
+import NodeSQL from "node-sql-parser/build/postgresql.js";
+export const MAX_PAGE_SIZE = config.query.maxPageSize;
+export const DEFAULT_PAGE_SIZE = config.query.defaultPageSize;
+// Set to 'false' to disable automatic LIMIT application
+const AUTO_LIMIT = config.query.autoLimit;
+// Maximum payload size in bytes (default 5MB)
+export const MAX_PAYLOAD_SIZE = config.query.maxPayloadSize;
+const sqlParser = new NodeSQL.Parser();
+function isReadOnlyMode() {
+    // Check environment variable directly to support test configuration changes
+    return process.env.READ_ONLY !== "false";
+}
+// Dangerous operations that are never allowed
+const DANGEROUS_OPERATIONS = [
+    "DROP",
+    "CREATE",
+    "ALTER",
+    "TRUNCATE",
+    "GRANT",
+    "REVOKE",
+    "VACUUM",
+    "ANALYZE",
+    "CLUSTER",
+    "REINDEX",
+    "COPY",
+    "BACKUP",
+    "RESTORE",
+    "ATTACH",
+    "DETACH",
+    "PRAGMA",
+];
+function validateSqlSafety(sqlString) {
+    if (!sqlString || typeof sqlString !== "string") {
+        return {
+            isValid: false,
+            error: "SQL query is required and must be a string",
+        };
+    }
+    const trimmedSql = sqlString.trim();
+    if (!trimmedSql) {
+        return { isValid: false, error: "SQL query cannot be empty" };
+    }
+    // Check for dangerous operations BEFORE parsing (since parser may not support them)
+    const upperSql = trimmedSql.toUpperCase();
+    const sqlWords = upperSql.split(/\s+/);
+    const firstWord = sqlWords[0];
+    if (DANGEROUS_OPERATIONS.includes(firstWord)) {
+        return {
+            isValid: false,
+            error: `Dangerous operation '${firstWord}' is not allowed`,
+        };
+    }
+    // Handle EXPLAIN queries - they're read-only and don't need parsing
+    if (firstWord === 'EXPLAIN') {
+        // EXPLAIN is allowed in both read-only and write modes
+        return { isValid: true };
+    }
+    // Handle MERGE and UPSERT - not allowed in read-only mode
+    if (firstWord === 'MERGE' || firstWord === 'UPSERT') {
+        if (isReadOnlyMode()) {
+            return {
+                isValid: false,
+                error: "Only SELECT, WITH, and EXPLAIN queries are allowed in read-only mode",
+            };
+        }
+        // These operations require WHERE clauses in write mode, but parser can't handle them
+        // For now, we'll reject them since we can't safely validate them
+        return {
+            isValid: false,
+            error: "MERGE and UPSERT operations are not currently supported",
+        };
+    }
+    // Parse SQL to understand its structure
+    let ast;
+    try {
+        ast = sqlParser.astify(trimmedSql);
+    }
+    catch (parseError) {
+        return {
+            isValid: false,
+            error: "Invalid SQL syntax - unable to parse query",
+        };
+    }
+    // Convert to array if single statement
+    const statements = Array.isArray(ast) ? ast : [ast];
+    // Validate each statement
+    for (const statement of statements) {
+        const statementType = statement.type?.toUpperCase();
+        // Check for dangerous operations
+        if (DANGEROUS_OPERATIONS.includes(statementType)) {
+            return {
+                isValid: false,
+                error: `Dangerous operation '${statementType}' is not allowed`,
+            };
+        }
+        // In read-only mode, only allow SELECT, WITH (CTE), and EXPLAIN
+        if (isReadOnlyMode()) {
+            const allowedTypes = ["SELECT", "WITH", "EXPLAIN"];
+            if (!allowedTypes.includes(statementType)) {
+                return {
+                    isValid: false,
+                    error: "Only SELECT, WITH, and EXPLAIN queries are allowed in read-only mode",
+                };
+            }
+        }
+        else {
+            // Even in write mode, validate UPDATE and DELETE have WHERE clauses
+            if (statementType === "UPDATE" || statementType === "DELETE") {
+                // Type guard to check if statement has a where property
+                if (!("where" in statement) || !statement.where) {
+                    return {
+                        isValid: false,
+                        error: `${statementType} operations must include a WHERE clause`,
+                    };
+                }
+                // Check for dangerous WHERE patterns that effectively disable the clause
+                // These are patterns like WHERE 1=1, WHERE TRUE, WHERE 1, WHERE '1'='1'
+                const where = statement.where;
+                // Check for WHERE TRUE
+                if (where && where.type === 'bool' && where.value === true) {
+                    return {
+                        isValid: false,
+                        error: `${statementType} operations cannot use trivial WHERE clauses like WHERE 1=1 or WHERE TRUE`,
+                    };
+                }
+                // Check for WHERE 1 (just a constant value)
+                if (where && where.type === 'number') {
+                    return {
+                        isValid: false,
+                        error: `${statementType} operations cannot use trivial WHERE clauses like WHERE 1=1 or WHERE TRUE`,
+                    };
+                }
+                // Check for WHERE 1=1 pattern (binary expression comparing same constants)
+                if (where && where.type === 'binary_expr' && where.operator === '=') {
+                    const left = where.left;
+                    const right = where.right;
+                    // Both sides are the same constant number
+                    if (left && right && left.type === 'number' && right.type === 'number' && left.value === right.value) {
+                        return {
+                            isValid: false,
+                            error: `${statementType} operations cannot use trivial WHERE clauses like WHERE 1=1 or WHERE TRUE`,
+                        };
+                    }
+                    // Both sides are the same string literal
+                    if (left && right && left.type === 'single_quote_string' && right.type === 'single_quote_string' && left.value === right.value) {
+                        return {
+                            isValid: false,
+                            error: `${statementType} operations cannot use trivial WHERE clauses like WHERE 1=1 or WHERE TRUE`,
+                        };
+                    }
+                    // Both sides are the same identifier (double-quoted or column reference)
+                    // In PostgreSQL, "1"="1" would be comparing column "1" to column "1"
+                    if (left && right && left.type === 'column_ref' && right.type === 'column_ref') {
+                        // Extract values from nested structure
+                        const leftExpr = left.column?.expr || left.column;
+                        const rightExpr = right.column?.expr || right.column;
+                        // Check if both are double_quote_string with same value
+                        if (leftExpr && rightExpr &&
+                            leftExpr.type === 'double_quote_string' &&
+                            rightExpr.type === 'double_quote_string' &&
+                            leftExpr.value === rightExpr.value) {
+                            return {
+                                isValid: false,
+                                error: `${statementType} operations cannot use trivial WHERE clauses like WHERE 1=1 or WHERE TRUE`,
+                            };
+                        }
+                        // Check if both are the same column name
+                        if (typeof leftExpr === 'string' && typeof rightExpr === 'string' && leftExpr === rightExpr) {
+                            return {
+                                isValid: false,
+                                error: `${statementType} operations cannot use trivial WHERE clauses like WHERE 1=1 or WHERE TRUE`,
+                            };
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return { isValid: true };
+}
+function isReadOnlyQuery(sqlString) {
+    const upperSql = sqlString.trim().toUpperCase();
+    return (upperSql.startsWith("SELECT") ||
+        upperSql.startsWith("WITH") ||
+        upperSql.startsWith("EXPLAIN"));
+}
+function isSingleRowAggregate(upperSql) {
+    // Check if it's an aggregate query that should return a single row
+    const hasAggregates = upperSql.includes("COUNT(") ||
+        upperSql.includes("SUM(") ||
+        upperSql.includes("AVG(") ||
+        upperSql.includes("MAX(") ||
+        upperSql.includes("MIN(");
+    const hasGroupBy = upperSql.includes("GROUP BY");
+    // Single row aggregate: has aggregates but no GROUP BY
+    return hasAggregates && !hasGroupBy;
+}
+function applyPagination(sqlString, pageSize, offset) {
+    // Strip trailing semicolons to avoid syntax errors when adding LIMIT/OFFSET
+    const cleanedSql = sqlString.trim().replace(/;+$/, '');
+    const upperSql = cleanedSql.toUpperCase();
+    // Don't modify if already has LIMIT or OFFSET
+    if (upperSql.includes("LIMIT") || upperSql.includes("OFFSET")) {
+        return {
+            sql: cleanedSql,
+            actualPageSize: pageSize || DEFAULT_PAGE_SIZE,
+            actualOffset: offset || 0,
+        };
+    }
+    // Use client-specified pageSize or default, capped at MAX_PAGE_SIZE
+    const actualPageSize = Math.min(pageSize || DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE);
+    const actualOffset = offset || 0;
+    // Don't add LIMIT to single-row aggregates
+    if (isSingleRowAggregate(upperSql)) {
+        return { sql: cleanedSql, actualPageSize, actualOffset };
+    }
+    // If AUTO_LIMIT is disabled and no pageSize was explicitly provided, don't add LIMIT
+    if (!AUTO_LIMIT && !pageSize) {
+        return { sql: cleanedSql, actualPageSize, actualOffset };
+    }
+    let paginatedSql = `${cleanedSql} LIMIT ${actualPageSize}`;
+    if (actualOffset > 0) {
+        paginatedSql += ` OFFSET ${actualOffset}`;
+    }
+    return { sql: paginatedSql, actualPageSize, actualOffset };
+}
+function validateParameters(parameters) {
+    for (const param of parameters) {
+        if (param !== null &&
+            typeof param !== "string" &&
+            typeof param !== "number" &&
+            typeof param !== "boolean") {
+            return {
+                error: "Invalid parameter type - only string, number, boolean, and null are allowed",
+            };
+        }
+        if (typeof param === "number" && !Number.isFinite(param)) {
+            return { error: "Invalid numeric parameter - must be finite number" };
+        }
+    }
+    return null;
+}
+export async function queryTool(input) {
+    try {
+        const inputValidation = validateInput(QueryInputSchema, input);
+        if (!inputValidation.success) {
+            return { error: `Input validation failed: ${inputValidation.error}` };
+        }
+        const validatedInput = inputValidation.data;
+        const sqlValidation = validateSqlSafety(validatedInput.sql);
+        if (!sqlValidation.isValid) {
+            return { error: sqlValidation.error };
+        }
+        const pool = getPool();
+        const trimmedSql = validatedInput.sql.trim();
+        const params = validatedInput.parameters ?? [];
+        if (params.length > 0) {
+            const paramError = validateParameters(params);
+            if (paramError)
+                return paramError;
+        }
+        if (isReadOnlyQuery(trimmedSql)) {
+            const { sql: paginatedSql, actualPageSize, actualOffset, } = applyPagination(trimmedSql, validatedInput.pageSize, validatedInput.offset);
+            // Execute the query
+            const result = params.length > 0
+                ? await pool.query(paginatedSql, params)
+                : await pool.query(paginatedSql);
+            // Check payload size after query execution
+            const payloadJson = JSON.stringify(result.rows);
+            const payloadSize = Buffer.byteLength(payloadJson, 'utf8');
+            if (payloadSize > MAX_PAYLOAD_SIZE) {
+                const sizeMB = (payloadSize / (1024 * 1024)).toFixed(2);
+                const maxMB = (MAX_PAYLOAD_SIZE / (1024 * 1024)).toFixed(2);
+                return {
+                    error: `Query result payload (${sizeMB}MB) exceeds maximum allowed size (${maxMB}MB). Please reduce pageSize or add more specific WHERE conditions to limit results.`,
+                };
+            }
+            // Determine if there are more rows available
+            const hasMore = result.rows.length === actualPageSize;
+            return {
+                rows: result.rows,
+                rowCount: result.rows.length,
+                pagination: {
+                    hasMore,
+                    pageSize: actualPageSize,
+                    offset: actualOffset,
+                },
+            };
+        }
+        else {
+            // For write operations (when not in read-only mode)
+            const cleanedSql = trimmedSql.replace(/;+$/, '');
+            const result = params.length > 0
+                ? await pool.query(cleanedSql, params)
+                : await pool.query(cleanedSql);
+            return {
+                rowCount: result.rowCount ?? 0,
+            };
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+        // Extract PostgreSQL-specific error details if available
+        const pgError = error;
+        const errorCode = pgError?.code || "UNKNOWN";
+        const hint = pgError?.hint;
+        const sanitizedError = errorMessage.replace(/\s+/g, " ").trim();
+        return {
+            error: sanitizedError,
+            code: errorCode,
+            hint: hint,
+        };
+    }
+}
+//# sourceMappingURL=query.js.map

package/dist/tools/query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.js","sourceRoot":"","sources":["../../src/tools/query.ts"],"names":[],"mappings":"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"}

package/dist/tools/schemas.d.ts

@@ -0,0 +1,10 @@
+export interface SchemaInfo {
+    schema_name: string;
+    schema_owner: string;
+}
+export interface ListSchemasOutput {
+    schemas?: SchemaInfo[];
+    error?: string;
+}
+export declare function listSchemasTool(input: unknown): Promise<ListSchemasOutput>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/tools/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/tools/schemas.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,UAAU;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wBAAsB,eAAe,CACnC,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,iBAAiB,CAAC,CAiD5B"}

package/dist/tools/schemas.js

@@ -0,0 +1,51 @@
+import { getDb } from "../db.js";
+import { sql } from "kysely";
+import { ListSchemasInputSchema, validateInput } from "../validation.js";
+export async function listSchemasTool(input) {
+    try {
+        const validation = validateInput(ListSchemasInputSchema, input);
+        if (!validation.success) {
+            return { error: `Input validation failed: ${validation.error}` };
+        }
+        const validatedInput = validation.data;
+        const db = getDb();
+        const includeSystem = validatedInput.includeSystemSchemas || false;
+        let query = sql `
+      SELECT 
+        schema_name,
+        schema_owner
+      FROM information_schema.schemata
+    `;
+        if (!includeSystem) {
+            query = sql `
+        SELECT 
+          schema_name,
+          schema_owner
+        FROM information_schema.schemata
+        WHERE schema_name NOT IN ('information_schema', 'pg_catalog', 'pg_toast')
+          AND schema_name NOT LIKE 'pg_temp_%'
+          AND schema_name NOT LIKE 'pg_toast_temp_%'
+        ORDER BY schema_name
+      `;
+        }
+        else {
+            query = sql `
+        SELECT 
+          schema_name,
+          schema_owner
+        FROM information_schema.schemata
+        ORDER BY schema_name
+      `;
+        }
+        const result = await query.execute(db);
+        return {
+            schemas: result.rows,
+        };
+    }
+    catch (error) {
+        return {
+            error: error instanceof Error ? error.message : "Unknown error occurred",
+        };
+    }
+}
+//# sourceMappingURL=schemas.js.map

package/dist/tools/schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../../src/tools/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAC;AAC7B,OAAO,EAAE,sBAAsB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAYzE,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,KAAc;IAEd,IAAI,CAAC;QACH,MAAM,UAAU,GAAG,aAAa,CAAC,sBAAsB,EAAE,KAAK,CAAC,CAAC;QAChE,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;YACxB,OAAO,EAAE,KAAK,EAAE,4BAA4B,UAAU,CAAC,KAAK,EAAE,EAAE,CAAC;QACnE,CAAC;QAED,MAAM,cAAc,GAAG,UAAU,CAAC,IAAI,CAAC;QACvC,MAAM,EAAE,GAAG,KAAK,EAAE,CAAC;QACnB,MAAM,aAAa,GAAG,cAAc,CAAC,oBAAoB,IAAI,KAAK,CAAC;QAEnE,IAAI,KAAK,GAAG,GAAG,CAAY;;;;;KAK1B,CAAC;QAEF,IAAI,CAAC,aAAa,EAAE,CAAC;YACnB,KAAK,GAAG,GAAG,CAAY;;;;;;;;;OAStB,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,KAAK,GAAG,GAAG,CAAY;;;;;;OAMtB,CAAC;QACJ,CAAC;QAED,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QAEvC,OAAO;YACL,OAAO,EAAE,MAAM,CAAC,IAAI;SACrB,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO;YACL,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,wBAAwB;SACzE,CAAC;IACJ,CAAC;AACH,CAAC"}

package/dist/validation.d.ts

@@ -0,0 +1,159 @@
+import { z } from 'zod';
+export declare const QueryInputSchema: z.ZodObject<{
+    sql: z.ZodString;
+    parameters: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, "many">>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    sql: string;
+    parameters?: (string | number | boolean | null)[] | undefined;
+    pageSize?: number | undefined;
+    offset?: number | undefined;
+}, {
+    sql: string;
+    parameters?: (string | number | boolean | null)[] | undefined;
+    pageSize?: number | undefined;
+    offset?: number | undefined;
+}>;
+export declare const QueryOutputSchema: z.ZodObject<{
+    rows: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">>;
+    rowCount: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodString>;
+    code: z.ZodOptional<z.ZodString>;
+    hint: z.ZodOptional<z.ZodString>;
+    pagination: z.ZodOptional<z.ZodObject<{
+        hasMore: z.ZodBoolean;
+        pageSize: z.ZodNumber;
+        offset: z.ZodNumber;
+        totalRows: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        pageSize: number;
+        offset: number;
+        hasMore: boolean;
+        totalRows?: number | undefined;
+    }, {
+        pageSize: number;
+        offset: number;
+        hasMore: boolean;
+        totalRows?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    error?: string | undefined;
+    code?: string | undefined;
+    rows?: Record<string, any>[] | undefined;
+    rowCount?: number | undefined;
+    hint?: string | undefined;
+    pagination?: {
+        pageSize: number;
+        offset: number;
+        hasMore: boolean;
+        totalRows?: number | undefined;
+    } | undefined;
+}, {
+    error?: string | undefined;
+    code?: string | undefined;
+    rows?: Record<string, any>[] | undefined;
+    rowCount?: number | undefined;
+    hint?: string | undefined;
+    pagination?: {
+        pageSize: number;
+        offset: number;
+        hasMore: boolean;
+        totalRows?: number | undefined;
+    } | undefined;
+}>;
+export declare const DescribeTableInputSchema: z.ZodObject<{
+    schema: z.ZodString;
+    table: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    schema: string;
+    table: string;
+}, {
+    schema: string;
+    table: string;
+}>;
+export declare const ListTablesInputSchema: z.ZodObject<{
+    schema: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    schema?: string | undefined;
+}, {
+    schema?: string | undefined;
+}>;
+export declare const ListSchemasInputSchema: z.ZodObject<{
+    includeSystemSchemas: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    includeSystemSchemas?: boolean | undefined;
+}, {
+    includeSystemSchemas?: boolean | undefined;
+}>;
+export declare const ListIndexesInputSchema: z.ZodObject<{
+    schema: z.ZodString;
+    table: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    schema: string;
+    table?: string | undefined;
+}, {
+    schema: string;
+    table?: string | undefined;
+}>;
+export declare const ExplainQueryInputSchema: z.ZodObject<{
+    sql: z.ZodString;
+    analyze: z.ZodOptional<z.ZodBoolean>;
+    buffers: z.ZodOptional<z.ZodBoolean>;
+    costs: z.ZodOptional<z.ZodBoolean>;
+    format: z.ZodOptional<z.ZodEnum<["text", "json", "xml", "yaml"]>>;
+}, "strip", z.ZodTypeAny, {
+    sql: string;
+    analyze?: boolean | undefined;
+    buffers?: boolean | undefined;
+    costs?: boolean | undefined;
+    format?: "text" | "json" | "xml" | "yaml" | undefined;
+}, {
+    sql: string;
+    analyze?: boolean | undefined;
+    buffers?: boolean | undefined;
+    costs?: boolean | undefined;
+    format?: "text" | "json" | "xml" | "yaml" | undefined;
+}>;
+export declare const GetTableStatsInputSchema: z.ZodObject<{
+    schema: z.ZodString;
+    table: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    schema: string;
+    table?: string | undefined;
+}, {
+    schema: string;
+    table?: string | undefined;
+}>;
+export declare const ListViewsInputSchema: z.ZodObject<{
+    schema: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    schema?: string | undefined;
+}, {
+    schema?: string | undefined;
+}>;
+export declare const ListFunctionsInputSchema: z.ZodObject<{
+    schema: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    schema?: string | undefined;
+}, {
+    schema?: string | undefined;
+}>;
+export declare function validateInput<T>(schema: z.ZodSchema<T>, input: unknown): {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: string;
+};
+export type QueryInput = z.infer<typeof QueryInputSchema>;
+export type QueryOutput = z.infer<typeof QueryOutputSchema>;
+export type DescribeTableInput = z.infer<typeof DescribeTableInputSchema>;
+export type ListTablesInput = z.infer<typeof ListTablesInputSchema>;
+export type ListSchemasInput = z.infer<typeof ListSchemasInputSchema>;
+export type ListIndexesInput = z.infer<typeof ListIndexesInputSchema>;
+export type ExplainQueryInput = z.infer<typeof ExplainQueryInputSchema>;
+export type GetTableStatsInput = z.infer<typeof GetTableStatsInputSchema>;
+export type ListViewsInput = z.infer<typeof ListViewsInputSchema>;
+export type ListFunctionsInput = z.infer<typeof ListFunctionsInputSchema>;
+//# sourceMappingURL=validation.d.ts.map

package/dist/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;EAU3B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAY5B,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;EAKnC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;EAIhC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;EAEjC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;EAMjC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;EAMlC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;EAMnC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;EAI/B,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;EAInC,CAAC;AAEH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAiBvI;AAED,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/validation.js

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+export const QueryInputSchema = z.object({
+    sql: z.string().min(1, "SQL query cannot be empty").max(50000, "SQL query too long"),
+    parameters: z.array(z.union([
+        z.string(),
+        z.number(),
+        z.boolean(),
+        z.null()
+    ])).optional().describe("Optional array of parameters for parameterized queries"),
+    pageSize: z.number().min(1).max(500).optional().describe("Number of rows to return (1-500, default: 100)"),
+    offset: z.number().min(0).optional().describe("Number of rows to skip for pagination")
+});
+export const QueryOutputSchema = z.object({
+    rows: z.array(z.record(z.any())).optional().describe("Query result rows (for SELECT queries)"),
+    rowCount: z.number().optional().describe("Number of rows affected/returned"),
+    error: z.string().optional().describe("Error message if query failed"),
+    code: z.string().optional().describe("Error code for categorized errors"),
+    hint: z.string().optional().describe("Helpful hint for resolving errors"),
+    pagination: z.object({
+        hasMore: z.boolean().describe("Whether more rows are available"),
+        pageSize: z.number().describe("Actual page size used"),
+        offset: z.number().describe("Offset used for this query"),
+        totalRows: z.number().optional().describe("Total rows available (if determinable)")
+    }).optional().describe("Pagination metadata for SELECT queries")
+});
+export const DescribeTableInputSchema = z.object({
+    schema: z.string().min(1, "Schema name is required").max(63, "Schema name too long")
+        .regex(/^[a-zA-Z_][a-zA-Z0-9_]*$/, "Invalid schema name format"),
+    table: z.string().min(1, "Table name is required").max(63, "Table name too long")
+        .regex(/^[a-zA-Z_][a-zA-Z0-9_]*$/, "Invalid table name format")
+});
+export const ListTablesInputSchema = z.object({
+    schema: z.string().min(1).max(63)
+        .regex(/^[a-zA-Z_][a-zA-Z0-9_]*$/, "Invalid schema name format")
+        .optional()
+});
+export const ListSchemasInputSchema = z.object({
+    includeSystemSchemas: z.boolean().optional()
+});
+export const ListIndexesInputSchema = z.object({
+    schema: z.string().min(1, "Schema name is required").max(63, "Schema name too long")
+        .regex(/^[a-zA-Z_][a-zA-Z0-9_]*$/, "Invalid schema name format"),
+    table: z.string().min(1).max(63)
+        .regex(/^[a-zA-Z_][a-zA-Z0-9_]*$/, "Invalid table name format")
+        .optional()
+});
+export const ExplainQueryInputSchema = z.object({
+    sql: z.string().min(1, "SQL query cannot be empty").max(50000, "SQL query too long"),
+    analyze: z.boolean().optional(),
+    buffers: z.boolean().optional(),
+    costs: z.boolean().optional(),
+    format: z.enum(['text', 'json', 'xml', 'yaml']).optional()
+});
+export const GetTableStatsInputSchema = z.object({
+    schema: z.string().min(1, "Schema name is required").max(63, "Schema name too long")
+        .regex(/^[a-zA-Z_][a-zA-Z0-9_]*$/, "Invalid schema name format"),
+    table: z.string().min(1).max(63)
+        .regex(/^[a-zA-Z_][a-zA-Z0-9_]*$/, "Invalid table name format")
+        .optional()
+});
+export const ListViewsInputSchema = z.object({
+    schema: z.string().min(1).max(63)
+        .regex(/^[a-zA-Z_][a-zA-Z0-9_]*$/, "Invalid schema name format")
+        .optional()
+});
+export const ListFunctionsInputSchema = z.object({
+    schema: z.string().min(1).max(63)
+        .regex(/^[a-zA-Z_][a-zA-Z0-9_]*$/, "Invalid schema name format")
+        .optional()
+});
+export function validateInput(schema, input) {
+    try {
+        const data = schema.parse(input);
+        return { success: true, data };
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            const firstError = error.errors[0];
+            return {
+                success: false,
+                error: `${firstError.path.join('.')}: ${firstError.message}`
+            };
+        }
+        return {
+            success: false,
+            error: 'Invalid input format'
+        };
+    }
+}
+//# sourceMappingURL=validation.js.map