surrealdb_core/api/middleware/
mod.rs

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
use std::ops::Deref;

pub mod api;
pub(super) mod invoke;

use revision::revisioned;
use serde::{Deserialize, Serialize};

use crate::{
	err::Error,
	sql::{statements::info::InfoStructure, Object, Value},
};

#[revisioned(revision = 1)]
#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
#[non_exhaustive]
pub struct RequestMiddleware(pub Vec<(String, Vec<Value>)>);

impl InfoStructure for RequestMiddleware {
	fn structure(self) -> Value {
		Value::Object(Object(self.0.into_iter().map(|(k, v)| (k, Value::from(v))).collect()))
	}
}

impl Deref for RequestMiddleware {
	type Target = Vec<(String, Vec<Value>)>;
	fn deref(&self) -> &Self::Target {
		&self.0
	}
}

pub type CollectedMiddleware<'a> = Vec<(&'a String, &'a Vec<Value>)>;

pub trait CollectMiddleware<'a> {
	fn collect(&'a self) -> Result<CollectedMiddleware<'a>, Error>;
}

impl<'a> CollectMiddleware<'a> for Vec<&'a RequestMiddleware> {
	fn collect(&'a self) -> Result<CollectedMiddleware<'a>, Error> {
		let mut middleware: CollectedMiddleware<'a> = Vec::new();

		for map in self.iter() {
			for (k, v) in map.iter() {
				match k.split_once("::") {
					Some(("api", _)) => middleware.push((k, v)),
					Some(("fn", _)) => {
						return Err(Error::Unreachable(
							"Custom middleware are not yet supported".into(),
						))
					}
					_ => {
						return Err(Error::Unreachable(
							"Found a middleware which is unparsable".into(),
						))
					}
				}
			}
		}

		Ok(middleware)
	}
}