4023928230

Build Type

github

Committed by GitHub

Commit Message

Merge fe141bf50 into 70bd6e0ad

Pull Request Pull Request #744: feat: Implement direct insert to cache pipeline

Run Details

243 of 243 new or added lines in 16 files covered. (100.0%)

23197 of 34900 relevant lines covered (66.47%)

45617.34 hits per line

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

92.73

/dozer-admin/src/services/endpoint_service.rs

use dozer_types::models::api_endpoint::ApiEndpoint;

use crate::{
    db::{persistable::Persistable, pool::DbPool},
    server::dozer_admin_grpc::{
        CreateEndpointRequest, CreateEndpointResponse, DeleteEndpointRequest,
        DeleteEndpointResponse, ErrorResponse, GetAllEndpointRequest, GetAllEndpointResponse,
        GetEndpointRequest, GetEndpointResponse, Pagination, UpdateEndpointRequest,
        UpdateEndpointResponse,
    },
};

pub struct EndpointService {
    db_pool: DbPool,
}

impl EndpointService {
    pub fn new(db_pool: DbPool) -> Self {
        Self { db_pool }
    }
}
impl EndpointService {
    pub fn create_endpoint(
        &self,
        request: CreateEndpointRequest,
    ) -> Result<CreateEndpointResponse, ErrorResponse> {
        let generated_id = uuid::Uuid::new_v4().to_string();
        let mut endpoint_info = dozer_types::models::api_endpoint::ApiEndpoint {
            id: Some(generated_id),
            app_id: Some(request.app_id.to_owned()),
            name: request.name.to_owned(),
            path: request.path.to_owned(),
            sql: Some(request.sql),
            index: request.index,
        };
        endpoint_info
            .upsert(self.db_pool.to_owned())
            .map_err(|op| ErrorResponse {
                message: op.to_string(),
            })?;
        Ok(CreateEndpointResponse {
            info: Some(endpoint_info),
        })
    }
    pub fn delete(
        &self,
        request: DeleteEndpointRequest,
    ) -> Result<DeleteEndpointResponse, ErrorResponse> {
        let _endpoint_info = dozer_types::models::api_endpoint::ApiEndpoint::delete(
            self.db_pool.to_owned(),
            request.endpoint_id,
            request.app_id,
        )
        .map_err(|op| ErrorResponse {
            message: op.to_string(),
        })?;
        Ok(DeleteEndpointResponse { success: true })
    }
    pub fn get_endpoint(
        &self,
        request: GetEndpointRequest,
    ) -> Result<GetEndpointResponse, ErrorResponse> {
        let endpoint_info = dozer_types::models::api_endpoint::ApiEndpoint::by_id(
            self.db_pool.to_owned(),
            request.endpoint_id,
            request.app_id,
        )
        .map_err(|op| ErrorResponse {
            message: op.to_string(),
        })?;
        Ok(GetEndpointResponse {
            info: Some(endpoint_info),
        })
    }

    pub fn list(
        &self,
        input: GetAllEndpointRequest,
    ) -> Result<GetAllEndpointResponse, ErrorResponse> {
        let endpoints: (
            Vec<dozer_types::models::api_endpoint::ApiEndpoint>,
            Pagination,
        ) = dozer_types::models::api_endpoint::ApiEndpoint::list(
            self.db_pool.clone(),
            input.app_id,
            input.limit,
            input.offset,
        )
        .map_err(|op| ErrorResponse {
            message: op.to_string(),
        })?;
        Ok(GetAllEndpointResponse {
            data: endpoints.0,
            pagination: Some(endpoints.1),
        })
    }

    pub fn update_endpoint(
        &self,
        request: UpdateEndpointRequest,
    ) -> Result<UpdateEndpointResponse, ErrorResponse> {
        let mut endpoint_by_id: ApiEndpoint =
            dozer_types::models::api_endpoint::ApiEndpoint::by_id(
                self.db_pool.to_owned(),
                request.id,
                request.app_id,
            )
            .map_err(|err| ErrorResponse {
                message: err.to_string(),
            })?;
        if let Some(name) = request.name {
            endpoint_by_id.name = name;
        }
        if let Some(path) = request.path {
            endpoint_by_id.path = path;
        }
        if let Some(sql) = request.sql {
            endpoint_by_id.sql = Some(sql);
        }
        if let Some(index) = request.index {
            endpoint_by_id.index = Some(index);
        }
        endpoint_by_id
            .upsert(self.db_pool.to_owned())
            .map_err(|op| ErrorResponse {
                message: op.to_string(),
            })?;
        Ok(UpdateEndpointResponse {
            info: Some(endpoint_by_id.to_owned()),
        })
    }
}

1	use dozer_types::models::api_endpoint::ApiEndpoint;
2
3	use crate::{
4	db::{persistable::Persistable, pool::DbPool},
5	server::dozer_admin_grpc::{
6	CreateEndpointRequest, CreateEndpointResponse, DeleteEndpointRequest,
7	DeleteEndpointResponse, ErrorResponse, GetAllEndpointRequest, GetAllEndpointResponse,
8	GetEndpointRequest, GetEndpointResponse, Pagination, UpdateEndpointRequest,
9	UpdateEndpointResponse,
10	},
11	};
12
13	pub struct EndpointService {
14	db_pool: DbPool,
15	}
16
17	impl EndpointService {
18	pub fn new(db_pool: DbPool) -> Self {	6✔
19	Self { db_pool }	6✔
20	}	6✔
21	}
22	impl EndpointService {
23	pub fn create_endpoint(	1✔
24	&self,	1✔
25	request: CreateEndpointRequest,	1✔
26	) -> Result<CreateEndpointResponse, ErrorResponse> {	1✔
27	let generated_id = uuid::Uuid::new_v4().to_string();	1✔
28	let mut endpoint_info = dozer_types::models::api_endpoint::ApiEndpoint {	1✔
29	id: Some(generated_id),	1✔
30	app_id: Some(request.app_id.to_owned()),	1✔
31	name: request.name.to_owned(),	1✔
32	path: request.path.to_owned(),	1✔
33	sql: Some(request.sql),	1✔
34	index: request.index,	1✔
35	};	1✔
36	endpoint_info	1✔
37	.upsert(self.db_pool.to_owned())	1✔
38	.map_err(\|op\| ErrorResponse {	1✔
39	message: op.to_string(),	×
40	})?;	1✔
41	Ok(CreateEndpointResponse {	1✔
42	info: Some(endpoint_info),	1✔
43	})	1✔
44	}	1✔
45	pub fn delete(	1✔
46	&self,	1✔
47	request: DeleteEndpointRequest,	1✔
48	) -> Result<DeleteEndpointResponse, ErrorResponse> {	1✔
49	let _endpoint_info = dozer_types::models::api_endpoint::ApiEndpoint::delete(	1✔
50	self.db_pool.to_owned(),	1✔
51	request.endpoint_id,	1✔
52	request.app_id,	1✔
53	)	1✔
54	.map_err(\|op\| ErrorResponse {	1✔
55	message: op.to_string(),	×
56	})?;	1✔
57	Ok(DeleteEndpointResponse { success: true })	1✔
58	}	1✔
59	pub fn get_endpoint(	1✔
60	&self,	1✔
61	request: GetEndpointRequest,	1✔
62	) -> Result<GetEndpointResponse, ErrorResponse> {	1✔
63	let endpoint_info = dozer_types::models::api_endpoint::ApiEndpoint::by_id(	1✔
64	self.db_pool.to_owned(),	1✔
65	request.endpoint_id,	1✔
66	request.app_id,	1✔
67	)	1✔
68	.map_err(\|op\| ErrorResponse {	1✔
69	message: op.to_string(),	×
70	})?;	1✔
71	Ok(GetEndpointResponse {	1✔
72	info: Some(endpoint_info),	1✔
73	})	1✔
74	}	1✔
75
76	pub fn list(	1✔
77	&self,	1✔
78	input: GetAllEndpointRequest,	1✔
79	) -> Result<GetAllEndpointResponse, ErrorResponse> {	1✔
80	let endpoints: (	1✔
81	Vec<dozer_types::models::api_endpoint::ApiEndpoint>,	1✔
82	Pagination,	1✔
83	) = dozer_types::models::api_endpoint::ApiEndpoint::list(	1✔
84	self.db_pool.clone(),	1✔
85	input.app_id,	1✔
86	input.limit,	1✔
87	input.offset,	1✔
88	)	1✔
89	.map_err(\|op\| ErrorResponse {	1✔
90	message: op.to_string(),	×
91	})?;	1✔
92	Ok(GetAllEndpointResponse {	1✔
93	data: endpoints.0,	1✔
94	pagination: Some(endpoints.1),	1✔
95	})	1✔
96	}	1✔
97
98	pub fn update_endpoint(	2✔
99	&self,	2✔
100	request: UpdateEndpointRequest,	2✔
101	) -> Result<UpdateEndpointResponse, ErrorResponse> {	2✔
102	let mut endpoint_by_id: ApiEndpoint =	1✔
103	dozer_types::models::api_endpoint::ApiEndpoint::by_id(	2✔
104	self.db_pool.to_owned(),	2✔
105	request.id,	2✔
106	request.app_id,	2✔
107	)	2✔
108	.map_err(\|err\| ErrorResponse {	2✔
109	message: err.to_string(),	1✔
110	})?;	2✔
111	if let Some(name) = request.name {	1✔
112	endpoint_by_id.name = name;	1✔
113	}	1✔
114	if let Some(path) = request.path {	1✔
115	endpoint_by_id.path = path;	×
116	}	1✔
117	if let Some(sql) = request.sql {	1✔
118	endpoint_by_id.sql = Some(sql);	×
119	}	1✔
120	if let Some(index) = request.index {	1✔
121	endpoint_by_id.index = Some(index);	×
122	}	1✔
123	endpoint_by_id	1✔
124	.upsert(self.db_pool.to_owned())	1✔
125	.map_err(\|op\| ErrorResponse {	1✔
126	message: op.to_string(),	×
127	})?;	1✔
128	Ok(UpdateEndpointResponse {	1✔
129	info: Some(endpoint_by_id.to_owned()),	1✔
130	})	1✔
131	}	2✔
132	}

getdozer / dozer / 4023928230

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