pgrsql 0.1.0

A beautiful TUI SQL editor for PostgreSQL
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

# pgrsql - Project Guidance

## Overview

pgrsql is a TUI (Terminal User Interface) SQL editor for PostgreSQL written in Rust. It provides a visual, keyboard-driven interface for connecting to PostgreSQL databases, browsing schemas, writing queries, and viewing results.

## Project Structure

```
pgrsql/
├── Cargo.toml          # Dependencies and project metadata
├── src/
│   ├── main.rs         # Entry point, terminal setup, main loop
│   ├── db/             # Database layer
│   │   ├── mod.rs
│   │   ├── connection.rs   # Connection management
│   │   ├── query.rs        # Query execution and result parsing
│   │   └── schema.rs       # Schema introspection
│   ├── editor/         # Text editor
│   │   ├── mod.rs
│   │   ├── buffer.rs       # Text buffer with cursor/selection
│   │   └── history.rs      # Query history
│   └── ui/             # User interface
│       ├── mod.rs
│       ├── app.rs          # Application state and input handling
│       ├── components.rs   # UI rendering
│       └── theme.rs        # Colors and syntax highlighting
├── README.md           # User documentation
└── LICENSE             # MIT license
```

## Development

### Building

```bash
cargo build          # Debug build
cargo build --release  # Release build
```

### Running

```bash
cargo run
```

### Key Dependencies

- **ratatui**: TUI framework (fork of tui-rs)
- **crossterm**: Terminal manipulation
- **tokio-postgres**: Async PostgreSQL driver
- **tokio**: Async runtime

## Coding Standards

- Use `rustfmt` for formatting
- Follow Rust naming conventions (snake_case for functions/variables, PascalCase for types)
- Keep modules focused and single-purpose
- Prefer returning `Result` over panicking
- Use `anyhow` for error handling in application code
- Use `thiserror` for library error types

## Architecture

### State Management

The `App` struct in `src/ui/app.rs` holds all application state:
- Connection state
- Editor buffer
- Query results
- UI focus and selections

### Event Loop

1. Terminal events are polled in `main.rs`
2. Key events are dispatched to `App::handle_input()`
3. Input handlers update state and may trigger async operations
4. The UI is redrawn with `ui::draw()`

### Database Operations

All database operations are async and use `tokio-postgres`. The `ConnectionManager` handles connection lifecycle and schema switching.

## Testing

Run tests with:
```bash
cargo test
```

Integration tests require a running PostgreSQL instance. Set `DATABASE_URL` environment variable or use the default local connection.