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

use std::{fmt::Debug, sync::Arc};

use futures::channel::mpsc::UnboundedSender;
use jsonrpc_core::{MetaIoHandler, Metadata, RpcMethodSimple};
use jsonrpc_pubsub::{PubSubHandler, PubSubMetadata, SubscribeRpcMethod, UnsubscribeRpcMethod};

#[derive(Clone, Debug, Default)]
pub struct Session {
    inner: Option<Arc<jsonrpc_pubsub::Session>>,
}

impl From<Arc<jsonrpc_pubsub::Session>> for Session {
    fn from(value: Arc<jsonrpc_pubsub::Session>) -> Self {
        Session { inner: Some(value) }
    }
}

impl Metadata for Session {}

impl PubSubMetadata for Session {
    fn session(&self) -> Option<Arc<jsonrpc_pubsub::Session>> {
        self.inner.clone()
    }
}

pub trait Handler {
    type Metadata: PubSubMetadata + Unpin + Debug;

    fn add_method<F>(&mut self, name: &str, method: F)
    where
        F: RpcMethodSimple;

    fn add_subscription<F, G>(
        &mut self,
        notification: &str,
        subscribe: (&str, F),
        unsubscribe: (&str, G),
    ) where
        F: SubscribeRpcMethod<Self::Metadata>,
        G: UnsubscribeRpcMethod<Self::Metadata>;

    fn as_meta_io_handler(&self) -> MetaIoHandler<Self::Metadata>;

    fn describe_api(&self) -> Vec<String>;

    // TODO: support async
    fn handle_request_sync(&self, request: &str, meta: Self::Metadata) -> Option<String>;

    fn metadata_from_sender(sender: UnboundedSender<String>) -> Self::Metadata;

    fn new() -> Self;
}

impl<M> Handler for PubSubHandler<M>
where
    M: PubSubMetadata + Unpin + Debug + From<Arc<jsonrpc_pubsub::Session>>,
{
    type Metadata = M;

    fn add_method<F>(&mut self, name: &str, method: F)
    where
        F: RpcMethodSimple,
    {
        MetaIoHandler::add_method(self, name, method)
    }

    fn add_subscription<F, G>(
        &mut self,
        notification: &str,
        subscribe: (&str, F),
        unsubscribe: (&str, G),
    ) where
        F: SubscribeRpcMethod<M>,
        G: UnsubscribeRpcMethod<M>,
    {
        PubSubHandler::add_subscription(self, notification, subscribe, unsubscribe)
    }

    fn as_meta_io_handler(&self) -> MetaIoHandler<Self::Metadata> {
        (*self).clone()
    }

    fn describe_api(&self) -> Vec<String> {
        self.iter().map(|(name, _)| name.clone()).collect()
    }

    fn handle_request_sync(&self, request: &str, meta: Self::Metadata) -> Option<String> {
        MetaIoHandler::handle_request_sync(self, request, meta)
    }

    fn metadata_from_sender(sender: UnboundedSender<String>) -> Self::Metadata {
        Self::Metadata::from(Arc::new(jsonrpc_pubsub::Session::new(sender)))
    }

    fn new() -> Self {
        PubSubHandler::new(jsonrpc_core::MetaIoHandler::default())
    }
}