reinhardt-graphql 0.3.19

#![warn(missing_docs)]
//! GraphQL support for Reinhardt framework
//!
//! This crate provides GraphQL API support for the Reinhardt framework.
//!
//! # Features
//!
//! - **graphql-grpc**: GraphQL facade over gRPC for Query/Mutation
//! - **subscription**: gRPC-based Subscriptions (Rust 2024 compatible)
//! - **di**: Dependency injection support for GraphQL resolvers
//! - **full**: All features enabled
//!
//! # GraphQL over gRPC
//!
//! Each RPC accepts only its advertised query, mutation, or subscription operation.
//! The adapter returns gRPC `INVALID_ARGUMENT` for malformed documents, invalid or
//! ambiguous operation selections, and operation-class mismatches before execution.
//! Documents with multiple operations require an exact operation name. A single
//! operation may omit the name or pass an empty name. Schema validation and resolver
//! authorization still apply after this transport-level check. Subscription errors
//! are delivered through the response stream.
//!
//! Build custom gRPC schemas with `GraphQLGrpcService::schema_builder` instead of
//! `Schema::build` / `Schema::new`. This installs the operation guard before user
//! extensions, so preparation limits and document rewrites run in their normal
//! order. `GraphQLGrpcService::new` panics for unguarded schemas. The built-in
//! `create_schema` helpers install the guard when `graphql-grpc` is enabled.
//!
//! # Dependency Injection
//!
//! Enable the `di` feature to use dependency injection in GraphQL resolvers:
//!
//! ```toml
//! [dependencies]
//! reinhardt-graphql = { version = "0.1", features = ["di"] }
//! ```
//!
//! Then use the `#[graphql_handler]` macro:
//!
//! ```rust,no_run
//! # use async_graphql::{Context, Object, Result, ID, SimpleObject};
//! # use reinhardt_graphql::{graphql_handler, GraphQLContextExt};
//! # use reinhardt_di::{InjectionContext, Injectable, DiResult};
//! # use async_trait::async_trait;
//! #
//! # #[derive(Clone, SimpleObject)]
//! # struct User {
//! #     id: ID,
//! #     name: String,
//! # }
//! #
//! # #[derive(Clone)]
//! # struct DatabaseConnection;
//! #
//! # #[async_trait]
//! # impl Injectable for DatabaseConnection {
//! #     async fn inject(_ctx: &InjectionContext) -> DiResult<Self> {
//! #         Ok(DatabaseConnection)
//! #     }
//! # }
//! #
//! # impl DatabaseConnection {
//! #     async fn fetch_user(&self, id: &ID) -> Result<User> {
//! #         Ok(User { id: id.clone(), name: "Test User".to_string() })
//! #     }
//! # }
//! #
//! # struct Query;
//! #
//! #[Object]
//! impl Query {
//!     async fn user(&self, ctx: &Context<'_>, id: ID) -> Result<User> {
//!         user_impl(ctx, id).await
//!     }
//! }
//!
//! #[graphql_handler]
//! async fn user_impl(
//!     ctx: &Context<'_>,
//!     id: ID,
//!     #[inject] db: DatabaseConnection,
//! ) -> Result<User> {
//!     // db is automatically resolved
//!     db.fetch_user(&id).await
//! }
//! ```

/// GraphQL execution context and data loaders.
pub mod context;
/// Resolver implementations for queries and mutations.
pub mod resolvers;
/// Schema definition, query limits, and built-in types.
pub mod schema;
/// Real-time GraphQL subscriptions with event broadcasting.
pub mod subscription;
/// GraphQL scalar and input type definitions.
pub mod types;

/// Dependency injection integration for GraphQL handlers.
#[cfg(feature = "di")]
pub mod di;

/// GraphQL-over-gRPC service adapter.
#[cfg(feature = "graphql-grpc")]
pub mod grpc_service;

pub use context::{ContextError, DataLoader, GraphQLContext, LoaderError};
pub use schema::{
	AppSchema, CreateUserInput, Mutation, Query, QueryLimits, User, UserStorage, create_schema,
	create_schema_with_limits, validate_query,
};
pub use subscription::{DEFAULT_CHANNEL_CAPACITY, EventBroadcaster, SubscriptionRoot, UserEvent};

#[cfg(feature = "graphql-grpc")]
pub use grpc_service::GraphQLGrpcService;

// gRPC integration: re-export of adapter traits and derive macros
#[cfg(any(feature = "graphql-grpc", feature = "subscription"))]
pub use reinhardt_grpc::{GrpcServiceAdapter, GrpcSubscriptionAdapter};

#[cfg(any(feature = "graphql-grpc", feature = "subscription"))]
pub use reinhardt_graphql_macros::{GrpcGraphQLConvert, GrpcSubscription};

// DI support: re-export extension traits and macro
#[cfg(feature = "di")]
pub use di::{GraphQLContextExt, SchemaBuilderExt};

#[cfg(feature = "di")]
pub use reinhardt_graphql_macros::graphql_handler;

// Re-export async_graphql base types for facade pattern.
// These types are commonly needed by user code to define GraphQL schemas,
// resolvers, and error handling without depending on async_graphql directly.
pub use async_graphql::{
	Context, Enum, Error, ErrorExtensions, FieldError, ID, InputObject, MergedObject,
	MergedSubscription, Object, Request, Result as GqlResult, Schema, SimpleObject, Subscription,
};

/// Re-export of `async_graphql::http` module for HTTP integration utilities
/// such as `playground_source` and `GraphQLPlaygroundConfig`.
pub use async_graphql::http;