reinhardt-graphql 0.3.1

GraphQL API support for Reinhardt (facade crate)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

#![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
//!
//! # 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;