GraphQL and WebSocket APIs with nestrs

[dependencies]
nestrs = { version = "1.5.0", features = ["graphql"] }
async-graphql = "7"

use nestrs::prelude::*;
use async_graphql::{Object, Schema, EmptyMutation, EmptySubscription};

pub struct QueryRoot;

#[Object]
impl QueryRoot {
    async fn hello(&self) -> &str {
        "Hello from nestrs GraphQL"
    }

    async fn add(&self, a: i32, b: i32) -> i32 {
        a + b
    }
}

#[module]
struct AppModule;

#[tokio::main]
async fn main() {
    let schema = Schema::build(QueryRoot, EmptyMutation, EmptySubscription)
        .finish();

    NestFactory::create::<AppModule>()
        .enable_graphql(schema)
        .listen(3000)
        .await;
}

.enable_graphql_with_path(schema, "/api/graphql")

use nestrs::graphql::GraphQlHttpOptions;

.enable_graphql_with_options(
    schema,
    "/graphql",
    GraphQlHttpOptions::default().disable_playground(),
)

use async_graphql::{Object, InputObject, Schema, SimpleObject};

#[derive(InputObject)]
pub struct CreateUserInput {
    pub email: String,
    pub name: String,
}

#[derive(SimpleObject)]
pub struct User {
    pub id: i64,
    pub email: String,
    pub name: String,
}

pub struct MutationRoot;

#[Object]
impl MutationRoot {
    async fn create_user(&self, input: CreateUserInput) -> User {
        User {
            id: 1,
            email: input.email,
            name: input.name,
        }
    }
}

let schema = Schema::build(QueryRoot, MutationRoot, EmptySubscription)
    .finish();

[dependencies]
nestrs = { version = "1.5.0", features = ["graphql-federation-gateway"] }

nestrs-cli graphql sdl --url http://127.0.0.1:3000/graphql --out subgraph.graphql
nestrs-cli graphql federation export --url http://127.0.0.1:3000/graphql --out subgraph.graphql

use nestrs::graphql::{export_schema_sdl_with_options, SDLExportOptions};

let sdl = export_schema_sdl_with_options(
    &schema,
    SDLExportOptions::default().federation(),
);

use std::sync::Arc;
use nestrs::graphql::federation::{
    federation_router, EntityResolver, FederationConfig, SubgraphSpec,
};

fn user_resolver() -> Arc<dyn EntityResolver> {
    Arc::new(
        |_ctx: &async_graphql::Context<'_>,
         reps: &[&serde_json::Value]|
         -> async_graphql::Result<Vec<Option<serde_json::Value>>> {
            // one DB round-trip for the whole batch — see below
            Ok(reps
                .iter()
                .map(|rep| {
                    let id = rep.get("id")?.as_str()?;
                    Some(serde_json::json!({ "id": id, "name": "Ada" }))
                })
                .collect())
        },
    )
}

let config = FederationConfig {
    subgraphs: vec![
        SubgraphSpec {
            name: "User".to_string(),
            sdl: users_sdl,
            entity_resolver: user_resolver(),
        },
        SubgraphSpec {
            name: "Product".to_string(),
            sdl: products_sdl,
            entity_resolver: product_resolver(),
        },
    ],
    ..Default::default()
};

let gateway = federation_router(config, "/graphql")
    .expect("subgraph SDLs parse");

NestFactory::create::<AppModule>()
    .use_global_layer(|router| router.merge(gateway))
    .listen(3000)
    .await;

pub trait EntityResolver: Send + Sync + 'static {
    fn resolve(
        &self,
        ctx: &async_graphql::Context<'_>,
        representations: &[&serde_json::Value],
    ) -> async_graphql::Result<Vec<Option<serde_json::Value>>>;
}

[dependencies]
nestrs = { version = "1.5.0", features = ["ws"] }

use nestrs::prelude::*;
use nestrs::ws::{WsClient, WsHandshake};

#[ws_gateway(path = "/ws")]
pub struct ChatGateway;

#[ws_routes]
impl ChatGateway {
    #[subscribe_message("message")]
    pub async fn on_message(
        &self,
        client: WsClient,
        data: serde_json::Value,
    ) {
        let text = data["text"].as_str().unwrap_or("");
        let _ = client.emit("message", serde_json::json!({ "text": text }));
    }

    #[subscribe_message("ping")]
    pub async fn on_ping(&self, client: WsClient, _data: serde_json::Value) {
        let _ = client.emit("pong", serde_json::json!({}));
    }
}

client.emit("notification", serde_json::json!({
    "type": "order_ready",
    "order_id": 42,
}))?;

use nestrs::ws::{WsCanActivate, WsHandshake, WsGuardError};

pub struct WsAuthGuard;

impl Default for WsAuthGuard { fn default() -> Self { Self } }

#[async_trait::async_trait]
impl WsCanActivate for WsAuthGuard {
    async fn can_activate_ws(
        &self,
        handshake: &WsHandshake,
        _event: &str,
        _payload: &serde_json::Value,
    ) -> Result<(), WsGuardError> {
        let token = handshake
            .headers()
            .get("authorization")
            .and_then(|v| v.to_str().ok());

        match token {
            Some(t) if t.starts_with("Bearer ") => Ok(()),
            _ => Err(WsGuardError::unauthorized("missing or invalid token")),
        }
    }
}

#[ws_gateway(path = "/ws")]
#[use_ws_guards(WsAuthGuard)]
pub struct ProtectedGateway;

#[module(controllers = [ChatGateway], providers = [ChatGateway])]
struct AppModule;

#[nestrs::async_trait]
impl WsCanActivate for WsAuthGuard {
    fn resolve(registry: &nestrs::core::ProviderRegistry) -> Self {
        let users: Arc<UserService> = registry.get(); // DI-backed guard
        Self { users }
    }
    // ...
}

use axum::Router;
use nestrs::ws::{ws_route_with_security, WsSecurityConfig};

let app = Router::new().route(
    "/ws",
    ws_route_with_security(
        gateway,
        WsSecurityConfig::allow_origins(["https://app.example.com"]),
    ),
);

let security = WsSecurityConfig::allow_origins(["https://app.example.com"])
    .require_origin(true);