4370280743

Build Type

push

github

Committed by GitHub

Commit Message

Bump async-trait from 0.1.65 to 0.1.66 (#1179)

Run Details

27808 of 38702 relevant lines covered (71.85%)

25323.55 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

67.86

/dozer-cache/src/reader.rs

use crate::cache::{expression::QueryExpression, RecordWithId, RoCache};

use super::cache::expression::FilterExpression;
use crate::errors::CacheError;
use dozer_types::{
    serde,
    types::{IndexDefinition, Record, Schema},
};
use serde::{Deserialize, Serialize};

#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
#[serde(crate = "self::serde")]

/// This filter gets dynamically added to the query.
pub struct AccessFilter {
    /// FilterExpression to evaluate access
    pub filter: Option<FilterExpression>,

    /// Fields to be restricted
    pub fields: Vec<String>,
}

#[derive(Debug)]
/// CacheReader dynamically attaches permissions on top of queries
pub struct CacheReader {
    cache: Box<dyn RoCache>,
}

impl CacheReader {
    pub fn new(cache: Box<dyn RoCache>) -> Self {
        Self { cache }
    }

    // TODO: Implement check_access
    fn check_access(&self, _rec: &Record, _access_filter: &AccessFilter) -> Result<(), CacheError> {
        Ok(())
    }

    pub fn get_schema(&self) -> Result<&(Schema, Vec<IndexDefinition>), CacheError> {
        self.cache.get_schema()
    }

    pub fn get(
        &self,
        key: &[u8],
        access_filter: &AccessFilter,
    ) -> Result<RecordWithId, CacheError> {
        let record = self.cache.get(key)?;
        match self.check_access(&record.record, access_filter) {
            Ok(_) => Ok(record),
            Err(e) => Err(e),
        }
    }

    pub fn query(
        &self,
        query: &mut QueryExpression,
        access_filter: AccessFilter,
    ) -> Result<Vec<RecordWithId>, CacheError> {
        self.apply_access_filter(query, access_filter);
        self.cache.query(query)
    }

    pub fn count(
        &self,
        query: &mut QueryExpression,
        access_filter: AccessFilter,
    ) -> Result<usize, CacheError> {
        self.apply_access_filter(query, access_filter);
        self.cache.count(query)
    }

    // Apply filter if specified in access
    fn apply_access_filter(&self, query: &mut QueryExpression, access_filter: AccessFilter) {
        // TODO: Use `fields` in `access_filter`.
        if let Some(access_filter) = access_filter.filter {
            let filter = match query.filter.take() {
                Some(query_filter) => FilterExpression::And(vec![access_filter, query_filter]),
                None => access_filter,
            };

            query.filter = Some(filter);
        }
    }
}

1	use crate::cache::{expression::QueryExpression, RecordWithId, RoCache};
2
3	use super::cache::expression::FilterExpression;
4	use crate::errors::CacheError;
5	use dozer_types::{
6	serde,
7	types::{IndexDefinition, Record, Schema},
8	};
9	use serde::{Deserialize, Serialize};
10
11	#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]	10✔
12	#[serde(crate = "self::serde")]
13
14	/// This filter gets dynamically added to the query.
15	pub struct AccessFilter {
16	/// FilterExpression to evaluate access
17	pub filter: Option<FilterExpression>,
18
19	/// Fields to be restricted
20	pub fields: Vec<String>,
21	}
22
23	#[derive(Debug)]	×
24	/// CacheReader dynamically attaches permissions on top of queries
25	pub struct CacheReader {
26	cache: Box<dyn RoCache>,
27	}
28
29	impl CacheReader {
30	pub fn new(cache: Box<dyn RoCache>) -> Self {	120✔
31	Self { cache }	120✔
32	}	120✔
33
34	// TODO: Implement check_access
35	fn check_access(&self, _rec: &Record, _access_filter: &AccessFilter) -> Result<(), CacheError> {	6✔
36	Ok(())	6✔
37	}	6✔
38
39	pub fn get_schema(&self) -> Result<&(Schema, Vec<IndexDefinition>), CacheError> {	126✔
40	self.cache.get_schema()	126✔
41	}	126✔
42		×
43	pub fn get(	6✔
44	&self,	6✔
45	key: &[u8],	6✔
46	access_filter: &AccessFilter,	6✔
47	) -> Result<RecordWithId, CacheError> {	6✔
48	let record = self.cache.get(key)?;	6✔
49	match self.check_access(&record.record, access_filter) {	6✔
50	Ok(_) => Ok(record),	6✔
51	Err(e) => Err(e),	×
52	}	×
53	}	6✔
54		×
55	pub fn query(	108✔
56	&self,	108✔
57	query: &mut QueryExpression,	108✔
58	access_filter: AccessFilter,	108✔
59	) -> Result<Vec<RecordWithId>, CacheError> {	108✔
60	self.apply_access_filter(query, access_filter);	108✔
61	self.cache.query(query)	108✔
62	}	108✔
63		×
64	pub fn count(	84✔
65	&self,	84✔
66	query: &mut QueryExpression,	84✔
67	access_filter: AccessFilter,	84✔
68	) -> Result<usize, CacheError> {	84✔
69	self.apply_access_filter(query, access_filter);	84✔
70	self.cache.count(query)	84✔
71	}	84✔
72		×
73	// Apply filter if specified in access	×
74	fn apply_access_filter(&self, query: &mut QueryExpression, access_filter: AccessFilter) {	×
75	// TODO: Use `fields` in `access_filter`.	×
76	if let Some(access_filter) = access_filter.filter {	192✔
77	let filter = match query.filter.take() {	×
78	Some(query_filter) => FilterExpression::And(vec![access_filter, query_filter]),	×
79	None => access_filter,	×
80	};
81		×
82	query.filter = Some(filter);	×
83	}	192✔
84	}	192✔
85	}

getdozer / dozer / 4370280743

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous