4164814422

Build Type

github

Committed by GitHub

Commit Message

Merge eae178c73 into 7cb6e2163

Pull Request Pull Request #883: refactor: Remove unused struct `PipelineDetails`

Run Details

211 of 211 new or added lines in 12 files covered. (100.0%)

23813 of 35480 relevant lines covered (67.12%)

41873.4 hits per line

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

63.54

/dozer-api/src/api_helper.rs

use crate::auth::Access;
use crate::errors::{ApiError, AuthError};
use crate::generator::oapi::generator::OpenApiGenerator;
use crate::RoCacheEndpoint;
use dozer_cache::cache::RecordWithId;
use dozer_cache::cache::{expression::QueryExpression, index};
use dozer_cache::errors::CacheError;
use dozer_cache::{AccessFilter, CacheReader};
use dozer_types::indexmap::IndexMap;
use dozer_types::json_str_to_field;
use dozer_types::models::api_endpoint::ApiEndpoint;
use dozer_types::record_to_map;
use dozer_types::serde_json::Value;
use dozer_types::types::Schema;
use openapiv3::OpenAPI;

pub struct ApiHelper<'a> {
    endpoint: &'a ApiEndpoint,
    reader: CacheReader,
}
impl<'a> ApiHelper<'a> {
    pub fn new(
        cache_endpoint: &'a RoCacheEndpoint,
        access: Option<Access>,
    ) -> Result<Self, ApiError> {
        let access = access.unwrap_or(Access::All);

        // Define Access Filter based on token
        let reader_access = match access {
            // No access filter.
            Access::All => AccessFilter {
                filter: None,
                fields: vec![],
            },

            Access::Custom(mut access_filters) => {
                if let Some(access_filter) = access_filters.remove(&cache_endpoint.endpoint.name) {
                    access_filter
                } else {
                    return Err(ApiError::ApiAuthError(AuthError::InvalidToken));
                }
            }
        };

        let reader = CacheReader {
            cache: cache_endpoint.cache.clone(),
            access: reader_access,
        };
        Ok(Self {
            endpoint: &cache_endpoint.endpoint,
            reader,
        })
    }

    pub fn generate_oapi3(&self) -> Result<OpenAPI, ApiError> {
        let (schema, secondary_indexes) = self
            .reader
            .get_schema_and_indexes_by_name(&self.endpoint.name)
            .map_err(ApiError::SchemaNotFound)?;

        let oapi_generator = OpenApiGenerator::new(
            schema,
            secondary_indexes,
            self.endpoint.clone(),
            vec![format!("http://localhost:{}", "8080")],
        );

        oapi_generator
            .generate_oas3()
            .map_err(ApiError::ApiGenerationError)
    }

    /// Get a single record by json string as primary key
    pub fn get_record(&self, key: &str) -> Result<IndexMap<String, Value>, CacheError> {
        let schema = self
            .reader
            .get_schema_and_indexes_by_name(&self.endpoint.name)?
            .0;

        let key = if schema.primary_index.is_empty() {
            json_str_to_field(key, dozer_types::types::FieldType::UInt, false)
                .map_err(CacheError::Type)
        } else if schema.primary_index.len() == 1 {
            let field = &schema.fields[schema.primary_index[0]];
            json_str_to_field(key, field.typ, field.nullable).map_err(CacheError::Type)
        } else {
            Err(CacheError::Query(
                dozer_cache::errors::QueryError::MultiIndexFetch(key.to_string()),
            ))
        }?;

        let key = index::get_primary_key(&[0], &[key]);
        let rec = self.reader.get(&key)?;

        record_to_map(&rec, &schema).map_err(CacheError::Type)
    }

    pub fn get_records_count(&self, mut exp: QueryExpression) -> Result<usize, CacheError> {
        self.reader.count(&self.endpoint.name, &mut exp)
    }

    /// Get multiple records
    pub fn get_records_map(
        &self,
        exp: QueryExpression,
    ) -> Result<Vec<IndexMap<String, Value>>, CacheError> {
        let mut maps = vec![];
        let (schema, records) = self.get_records(exp)?;
        for rec in records.iter() {
            let map = record_to_map(&rec.record, &schema)?;
            maps.push(map);
        }
        Ok(maps)
    }
    /// Get multiple records
    pub fn get_records(
        &self,
        mut exp: QueryExpression,
    ) -> Result<(Schema, Vec<RecordWithId>), CacheError> {
        let schema = self
            .reader
            .get_schema_and_indexes_by_name(&self.endpoint.name)?
            .0;
        let records = self.reader.query(&self.endpoint.name, &mut exp)?;

        Ok((schema, records))
    }

    /// Get schema
    pub fn get_schema(&self) -> Result<Schema, CacheError> {
        let schema = self
            .reader
            .get_schema_and_indexes_by_name(&self.endpoint.name)?
            .0;
        Ok(schema)
    }
}

1	use crate::auth::Access;
2	use crate::errors::{ApiError, AuthError};
3	use crate::generator::oapi::generator::OpenApiGenerator;
4	use crate::RoCacheEndpoint;
5	use dozer_cache::cache::RecordWithId;
6	use dozer_cache::cache::{expression::QueryExpression, index};
7	use dozer_cache::errors::CacheError;
8	use dozer_cache::{AccessFilter, CacheReader};
9	use dozer_types::indexmap::IndexMap;
10	use dozer_types::json_str_to_field;
11	use dozer_types::models::api_endpoint::ApiEndpoint;
12	use dozer_types::record_to_map;
13	use dozer_types::serde_json::Value;
14	use dozer_types::types::Schema;
15	use openapiv3::OpenAPI;
16
17	pub struct ApiHelper<'a> {
18	endpoint: &'a ApiEndpoint,
19	reader: CacheReader,
20	}	×
21	impl<'a> ApiHelper<'a> {	×
22	pub fn new(	37✔
23	cache_endpoint: &'a RoCacheEndpoint,	37✔
24	access: Option<Access>,	37✔
25	) -> Result<Self, ApiError> {	37✔
26	let access = access.unwrap_or(Access::All);	37✔
27		×
28	// Define Access Filter based on token
29	let reader_access = match access {	37✔
30	// No access filter.	×
31	Access::All => AccessFilter {	37✔
32	filter: None,	37✔
33	fields: vec![],	37✔
34	},	37✔
35		×
36	Access::Custom(mut access_filters) => {	×
37	if let Some(access_filter) = access_filters.remove(&cache_endpoint.endpoint.name) {	×
38	access_filter	×
39	} else {
40	return Err(ApiError::ApiAuthError(AuthError::InvalidToken));	×
41	}
42	}
43	};	×
44		×
45	let reader = CacheReader {	37✔
46	cache: cache_endpoint.cache.clone(),	37✔
47	access: reader_access,	37✔
48	};	37✔
49	Ok(Self {	37✔
50	endpoint: &cache_endpoint.endpoint,	37✔
51	reader,	37✔
52	})	37✔
53	}	37✔
54		×
55	pub fn generate_oapi3(&self) -> Result<OpenAPI, ApiError> {	×
56	let (schema, secondary_indexes) = self	×
57	.reader	×
58	.get_schema_and_indexes_by_name(&self.endpoint.name)	×
59	.map_err(ApiError::SchemaNotFound)?;	×
60		×
61	let oapi_generator = OpenApiGenerator::new(	×
62	schema,	×
63	secondary_indexes,	×
64	self.endpoint.clone(),	×
65	vec![format!("http://localhost:{}", "8080")],	×
66	);	×
67		×
68	oapi_generator	×
69	.generate_oas3()	×
70	.map_err(ApiError::ApiGenerationError)	×
71	}	×
72
73	/// Get a single record by json string as primary key
74	pub fn get_record(&self, key: &str) -> Result<IndexMap<String, Value>, CacheError> {	1✔
75	let schema = self	1✔
76	.reader	1✔
77	.get_schema_and_indexes_by_name(&self.endpoint.name)?	1✔
78	.0;
79
80	let key = if schema.primary_index.is_empty() {	1✔
81	json_str_to_field(key, dozer_types::types::FieldType::UInt, false)	×
82	.map_err(CacheError::Type)	×
83	} else if schema.primary_index.len() == 1 {	1✔
84	let field = &schema.fields[schema.primary_index[0]];	1✔
85	json_str_to_field(key, field.typ, field.nullable).map_err(CacheError::Type)	1✔
86	} else {
87	Err(CacheError::Query(	×
88	dozer_cache::errors::QueryError::MultiIndexFetch(key.to_string()),	×
89	))	×
90	}?;	×
91
92	let key = index::get_primary_key(&[0], &[key]);	1✔
93	let rec = self.reader.get(&key)?;	1✔
94
95	record_to_map(&rec, &schema).map_err(CacheError::Type)	1✔
96	}	1✔
97
98	pub fn get_records_count(&self, mut exp: QueryExpression) -> Result<usize, CacheError> {	14✔
99	self.reader.count(&self.endpoint.name, &mut exp)	14✔
100	}	14✔
101
102	/// Get multiple records
103	pub fn get_records_map(	8✔
104	&self,	8✔
105	exp: QueryExpression,	8✔
106	) -> Result<Vec<IndexMap<String, Value>>, CacheError> {	8✔
107	let mut maps = vec![];	8✔
108	let (schema, records) = self.get_records(exp)?;	8✔
109	for rec in records.iter() {	312✔
110	let map = record_to_map(&rec.record, &schema)?;	312✔
111	maps.push(map);	312✔
112	}
113	Ok(maps)	8✔
114	}	8✔
115	/// Get multiple records
116	pub fn get_records(	17✔
117	&self,	17✔
118	mut exp: QueryExpression,	17✔
119	) -> Result<(Schema, Vec<RecordWithId>), CacheError> {	17✔
120	let schema = self	17✔
121	.reader	17✔
122	.get_schema_and_indexes_by_name(&self.endpoint.name)?	17✔
123	.0;
124	let records = self.reader.query(&self.endpoint.name, &mut exp)?;	17✔
125
126	Ok((schema, records))	17✔
127	}	17✔
128
129	/// Get schema
130	pub fn get_schema(&self) -> Result<Schema, CacheError> {	5✔
131	let schema = self	5✔
132	.reader	5✔
133	.get_schema_and_indexes_by_name(&self.endpoint.name)?	5✔
134	.0;
135	Ok(schema)	5✔
136	}	5✔
137	}

getdozer / dozer / 4164814422

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