sql-talk/dist/core/errors.js

SQL Talk - 自然言語をSQLに変換するMCPサーバー（安全性保護・SSHトンネル対応） / SQL Talk - MCP Server for Natural Language to SQL conversion with safety guards and SSH tunnel support

/**
 * Custom error classes for MCP NL-to-SQL server
 */
export class MCPError extends Error {
    code;
    statusCode;
    details;
    constructor(message, code, statusCode = 500, details) {
        super(message);
        this.name = 'MCPError';
        this.code = code;
        this.statusCode = statusCode;
        this.details = details;
        // Maintains proper stack trace for where our error was thrown
        if (Error.captureStackTrace) {
            Error.captureStackTrace(this, MCPError);
        }
    }
    toJSON() {
        return {
            name: this.name,
            message: this.message,
            code: this.code,
            statusCode: this.statusCode,
            details: this.details,
            stack: this.stack
        };
    }
}
export class ConfigurationError extends MCPError {
    constructor(message, details) {
        super(message, 'CONFIGURATION_ERROR', 500, details);
        this.name = 'ConfigurationError';
    }
}
export class DatabaseError extends MCPError {
    constructor(message, details) {
        super(message, 'DATABASE_ERROR', 500, details);
        this.name = 'DatabaseError';
    }
}
export class SecurityError extends MCPError {
    constructor(message, details) {
        super(message, 'SECURITY_ERROR', 403, details);
        this.name = 'SecurityError';
    }
}
export class ValidationError extends MCPError {
    constructor(message, details) {
        super(message, 'VALIDATION_ERROR', 400, details);
        this.name = 'ValidationError';
    }
}
export class SqlLintError extends MCPError {
    constructor(message, details) {
        super(message, 'SQL_LINT_ERROR', 400, details);
        this.name = 'SqlLintError';
    }
}
export class AuthorizationError extends MCPError {
    constructor(message, details) {
        super(message, 'AUTHORIZATION_ERROR', 401, details);
        this.name = 'AuthorizationError';
    }
}
export class TimeoutError extends MCPError {
    constructor(message, details) {
        super(message, 'TIMEOUT_ERROR', 408, details);
        this.name = 'TimeoutError';
    }
}
export class SchemaError extends MCPError {
    constructor(message, details) {
        super(message, 'SCHEMA_ERROR', 500, details);
        this.name = 'SchemaError';
    }
}
/**
 * Error handler utility functions
 */
export class ErrorHandler {
    static isMCPError(error) {
        return error instanceof MCPError;
    }
    static isKnownError(error) {
        return error instanceof MCPError || error instanceof Error;
    }
    static formatError(error) {
        if (error instanceof MCPError) {
            return {
                message: error.message,
                code: error.code,
                details: error.details
            };
        }
        else if (error instanceof Error) {
            return {
                message: error.message,
                code: 'UNKNOWN_ERROR',
                details: { stack: error.stack }
            };
        }
        else {
            return {
                message: String(error),
                code: 'UNKNOWN_ERROR'
            };
        }
    }
    static createSafeError(error) {
        if (error instanceof MCPError) {
            return error;
        }
        else if (error instanceof Error) {
            return new MCPError(error.message, 'WRAPPED_ERROR', 500, { originalError: error.constructor.name });
        }
        else {
            return new MCPError(String(error), 'UNKNOWN_ERROR', 500);
        }
    }
}
/**
 * Async error wrapper for better error handling
 */
export function asyncHandler(fn) {
    return async (...args) => {
        try {
            return await fn(...args);
        }
        catch (error) {
            throw ErrorHandler.createSafeError(error);
        }
    };
}
//# sourceMappingURL=errors.js.map