grpc_graphql_gateway 1.2.4

//! # grpc-graphql-gateway-rs
//!
//! A high-performance Rust gateway that bridges gRPC services to GraphQL with full Apollo Federation v2 support.
#![allow(clippy::result_large_err)]
//!
//! ## Features
//!
//! - **Dynamic Schema Generation**: Automatic GraphQL schema from protobuf descriptors
//! - **Federation v2**: Complete Apollo Federation support with entity resolution and `@shareable`
//! - **Batching**: Built-in [`EntityDataLoader`] for efficient N+1 query prevention
//! - **Subscriptions**: Real-time data via GraphQL subscriptions (WebSocket)
//! - **Multiplex Subscriptions**: Support for multiple concurrent subscriptions per WebSocket connection
//! - **Middleware**: Extensible middleware system for auth and logging
//! - **Response Caching**: In-memory LRU cache with TTL and mutation-triggered invalidation
//! - **@defer Support**: Incremental delivery of query results via multipart/mixed responses
//!
//! ## Main Components
//!
//! - [`Gateway`]: The main entry point for creating and running the gateway.
//! - [`GatewayBuilder`]: Configuration builder for the gateway.
//! - [`SchemaBuilder`]: Low-level builder for the dynamic GraphQL schema.
//! - [`GrpcClient`]: Manages connections to gRPC services.
//! - [`GrpcEntityResolver`]: Handles federation entity resolution.
//!
//! ## Federation
//!
//! To enable federation, use the [`GatewayBuilder::enable_federation`] method and configure
//! an entity resolver. See [`GrpcEntityResolver`] and [`EntityDataLoader`] for details.
//!
//! ## Example
//!
//! ```rust,no_run
//! use grpc_graphql_gateway::{Gateway, GrpcClient};
//!
//! #[tokio::main]
//! async fn main() -> Result<(), Box<dyn std::error::Error>> {
//!     let grpc_client = GrpcClient::new("http://localhost:50051").await?;
//!     
//!     let gateway = Gateway::builder()
//!         .add_grpc_client("greeter", grpc_client)
//!         .build()?;
//!     
//!     let app = gateway.into_router();
//!     
//!     let listener = tokio::net::TcpListener::bind("0.0.0.0:8888").await?;
//!     axum::serve(listener, app).await?;
//!     
//!     Ok(())
//! }
//! ```

/// Generated types for graphql.proto options.
#[allow(clippy::all)]
pub mod graphql {
    include!("generated/graphql.rs");
}

pub mod analytics;
pub mod cache;
pub mod circuit_breaker;
pub mod compression;
pub mod dataloader;
pub mod defer;
pub mod error;
pub mod federation;
pub mod gateway;
pub mod gbp;
pub mod grpc_client;
pub mod headers;
pub mod health;
pub mod high_performance;
pub mod live_query;
pub mod lz4_compression;
pub mod metrics;
pub mod middleware;
pub mod mtls;
pub mod openapi;
pub mod persisted_queries;
pub mod plugin;
pub mod query_cost_analyzer;
pub mod query_whitelist;
pub mod quic;
pub mod request_collapsing;
pub mod rest_connector;
pub mod router;
pub mod runtime;
pub mod schema;
pub mod shutdown;
pub mod smart_ttl;
pub mod subscription;
pub mod subscription_federation;
pub mod tracing_otel;
pub mod types;
pub mod waf;
#[cfg(feature = "wasm")]
pub mod wasm_plugin;

pub use analytics::{
    create_analytics, AnalyticsConfig, AnalyticsGuard, AnalyticsSnapshot, ErrorStats, FieldStats,
    QueryAnalytics, QueryStats, SharedQueryAnalytics,
};
pub use cache::{
    create_response_cache, is_mutation, CacheConfig, CacheLookupResult, CacheStats, CachedResponse,
    ResponseCache, SharedResponseCache,
};
pub use circuit_breaker::{
    create_circuit_breaker_registry, CircuitBreaker, CircuitBreakerConfig, CircuitBreakerError,
    CircuitBreakerRegistry, CircuitState, SharedCircuitBreakerRegistry,
};
pub use compression::{
    create_compression_layer, CompressionConfig, CompressionLevel, CompressionStats,
};
pub use dataloader::EntityDataLoader;
pub use defer::{
    extract_deferred_fragments, format_initial_part, format_subsequent_part, has_defer_directive,
    strip_defer_directives, DeferConfig, DeferError, DeferStats, DeferredExecution,
    DeferredFragment, DeferredPart, IncrementalPatch, InitialPayload, SubsequentPayload,
    MULTIPART_CONTENT_TYPE,
};
pub use error::{Error, Result};
pub use federation::{
    EntityConfig, EntityResolver, EntityResolverMapping, FederationConfig, GrpcEntityResolver,
    GrpcEntityResolverBuilder,
};
pub use gateway::{Gateway, GatewayBuilder};
pub use gbp::GbpEncoder;
pub use grpc_client::GrpcClient;
pub use headers::{apply_metadata_to_request, HeaderPropagationConfig};
pub use health::{ComponentHealth, HealthResponse, HealthState, HealthStatus};
pub use high_performance::{
    pin_to_core, recommended_workers, BatchConfig, BatchProcessor, CacheStats as ShardedCacheStats,
    FastJsonError, FastJsonParser, HighPerfConfig, ObjectPool, OptimizedConnectionConfig,
    PerfMetrics, ResponseTemplates, ShardedCache,
};
pub use live_query::{
    create_live_query_store,
    create_live_query_store_with_config,
    detect_field_changes,
    generate_cache_control,
    generate_subscription_id,
    global_live_query_store,
    has_live_directive,
    matches_filter,
    parse_query_arguments,
    strip_live_directive,
    ActiveLiveQuery,
    // Advanced features
    BatchInvalidationConfig,
    CacheControl,
    DataVolatility,
    FieldChange,
    InvalidationEvent,
    LiveQueryConfig,
    LiveQueryConfigInfo,
    LiveQueryError,
    LiveQueryStats,
    LiveQueryStore,
    LiveQueryStrategy,
    LiveQueryUpdate,
    SharedLiveQueryStore,
};
pub use lz4_compression::{
    compress_lz4, decompress_lz4, lz4_compression_middleware, Lz4CacheCompressor,
};
pub use metrics::{GatewayMetrics, GrpcTimer, RequestTimer};
pub use middleware::{
    AuthClaims, AuthConfig, AuthMiddleware, AuthScheme, Context, CorsMiddleware,
    EnhancedAuthMiddleware, EnhancedLoggingMiddleware, LogLevel, LoggingConfig, LoggingMiddleware,
    Middleware, MiddlewareChain, RateLimitMiddleware, TokenValidator,
};
pub use mtls::{
    export_svid, issue_subgraph_svid, CertificateAuthority, MtlsConfig, MtlsError, MtlsProvider,
    MtlsStatus, Svid,
};
pub use openapi::{
    Components, MediaType, OpenApiInfo, OpenApiParser, OpenApiServer, OpenApiSpec, Operation,
    OperationInfo, Parameter, PathItem, RequestBody, Response, SchemaObject,
};
pub use persisted_queries::{
    create_apq_store, process_apq_request, PersistedQueryConfig, PersistedQueryError,
    PersistedQueryExtension, PersistedQueryStore, SharedPersistedQueryStore,
};
pub use plugin::{Plugin, PluginRegistry};
pub use query_cost_analyzer::{
    QueryCostAnalytics, QueryCostAnalyzer, QueryCostConfig, QueryCostResult,
};
pub use query_whitelist::{
    QueryWhitelist, QueryWhitelistConfig, QueryWhitelistError, SharedQueryWhitelist, WhitelistMode,
    WhitelistStats,
};
pub use quic::{alt_svc_header_value, QuicConfig, QuicStatus};
pub use request_collapsing::{
    create_collapsing_metrics, create_request_collapsing_registry, CollapseResult,
    CollapsingMetrics, CollapsingMetricsSnapshot, CollapsingStats, RequestBroadcaster,
    RequestCollapsingConfig, RequestCollapsingRegistry, RequestKey, RequestReceiver,
    SharedCollapsingMetrics, SharedRequestCollapsingRegistry,
};
pub use rest_connector::{
    ApiKeyInterceptor, BearerAuthInterceptor, DefaultTransformer, HttpMethod, RequestInterceptor,
    ResponseTransformer, RestConnector, RestConnectorBuilder, RestConnectorConfig,
    RestConnectorRegistry, RestEndpoint, RestFieldType, RestGraphQLField, RestRequest,
    RestResponse, RestResponseField, RestResponseSchema, RetryConfig,
};
pub use runtime::{build_tcp_listener_tuned, serve_reuseport, ServeMux};
pub use schema::SchemaBuilder;
pub use shutdown::{
    os_signal_shutdown, run_with_graceful_shutdown, RequestGuard, ShutdownConfig,
    ShutdownCoordinator, ShutdownState,
};
pub use smart_ttl::{
    parse_cache_hint, SmartTtlAnalytics, SmartTtlConfig, SmartTtlManager, TtlResult, TtlStrategy,
};
pub use subscription::{
    GrpcSubscriptionMapping, GrpcSubscriptionResolver, MultiplexSubscription,
    MultiplexSubscriptionBuilder, ProtocolMessage, SubscriptionConfig, SubscriptionInfo,
    SubscriptionPayload, SubscriptionRegistry, SubscriptionResolver, SubscriptionState,
};
pub use subscription_federation::{
    parse_subscription_fields, SubgraphEndpoint, SubscriptionFederationConfig,
    SubscriptionFederationEngine, SubscriptionFederationMetrics,
};
pub use tracing_otel::{init_tracer, shutdown_tracer, GraphQLSpan, GrpcSpan, TracingConfig};
pub use waf::{validate_request, WafMiddleware};
#[cfg(feature = "wasm")]
pub use wasm_plugin::{
    WasmPlugin, WasmPluginConfig, WasmPluginEngine, WasmPluginManager, WasmResourceLimits,
};