rullst_orm/

lib.rs

pub use sqlx;

/// Auto-Healing Database Migrations & SQL Interceptor (Milestone 21).
pub mod auto_healing;

#[cfg(not(any(
    feature = "strict-postgres",
    feature = "strict-mysql",
    feature = "strict-sqlite"
)))]
pub use sqlx::AnyPool as RullstPool;

#[cfg(not(any(
    feature = "strict-postgres",
    feature = "strict-mysql",
    feature = "strict-sqlite"
)))]
pub use sqlx::any::AnyPoolOptions as RullstPoolOptions;

#[cfg(feature = "strict-postgres")]
pub use sqlx::PgPool as RullstPool;

#[cfg(feature = "strict-postgres")]
pub use sqlx::postgres::PgPoolOptions as RullstPoolOptions;

#[cfg(all(feature = "strict-mysql", not(feature = "strict-postgres")))]
pub use sqlx::MySqlPool as RullstPool;

#[cfg(all(feature = "strict-mysql", not(feature = "strict-postgres")))]
pub use sqlx::mysql::MySqlPoolOptions as RullstPoolOptions;

#[cfg(all(
    feature = "strict-sqlite",
    not(feature = "strict-postgres"),
    not(feature = "strict-mysql")
))]
pub use sqlx::SqlitePool as RullstPool;

#[cfg(all(
    feature = "strict-sqlite",
    not(feature = "strict-postgres"),
    not(feature = "strict-mysql")
))]
pub use sqlx::sqlite::SqlitePoolOptions as RullstPoolOptions;

// Hide underlying libraries for macro usage while keeping the public API clean
#[doc(hidden)]
pub use async_stream as _async_stream;
#[doc(hidden)]
pub use futures as _futures;
#[doc(hidden)]
pub use serde as _serde;
#[doc(hidden)]
pub use serde_json as _serde_json;
#[doc(hidden)]
pub use sqlx as _sqlx;
#[doc(hidden)]
pub use tracing as _tracing;

#[cfg(feature = "pgvector")]
#[doc(hidden)]
pub use pgvector as _pgvector;

#[cfg(feature = "redis")]
#[doc(hidden)]
pub use redis as _redis;

pub mod admin;
pub mod audit;
pub mod collection;
pub mod database;
pub mod db;
mod enum_codecs;
pub mod error;
pub mod intent;
pub mod outbox;
pub mod policy;
pub mod polyglot;
pub mod pool;
pub mod post_commit;
pub mod privacy;
#[cfg(feature = "redis")]
#[doc(hidden)]
pub mod query_cache;
pub mod raw;
#[cfg(feature = "redis")]
pub mod redis_data;
pub mod replica;
pub mod repository;
pub mod resource;
pub mod schema;
pub mod schema_diff;
pub mod scout;
#[doc(hidden)]
pub mod telemetry;
pub mod tenant;
pub mod types;
pub mod value;

#[cfg(test)]
mod tests;

// Re-exports
pub use _sqlx::FromRow;
pub use admin::dashboard_html;
pub use async_trait::async_trait;
pub use collection::RullstCollection;
pub use database::RullstDatabase;
pub use error::RullstError as Error;
pub use intent::IntentAnalyzer;
pub use outbox::{ClaimedOutboxEvent, EnqueuedOutboxEvent, Outbox, OutboxMigration};
#[cfg(feature = "pgvector")]
pub use pgvector::Vector;
pub use policy::Policy;
pub use polyglot::{
    Backend, BackendCapabilities, Capability, CollectionName, DocumentEntry, DocumentId,
    DocumentInventory, DocumentPage, DocumentRecoveryBinding, DocumentRecoveryError,
    DocumentRecoveryKey, DocumentRecoveryPolicy, DocumentRecoveryReport, DocumentRepository,
    EncryptedDocumentSnapshot, MockDocumentStore, PolyglotError, export_document_snapshot,
    restore_document_snapshot,
};
#[cfg(feature = "qdrant")]
pub use polyglot::{
    QdrantConfig, QdrantStore, VectorCollectionName, VectorDimensions, VectorMatch, VectorPoint,
    VectorQueryLimit, VectorRepository,
};
#[doc(hidden)]
pub use pool::portable_subquery;
/// Whether generated builder filters cast `#[derive(Enum)]` values to their
/// named PostgreSQL type. Only the strict PostgreSQL runtime decodes native
/// enum columns; under SQLx `Any` such fields live in text columns.
#[doc(hidden)]
pub const __NATIVE_ENUM_FILTER_CASTS: bool = cfg!(feature = "strict-postgres");
pub use pool::{
    Orm, PaginationResult, RagContext, RullstModel, Seeder, is_lazy_loading_prevented,
    prevent_lazy_loading, replace_placeholders,
};
pub use post_commit::{ModelCommittedEvent, ModelOperation, after_commit};
pub use privacy::{ComplianceModel, PrivacyReport, SecretString};
#[cfg(feature = "redis")]
pub use redis_data::{
    RedisDataConfig, RedisDataKey, RedisDataStore, RedisField, RedisMember, RedisScanLimit,
    RedisStructure, RedisStructuresRepository, RedisValue, ScoredRedisMember,
};
pub use replica::ReplicaPool;
pub use repository::{GenericRepository, Repository};
pub use resource::{ApiResource, JsonResource, ResourceCollection};
pub use rullst_orm_macros::{Enum, Nexus, Orm, PersonalData, TursoModel, test};
pub use schema::{DatabaseEnum, JoinClause, SubqueryBuilder};
#[cfg(feature = "scout-http")]
pub use scout::{AlgoliaEngine, ElasticsearchEngine, MeilisearchEngine};
pub use scout::{MockSearchEngine, SearchEngine, get_search_engine, set_search_engine};
pub use tenant::{get_tenant_id, with_tenant};
pub use types::Json;
pub use value::RullstValue;

#[doc(hidden)]
#[path = "transaction_access.rs"]
pub mod __transaction_access;

#[doc(hidden)]
#[path = "eager_limit.rs"]
pub mod __eager_limit;

tokio::task_local! {
    pub static CURRENT_TX: std::sync::Arc<tokio::sync::Mutex<Option<crate::db::Transaction<'static>>>>;
}

/// Serializes SQLite tests generated by `#[rullst_orm::test]` within one test
/// process. SQLite schema changes can otherwise race with another sandbox
/// transaction and fail nondeterministically with `SQLITE_LOCKED`.
#[doc(hidden)]
pub static TEST_SANDBOX_LOCK: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());

#[macro_export]
macro_rules! execute_query {
    ($query:expr, $method:ident, $pool_fn:ident) => {{
        $crate::__transaction_access::ensure_allowed()?;
        if let Ok(tx_arc) = $crate::CURRENT_TX.try_with(|tx| tx.clone()) {
            let mut tx_guard = tx_arc.lock().await;
            if let Some(tx) = tx_guard.as_mut() {
                $query.$method(&mut **tx).await
            } else {
                let pool = $crate::Orm::$pool_fn()?;
                $query.$method(pool).await
            }
        } else {
            let pool = $crate::Orm::$pool_fn()?;
            $query.$method(pool).await
        }
    }};
}

#[macro_export]
macro_rules! dispatch_executor {
    ($pool_fn:ident, |$executor:ident| $e:expr) => {{
        $crate::__transaction_access::ensure_allowed()?;
        if let Ok(tx_arc) = $crate::CURRENT_TX.try_with(|tx| tx.clone()) {
            let mut tx_guard = tx_arc.lock().await;
            if let Some(tx) = tx_guard.as_mut() {
                let $executor = &mut **tx;
                $e
            } else {
                let $executor = $crate::Orm::$pool_fn()?;
                $e
            }
        } else {
            let $executor = $crate::Orm::$pool_fn()?;
            $e
        }
    }};
}