rpc-rs 0.1.1

A blazingly fast, lightweight, and type-safe RPC/IPC framework for Rust and Web/Tauri-based applications, based on `specta`.
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

//! Macros for `rpc-rs`.

/// A macro to create a module for a prisma-client-rust module.
/// Your client must be an `Arc<...>`, as the state of the router.
///
/// Params:
/// - `client` - The path to the `PrismaClient` struct.
/// - `module` - The path to the module inside the generated `prisma` mod.
/// - `container` - The module's name. If you use `client.xxx.create(...)`, the container would be `xxx`.
/// - `primary_key` - The name of the model's primary key.
#[cfg(feature = "prisma")]
#[macro_export]
macro_rules! prisma_single_module {
    {
        client: $client: ty,
        module: $module: ident,
        container: $cont: ident,
        primary_key: $pkey: ident,
    } => {
        Module::builder()
                .read(wrap(|cx: Arc<$client>, item_id: i32| async move {
                    cx.$cont()
                        .find_first(vec![$module::$pkey::equals(item_id)])
                        .exec()
                        .await
                        .unwrap_or_default()
                }))
                .create(wrap(
                    |cx: Arc<$client>, item: $module::CreateUnchecked| async move {
                        cx.$cont()
                            .create_many(vec![item])
                            .exec()
                            .await
                            .map_err(|v| v.to_string())
                    },
                ))
                .update(wrap(
                    |cx: Arc<$client>, update: $module::Update| async move {
                        cx.$cont()
                            .update($module::$pkey::equals(update.id), update.as_params())
                            .exec()
                            .await
                            .map_err(|v| v.to_string())
                    },
                ))
                .delete(wrap(
                    |cx: Arc<$client>, item_id: i32| async move {
                        cx.$cont()
                            .delete($module::$pkey::equals(item_id))
                            .exec()
                            .await
                            .map_err(|v| v.to_string())
                    },
                ))
                .build()
    };
}

/// A macro to create a module for a prisma-client-rust module.
/// Your client must be an `Arc<...>`, as the state of the router.
/// This will work with a `Vec<...>` of the model.
///
/// Params:
/// - `client` - The path to the `PrismaClient` struct.
/// - `module` - The path to the module inside the generated `prisma` mod.
/// - `container` - The module's name. If you use `client.xxx.create(...)`, the container would be `xxx`.
/// - `primary_key` - The name of the model's primary key.
#[cfg(feature = "prisma")]
#[macro_export]
macro_rules! prisma_multi_module {
    {
        client: $client: ty,
        module: $module: ident,
        container: $cont: ident,
        primary_key: $pkey: ident,
    } => {
        Module::builder()
                .read(wrap(|cx: Arc<$client>, _: ()| async move {
                    cx.$cont()
                        .find_many(vec![])
                        .exec()
                        .await
                        .unwrap_or_default()
                }))
                .create(wrap(
                    |cx: Arc<$client>, m: Vec<$module::CreateUnchecked>| async move {
                        cx.$cont()
                            .create_many(m)
                            .exec()
                            .await
                            .map_err(|v| v.to_string())
                    },
                ))
                .delete(wrap(|cx: Arc<$client>, ids: Vec<i32>| async move {
                    cx.$cont()
                        .delete_many(ids.iter().map(|v| $module::$pkey::equals(v.clone())).collect())
                        .exec()
                        .await
                        .map_err(|v| v.to_string())
                }))
                .build()
    };
}

/// A macro to create a module for a prisma-client-rust module.
/// Your client must be an `Arc<...>`, as the state of the router.
///
/// Params:
/// - `router` - The variable containing router (must be `mut`).
/// - `single` - The name for the single route.
/// - `multi` - The name for the multi route.
/// - `client` - The path to the `PrismaClient` struct.
/// - `module` - The path to the module inside the generated `prisma` mod.
/// - `container` - The module's name. If you use `client.xxx.create(...)`, the container would be `xxx`.
/// - `primary_key` - The name of the model's primary key.
#[cfg(feature = "prisma")]
#[macro_export]
macro_rules! prisma_module {
    ($router: ident += [$single: expr, $multi: expr] {
        client: $client: ty,
        module: $module: ident,
        container: $cont: ident,
        primary_key: $pkey: ident,
    }) => {
        $router = $router.mount(
            $single,
            $crate::prisma_single_module! {
                client: $client,
                module: $module,
                container: $cont,
                primary_key: $pkey,
            },
        );

        $router = $router.mount(
            $multi,
            $crate::prisma_multi_module! {
                client: $client,
                module: $module,
                container: $cont,
                primary_key: $pkey,
            },
        );
    };
}