Documents backend api

common/proto/document_data.proto

@@ -2,8 +2,11 @@ syntax = "proto3";
 package komp_ac.document_data;
 
 service DocumentDataService {
-  rpc SaveGeneratedPrintJson(SaveGeneratedPrintJsonRequest) returns (SaveGeneratedPrintJsonResponse);
+  rpc SaveDocument(SaveDocumentRequest) returns (SaveDocumentResponse);
-  rpc SaveUserAdjustedPrintJson(SaveUserAdjustedPrintJsonRequest) returns (SaveUserAdjustedPrintJsonResponse);
+  rpc UpdateDocument(UpdateDocumentRequest) returns (UpdateDocumentResponse);
+  rpc GetDocuments(GetDocumentsRequest) returns (GetDocumentsResponse);
+  rpc GetDocument(GetDocumentRequest) returns (GetDocumentResponse);
+  rpc GetDocumentVersion(GetDocumentVersionRequest) returns (GetDocumentVersionResponse);
 }
 
 message SourceRecord {
@@ -13,7 +16,7 @@ message SourceRecord {
   int64 record_id = 4;
 }
 
-message SaveGeneratedPrintJsonRequest {
+message SaveDocumentRequest {
   optional int64 schema_id = 1;
   repeated SourceRecord source_records = 2;
   optional string template_name = 3;
@@ -22,14 +25,14 @@ message SaveGeneratedPrintJsonRequest {
   string data_json = 6;
 }
 
-message SaveGeneratedPrintJsonResponse {
+message SaveDocumentResponse {
-  int64 document_run_id = 1;
+  int64 document_id = 1;
   int64 snapshot_id = 2;
   int32 version_number = 3;
 }
 
-message SaveUserAdjustedPrintJsonRequest {
+message UpdateDocumentRequest {
-  int64 document_run_id = 1;
+  int64 document_id = 1;
   optional int64 schema_id = 2;
   repeated SourceRecord source_records = 3;
   optional string template_name = 4;
@@ -38,8 +41,50 @@ message SaveUserAdjustedPrintJsonRequest {
   string data_json = 7;
 }
 
-message SaveUserAdjustedPrintJsonResponse {
+message UpdateDocumentResponse {
-  int64 document_run_id = 1;
+  int64 document_id = 1;
   int64 snapshot_id = 2;
   int32 version_number = 3;
 }
+
+message GetDocumentsRequest {
+  optional int64 schema_id = 1;
+  uint32 limit = 2;
+  optional string template_name = 3;
+}
+
+message Document {
+  int64 snapshot_id = 1;
+  int64 document_id = 2;
+  optional int64 schema_id = 3;
+  repeated SourceRecord source_records = 4;
+  optional string template_name = 5;
+  optional string template_kind = 6;
+  optional string template_path = 7;
+  string data_json = 8;
+  string change_kind = 9;
+  int32 version_number = 10;
+  string created_at = 11;
+  string updated_at = 12;
+}
+
+message GetDocumentsResponse {
+  repeated Document documents = 1;
+}
+
+message GetDocumentRequest {
+  int64 document_id = 1;
+}
+
+message GetDocumentResponse {
+  optional Document document = 1;
+}
+
+message GetDocumentVersionRequest {
+  int64 document_id = 1;
+  int32 version_number = 2;
+}
+
+message GetDocumentVersionResponse {
+  optional Document document = 1;
+}

common/src/proto/komp_ac.document_data.rs

@@ -11,7 +11,7 @@ pub struct SourceRecord {
     pub record_id: i64,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct SaveGeneratedPrintJsonRequest {
+pub struct SaveDocumentRequest {
     #[prost(int64, optional, tag = "1")]
     pub schema_id: ::core::option::Option<i64>,
     #[prost(message, repeated, tag = "2")]
@@ -26,18 +26,18 @@ pub struct SaveGeneratedPrintJsonRequest {
     pub data_json: ::prost::alloc::string::String,
 }
 #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
-pub struct SaveGeneratedPrintJsonResponse {
+pub struct SaveDocumentResponse {
     #[prost(int64, tag = "1")]
-    pub document_run_id: i64,
+    pub document_id: i64,
     #[prost(int64, tag = "2")]
     pub snapshot_id: i64,
     #[prost(int32, tag = "3")]
     pub version_number: i32,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct SaveUserAdjustedPrintJsonRequest {
+pub struct UpdateDocumentRequest {
     #[prost(int64, tag = "1")]
-    pub document_run_id: i64,
+    pub document_id: i64,
     #[prost(int64, optional, tag = "2")]
     pub schema_id: ::core::option::Option<i64>,
     #[prost(message, repeated, tag = "3")]
@@ -52,14 +52,77 @@ pub struct SaveUserAdjustedPrintJsonRequest {
     pub data_json: ::prost::alloc::string::String,
 }
 #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
-pub struct SaveUserAdjustedPrintJsonResponse {
+pub struct UpdateDocumentResponse {
     #[prost(int64, tag = "1")]
-    pub document_run_id: i64,
+    pub document_id: i64,
     #[prost(int64, tag = "2")]
     pub snapshot_id: i64,
     #[prost(int32, tag = "3")]
     pub version_number: i32,
 }
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct GetDocumentsRequest {
+    #[prost(int64, optional, tag = "1")]
+    pub schema_id: ::core::option::Option<i64>,
+    #[prost(uint32, tag = "2")]
+    pub limit: u32,
+    #[prost(string, optional, tag = "3")]
+    pub template_name: ::core::option::Option<::prost::alloc::string::String>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Document {
+    #[prost(int64, tag = "1")]
+    pub snapshot_id: i64,
+    #[prost(int64, tag = "2")]
+    pub document_id: i64,
+    #[prost(int64, optional, tag = "3")]
+    pub schema_id: ::core::option::Option<i64>,
+    #[prost(message, repeated, tag = "4")]
+    pub source_records: ::prost::alloc::vec::Vec<SourceRecord>,
+    #[prost(string, optional, tag = "5")]
+    pub template_name: ::core::option::Option<::prost::alloc::string::String>,
+    #[prost(string, optional, tag = "6")]
+    pub template_kind: ::core::option::Option<::prost::alloc::string::String>,
+    #[prost(string, optional, tag = "7")]
+    pub template_path: ::core::option::Option<::prost::alloc::string::String>,
+    #[prost(string, tag = "8")]
+    pub data_json: ::prost::alloc::string::String,
+    #[prost(string, tag = "9")]
+    pub change_kind: ::prost::alloc::string::String,
+    #[prost(int32, tag = "10")]
+    pub version_number: i32,
+    #[prost(string, tag = "11")]
+    pub created_at: ::prost::alloc::string::String,
+    #[prost(string, tag = "12")]
+    pub updated_at: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetDocumentsResponse {
+    #[prost(message, repeated, tag = "1")]
+    pub documents: ::prost::alloc::vec::Vec<Document>,
+}
+#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct GetDocumentRequest {
+    #[prost(int64, tag = "1")]
+    pub document_id: i64,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetDocumentResponse {
+    #[prost(message, optional, tag = "1")]
+    pub document: ::core::option::Option<Document>,
+}
+#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct GetDocumentVersionRequest {
+    #[prost(int64, tag = "1")]
+    pub document_id: i64,
+    #[prost(int32, tag = "2")]
+    pub version_number: i32,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetDocumentVersionResponse {
+    #[prost(message, optional, tag = "1")]
+    pub document: ::core::option::Option<Document>,
+}
 /// Generated client implementations.
 pub mod document_data_service_client {
     #![allow(
@@ -151,11 +214,11 @@ pub mod document_data_service_client {
             self.inner = self.inner.max_encoding_message_size(limit);
             self
         }
-        pub async fn save_generated_print_json(
+        pub async fn save_document(
             &mut self,
-            request: impl tonic::IntoRequest<super::SaveGeneratedPrintJsonRequest>,
+            request: impl tonic::IntoRequest<super::SaveDocumentRequest>,
         ) -> std::result::Result<
-            tonic::Response<super::SaveGeneratedPrintJsonResponse>,
+            tonic::Response<super::SaveDocumentResponse>,
             tonic::Status,
         > {
             self.inner
@@ -168,23 +231,23 @@ pub mod document_data_service_client {
                 })?;
             let codec = tonic_prost::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.document_data.DocumentDataService/SaveGeneratedPrintJson",
+                "/komp_ac.document_data.DocumentDataService/SaveDocument",
             );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(
                     GrpcMethod::new(
                         "komp_ac.document_data.DocumentDataService",
-                        "SaveGeneratedPrintJson",
+                        "SaveDocument",
                     ),
                 );
             self.inner.unary(req, path, codec).await
         }
-        pub async fn save_user_adjusted_print_json(
+        pub async fn update_document(
             &mut self,
-            request: impl tonic::IntoRequest<super::SaveUserAdjustedPrintJsonRequest>,
+            request: impl tonic::IntoRequest<super::UpdateDocumentRequest>,
         ) -> std::result::Result<
-            tonic::Response<super::SaveUserAdjustedPrintJsonResponse>,
+            tonic::Response<super::UpdateDocumentResponse>,
             tonic::Status,
         > {
             self.inner
@@ -197,14 +260,101 @@ pub mod document_data_service_client {
                 })?;
             let codec = tonic_prost::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.document_data.DocumentDataService/SaveUserAdjustedPrintJson",
+                "/komp_ac.document_data.DocumentDataService/UpdateDocument",
             );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(
                     GrpcMethod::new(
                         "komp_ac.document_data.DocumentDataService",
-                        "SaveUserAdjustedPrintJson",
+                        "UpdateDocument",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_documents(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetDocumentsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetDocumentsResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic_prost::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/komp_ac.document_data.DocumentDataService/GetDocuments",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "komp_ac.document_data.DocumentDataService",
+                        "GetDocuments",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_document(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetDocumentRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetDocumentResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic_prost::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/komp_ac.document_data.DocumentDataService/GetDocument",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "komp_ac.document_data.DocumentDataService",
+                        "GetDocument",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_document_version(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetDocumentVersionRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetDocumentVersionResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic_prost::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/komp_ac.document_data.DocumentDataService/GetDocumentVersion",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "komp_ac.document_data.DocumentDataService",
+                        "GetDocumentVersion",
                     ),
                 );
             self.inner.unary(req, path, codec).await
@@ -224,18 +374,39 @@ pub mod document_data_service_server {
     /// Generated trait containing gRPC methods that should be implemented for use with DocumentDataServiceServer.
     #[async_trait]
     pub trait DocumentDataService: std::marker::Send + std::marker::Sync + 'static {
-        async fn save_generated_print_json(
+        async fn save_document(
             &self,
-            request: tonic::Request<super::SaveGeneratedPrintJsonRequest>,
+            request: tonic::Request<super::SaveDocumentRequest>,
         ) -> std::result::Result<
-            tonic::Response<super::SaveGeneratedPrintJsonResponse>,
+            tonic::Response<super::SaveDocumentResponse>,
             tonic::Status,
         >;
-        async fn save_user_adjusted_print_json(
+        async fn update_document(
             &self,
-            request: tonic::Request<super::SaveUserAdjustedPrintJsonRequest>,
+            request: tonic::Request<super::UpdateDocumentRequest>,
         ) -> std::result::Result<
-            tonic::Response<super::SaveUserAdjustedPrintJsonResponse>,
+            tonic::Response<super::UpdateDocumentResponse>,
+            tonic::Status,
+        >;
+        async fn get_documents(
+            &self,
+            request: tonic::Request<super::GetDocumentsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetDocumentsResponse>,
+            tonic::Status,
+        >;
+        async fn get_document(
+            &self,
+            request: tonic::Request<super::GetDocumentRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetDocumentResponse>,
+            tonic::Status,
+        >;
+        async fn get_document_version(
+            &self,
+            request: tonic::Request<super::GetDocumentVersionRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetDocumentVersionResponse>,
             tonic::Status,
         >;
     }
@@ -315,28 +486,25 @@ pub mod document_data_service_server {
         }
         fn call(&mut self, req: http::Request<B>) -> Self::Future {
             match req.uri().path() {
-                "/komp_ac.document_data.DocumentDataService/SaveGeneratedPrintJson" => {
+                "/komp_ac.document_data.DocumentDataService/SaveDocument" => {
                     #[allow(non_camel_case_types)]
-                    struct SaveGeneratedPrintJsonSvc<T: DocumentDataService>(pub Arc<T>);
+                    struct SaveDocumentSvc<T: DocumentDataService>(pub Arc<T>);
                     impl<
                         T: DocumentDataService,
-                    > tonic::server::UnaryService<super::SaveGeneratedPrintJsonRequest>
+                    > tonic::server::UnaryService<super::SaveDocumentRequest>
-                    for SaveGeneratedPrintJsonSvc<T> {
+                    for SaveDocumentSvc<T> {
-                        type Response = super::SaveGeneratedPrintJsonResponse;
+                        type Response = super::SaveDocumentResponse;
                         type Future = BoxFuture<
                             tonic::Response<Self::Response>,
                             tonic::Status,
                         >;
                         fn call(
                             &mut self,
-                            request: tonic::Request<super::SaveGeneratedPrintJsonRequest>,
+                            request: tonic::Request<super::SaveDocumentRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as DocumentDataService>::save_generated_print_json(
+                                <T as DocumentDataService>::save_document(&inner, request)
-                                        &inner,
-                                        request,
-                                    )
                                     .await
                             };
                             Box::pin(fut)
@@ -348,7 +516,7 @@ pub mod document_data_service_server {
                     let max_encoding_message_size = self.max_encoding_message_size;
                     let inner = self.inner.clone();
                     let fut = async move {
-                        let method = SaveGeneratedPrintJsonSvc(inner);
+                        let method = SaveDocumentSvc(inner);
                         let codec = tonic_prost::ProstCodec::default();
                         let mut grpc = tonic::server::Grpc::new(codec)
                             .apply_compression_config(
@@ -364,30 +532,163 @@ pub mod document_data_service_server {
                     };
                     Box::pin(fut)
                 }
-                "/komp_ac.document_data.DocumentDataService/SaveUserAdjustedPrintJson" => {
+                "/komp_ac.document_data.DocumentDataService/UpdateDocument" => {
                     #[allow(non_camel_case_types)]
-                    struct SaveUserAdjustedPrintJsonSvc<T: DocumentDataService>(
+                    struct UpdateDocumentSvc<T: DocumentDataService>(pub Arc<T>);
-                        pub Arc<T>,
-                    );
                     impl<
                         T: DocumentDataService,
-                    > tonic::server::UnaryService<
+                    > tonic::server::UnaryService<super::UpdateDocumentRequest>
-                        super::SaveUserAdjustedPrintJsonRequest,
+                    for UpdateDocumentSvc<T> {
-                    > for SaveUserAdjustedPrintJsonSvc<T> {
+                        type Response = super::UpdateDocumentResponse;
-                        type Response = super::SaveUserAdjustedPrintJsonResponse;
                         type Future = BoxFuture<
                             tonic::Response<Self::Response>,
                             tonic::Status,
                         >;
                         fn call(
                             &mut self,
-                            request: tonic::Request<
+                            request: tonic::Request<super::UpdateDocumentRequest>,
-                                super::SaveUserAdjustedPrintJsonRequest,
-                            >,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as DocumentDataService>::save_user_adjusted_print_json(
+                                <T as DocumentDataService>::update_document(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = UpdateDocumentSvc(inner);
+                        let codec = tonic_prost::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/komp_ac.document_data.DocumentDataService/GetDocuments" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetDocumentsSvc<T: DocumentDataService>(pub Arc<T>);
+                    impl<
+                        T: DocumentDataService,
+                    > tonic::server::UnaryService<super::GetDocumentsRequest>
+                    for GetDocumentsSvc<T> {
+                        type Response = super::GetDocumentsResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetDocumentsRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as DocumentDataService>::get_documents(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetDocumentsSvc(inner);
+                        let codec = tonic_prost::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/komp_ac.document_data.DocumentDataService/GetDocument" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetDocumentSvc<T: DocumentDataService>(pub Arc<T>);
+                    impl<
+                        T: DocumentDataService,
+                    > tonic::server::UnaryService<super::GetDocumentRequest>
+                    for GetDocumentSvc<T> {
+                        type Response = super::GetDocumentResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetDocumentRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as DocumentDataService>::get_document(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetDocumentSvc(inner);
+                        let codec = tonic_prost::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/komp_ac.document_data.DocumentDataService/GetDocumentVersion" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetDocumentVersionSvc<T: DocumentDataService>(pub Arc<T>);
+                    impl<
+                        T: DocumentDataService,
+                    > tonic::server::UnaryService<super::GetDocumentVersionRequest>
+                    for GetDocumentVersionSvc<T> {
+                        type Response = super::GetDocumentVersionResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetDocumentVersionRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as DocumentDataService>::get_document_version(
                                         &inner,
                                         request,
                                     )
@@ -402,7 +703,7 @@ pub mod document_data_service_server {
                     let max_encoding_message_size = self.max_encoding_message_size;
                     let inner = self.inner.clone();
                     let fut = async move {
-                        let method = SaveUserAdjustedPrintJsonSvc(inner);
+                        let method = GetDocumentVersionSvc(inner);
                         let codec = tonic_prost::ProstCodec::default();
                         let mut grpc = tonic::server::Grpc::new(codec)
                             .apply_compression_config(