prax-query

Type-safe query builder for the Prax ORM.

This crate provides the core query building functionality, including:

• Fluent API for building queries (find_many, find_unique, create, update, delete)
• Type-safe filtering with where clauses
• Sorting and pagination
• Relation loading (include, select)
• Transaction support
• Raw SQL escape hatch
• Middleware system
• Multi-tenant support

Filters

Build type-safe filters for queries:

use prax_query::{Filter, FilterValue};

// Equality filter
let filter = Filter::Equals("email".into(), FilterValue::String("test@example.com".into()));

// Greater than filter
let filter = Filter::Gt("age".into(), FilterValue::Int(18));

// Contains filter (for strings)
let filter = Filter::Contains("name".into(), FilterValue::String("john".into()));

// Combine filters with AND/OR
let combined = Filter::and([
    Filter::Equals("active".into(), FilterValue::Bool(true)),
    Filter::Gt("age".into(), FilterValue::Int(18)),
]);

let either = Filter::or([
    Filter::Equals("role".into(), FilterValue::String("admin".into())),
    Filter::Equals("role".into(), FilterValue::String("moderator".into())),
]);

Filter Values

Convert Rust types to filter values:

use prax_query::FilterValue;

// Integer values
let val: FilterValue = 42.into();
assert!(matches!(val, FilterValue::Int(42)));

// String values
let val: FilterValue = "hello".into();
assert!(matches!(val, FilterValue::String(_)));

// Boolean values
let val: FilterValue = true.into();
assert!(matches!(val, FilterValue::Bool(true)));

// Float values
let val: FilterValue = 3.14f64.into();
assert!(matches!(val, FilterValue::Float(_)));

// Null values
let val = FilterValue::Null;

Sorting

Build sort specifications:

use prax_query::{OrderBy, OrderByField, NullsOrder};

// Ascending order
let order = OrderByField::asc("created_at");

// Descending order
let order = OrderByField::desc("updated_at");

// With NULLS FIRST/LAST
let order = OrderByField::asc("name").nulls(NullsOrder::First);
let order = OrderByField::desc("score").nulls(NullsOrder::Last);

// Combine multiple orderings
let orders = OrderBy::Field(OrderByField::asc("name"))
    .then(OrderByField::desc("created_at"));

Raw SQL

Build raw SQL queries with parameter binding:

use prax_query::Sql;

// Simple query
let sql = Sql::new("SELECT * FROM users");
assert_eq!(sql.sql(), "SELECT * FROM users");

// Query with parameter - bind appends placeholder
let sql = Sql::new("SELECT * FROM users WHERE id = ")
    .bind(42);
assert_eq!(sql.params().len(), 1);

Connection Strings

Parse database connection strings:

use prax_query::ConnectionString;

// PostgreSQL
let conn = ConnectionString::parse("postgres://user:pass@localhost:5432/mydb").unwrap();
assert_eq!(conn.host(), Some("localhost"));
assert_eq!(conn.port(), Some(5432));
assert_eq!(conn.database(), Some("mydb"));

// MySQL
let conn = ConnectionString::parse("mysql://user:pass@localhost:3306/mydb").unwrap();

Transaction Config

Configure transaction behavior:

use prax_query::IsolationLevel;

let level = IsolationLevel::Serializable;
assert_eq!(level.as_sql(), "SERIALIZABLE");

Error Handling

Work with query errors:

use prax_query::{QueryError, ErrorCode};

// Create errors
let err = QueryError::not_found("User");
assert_eq!(err.code, ErrorCode::RecordNotFound);