Skip to main content

Build robust Rust applications

A comprehensive utility library with support for WebAssembly, Protocol Buffers, gRPC, and Google AIP-compliant API requests

Get StartedAPI Reference

Quick start

Get up and running with Bomboni in minutes

1

Add Bomboni to your project

Add the crate to your Cargo.toml with the features you need:
Cargo.toml
[dependencies]
bomboni = { version = "0.2.1", features = ["request", "proto", "wasm"] }
  • derive - Enable derive macros for request parsing and WASM bindings
  • prost - Protocol Buffers utilities with prost
  • proto - Google well-known protobuf types
  • request - API request parsing, filtering, and validation
  • template - Handlebars template utilities
  • wasm - WebAssembly support with TypeScript bindings
  • fs - File system utilities
  • postgres - PostgreSQL type conversions
  • mysql - MySQL type conversions
2

Generate unique identifiers

Use ULID-based IDs for sortable, unique identifiers:
use bomboni::common::id::Id;

// Generate a random sortable ID
let id = Id::generate();
println!("ID: {}", id);

// Parse from string
let id: Id = "01ARZ3NDEKTSV4RRFFQ69G5FAV".parse().unwrap();
3

Filter and query your data

Build Google AIP-compliant filters and queries:
use bomboni::request::filter::Filter;

// Parse complex filter expressions
let filter = Filter::parse(r#"
    age >= 18 AND status = "active"
"#).unwrap();

// Evaluate against your data
let result = filter.evaluate(&my_item).unwrap();
Bomboni supports Google AIP-160 compliant filtering with logical operators (AND, OR, NOT) and comparison operators.
4

Generate SQL from filters

Convert filters to SQL for PostgreSQL or MySQL:
use bomboni::request::sql::{SqlFilterBuilder, SqlDialect};

let (sql, args) = SqlFilterBuilder::new(SqlDialect::Postgres, &schema)
    .build(&filter)
    .unwrap();

// Use with your database query
println!("WHERE {}", sql);

Explore by topic

Deep dive into each module of Bomboni

Core modules

Unique IDs, UTC datetime, and common utilities

API requests

Filtering, ordering, pagination, and validation

Protocol Buffers

Prost utilities and enhanced Google types

WebAssembly

TypeScript bindings and JavaScript interop

Templates

Handlebars with custom helpers

Database integration

PostgreSQL and MySQL support

Key features

Everything you need to build production-ready applications

ULID-based identifiers

Generate sortable, unique IDs with support for both random and worker-based generation for distributed systems

Google AIP compliance

Filter parsing, list queries, search queries, and pagination following Google API Improvement Proposals

SQL generation

Convert filters and ordering to SQL queries for PostgreSQL and MySQL with type-safe parameters

Parse derive macros

Automatic conversion between protobuf messages and Rust types with powerful field mapping options

WebAssembly ready

Full WASM support with TypeScript declaration generation for seamless browser integration

Enhanced protobuf types

Google well-known types with additional functionality, serde support, and ergonomic conversions

Ready to get started?

Follow our quickstart guide to integrate Bomboni into your Rust application in minutes

Get Started