a3s-boot 0.1.3

Adapter-first modular Rust web framework for A3S inspired by Nest.js
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

use super::gateway::WebSocketGatewayDefinition;
use super::server::WebSocketGatewayServer;
use crate::{BootRequest, ExecutionContext};
use std::ops::Deref;

/// Context available to WebSocket guards and interceptors.
#[derive(Debug, Clone)]
pub struct WebSocketContext {
    pub request: BootRequest,
    pub gateway_path: String,
    pub event: String,
    pub namespace: Option<String>,
    pub module_name: Option<String>,
    server: WebSocketGatewayServer,
    execution_context: ExecutionContext,
}

impl WebSocketContext {
    pub(crate) fn new(
        gateway: &WebSocketGatewayDefinition,
        request: BootRequest,
        event: &str,
    ) -> Self {
        let gateway_path = gateway.path().to_string();
        let event = event.to_string();
        let namespace = gateway.namespace().map(str::to_string);
        let module_name = gateway.module_name().map(str::to_string);
        let metadata = gateway
            .event_metadata(&event)
            .cloned()
            .unwrap_or_else(|| gateway.metadata().clone());
        let execution_context = ExecutionContext::websocket(
            request.clone(),
            gateway_path.clone(),
            event.clone(),
            namespace.clone(),
            module_name.clone(),
            metadata,
        );
        Self {
            request,
            gateway_path,
            event,
            namespace,
            module_name,
            server: gateway.server(),
            execution_context,
        }
    }

    pub fn server(&self) -> WebSocketGatewayServer {
        self.server.clone()
    }

    pub fn execution_context(&self) -> &ExecutionContext {
        &self.execution_context
    }

    pub fn into_execution_context(self) -> ExecutionContext {
        self.execution_context
    }
}

impl Deref for WebSocketContext {
    type Target = ExecutionContext;

    fn deref(&self) -> &Self::Target {
        self.execution_context()
    }
}

/// Context passed to WebSocket gateway initialization hooks.
#[derive(Debug, Clone)]
pub struct WebSocketGatewayInitContext {
    pub gateway_path: String,
    pub namespace: Option<String>,
    pub module_name: Option<String>,
    pub events: Vec<String>,
    server: WebSocketGatewayServer,
}

impl WebSocketGatewayInitContext {
    pub(crate) fn new(gateway: &WebSocketGatewayDefinition) -> Self {
        Self {
            gateway_path: gateway.path().to_string(),
            namespace: gateway.namespace().map(str::to_string),
            module_name: gateway.module_name().map(str::to_string),
            events: gateway.events().into_iter().map(str::to_string).collect(),
            server: gateway.server(),
        }
    }

    pub fn server(&self) -> WebSocketGatewayServer {
        self.server.clone()
    }
}