Error Handling Guide

import asyncio
import logging
from typing import Optional
from geode_client import Client, GeodeError, ConnectionError, TimeoutError

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

async def connect_with_retry(
    host: str,
    port: int,
    max_retries: int = 5,
    base_delay: float = 1.0
) -> Optional[Client]:
    """Connect to Geode with exponential backoff retry."""
    client = Client(host=host, port=port, skip_verify=True)

    for attempt in range(1, max_retries + 1):
        try:
            async with client.connection() as conn:
                # Test connection with ping
                await conn.query("RETURN 1")
                logger.info(f"Connected successfully on attempt {attempt}")
                return client

        except ConnectionError as e:
            logger.warning(f"Attempt {attempt}: Connection refused - {e}")
        except TimeoutError as e:
            logger.warning(f"Attempt {attempt}: Connection timeout - {e}")
        except GeodeError as e:
            logger.warning(f"Attempt {attempt}: Geode error {e.code} - {e.message}")
        except Exception as e:
            logger.warning(f"Attempt {attempt}: Unexpected error - {e}")

        if attempt < max_retries:
            delay = base_delay * (2 ** (attempt - 1))  # Exponential backoff
            logger.info(f"Retrying in {delay} seconds...")
            await asyncio.sleep(delay)

    logger.error(f"Failed to connect after {max_retries} attempts")
    return None


def handle_connection_error(error: Exception) -> None:
    """Handle and log connection errors appropriately."""
    if isinstance(error, GeodeError):
        error_handlers = {
            "GQL-00001": "Connection refused - is Geode server running?",
            "GQL-00002": "Connection timeout - check network connectivity",
            "GQL-00003": "Connection closed - server may have restarted",
        }
        message = error_handlers.get(error.code, f"Connection error: {error.message}")
        logger.error(message)
    elif isinstance(error, ConnectionError):
        logger.error(f"Connection error: {error}")
    elif isinstance(error, TimeoutError):
        logger.error(f"Timeout error: {error}")
    else:
        logger.error(f"Unknown error: {error}")


async def main():
    client = await connect_with_retry("localhost", 3141)

    if client is None:
        return

    try:
        async with client.connection() as conn:
            # Use connection
            result, _ = await conn.query("MATCH (n) RETURN count(n)")
            print(f"Node count: {result.rows[0]['count(n)'].as_int}")
    except Exception as e:
        handle_connection_error(e)


if __name__ == "__main__":
    asyncio.run(main())

use geode_client::{Client, Error, ErrorCode};
use std::time::Duration;
use tokio::time::sleep;
use tracing::{error, info, warn};

async fn connect_with_retry(
    host: &str,
    port: u16,
    max_retries: u32,
) -> Result<Client, Error> {
    let mut last_error = None;

    for attempt in 1..=max_retries {
        match Client::new(host, port).skip_verify(true).connect().await {
            Ok(conn) => {
                info!("Connected successfully on attempt {}", attempt);
                return Ok(Client::new(host, port).skip_verify(true));
            }
            Err(e) => {
                warn!("Attempt {}: Connection failed - {:?}", attempt, e);
                last_error = Some(e);

                if attempt < max_retries {
                    let delay = Duration::from_secs(2u64.pow(attempt - 1));
                    info!("Retrying in {:?}...", delay);
                    sleep(delay).await;
                }
            }
        }
    }

    Err(last_error.unwrap_or(Error::ConnectionRefused))
}

fn handle_connection_error(error: &Error) {
    match error.code() {
        Some(ErrorCode::ConnectionRefused) => {
            error!("Connection refused - is Geode server running?");
        }
        Some(ErrorCode::ConnectionTimeout) => {
            error!("Connection timeout - check network connectivity");
        }
        Some(ErrorCode::ConnectionClosed) => {
            error!("Connection closed - server may have restarted");
        }
        Some(code) => {
            error!("Connection error {:?}: {}", code, error);
        }
        None => {
            error!("Unknown connection error: {}", error);
        }
    }
}

#[tokio::main]
async fn main() {
    tracing_subscriber::init();

    match connect_with_retry("127.0.0.1", 3141, 5).await {
        Ok(client) => {
            // Use client
            match client.connect().await {
                Ok(mut conn) => {
                    let (page, _) = conn.query("MATCH (n) RETURN count(n)").await.unwrap();
                    println!("Node count: {:?}", page.rows);
                }
                Err(e) => handle_connection_error(&e),
            }
        }
        Err(e) => {
            handle_connection_error(&e);
        }
    }
}

import { createClient, GeodeClient, GeodeError } from '@geodedb/client';

const logger = {
    info: (msg: string) => console.log(`[INFO] ${msg}`),
    warn: (msg: string) => console.warn(`[WARN] ${msg}`),
    error: (msg: string) => console.error(`[ERROR] ${msg}`),
};

async function connectWithRetry(
    url: string,
    maxRetries: number = 5,
    baseDelay: number = 1000
): Promise<GeodeClient | null> {
    let lastError: Error | null = null;

    for (let attempt = 1; attempt <= maxRetries; attempt++) {
        try {
            const client = await createClient(url);
            // Test connection
            await client.queryAll('RETURN 1');
            logger.info(`Connected successfully on attempt ${attempt}`);
            return client;
        } catch (error) {
            lastError = error as Error;

            if (error instanceof GeodeError) {
                logger.warn(`Attempt ${attempt}: Geode error ${error.code} - ${error.message}`);
            } else {
                logger.warn(`Attempt ${attempt}: ${error}`);
            }

            if (attempt < maxRetries) {
                const delay = baseDelay * Math.pow(2, attempt - 1);
                logger.info(`Retrying in ${delay}ms...`);
                await new Promise(resolve => setTimeout(resolve, delay));
            }
        }
    }

    logger.error(`Failed to connect after ${maxRetries} attempts`);
    return null;
}

function handleConnectionError(error: unknown): void {
    if (error instanceof GeodeError) {
        const errorMessages: Record<string, string> = {
            'GQL-00001': 'Connection refused - is Geode server running?',
            'GQL-00002': 'Connection timeout - check network connectivity',
            'GQL-00003': 'Connection closed - server may have restarted',
        };

        const message = errorMessages[error.code] || `Connection error: ${error.message}`;
        logger.error(message);
    } else if (error instanceof Error) {
        logger.error(`Error: ${error.message}`);
    } else {
        logger.error(`Unknown error: ${error}`);
    }
}

async function main() {
    const client = await connectWithRetry('quic://localhost:3141');

    if (!client) {
        return;
    }

    try {
        const rows = await client.queryAll('MATCH (n) RETURN count(n)');
        console.log('Node count:', rows[0].get('count(n)')?.asNumber);
    } catch (error) {
        handleConnectionError(error);
    } finally {
        await client.close();
    }
}

main();

const std = @import("std");
const geode = @import("geode_client");

const Logger = struct {
    pub fn info(comptime fmt: []const u8, args: anytype) void {
        std.debug.print("[INFO] " ++ fmt ++ "\n", args);
    }

    pub fn warn(comptime fmt: []const u8, args: anytype) void {
        std.debug.print("[WARN] " ++ fmt ++ "\n", args);
    }

    pub fn err(comptime fmt: []const u8, args: anytype) void {
        std.debug.print("[ERROR] " ++ fmt ++ "\n", args);
    }
};

pub fn connectWithRetry(
    allocator: std.mem.Allocator,
    host: []const u8,
    port: u16,
    max_retries: u32,
) !geode.GeodeClient {
    var last_error: ?anyerror = null;

    var attempt: u32 = 1;
    while (attempt <= max_retries) : (attempt += 1) {
        var client = geode.GeodeClient.init(allocator, host, port, true);

        client.connect() catch |e| {
            Logger.warn("Attempt {d}: Connection failed - {any}", .{ attempt, e });
            last_error = e;

            if (attempt < max_retries) {
                const delay_ms = std.math.pow(u64, 2, attempt - 1) * 1000;
                Logger.info("Retrying in {d}ms...", .{delay_ms});
                std.time.sleep(delay_ms * std.time.ns_per_ms);
            }
            continue;
        };

        client.sendHello("app", "1.0.0") catch |e| {
            Logger.warn("Attempt {d}: Handshake failed - {any}", .{ attempt, e });
            last_error = e;
            client.deinit();
            continue;
        };

        _ = client.receiveMessage(30000) catch |e| {
            Logger.warn("Attempt {d}: Hello response failed - {any}", .{ attempt, e });
            last_error = e;
            client.deinit();
            continue;
        };

        Logger.info("Connected successfully on attempt {d}", .{attempt});
        return client;
    }

    Logger.err("Failed to connect after {d} attempts", .{max_retries});
    return last_error orelse error.ConnectionFailed;
}

pub fn handleConnectionError(err: anyerror) void {
    switch (err) {
        error.ConnectionRefused => {
            Logger.err("Connection refused - is Geode server running?", .{});
        },
        error.ConnectionTimeout => {
            Logger.err("Connection timeout - check network connectivity", .{});
        },
        error.ConnectionClosed => {
            Logger.err("Connection closed - server may have restarted", .{});
        },
        else => {
            Logger.err("Connection error: {any}", .{err});
        },
    }
}

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    var client = connectWithRetry(allocator, "localhost", 3141, 5) catch |e| {
        handleConnectionError(e);
        return;
    };
    defer client.deinit();

    // Use client
    client.sendRunGql(1, "MATCH (n) RETURN count(n)", null) catch |e| {
        handleConnectionError(e);
        return;
    };

    const result = client.receiveMessage(30000) catch |e| {
        handleConnectionError(e);
        return;
    };
    defer allocator.free(result);

    std.debug.print("Result: {s}\n", .{result});
}

from dataclasses import dataclass
from typing import Optional
from geode_client import GeodeError, SyntaxError, SemanticError

@dataclass
class QueryError:
    code: str
    message: str
    query: str
    position: Optional[int] = None
    line: Optional[int] = None
    column: Optional[int] = None

    def __str__(self) -> str:
        if self.line and self.column:
            return f"[{self.code}] {self.message} (line {self.line}, column {self.column})"
        return f"[{self.code}] {self.message}"


async def execute_query(conn, query: str) -> None:
    """Execute a query with detailed error handling."""
    try:
        await conn.execute(query)
    except SyntaxError as e:
        logger.error(f"Syntax error in query: {e.message}")
        logger.error(f"Query: {query}")
        if e.position:
            logger.error(f"Error at position: {e.position}")
        raise QueryError(
            code=e.code,
            message=e.message,
            query=query,
            position=e.position,
            line=e.line,
            column=e.column,
        )
    except SemanticError as e:
        logger.error(f"Semantic error: {e.message}")
        raise QueryError(
            code=e.code,
            message=e.message,
            query=query,
        )
    except GeodeError as e:
        logger.error(f"Query error [{e.code}]: {e.message}")
        raise


def format_query_error(query: str, error: QueryError) -> str:
    """Format query error with visual indication of error location."""
    lines = query.split('\n')
    output = ["Query error:"]

    for i, line in enumerate(lines, 1):
        output.append(f"  {i:3d} | {line}")
        if error.line == i and error.column:
            marker = " " * (8 + error.column - 1) + "^"
            output.append(marker)

    output.append(f"\nError: {error}")
    return '\n'.join(output)


# Usage example
async def safe_query(conn, query: str):
    try:
        return await conn.query(query)
    except QueryError as e:
        print(format_query_error(query, e))
        raise

use geode_client::{Error, ErrorCode};
use thiserror::Error;

#[derive(Error, Debug)]
pub struct QueryError {
    pub code: String,
    pub message: String,
    pub query: String,
    pub position: Option<usize>,
    pub line: Option<usize>,
    pub column: Option<usize>,
}

impl std::fmt::Display for QueryError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if let (Some(line), Some(column)) = (self.line, self.column) {
            write!(f, "[{}] {} (line {}, column {})",
                self.code, self.message, line, column)
        } else {
            write!(f, "[{}] {}", self.code, self.message)
        }
    }
}

async fn execute_query(conn: &mut Connection, query: &str) -> Result<(), QueryError> {
    match conn.query(query).await {
        Ok(_) => Ok(()),
        Err(e) => {
            let error = QueryError {
                code: e.code().map(|c| format!("{:?}", c)).unwrap_or_default(),
                message: e.to_string(),
                query: query.to_string(),
                position: e.position(),
                line: e.line(),
                column: e.column(),
            };

            match e.code() {
                Some(ErrorCode::SyntaxError) => {
                    error!("Syntax error in query: {}", error.message);
                    error!("Query: {}", query);
                    if let Some(pos) = error.position {
                        error!("Error at position: {}", pos);
                    }
                }
                Some(ErrorCode::UnknownLabel) => {
                    error!("Unknown label referenced: {}", error.message);
                }
                Some(ErrorCode::TypeMismatch) => {
                    error!("Type mismatch: {}", error.message);
                }
                _ => {
                    error!("Query error: {}", error);
                }
            }

            Err(error)
        }
    }
}

fn format_query_error(query: &str, error: &QueryError) -> String {
    let mut output = vec!["Query error:".to_string()];

    for (i, line) in query.lines().enumerate() {
        output.push(format!("  {:3} | {}", i + 1, line));

        if error.line == Some(i + 1) {
            if let Some(column) = error.column {
                let marker = format!("{}^", " ".repeat(8 + column - 1));
                output.push(marker);
            }
        }
    }

    output.push(format!("\nError: {}", error));
    output.join("\n")
}

import { GeodeError, SyntaxError, SemanticError } from '@geodedb/client';

interface QueryErrorDetails {
    code: string;
    message: string;
    query: string;
    position?: number;
    line?: number;
    column?: number;
}

class QueryError extends Error {
    constructor(public details: QueryErrorDetails) {
        super(details.message);
        this.name = 'QueryError';
    }

    toString(): string {
        const { code, message, line, column } = this.details;
        if (line && column) {
            return `[${code}] ${message} (line ${line}, column ${column})`;
        }
        return `[${code}] ${message}`;
    }
}

async function executeQuery(client: GeodeClient, query: string): Promise<void> {
    try {
        await client.exec(query);
    } catch (error) {
        if (error instanceof SyntaxError) {
            console.error(`Syntax error in query: ${error.message}`);
            console.error(`Query: ${query}`);
            if (error.position) {
                console.error(`Error at position: ${error.position}`);
            }
            throw new QueryError({
                code: error.code,
                message: error.message,
                query,
                position: error.position,
                line: error.line,
                column: error.column,
            });
        }

        if (error instanceof SemanticError) {
            console.error(`Semantic error: ${error.message}`);
            throw new QueryError({
                code: error.code,
                message: error.message,
                query,
            });
        }

        if (error instanceof GeodeError) {
            console.error(`Query error [${error.code}]: ${error.message}`);
            throw error;
        }

        throw error;
    }
}

function formatQueryError(query: string, error: QueryError): string {
    const lines = query.split('\n');
    const output: string[] = ['Query error:'];

    lines.forEach((line, index) => {
        const lineNum = index + 1;
        output.push(`  ${lineNum.toString().padStart(3)} | ${line}`);

        if (error.details.line === lineNum && error.details.column) {
            const marker = ' '.repeat(8 + error.details.column - 1) + '^';
            output.push(marker);
        }
    });

    output.push(`\nError: ${error.toString()}`);
    return output.join('\n');
}

const std = @import("std");
const geode = @import("geode_client");

pub const QueryError = struct {
    code: []const u8,
    message: []const u8,
    query: []const u8,
    position: ?usize,
    line: ?usize,
    column: ?usize,

    pub fn format(self: QueryError, writer: anytype) !void {
        if (self.line != null and self.column != null) {
            try writer.print("[{s}] {s} (line {d}, column {d})",
                .{ self.code, self.message, self.line.?, self.column.? });
        } else {
            try writer.print("[{s}] {s}", .{ self.code, self.message });
        }
    }
};

pub fn executeQuery(
    client: *geode.GeodeClient,
    query_id: i64,
    query: []const u8,
) !void {
    client.sendRunGql(query_id, query, null) catch |e| {
        std.debug.print("Failed to send query: {any}\n", .{e});
        return e;
    };

    const response = client.receiveMessage(30000) catch |e| {
        std.debug.print("Failed to receive response: {any}\n", .{e});
        return e;
    };
    defer client.allocator.free(response);

    // Parse response and check for errors
    const parsed = std.json.parseFromSlice(
        std.json.Value,
        client.allocator,
        response,
        .{},
    ) catch |e| {
        std.debug.print("Failed to parse response: {any}\n", .{e});
        return e;
    };
    defer parsed.deinit();

    if (parsed.value.object.get("error")) |error_value| {
        const error_obj = error_value.object;
        const code = error_obj.get("code").?.string;
        const message = error_obj.get("message").?.string;

        std.debug.print("Query error [{s}]: {s}\n", .{ code, message });
        std.debug.print("Query: {s}\n", .{query});

        return error.QueryError;
    }
}

pub fn formatQueryError(
    allocator: std.mem.Allocator,
    query: []const u8,
    err: QueryError,
) ![]const u8 {
    var output = std.ArrayList(u8).init(allocator);
    const writer = output.writer();

    try writer.writeAll("Query error:\n");

    var line_num: usize = 1;
    var line_start: usize = 0;

    for (query, 0..) |char, i| {
        if (char == '\n' or i == query.len - 1) {
            const line_end = if (char == '\n') i else i + 1;
            try writer.print("  {d:3} | {s}\n", .{ line_num, query[line_start..line_end] });

            if (err.line == line_num) {
                if (err.column) |col| {
                    try writer.writeByteNTimes(' ', 8 + col - 1);
                    try writer.writeAll("^\n");
                }
            }

            line_num += 1;
            line_start = i + 1;
        }
    }

    try writer.writeAll("\nError: ");
    try err.format(writer);
    try writer.writeAll("\n");

    return output.toOwnedSlice();
}