rspc 0.4.1

A blazing fast and easy to use TRPC server for Rust.
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
126
127
128
129
130

use std::{fmt, future::Future, marker::PhantomData, sync::Arc};

use crate::{
    middleware::{IntoMiddleware, MiddlewareHandler},
    Error, Procedure,
};

use super::{ErasedProcedure, ProcedureKind, ProcedureMeta};

use futures_util::{FutureExt, Stream};
use rspc_procedure::State;

// TODO: Document the generics like `Middleware`. What order should they be in?
pub struct ProcedureBuilder<TError, TBaseCtx, TCtx, TBaseInput, TInput, TBaseResult, TResult> {
    pub(crate) build: Box<
        dyn FnOnce(
            ProcedureKind,
            Vec<Box<dyn FnOnce(&mut State, ProcedureMeta) + 'static>>,
            MiddlewareHandler<TError, TCtx, TInput, TResult>,
        ) -> ErasedProcedure<TBaseCtx>,
    >,
    pub(crate) phantom: PhantomData<(TBaseInput, TBaseResult)>,
}

impl<TBaseCtx, TError, TCtx, TBaseInput, TInput, TBaseResult, TResult> fmt::Debug
    for ProcedureBuilder<TError, TBaseCtx, TCtx, TBaseInput, TInput, TBaseResult, TResult>
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Procedure").finish()
    }
}

impl<TRootCtx, TCtx, TError, TBaseInput, TInput, TBaseResult, TResult>
    ProcedureBuilder<TError, TRootCtx, TCtx, TBaseInput, TInput, TBaseResult, TResult>
where
    TError: Error,
    TRootCtx: 'static,
    TCtx: 'static,
    TInput: 'static,
    TBaseInput: 'static,
    TResult: 'static,
    TBaseResult: 'static,
{
    pub fn with<
        M: IntoMiddleware<TError, TRootCtx, TCtx, TBaseInput, TInput, TBaseResult, TResult>,
    >(
        self,
        mw: M,
    ) -> ProcedureBuilder<TError, TRootCtx, M::TNextCtx, TBaseInput, M::I, TBaseResult, M::R>
// where
    //     TNextCtx: 'static,
    //     I: 'static,
    //     R: 'static,
    {
        mw.build(self)
    }

    pub fn setup(self, func: impl FnOnce(&mut State, ProcedureMeta) + 'static) -> Self {
        Self {
            build: Box::new(|ty, mut setups, handler| {
                setups.push(Box::new(func));
                (self.build)(ty, setups, handler)
            }),
            phantom: PhantomData,
        }
    }

    pub fn query<F: Future<Output = Result<TResult, TError>> + Send + 'static>(
        self,
        handler: impl Fn(TCtx, TInput) -> F + Send + Sync + 'static,
    ) -> Procedure<TRootCtx, TBaseInput, TBaseResult> {
        Procedure {
            build: Box::new(move |setups| {
                (self.build)(
                    ProcedureKind::Query,
                    setups,
                    Arc::new(move |ctx, input, _| Box::pin(handler(ctx, input))),
                )
            }),
            phantom: PhantomData,
        }
    }

    pub fn mutation<F: Future<Output = Result<TResult, TError>> + Send + 'static>(
        self,
        handler: impl Fn(TCtx, TInput) -> F + Send + Sync + 'static,
    ) -> Procedure<TRootCtx, TBaseInput, TBaseResult> {
        Procedure {
            build: Box::new(move |setups| {
                (self.build)(
                    ProcedureKind::Mutation,
                    setups,
                    Arc::new(move |ctx, input, _| Box::pin(handler(ctx, input))),
                )
            }),
            phantom: PhantomData,
        }
    }
}

impl<TRootCtx, TCtx, TError, TBaseInput, TInput, TBaseResult, TResult, S>
    ProcedureBuilder<TError, TRootCtx, TCtx, TBaseInput, TInput, TBaseResult, crate::Stream<S>>
where
    TError: Error,
    TRootCtx: 'static,
    TCtx: 'static,
    TInput: 'static,
    TBaseInput: 'static,
    TResult: 'static,
    TBaseResult: 'static,
    S: Stream<Item = TResult> + 'static,
{
    pub fn subscription<F: Future<Output = Result<S, TError>> + Send + 'static>(
        self,
        handler: impl Fn(TCtx, TInput) -> F + Send + Sync + 'static,
    ) -> Procedure<TRootCtx, TBaseInput, crate::Stream<S>> {
        Procedure {
            build: Box::new(move |setups| {
                (self.build)(
                    ProcedureKind::Subscription,
                    setups,
                    Arc::new(move |ctx, input, _| {
                        Box::pin(handler(ctx, input).map(|f| f.map(|s| crate::Stream(s))))
                    }),
                )
            }),
            phantom: PhantomData,
        }
    }
}