serialization of the gRPC JSONB now fully works for the validation

Cargo.lock

@@ -595,8 +595,8 @@ dependencies = [
  "dotenvy",
  "futures",
  "lazy_static",
- "prost",
+ "prost 0.13.5",
- "prost-types",
+ "prost-types 0.13.5",
  "ratatui",
  "rstest",
  "serde",
@@ -637,9 +637,11 @@ dependencies = [
 name = "common"
 version = "0.5.0"
 dependencies = [
- "prost",
+ "prost 0.13.5",
- "prost-types",
+ "prost-build 0.14.1",
+ "prost-types 0.13.5",
  "serde",
+ "serde_json",
  "tantivy",
  "tonic",
  "tonic-build",
@@ -2504,7 +2506,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2796faa41db3ec313a31f7624d9286acf277b52de526150b7e69f3debf891ee5"
 dependencies = [
  "bytes",
- "prost-derive",
+ "prost-derive 0.13.5",
+]
+
+[[package]]
+name = "prost"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7231bd9b3d3d33c86b58adbac74b5ec0ad9f496b19d22801d773636feaa95f3d"
+dependencies = [
+ "bytes",
+ "prost-derive 0.14.1",
 ]
 
 [[package]]
@@ -2520,8 +2532,28 @@ dependencies = [
  "once_cell",
  "petgraph",
  "prettyplease",
- "prost",
+ "prost 0.13.5",
- "prost-types",
+ "prost-types 0.13.5",
+ "regex",
+ "syn 2.0.104",
+ "tempfile",
+]
+
+[[package]]
+name = "prost-build"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac6c3320f9abac597dcbc668774ef006702672474aad53c6d596b62e487b40b1"
+dependencies = [
+ "heck",
+ "itertools 0.14.0",
+ "log",
+ "multimap",
+ "once_cell",
+ "petgraph",
+ "prettyplease",
+ "prost 0.14.1",
+ "prost-types 0.14.1",
  "regex",
  "syn 2.0.104",
  "tempfile",
@@ -2540,13 +2572,35 @@ dependencies = [
  "syn 2.0.104",
 ]
 
+[[package]]
+name = "prost-derive"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9120690fafc389a67ba3803df527d0ec9cbbc9cc45e4cc20b332996dfb672425"
+dependencies = [
+ "anyhow",
+ "itertools 0.14.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.104",
+]
+
 [[package]]
 name = "prost-types"
 version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "52c2c1bf36ddb1a1c396b3601a3cec27c2462e45f07c386894ec3ccf5332bd16"
 dependencies = [
- "prost",
+ "prost 0.13.5",
+]
+
+[[package]]
+name = "prost-types"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9b4db3d6da204ed77bb26ba83b6122a73aeb2e87e25fbf7ad2e84c4ccbf8f72"
+dependencies = [
+ "prost 0.14.1",
 ]
 
 [[package]]
@@ -3050,7 +3104,7 @@ version = "0.5.0"
 dependencies = [
  "anyhow",
  "common",
- "prost",
+ "prost 0.13.5",
  "serde",
  "serde_json",
  "sqlx",
@@ -3156,8 +3210,9 @@ dependencies = [
  "futures",
  "jsonwebtoken",
  "lazy_static",
- "prost",
+ "prost 0.13.5",
- "prost-types",
+ "prost-build 0.14.1",
+ "prost-types 0.13.5",
  "rand 0.9.2",
  "regex",
  "rstest",
@@ -4193,7 +4248,7 @@ dependencies = [
  "hyper-util",
  "percent-encoding",
  "pin-project",
- "prost",
+ "prost 0.13.5",
  "socket2 0.5.10",
  "tokio",
  "tokio-stream",
@@ -4211,8 +4266,8 @@ checksum = "eac6f67be712d12f0b41328db3137e0d0757645d8904b4cb7d51cd9c2279e847"
 dependencies = [
  "prettyplease",
  "proc-macro2",
- "prost-build",
+ "prost-build 0.13.5",
- "prost-types",
+ "prost-types 0.13.5",
  "quote",
  "syn 2.0.104",
 ]
@@ -4223,8 +4278,8 @@ version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f9687bd5bfeafebdded2356950f278bba8226f0b32109537c4253406e09aafe1"
 dependencies = [
- "prost",
+ "prost 0.13.5",
- "prost-types",
+ "prost-types 0.13.5",
  "tokio",
  "tokio-stream",
  "tonic",

client/Cargo.toml

@@ -8,7 +8,7 @@ license.workspace = true
 anyhow = { workspace = true }
 async-trait = "0.1.88"
 common = { path = "../common" }
-canvas = { path = "../canvas", features = ["gui", "suggestions", "cursor-style", "keymap"] }
+canvas = { path = "../canvas", features = ["gui", "suggestions", "cursor-style", "keymap", "validation"] }
 
 ratatui = { workspace = true }
 crossterm = { workspace = true }
@@ -30,8 +30,9 @@ unicode-segmentation = "1.12.0"
 unicode-width.workspace = true
 
 [features]
-default = []
+default = ["validation"]
 ui-debug = []
+validation = []
 
 [dev-dependencies]
 rstest = "0.25.0"

client/src/pages/forms/state.rs

@@ -1,6 +1,10 @@
 // src/pages/forms/state.rs
 
 use canvas::{DataProvider, AppMode};
+#[cfg(feature = "validation")]
+use canvas::{CharacterLimits, ValidationConfig, ValidationConfigBuilder};
+#[cfg(feature = "validation")]
+use canvas::validation::limits::CountMode;
 use common::proto::komp_ac::search::search_response::Hit;
 use std::collections::HashMap;
 
@@ -39,6 +43,18 @@ pub struct FormState {
     pub autocomplete_loading: bool,
     pub link_display_map: HashMap<usize, String>,
     pub app_mode: AppMode,
+    // Validation 1 (character limits) per field. None = no validation for that field.
+    // Leave room for future rules (patterns, masks, etc.).
+    pub char_limits: Vec<Option<CharLimitsRule>>,
+}
+
+#[cfg(feature = "validation")]
+#[derive(Debug, Clone)]
+pub struct CharLimitsRule {
+    pub min: Option<usize>,
+    pub max: Option<usize>,
+    pub warn_at: Option<usize>,
+    pub count_mode: CountMode,
 }
 
 impl FormState {
@@ -56,6 +72,7 @@ impl FormState {
         fields: Vec<FieldDefinition>,
     ) -> Self {
         let values = vec![String::new(); fields.len()];
+        let len = values.len();
         FormState {
             id: 0,
             profile_name,
@@ -73,6 +90,7 @@ impl FormState {
             autocomplete_loading: false,
             link_display_map: HashMap::new(),
             app_mode: canvas::AppMode::Edit,
+            char_limits: vec![None; len],
         }
     }
 
@@ -256,6 +274,24 @@ impl FormState {
     pub fn set_current_cursor_pos(&mut self, pos: usize) {
         self.current_cursor_pos = pos;
     }
+
+    #[cfg(feature = "validation")]
+    pub fn set_character_limits_rules(
+        &mut self,
+        rules: Vec<Option<CharLimitsRule>>,
+    ) {
+        if rules.len() == self.fields.len() {
+            self.char_limits = rules;
+        } else {
+            tracing::warn!(
+                "Character limits count {} != field count {} for {}.{}",
+                rules.len(),
+                self.fields.len(),
+                self.profile_name,
+                self.table_name
+            );
+        }
+    }
 }
 
 // Step 2: Implement DataProvider for FormState
@@ -282,4 +318,26 @@ impl DataProvider for FormState {
     fn supports_suggestions(&self, field_index: usize) -> bool {
         self.fields.get(field_index).map(|f| f.is_link).unwrap_or(false)
     }
+
+    // Validation 1: Provide character-limit-based validation to canvas
+    // Only compiled when the "validation" feature is enabled on canvas.
+    #[cfg(feature = "validation")]
+    fn validation_config(&self, index: usize) -> Option<ValidationConfig> {
+        let rule = self.char_limits.get(index)?.as_ref()?;
+        let mut limits = match (rule.min, rule.max) {
+            (Some(min), Some(max)) => CharacterLimits::new_range(min, max),
+            (None, Some(max)) => CharacterLimits::new(max),
+            (Some(min), None) => CharacterLimits::new_range(min, usize::MAX),
+            (None, None) => CharacterLimits::new(usize::MAX),
+        };
+        limits = limits.with_count_mode(rule.count_mode);
+        if let Some(warn) = rule.warn_at {
+            limits = limits.with_warning_threshold(warn);
+        }
+        Some(
+            ValidationConfigBuilder::new()
+                .with_character_limits(limits)
+                .build(),
+        )
+    }
 }

client/src/services/grpc_client.rs

@@ -26,6 +26,14 @@ use common::proto::komp_ac::tables_data::{
 };
 use crate::search::SearchGrpc;
 use common::proto::komp_ac::search::SearchResponse;
+use common::proto::komp_ac::table_validation::{
+    table_validation_service_client::TableValidationServiceClient,
+    GetTableValidationRequest,
+    TableValidationResponse,
+    CountMode as PbCountMode,
+    FieldValidation as PbFieldValidation,
+    CharacterLimits as PbCharacterLimits,
+};
 use anyhow::{Context, Result};
 use std::collections::HashMap;
 use tonic::transport::{Channel, Endpoint};
@@ -40,6 +48,7 @@ pub struct GrpcClient {
     table_script_client: TableScriptClient<Channel>,
     tables_data_client: TablesDataClient<Channel>,
     search_client: SearchGrpc,
+    table_validation_client: TableValidationServiceClient<Channel>,
 }
 
 impl GrpcClient {
@@ -63,6 +72,8 @@ impl GrpcClient {
         let table_script_client = TableScriptClient::new(channel.clone());
         let tables_data_client = TablesDataClient::new(channel.clone());
         let search_client = SearchGrpc::new(channel.clone());
+        let table_validation_client =
+            TableValidationServiceClient::new(channel.clone());
 
         Ok(Self {
             channel,
@@ -71,6 +82,7 @@ impl GrpcClient {
             table_script_client,
             tables_data_client,
             search_client,
+            table_validation_client,
         })
     }
 
@@ -79,6 +91,24 @@ impl GrpcClient {
         self.channel.clone()
     }
 
+    // Fetch validation rules for a table. Absence of a field in response = no validation.
+    pub async fn get_table_validation(
+        &mut self,
+        profile_name: String,
+        table_name: String,
+    ) -> Result<TableValidationResponse> {
+        let req = GetTableValidationRequest {
+            profile_name,
+            table_name,
+        };
+        let resp = self
+            .table_validation_client
+            .get_table_validation(tonic::Request::new(req))
+            .await
+            .context("gRPC GetTableValidation call failed")?;
+        Ok(resp.into_inner())
+    }
+
     pub async fn get_table_structure(
         &mut self,
         profile_name: String,

client/src/services/ui_service.rs

@@ -6,6 +6,8 @@ use crate::pages::admin_panel::add_logic::state::AddLogicState;
 use crate::pages::forms::logic::SaveOutcome;
 use crate::utils::columns::filter_user_columns;
 use crate::pages::forms::{FieldDefinition, FormState};
+use common::proto::komp_ac::table_validation::CountMode as PbCountMode;
+use canvas::validation::limits::CountMode;
 use anyhow::{anyhow, Context, Result};
 use std::sync::Arc;
 
@@ -314,4 +316,60 @@ impl UiService {
         }
         Ok(())
     }
+
+    /// Fetch and apply "Validation 1" (character limits) rules for this form.
+    pub async fn apply_validation1_for_form(
+        grpc_client: &mut GrpcClient,
+        app_state: &mut AppState,
+        path: &str,
+    ) -> Result<()> {
+        let (profile, table) = path
+            .split_once('/')
+            .context("Invalid form path for validation")?;
+
+        let resp = grpc_client
+            .get_table_validation(profile.to_string(), table.to_string())
+            .await
+            .context("Failed to fetch table validation")?;
+
+        if let Some(fs) = app_state.form_state_for_path(path) {
+            let mut rules: Vec<Option<crate::pages::forms::state::CharLimitsRule>> =
+                vec![None; fs.fields.len()];
+
+            for f in resp.fields {
+                if let Some(idx) = fs.fields.iter().position(|fd| fd.data_key == f.data_key) {
+                    if let Some(limits) = f.limits {
+                        let has_any =
+                            limits.min != 0 || limits.max != 0 || limits.warn_at.is_some();
+                        if has_any {
+                            let cm = match PbCountMode::from_i32(limits.count_mode) {
+                                Some(PbCountMode::Unspecified) | None => CountMode::Characters, // protobuf default → fallback
+                                Some(PbCountMode::Chars) => CountMode::Characters,
+                                Some(PbCountMode::Bytes) => CountMode::Bytes,
+                                Some(PbCountMode::DisplayWidth) => CountMode::DisplayWidth,
+                            };
+
+                            let min = if limits.min == 0 { None } else { Some(limits.min as usize) };
+                            let max = if limits.max == 0 { None } else { Some(limits.max as usize) };
+                            let warn_at = limits.warn_at.map(|w| w as usize);
+
+                            rules[idx] = Some(crate::pages::forms::state::CharLimitsRule {
+                                min,
+                                max,
+                                warn_at,
+                                count_mode: cm,
+                            });
+                        }
+                    }
+                }
+            }
+            fs.set_character_limits_rules(rules);
+        }
+
+        if let Some(editor) = app_state.editor_for_path(path) {
+            editor.set_validation_enabled(true);
+        }
+
+        Ok(())
+    }
 }

client/src/ui/handlers/ui.rs

@@ -123,6 +123,10 @@ pub async fn run_ui() -> Result<()> {
     app_state.ensure_form_editor(&path, &config, || {
         FormState::new(initial_profile.clone(), initial_table.clone(), initial_field_defs)
     });
+    #[cfg(feature = "validation")]
+    UiService::apply_validation1_for_form(&mut grpc_client, &mut app_state, &path)
+        .await
+        .ok();
     buffer_state.update_history(AppView::Form(path.clone()));
     router.navigate(Page::Form(path.clone()));
 
@@ -516,6 +520,21 @@ pub async fn run_ui() -> Result<()> {
                             prev_view_profile_name = current_view_profile;
                             prev_view_table_name = current_view_table;
                             table_just_switched = true;
+                            // Apply character-limit validation for the new form
+                            #[cfg(feature = "validation")]
+                            if let (Some(prof), Some(tbl)) = (
+                                app_state.current_view_profile_name.as_ref(),
+                                app_state.current_view_table_name.as_ref(),
+                            ) {
+                                let p = format!("{}/{}", prof, tbl);
+                                UiService::apply_validation1_for_form(
+                                    &mut grpc_client,
+                                    &mut app_state,
+                                    &p,
+                                )
+                                    .await
+                                    .ok();
+                            }
                         }
                         Err(e) => {
                             app_state.update_dialog_content(

common/Cargo.toml

@@ -13,6 +13,8 @@ serde = { version = "1.0.219", features = ["derive"] }
 
 # Search
 tantivy = { workspace = true }
+serde_json.workspace = true
 
 [build-dependencies]
-tonic-build = "0.13.0"
+tonic-build = { version = "0.13.0", features = ["prost-build"] }
+prost-build = "0.14.1"

common/build.rs

@@ -1,21 +1,47 @@
-// common/build.rs
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     tonic_build::configure()
         .build_server(true)
-        .out_dir("src/proto")
         .file_descriptor_set_path("src/proto/descriptor.bin")
-        .compile_protos( // Changed from .compile()
+        .out_dir("src/proto")
+        // Derive serde for the messages
+        .type_attribute(
+            ".komp_ac.table_validation.FieldValidation",
+            "#[derive(serde::Serialize, serde::Deserialize)]",
+        )
+        .type_attribute(
+            ".komp_ac.table_validation.CharacterLimits",
+            "#[derive(serde::Serialize, serde::Deserialize)]",
+        )
+        .type_attribute(
+            ".komp_ac.table_validation.TableValidationResponse",
+            "#[derive(serde::Serialize, serde::Deserialize)]",
+        )
+        .type_attribute(
+            ".komp_ac.table_validation.UpdateFieldValidationRequest",
+            "#[derive(serde::Serialize, serde::Deserialize)]",
+        )
+        .type_attribute(
+            ".komp_ac.table_validation.UpdateFieldValidationResponse",
+            "#[derive(serde::Serialize, serde::Deserialize)]",
+        )
+        // Enum -> readable strings in JSON ("BYTES", "DISPLAY_WIDTH")
+        .type_attribute(
+            ".komp_ac.table_validation.CountMode",
+            "#[derive(serde::Serialize, serde::Deserialize)] #[serde(rename_all = \"SCREAMING_SNAKE_CASE\")]",
+        )
+        .compile_protos(
             &[
                 "proto/common.proto",
                 "proto/adresar.proto",
                 "proto/auth.proto",
-                "proto/uctovnictvo.proto",
-                "proto/table_structure.proto",
-                "proto/table_definition.proto",
-                "proto/tables_data.proto",
-                "proto/table_script.proto",
                 "proto/search.proto",
                 "proto/search2.proto",
+                "proto/table_definition.proto",
+                "proto/table_script.proto",
+                "proto/table_structure.proto",
+                "proto/table_validation.proto",
+                "proto/tables_data.proto",
+                "proto/uctovnictvo.proto",
             ],
             &["proto"],
         )?;

common/proto/table_validation.proto

@@ -0,0 +1,71 @@
+// common/proto/table_validation.proto
+syntax = "proto3";
+package komp_ac.table_validation;
+
+// Request validation rules for a table
+message GetTableValidationRequest {
+  string profileName = 1;
+  string tableName = 2;
+}
+
+// Response with field-level validations; if a field is omitted,
+// no validation is applied (default unspecified).
+message TableValidationResponse {
+  repeated FieldValidation fields = 1;
+}
+
+// Field-level validation (extensible for future kinds)
+message FieldValidation {
+  // MUST match your frontend FormState.dataKey for the column
+  string dataKey = 1;
+
+  // Current: only CharacterLimits. More rules can be added later.
+  CharacterLimits limits = 10;
+  // Future expansion:
+  // PatternRules pattern = 11;
+  // DisplayMask mask = 12;
+  // ExternalValidation external = 13;
+  // CustomFormatter formatter = 14;
+}
+
+// Character length counting mode
+enum CountMode {
+  COUNT_MODE_UNSPECIFIED = 0; // default: same as CHARS
+  CHARS = 1;
+  BYTES = 2;
+  DISPLAY_WIDTH = 3;
+}
+
+// Character limit validation (Validation 1)
+message CharacterLimits {
+  // When zero, the field is considered "not set". If both min/max are zero,
+  // the server should avoid sending this FieldValidation (no validation).
+  uint32 min = 1;
+  uint32 max = 2;
+
+  // Optional warning threshold; when unset, no warning threshold is applied.
+  optional uint32 warnAt = 3;
+
+  CountMode countMode = 4; // defaults to CHARS if unspecified
+}
+
+// Service to fetch validations for a table
+service TableValidationService {
+  rpc GetTableValidation(GetTableValidationRequest)
+      returns (TableValidationResponse);
+
+  rpc UpdateFieldValidation(UpdateFieldValidationRequest)
+      returns (UpdateFieldValidationResponse);
+}
+
+message UpdateFieldValidationRequest {
+  string profileName = 1;
+  string tableName = 2;
+  string dataKey = 3;
+  FieldValidation validation = 4;
+}
+
+message UpdateFieldValidationResponse {
+  bool success = 1;
+  string message = 2;
+}

common/src/lib.rs

@@ -34,6 +34,9 @@ pub mod proto {
         pub mod search2 {
             include!("proto/komp_ac.search2.rs");
         }
+        pub mod table_validation {
+            include!("proto/komp_ac.table_validation.rs");
+        }
         pub const FILE_DESCRIPTOR_SET: &[u8] =
             include_bytes!("proto/descriptor.bin");
     }

common/src/proto/komp_ac.table_validation.rs

@@ -1,78 +1,112 @@
 // This file is @generated by prost-build.
+/// Request validation rules for a table
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct TableLink {
+pub struct GetTableValidationRequest {
     #[prost(string, tag = "1")]
-    pub linked_table_name: ::prost::alloc::string::String,
-    #[prost(bool, tag = "2")]
-    pub required: bool,
-}
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PostTableDefinitionRequest {
-    #[prost(string, tag = "1")]
-    pub table_name: ::prost::alloc::string::String,
-    #[prost(message, repeated, tag = "2")]
-    pub links: ::prost::alloc::vec::Vec<TableLink>,
-    #[prost(message, repeated, tag = "3")]
-    pub columns: ::prost::alloc::vec::Vec<ColumnDefinition>,
-    #[prost(string, repeated, tag = "4")]
-    pub indexes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
-    #[prost(string, tag = "5")]
     pub profile_name: ::prost::alloc::string::String,
-}
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ColumnDefinition {
-    #[prost(string, tag = "1")]
-    pub name: ::prost::alloc::string::String,
     #[prost(string, tag = "2")]
-    pub field_type: ::prost::alloc::string::String,
+    pub table_name: ::prost::alloc::string::String,
 }
+/// Response with field-level validations; if a field is omitted,
+/// no validation is applied (default unspecified).
+#[derive(serde::Serialize, serde::Deserialize)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct TableDefinitionResponse {
+pub struct TableValidationResponse {
-    #[prost(bool, tag = "1")]
-    pub success: bool,
-    #[prost(string, tag = "2")]
-    pub sql: ::prost::alloc::string::String,
-}
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ProfileTreeResponse {
     #[prost(message, repeated, tag = "1")]
-    pub profiles: ::prost::alloc::vec::Vec<profile_tree_response::Profile>,
+    pub fields: ::prost::alloc::vec::Vec<FieldValidation>,
-}
-/// Nested message and enum types in `ProfileTreeResponse`.
-pub mod profile_tree_response {
-    #[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct Table {
-        #[prost(int64, tag = "1")]
-        pub id: i64,
-        #[prost(string, tag = "2")]
-        pub name: ::prost::alloc::string::String,
-        #[prost(string, repeated, tag = "3")]
-        pub depends_on: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
-    }
-    #[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct Profile {
-        #[prost(string, tag = "1")]
-        pub name: ::prost::alloc::string::String,
-        #[prost(message, repeated, tag = "2")]
-        pub tables: ::prost::alloc::vec::Vec<Table>,
-    }
 }
+/// Field-level validation (extensible for future kinds)
+#[derive(serde::Serialize, serde::Deserialize)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct DeleteTableRequest {
+pub struct FieldValidation {
+    /// MUST match your frontend FormState.dataKey for the column
+    #[prost(string, tag = "1")]
+    pub data_key: ::prost::alloc::string::String,
+    /// Current: only CharacterLimits. More rules can be added later.
+    ///
+    /// Future expansion:
+    /// PatternRules pattern = 11;
+    /// DisplayMask mask = 12;
+    /// ExternalValidation external = 13;
+    /// CustomFormatter formatter = 14;
+    #[prost(message, optional, tag = "10")]
+    pub limits: ::core::option::Option<CharacterLimits>,
+}
+/// Character limit validation (Validation 1)
+#[derive(serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct CharacterLimits {
+    /// When zero, the field is considered "not set". If both min/max are zero,
+    /// the server should avoid sending this FieldValidation (no validation).
+    #[prost(uint32, tag = "1")]
+    pub min: u32,
+    #[prost(uint32, tag = "2")]
+    pub max: u32,
+    /// Optional warning threshold; when unset, no warning threshold is applied.
+    #[prost(uint32, optional, tag = "3")]
+    pub warn_at: ::core::option::Option<u32>,
+    /// defaults to CHARS if unspecified
+    #[prost(enumeration = "CountMode", tag = "4")]
+    pub count_mode: i32,
+}
+#[derive(serde::Serialize, serde::Deserialize)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct UpdateFieldValidationRequest {
     #[prost(string, tag = "1")]
     pub profile_name: ::prost::alloc::string::String,
     #[prost(string, tag = "2")]
     pub table_name: ::prost::alloc::string::String,
+    #[prost(string, tag = "3")]
+    pub data_key: ::prost::alloc::string::String,
+    #[prost(message, optional, tag = "4")]
+    pub validation: ::core::option::Option<FieldValidation>,
 }
+#[derive(serde::Serialize, serde::Deserialize)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct DeleteTableResponse {
+pub struct UpdateFieldValidationResponse {
     #[prost(bool, tag = "1")]
     pub success: bool,
     #[prost(string, tag = "2")]
     pub message: ::prost::alloc::string::String,
 }
+/// Character length counting mode
+#[derive(serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+#[repr(i32)]
+pub enum CountMode {
+    /// default: same as CHARS
+    Unspecified = 0,
+    Chars = 1,
+    Bytes = 2,
+    DisplayWidth = 3,
+}
+impl CountMode {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            Self::Unspecified => "COUNT_MODE_UNSPECIFIED",
+            Self::Chars => "CHARS",
+            Self::Bytes => "BYTES",
+            Self::DisplayWidth => "DISPLAY_WIDTH",
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "COUNT_MODE_UNSPECIFIED" => Some(Self::Unspecified),
+            "CHARS" => Some(Self::Chars),
+            "BYTES" => Some(Self::Bytes),
+            "DISPLAY_WIDTH" => Some(Self::DisplayWidth),
+            _ => None,
+        }
+    }
+}
 /// Generated client implementations.
-pub mod table_definition_client {
+pub mod table_validation_service_client {
     #![allow(
         unused_variables,
         dead_code,
@@ -82,11 +116,12 @@ pub mod table_definition_client {
     )]
     use tonic::codegen::*;
     use tonic::codegen::http::Uri;
+    /// Service to fetch validations for a table
     #[derive(Debug, Clone)]
-    pub struct TableDefinitionClient<T> {
+    pub struct TableValidationServiceClient<T> {
         inner: tonic::client::Grpc<T>,
     }
-    impl TableDefinitionClient<tonic::transport::Channel> {
+    impl TableValidationServiceClient<tonic::transport::Channel> {
         /// Attempt to create a new client by connecting to a given endpoint.
         pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
         where
@@ -97,7 +132,7 @@ pub mod table_definition_client {
             Ok(Self::new(conn))
         }
     }
-    impl<T> TableDefinitionClient<T>
+    impl<T> TableValidationServiceClient<T>
     where
         T: tonic::client::GrpcService<tonic::body::Body>,
         T::Error: Into<StdError>,
@@ -115,7 +150,7 @@ pub mod table_definition_client {
         pub fn with_interceptor<F>(
             inner: T,
             interceptor: F,
-        ) -> TableDefinitionClient<InterceptedService<T, F>>
+        ) -> TableValidationServiceClient<InterceptedService<T, F>>
         where
             F: tonic::service::Interceptor,
             T::ResponseBody: Default,
@@ -129,7 +164,9 @@ pub mod table_definition_client {
                 http::Request<tonic::body::Body>,
             >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
         {
-            TableDefinitionClient::new(InterceptedService::new(inner, interceptor))
+            TableValidationServiceClient::new(
+                InterceptedService::new(inner, interceptor),
+            )
         }
         /// Compress requests with the given encoding.
         ///
@@ -162,11 +199,11 @@ pub mod table_definition_client {
             self.inner = self.inner.max_encoding_message_size(limit);
             self
         }
-        pub async fn post_table_definition(
+        pub async fn get_table_validation(
             &mut self,
-            request: impl tonic::IntoRequest<super::PostTableDefinitionRequest>,
+            request: impl tonic::IntoRequest<super::GetTableValidationRequest>,
         ) -> std::result::Result<
-            tonic::Response<super::TableDefinitionResponse>,
+            tonic::Response<super::TableValidationResponse>,
             tonic::Status,
         > {
             self.inner
@@ -179,23 +216,23 @@ pub mod table_definition_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.table_definition.TableDefinition/PostTableDefinition",
+                "/komp_ac.table_validation.TableValidationService/GetTableValidation",
             );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(
                     GrpcMethod::new(
-                        "komp_ac.table_definition.TableDefinition",
+                        "komp_ac.table_validation.TableValidationService",
-                        "PostTableDefinition",
+                        "GetTableValidation",
                     ),
                 );
             self.inner.unary(req, path, codec).await
         }
-        pub async fn get_profile_tree(
+        pub async fn update_field_validation(
             &mut self,
-            request: impl tonic::IntoRequest<super::super::common::Empty>,
+            request: impl tonic::IntoRequest<super::UpdateFieldValidationRequest>,
         ) -> std::result::Result<
-            tonic::Response<super::ProfileTreeResponse>,
+            tonic::Response<super::UpdateFieldValidationResponse>,
             tonic::Status,
         > {
             self.inner
@@ -208,43 +245,14 @@ pub mod table_definition_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.table_definition.TableDefinition/GetProfileTree",
+                "/komp_ac.table_validation.TableValidationService/UpdateFieldValidation",
             );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(
                     GrpcMethod::new(
-                        "komp_ac.table_definition.TableDefinition",
+                        "komp_ac.table_validation.TableValidationService",
-                        "GetProfileTree",
+                        "UpdateFieldValidation",
-                    ),
-                );
-            self.inner.unary(req, path, codec).await
-        }
-        pub async fn delete_table(
-            &mut self,
-            request: impl tonic::IntoRequest<super::DeleteTableRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::DeleteTableResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.table_definition.TableDefinition/DeleteTable",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "komp_ac.table_definition.TableDefinition",
-                        "DeleteTable",
                     ),
                 );
             self.inner.unary(req, path, codec).await
@@ -252,7 +260,7 @@ pub mod table_definition_client {
     }
 }
 /// Generated server implementations.
-pub mod table_definition_server {
+pub mod table_validation_service_server {
     #![allow(
         unused_variables,
         dead_code,
@@ -261,40 +269,34 @@ pub mod table_definition_server {
         clippy::let_unit_value,
     )]
     use tonic::codegen::*;
-    /// Generated trait containing gRPC methods that should be implemented for use with TableDefinitionServer.
+    /// Generated trait containing gRPC methods that should be implemented for use with TableValidationServiceServer.
     #[async_trait]
-    pub trait TableDefinition: std::marker::Send + std::marker::Sync + 'static {
+    pub trait TableValidationService: std::marker::Send + std::marker::Sync + 'static {
-        async fn post_table_definition(
+        async fn get_table_validation(
             &self,
-            request: tonic::Request<super::PostTableDefinitionRequest>,
+            request: tonic::Request<super::GetTableValidationRequest>,
         ) -> std::result::Result<
-            tonic::Response<super::TableDefinitionResponse>,
+            tonic::Response<super::TableValidationResponse>,
             tonic::Status,
         >;
-        async fn get_profile_tree(
+        async fn update_field_validation(
             &self,
-            request: tonic::Request<super::super::common::Empty>,
+            request: tonic::Request<super::UpdateFieldValidationRequest>,
         ) -> std::result::Result<
-            tonic::Response<super::ProfileTreeResponse>,
+            tonic::Response<super::UpdateFieldValidationResponse>,
-            tonic::Status,
-        >;
-        async fn delete_table(
-            &self,
-            request: tonic::Request<super::DeleteTableRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::DeleteTableResponse>,
             tonic::Status,
         >;
     }
+    /// Service to fetch validations for a table
     #[derive(Debug)]
-    pub struct TableDefinitionServer<T> {
+    pub struct TableValidationServiceServer<T> {
         inner: Arc<T>,
         accept_compression_encodings: EnabledCompressionEncodings,
         send_compression_encodings: EnabledCompressionEncodings,
         max_decoding_message_size: Option<usize>,
         max_encoding_message_size: Option<usize>,
     }
-    impl<T> TableDefinitionServer<T> {
+    impl<T> TableValidationServiceServer<T> {
         pub fn new(inner: T) -> Self {
             Self::from_arc(Arc::new(inner))
         }
@@ -345,9 +347,10 @@ pub mod table_definition_server {
             self
         }
     }
-    impl<T, B> tonic::codegen::Service<http::Request<B>> for TableDefinitionServer<T>
+    impl<T, B> tonic::codegen::Service<http::Request<B>>
+    for TableValidationServiceServer<T>
     where
-        T: TableDefinition,
+        T: TableValidationService,
         B: Body + std::marker::Send + 'static,
         B::Error: Into<StdError> + std::marker::Send + 'static,
     {
@@ -362,25 +365,25 @@ pub mod table_definition_server {
         }
         fn call(&mut self, req: http::Request<B>) -> Self::Future {
             match req.uri().path() {
-                "/komp_ac.table_definition.TableDefinition/PostTableDefinition" => {
+                "/komp_ac.table_validation.TableValidationService/GetTableValidation" => {
                     #[allow(non_camel_case_types)]
-                    struct PostTableDefinitionSvc<T: TableDefinition>(pub Arc<T>);
+                    struct GetTableValidationSvc<T: TableValidationService>(pub Arc<T>);
                     impl<
-                        T: TableDefinition,
+                        T: TableValidationService,
-                    > tonic::server::UnaryService<super::PostTableDefinitionRequest>
+                    > tonic::server::UnaryService<super::GetTableValidationRequest>
-                    for PostTableDefinitionSvc<T> {
+                    for GetTableValidationSvc<T> {
-                        type Response = super::TableDefinitionResponse;
+                        type Response = super::TableValidationResponse;
                         type Future = BoxFuture<
                             tonic::Response<Self::Response>,
                             tonic::Status,
                         >;
                         fn call(
                             &mut self,
-                            request: tonic::Request<super::PostTableDefinitionRequest>,
+                            request: tonic::Request<super::GetTableValidationRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as TableDefinition>::post_table_definition(
+                                <T as TableValidationService>::get_table_validation(
                                         &inner,
                                         request,
                                     )
@@ -395,7 +398,7 @@ pub mod table_definition_server {
                     let max_encoding_message_size = self.max_encoding_message_size;
                     let inner = self.inner.clone();
                     let fut = async move {
-                        let method = PostTableDefinitionSvc(inner);
+                        let method = GetTableValidationSvc(inner);
                         let codec = tonic::codec::ProstCodec::default();
                         let mut grpc = tonic::server::Grpc::new(codec)
                             .apply_compression_config(
@@ -411,25 +414,30 @@ pub mod table_definition_server {
                     };
                     Box::pin(fut)
                 }
-                "/komp_ac.table_definition.TableDefinition/GetProfileTree" => {
+                "/komp_ac.table_validation.TableValidationService/UpdateFieldValidation" => {
                     #[allow(non_camel_case_types)]
-                    struct GetProfileTreeSvc<T: TableDefinition>(pub Arc<T>);
+                    struct UpdateFieldValidationSvc<T: TableValidationService>(
+                        pub Arc<T>,
+                    );
                     impl<
-                        T: TableDefinition,
+                        T: TableValidationService,
-                    > tonic::server::UnaryService<super::super::common::Empty>
+                    > tonic::server::UnaryService<super::UpdateFieldValidationRequest>
-                    for GetProfileTreeSvc<T> {
+                    for UpdateFieldValidationSvc<T> {
-                        type Response = super::ProfileTreeResponse;
+                        type Response = super::UpdateFieldValidationResponse;
                         type Future = BoxFuture<
                             tonic::Response<Self::Response>,
                             tonic::Status,
                         >;
                         fn call(
                             &mut self,
-                            request: tonic::Request<super::super::common::Empty>,
+                            request: tonic::Request<super::UpdateFieldValidationRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as TableDefinition>::get_profile_tree(&inner, request)
+                                <T as TableValidationService>::update_field_validation(
+                                        &inner,
+                                        request,
+                                    )
                                     .await
                             };
                             Box::pin(fut)
@@ -441,52 +449,7 @@ pub mod table_definition_server {
                     let max_encoding_message_size = self.max_encoding_message_size;
                     let inner = self.inner.clone();
                     let fut = async move {
-                        let method = GetProfileTreeSvc(inner);
+                        let method = UpdateFieldValidationSvc(inner);
-                        let codec = tonic::codec::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.table_definition.TableDefinition/DeleteTable" => {
-                    #[allow(non_camel_case_types)]
-                    struct DeleteTableSvc<T: TableDefinition>(pub Arc<T>);
-                    impl<
-                        T: TableDefinition,
-                    > tonic::server::UnaryService<super::DeleteTableRequest>
-                    for DeleteTableSvc<T> {
-                        type Response = super::DeleteTableResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<super::DeleteTableRequest>,
-                        ) -> Self::Future {
-                            let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as TableDefinition>::delete_table(&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 = DeleteTableSvc(inner);
                         let codec = tonic::codec::ProstCodec::default();
                         let mut grpc = tonic::server::Grpc::new(codec)
                             .apply_compression_config(
@@ -524,7 +487,7 @@ pub mod table_definition_server {
             }
         }
     }
-    impl<T> Clone for TableDefinitionServer<T> {
+    impl<T> Clone for TableValidationServiceServer<T> {
         fn clone(&self) -> Self {
             let inner = self.inner.clone();
             Self {
@@ -537,8 +500,8 @@ pub mod table_definition_server {
         }
     }
     /// Generated gRPC service name
-    pub const SERVICE_NAME: &str = "komp_ac.table_definition.TableDefinition";
+    pub const SERVICE_NAME: &str = "komp_ac.table_validation.TableValidationService";
-    impl<T> tonic::server::NamedService for TableDefinitionServer<T> {
+    impl<T> tonic::server::NamedService for TableValidationServiceServer<T> {
         const NAME: &'static str = SERVICE_NAME;
     }
 }

common/src/proto/multieko2.adresar.rs

@@ -1,791 +0,0 @@
-// This file is @generated by prost-build.
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct GetAdresarRequest {
-    #[prost(int64, tag = "1")]
-    pub id: i64,
-}
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct DeleteAdresarRequest {
-    #[prost(int64, tag = "1")]
-    pub id: i64,
-}
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PostAdresarRequest {
-    #[prost(string, tag = "1")]
-    pub firma: ::prost::alloc::string::String,
-    #[prost(string, tag = "2")]
-    pub kz: ::prost::alloc::string::String,
-    #[prost(string, tag = "3")]
-    pub drc: ::prost::alloc::string::String,
-    #[prost(string, tag = "4")]
-    pub ulica: ::prost::alloc::string::String,
-    #[prost(string, tag = "5")]
-    pub psc: ::prost::alloc::string::String,
-    #[prost(string, tag = "6")]
-    pub mesto: ::prost::alloc::string::String,
-    #[prost(string, tag = "7")]
-    pub stat: ::prost::alloc::string::String,
-    #[prost(string, tag = "8")]
-    pub banka: ::prost::alloc::string::String,
-    #[prost(string, tag = "9")]
-    pub ucet: ::prost::alloc::string::String,
-    #[prost(string, tag = "10")]
-    pub skladm: ::prost::alloc::string::String,
-    #[prost(string, tag = "11")]
-    pub ico: ::prost::alloc::string::String,
-    #[prost(string, tag = "12")]
-    pub kontakt: ::prost::alloc::string::String,
-    #[prost(string, tag = "13")]
-    pub telefon: ::prost::alloc::string::String,
-    #[prost(string, tag = "14")]
-    pub skladu: ::prost::alloc::string::String,
-    #[prost(string, tag = "15")]
-    pub fax: ::prost::alloc::string::String,
-}
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct AdresarResponse {
-    #[prost(int64, tag = "1")]
-    pub id: i64,
-    #[prost(string, tag = "2")]
-    pub firma: ::prost::alloc::string::String,
-    #[prost(string, tag = "3")]
-    pub kz: ::prost::alloc::string::String,
-    #[prost(string, tag = "4")]
-    pub drc: ::prost::alloc::string::String,
-    #[prost(string, tag = "5")]
-    pub ulica: ::prost::alloc::string::String,
-    #[prost(string, tag = "6")]
-    pub psc: ::prost::alloc::string::String,
-    #[prost(string, tag = "7")]
-    pub mesto: ::prost::alloc::string::String,
-    #[prost(string, tag = "8")]
-    pub stat: ::prost::alloc::string::String,
-    #[prost(string, tag = "9")]
-    pub banka: ::prost::alloc::string::String,
-    #[prost(string, tag = "10")]
-    pub ucet: ::prost::alloc::string::String,
-    #[prost(string, tag = "11")]
-    pub skladm: ::prost::alloc::string::String,
-    #[prost(string, tag = "12")]
-    pub ico: ::prost::alloc::string::String,
-    #[prost(string, tag = "13")]
-    pub kontakt: ::prost::alloc::string::String,
-    #[prost(string, tag = "14")]
-    pub telefon: ::prost::alloc::string::String,
-    #[prost(string, tag = "15")]
-    pub skladu: ::prost::alloc::string::String,
-    #[prost(string, tag = "16")]
-    pub fax: ::prost::alloc::string::String,
-}
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PutAdresarRequest {
-    #[prost(int64, tag = "1")]
-    pub id: i64,
-    #[prost(string, tag = "2")]
-    pub firma: ::prost::alloc::string::String,
-    #[prost(string, tag = "3")]
-    pub kz: ::prost::alloc::string::String,
-    #[prost(string, tag = "4")]
-    pub drc: ::prost::alloc::string::String,
-    #[prost(string, tag = "5")]
-    pub ulica: ::prost::alloc::string::String,
-    #[prost(string, tag = "6")]
-    pub psc: ::prost::alloc::string::String,
-    #[prost(string, tag = "7")]
-    pub mesto: ::prost::alloc::string::String,
-    #[prost(string, tag = "8")]
-    pub stat: ::prost::alloc::string::String,
-    #[prost(string, tag = "9")]
-    pub banka: ::prost::alloc::string::String,
-    #[prost(string, tag = "10")]
-    pub ucet: ::prost::alloc::string::String,
-    #[prost(string, tag = "11")]
-    pub skladm: ::prost::alloc::string::String,
-    #[prost(string, tag = "12")]
-    pub ico: ::prost::alloc::string::String,
-    #[prost(string, tag = "13")]
-    pub kontakt: ::prost::alloc::string::String,
-    #[prost(string, tag = "14")]
-    pub telefon: ::prost::alloc::string::String,
-    #[prost(string, tag = "15")]
-    pub skladu: ::prost::alloc::string::String,
-    #[prost(string, tag = "16")]
-    pub fax: ::prost::alloc::string::String,
-}
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct DeleteAdresarResponse {
-    #[prost(bool, tag = "1")]
-    pub success: bool,
-}
-/// Generated client implementations.
-pub mod adresar_client {
-    #![allow(
-        unused_variables,
-        dead_code,
-        missing_docs,
-        clippy::wildcard_imports,
-        clippy::let_unit_value,
-    )]
-    use tonic::codegen::*;
-    use tonic::codegen::http::Uri;
-    #[derive(Debug, Clone)]
-    pub struct AdresarClient<T> {
-        inner: tonic::client::Grpc<T>,
-    }
-    impl AdresarClient<tonic::transport::Channel> {
-        /// Attempt to create a new client by connecting to a given endpoint.
-        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
-        where
-            D: TryInto<tonic::transport::Endpoint>,
-            D::Error: Into<StdError>,
-        {
-            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
-            Ok(Self::new(conn))
-        }
-    }
-    impl<T> AdresarClient<T>
-    where
-        T: tonic::client::GrpcService<tonic::body::Body>,
-        T::Error: Into<StdError>,
-        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
-        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
-    {
-        pub fn new(inner: T) -> Self {
-            let inner = tonic::client::Grpc::new(inner);
-            Self { inner }
-        }
-        pub fn with_origin(inner: T, origin: Uri) -> Self {
-            let inner = tonic::client::Grpc::with_origin(inner, origin);
-            Self { inner }
-        }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> AdresarClient<InterceptedService<T, F>>
-        where
-            F: tonic::service::Interceptor,
-            T::ResponseBody: Default,
-            T: tonic::codegen::Service<
-                http::Request<tonic::body::Body>,
-                Response = http::Response<
-                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
-                >,
-            >,
-            <T as tonic::codegen::Service<
-                http::Request<tonic::body::Body>,
-            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
-        {
-            AdresarClient::new(InterceptedService::new(inner, interceptor))
-        }
-        /// Compress requests with the given encoding.
-        ///
-        /// This requires the server to support it otherwise it might respond with an
-        /// error.
-        #[must_use]
-        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.inner = self.inner.send_compressed(encoding);
-            self
-        }
-        /// Enable decompressing responses.
-        #[must_use]
-        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.inner = self.inner.accept_compressed(encoding);
-            self
-        }
-        /// Limits the maximum size of a decoded message.
-        ///
-        /// Default: `4MB`
-        #[must_use]
-        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
-            self.inner = self.inner.max_decoding_message_size(limit);
-            self
-        }
-        /// Limits the maximum size of an encoded message.
-        ///
-        /// Default: `usize::MAX`
-        #[must_use]
-        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
-            self.inner = self.inner.max_encoding_message_size(limit);
-            self
-        }
-        pub async fn post_adresar(
-            &mut self,
-            request: impl tonic::IntoRequest<super::PostAdresarRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::AdresarResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.adresar.Adresar/PostAdresar",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("komp_ac.adresar.Adresar", "PostAdresar"));
-            self.inner.unary(req, path, codec).await
-        }
-        pub async fn get_adresar(
-            &mut self,
-            request: impl tonic::IntoRequest<super::GetAdresarRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::AdresarResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.adresar.Adresar/GetAdresar",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("komp_ac.adresar.Adresar", "GetAdresar"));
-            self.inner.unary(req, path, codec).await
-        }
-        pub async fn put_adresar(
-            &mut self,
-            request: impl tonic::IntoRequest<super::PutAdresarRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::AdresarResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.adresar.Adresar/PutAdresar",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("komp_ac.adresar.Adresar", "PutAdresar"));
-            self.inner.unary(req, path, codec).await
-        }
-        pub async fn delete_adresar(
-            &mut self,
-            request: impl tonic::IntoRequest<super::DeleteAdresarRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::DeleteAdresarResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.adresar.Adresar/DeleteAdresar",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("komp_ac.adresar.Adresar", "DeleteAdresar"));
-            self.inner.unary(req, path, codec).await
-        }
-        pub async fn get_adresar_count(
-            &mut self,
-            request: impl tonic::IntoRequest<super::super::common::Empty>,
-        ) -> std::result::Result<
-            tonic::Response<super::super::common::CountResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.adresar.Adresar/GetAdresarCount",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("komp_ac.adresar.Adresar", "GetAdresarCount"));
-            self.inner.unary(req, path, codec).await
-        }
-        pub async fn get_adresar_by_position(
-            &mut self,
-            request: impl tonic::IntoRequest<super::super::common::PositionRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::AdresarResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.adresar.Adresar/GetAdresarByPosition",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("komp_ac.adresar.Adresar", "GetAdresarByPosition"),
-                );
-            self.inner.unary(req, path, codec).await
-        }
-    }
-}
-/// Generated server implementations.
-pub mod adresar_server {
-    #![allow(
-        unused_variables,
-        dead_code,
-        missing_docs,
-        clippy::wildcard_imports,
-        clippy::let_unit_value,
-    )]
-    use tonic::codegen::*;
-    /// Generated trait containing gRPC methods that should be implemented for use with AdresarServer.
-    #[async_trait]
-    pub trait Adresar: std::marker::Send + std::marker::Sync + 'static {
-        async fn post_adresar(
-            &self,
-            request: tonic::Request<super::PostAdresarRequest>,
-        ) -> std::result::Result<tonic::Response<super::AdresarResponse>, tonic::Status>;
-        async fn get_adresar(
-            &self,
-            request: tonic::Request<super::GetAdresarRequest>,
-        ) -> std::result::Result<tonic::Response<super::AdresarResponse>, tonic::Status>;
-        async fn put_adresar(
-            &self,
-            request: tonic::Request<super::PutAdresarRequest>,
-        ) -> std::result::Result<tonic::Response<super::AdresarResponse>, tonic::Status>;
-        async fn delete_adresar(
-            &self,
-            request: tonic::Request<super::DeleteAdresarRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::DeleteAdresarResponse>,
-            tonic::Status,
-        >;
-        async fn get_adresar_count(
-            &self,
-            request: tonic::Request<super::super::common::Empty>,
-        ) -> std::result::Result<
-            tonic::Response<super::super::common::CountResponse>,
-            tonic::Status,
-        >;
-        async fn get_adresar_by_position(
-            &self,
-            request: tonic::Request<super::super::common::PositionRequest>,
-        ) -> std::result::Result<tonic::Response<super::AdresarResponse>, tonic::Status>;
-    }
-    #[derive(Debug)]
-    pub struct AdresarServer<T> {
-        inner: Arc<T>,
-        accept_compression_encodings: EnabledCompressionEncodings,
-        send_compression_encodings: EnabledCompressionEncodings,
-        max_decoding_message_size: Option<usize>,
-        max_encoding_message_size: Option<usize>,
-    }
-    impl<T> AdresarServer<T> {
-        pub fn new(inner: T) -> Self {
-            Self::from_arc(Arc::new(inner))
-        }
-        pub fn from_arc(inner: Arc<T>) -> Self {
-            Self {
-                inner,
-                accept_compression_encodings: Default::default(),
-                send_compression_encodings: Default::default(),
-                max_decoding_message_size: None,
-                max_encoding_message_size: None,
-            }
-        }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> InterceptedService<Self, F>
-        where
-            F: tonic::service::Interceptor,
-        {
-            InterceptedService::new(Self::new(inner), interceptor)
-        }
-        /// Enable decompressing requests with the given encoding.
-        #[must_use]
-        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.accept_compression_encodings.enable(encoding);
-            self
-        }
-        /// Compress responses with the given encoding, if the client supports it.
-        #[must_use]
-        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.send_compression_encodings.enable(encoding);
-            self
-        }
-        /// Limits the maximum size of a decoded message.
-        ///
-        /// Default: `4MB`
-        #[must_use]
-        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
-            self.max_decoding_message_size = Some(limit);
-            self
-        }
-        /// Limits the maximum size of an encoded message.
-        ///
-        /// Default: `usize::MAX`
-        #[must_use]
-        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
-            self.max_encoding_message_size = Some(limit);
-            self
-        }
-    }
-    impl<T, B> tonic::codegen::Service<http::Request<B>> for AdresarServer<T>
-    where
-        T: Adresar,
-        B: Body + std::marker::Send + 'static,
-        B::Error: Into<StdError> + std::marker::Send + 'static,
-    {
-        type Response = http::Response<tonic::body::Body>;
-        type Error = std::convert::Infallible;
-        type Future = BoxFuture<Self::Response, Self::Error>;
-        fn poll_ready(
-            &mut self,
-            _cx: &mut Context<'_>,
-        ) -> Poll<std::result::Result<(), Self::Error>> {
-            Poll::Ready(Ok(()))
-        }
-        fn call(&mut self, req: http::Request<B>) -> Self::Future {
-            match req.uri().path() {
-                "/komp_ac.adresar.Adresar/PostAdresar" => {
-                    #[allow(non_camel_case_types)]
-                    struct PostAdresarSvc<T: Adresar>(pub Arc<T>);
-                    impl<
-                        T: Adresar,
-                    > tonic::server::UnaryService<super::PostAdresarRequest>
-                    for PostAdresarSvc<T> {
-                        type Response = super::AdresarResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<super::PostAdresarRequest>,
-                        ) -> Self::Future {
-                            let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as Adresar>::post_adresar(&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 = PostAdresarSvc(inner);
-                        let codec = tonic::codec::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.adresar.Adresar/GetAdresar" => {
-                    #[allow(non_camel_case_types)]
-                    struct GetAdresarSvc<T: Adresar>(pub Arc<T>);
-                    impl<
-                        T: Adresar,
-                    > tonic::server::UnaryService<super::GetAdresarRequest>
-                    for GetAdresarSvc<T> {
-                        type Response = super::AdresarResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<super::GetAdresarRequest>,
-                        ) -> Self::Future {
-                            let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as Adresar>::get_adresar(&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 = GetAdresarSvc(inner);
-                        let codec = tonic::codec::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.adresar.Adresar/PutAdresar" => {
-                    #[allow(non_camel_case_types)]
-                    struct PutAdresarSvc<T: Adresar>(pub Arc<T>);
-                    impl<
-                        T: Adresar,
-                    > tonic::server::UnaryService<super::PutAdresarRequest>
-                    for PutAdresarSvc<T> {
-                        type Response = super::AdresarResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<super::PutAdresarRequest>,
-                        ) -> Self::Future {
-                            let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as Adresar>::put_adresar(&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 = PutAdresarSvc(inner);
-                        let codec = tonic::codec::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.adresar.Adresar/DeleteAdresar" => {
-                    #[allow(non_camel_case_types)]
-                    struct DeleteAdresarSvc<T: Adresar>(pub Arc<T>);
-                    impl<
-                        T: Adresar,
-                    > tonic::server::UnaryService<super::DeleteAdresarRequest>
-                    for DeleteAdresarSvc<T> {
-                        type Response = super::DeleteAdresarResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<super::DeleteAdresarRequest>,
-                        ) -> Self::Future {
-                            let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as Adresar>::delete_adresar(&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 = DeleteAdresarSvc(inner);
-                        let codec = tonic::codec::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.adresar.Adresar/GetAdresarCount" => {
-                    #[allow(non_camel_case_types)]
-                    struct GetAdresarCountSvc<T: Adresar>(pub Arc<T>);
-                    impl<
-                        T: Adresar,
-                    > tonic::server::UnaryService<super::super::common::Empty>
-                    for GetAdresarCountSvc<T> {
-                        type Response = super::super::common::CountResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<super::super::common::Empty>,
-                        ) -> Self::Future {
-                            let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as Adresar>::get_adresar_count(&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 = GetAdresarCountSvc(inner);
-                        let codec = tonic::codec::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.adresar.Adresar/GetAdresarByPosition" => {
-                    #[allow(non_camel_case_types)]
-                    struct GetAdresarByPositionSvc<T: Adresar>(pub Arc<T>);
-                    impl<
-                        T: Adresar,
-                    > tonic::server::UnaryService<super::super::common::PositionRequest>
-                    for GetAdresarByPositionSvc<T> {
-                        type Response = super::AdresarResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<
-                                super::super::common::PositionRequest,
-                            >,
-                        ) -> Self::Future {
-                            let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as Adresar>::get_adresar_by_position(&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 = GetAdresarByPositionSvc(inner);
-                        let codec = tonic::codec::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)
-                }
-                _ => {
-                    Box::pin(async move {
-                        let mut response = http::Response::new(
-                            tonic::body::Body::default(),
-                        );
-                        let headers = response.headers_mut();
-                        headers
-                            .insert(
-                                tonic::Status::GRPC_STATUS,
-                                (tonic::Code::Unimplemented as i32).into(),
-                            );
-                        headers
-                            .insert(
-                                http::header::CONTENT_TYPE,
-                                tonic::metadata::GRPC_CONTENT_TYPE,
-                            );
-                        Ok(response)
-                    })
-                }
-            }
-        }
-    }
-    impl<T> Clone for AdresarServer<T> {
-        fn clone(&self) -> Self {
-            let inner = self.inner.clone();
-            Self {
-                inner,
-                accept_compression_encodings: self.accept_compression_encodings,
-                send_compression_encodings: self.send_compression_encodings,
-                max_decoding_message_size: self.max_decoding_message_size,
-                max_encoding_message_size: self.max_encoding_message_size,
-            }
-        }
-    }
-    /// Generated gRPC service name
-    pub const SERVICE_NAME: &str = "komp_ac.adresar.Adresar";
-    impl<T> tonic::server::NamedService for AdresarServer<T> {
-        const NAME: &'static str = SERVICE_NAME;
-    }
-}

common/src/proto/multieko2.auth.rs

@@ -1,418 +0,0 @@
-// This file is @generated by prost-build.
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct RegisterRequest {
-    #[prost(string, tag = "1")]
-    pub username: ::prost::alloc::string::String,
-    #[prost(string, tag = "2")]
-    pub email: ::prost::alloc::string::String,
-    #[prost(string, tag = "3")]
-    pub password: ::prost::alloc::string::String,
-    #[prost(string, tag = "4")]
-    pub password_confirmation: ::prost::alloc::string::String,
-    #[prost(string, tag = "5")]
-    pub role: ::prost::alloc::string::String,
-}
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct AuthResponse {
-    /// UUID in string format
-    #[prost(string, tag = "1")]
-    pub id: ::prost::alloc::string::String,
-    /// Registered username
-    #[prost(string, tag = "2")]
-    pub username: ::prost::alloc::string::String,
-    /// Registered email (if provided)
-    #[prost(string, tag = "3")]
-    pub email: ::prost::alloc::string::String,
-    /// Default role: 'accountant'
-    #[prost(string, tag = "4")]
-    pub role: ::prost::alloc::string::String,
-}
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct LoginRequest {
-    /// Can be username or email
-    #[prost(string, tag = "1")]
-    pub identifier: ::prost::alloc::string::String,
-    #[prost(string, tag = "2")]
-    pub password: ::prost::alloc::string::String,
-}
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct LoginResponse {
-    /// JWT token
-    #[prost(string, tag = "1")]
-    pub access_token: ::prost::alloc::string::String,
-    /// Usually "Bearer"
-    #[prost(string, tag = "2")]
-    pub token_type: ::prost::alloc::string::String,
-    /// Expiration in seconds (86400 for 24 hours)
-    #[prost(int32, tag = "3")]
-    pub expires_in: i32,
-    /// User's UUID in string format
-    #[prost(string, tag = "4")]
-    pub user_id: ::prost::alloc::string::String,
-    /// User's role
-    #[prost(string, tag = "5")]
-    pub role: ::prost::alloc::string::String,
-    #[prost(string, tag = "6")]
-    pub username: ::prost::alloc::string::String,
-}
-/// Generated client implementations.
-pub mod auth_service_client {
-    #![allow(
-        unused_variables,
-        dead_code,
-        missing_docs,
-        clippy::wildcard_imports,
-        clippy::let_unit_value,
-    )]
-    use tonic::codegen::*;
-    use tonic::codegen::http::Uri;
-    #[derive(Debug, Clone)]
-    pub struct AuthServiceClient<T> {
-        inner: tonic::client::Grpc<T>,
-    }
-    impl AuthServiceClient<tonic::transport::Channel> {
-        /// Attempt to create a new client by connecting to a given endpoint.
-        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
-        where
-            D: TryInto<tonic::transport::Endpoint>,
-            D::Error: Into<StdError>,
-        {
-            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
-            Ok(Self::new(conn))
-        }
-    }
-    impl<T> AuthServiceClient<T>
-    where
-        T: tonic::client::GrpcService<tonic::body::Body>,
-        T::Error: Into<StdError>,
-        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
-        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
-    {
-        pub fn new(inner: T) -> Self {
-            let inner = tonic::client::Grpc::new(inner);
-            Self { inner }
-        }
-        pub fn with_origin(inner: T, origin: Uri) -> Self {
-            let inner = tonic::client::Grpc::with_origin(inner, origin);
-            Self { inner }
-        }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> AuthServiceClient<InterceptedService<T, F>>
-        where
-            F: tonic::service::Interceptor,
-            T::ResponseBody: Default,
-            T: tonic::codegen::Service<
-                http::Request<tonic::body::Body>,
-                Response = http::Response<
-                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
-                >,
-            >,
-            <T as tonic::codegen::Service<
-                http::Request<tonic::body::Body>,
-            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
-        {
-            AuthServiceClient::new(InterceptedService::new(inner, interceptor))
-        }
-        /// Compress requests with the given encoding.
-        ///
-        /// This requires the server to support it otherwise it might respond with an
-        /// error.
-        #[must_use]
-        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.inner = self.inner.send_compressed(encoding);
-            self
-        }
-        /// Enable decompressing responses.
-        #[must_use]
-        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.inner = self.inner.accept_compressed(encoding);
-            self
-        }
-        /// Limits the maximum size of a decoded message.
-        ///
-        /// Default: `4MB`
-        #[must_use]
-        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
-            self.inner = self.inner.max_decoding_message_size(limit);
-            self
-        }
-        /// Limits the maximum size of an encoded message.
-        ///
-        /// Default: `usize::MAX`
-        #[must_use]
-        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
-            self.inner = self.inner.max_encoding_message_size(limit);
-            self
-        }
-        pub async fn register(
-            &mut self,
-            request: impl tonic::IntoRequest<super::RegisterRequest>,
-        ) -> std::result::Result<tonic::Response<super::AuthResponse>, tonic::Status> {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.auth.AuthService/Register",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("komp_ac.auth.AuthService", "Register"));
-            self.inner.unary(req, path, codec).await
-        }
-        pub async fn login(
-            &mut self,
-            request: impl tonic::IntoRequest<super::LoginRequest>,
-        ) -> std::result::Result<tonic::Response<super::LoginResponse>, tonic::Status> {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.auth.AuthService/Login",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("komp_ac.auth.AuthService", "Login"));
-            self.inner.unary(req, path, codec).await
-        }
-    }
-}
-/// Generated server implementations.
-pub mod auth_service_server {
-    #![allow(
-        unused_variables,
-        dead_code,
-        missing_docs,
-        clippy::wildcard_imports,
-        clippy::let_unit_value,
-    )]
-    use tonic::codegen::*;
-    /// Generated trait containing gRPC methods that should be implemented for use with AuthServiceServer.
-    #[async_trait]
-    pub trait AuthService: std::marker::Send + std::marker::Sync + 'static {
-        async fn register(
-            &self,
-            request: tonic::Request<super::RegisterRequest>,
-        ) -> std::result::Result<tonic::Response<super::AuthResponse>, tonic::Status>;
-        async fn login(
-            &self,
-            request: tonic::Request<super::LoginRequest>,
-        ) -> std::result::Result<tonic::Response<super::LoginResponse>, tonic::Status>;
-    }
-    #[derive(Debug)]
-    pub struct AuthServiceServer<T> {
-        inner: Arc<T>,
-        accept_compression_encodings: EnabledCompressionEncodings,
-        send_compression_encodings: EnabledCompressionEncodings,
-        max_decoding_message_size: Option<usize>,
-        max_encoding_message_size: Option<usize>,
-    }
-    impl<T> AuthServiceServer<T> {
-        pub fn new(inner: T) -> Self {
-            Self::from_arc(Arc::new(inner))
-        }
-        pub fn from_arc(inner: Arc<T>) -> Self {
-            Self {
-                inner,
-                accept_compression_encodings: Default::default(),
-                send_compression_encodings: Default::default(),
-                max_decoding_message_size: None,
-                max_encoding_message_size: None,
-            }
-        }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> InterceptedService<Self, F>
-        where
-            F: tonic::service::Interceptor,
-        {
-            InterceptedService::new(Self::new(inner), interceptor)
-        }
-        /// Enable decompressing requests with the given encoding.
-        #[must_use]
-        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.accept_compression_encodings.enable(encoding);
-            self
-        }
-        /// Compress responses with the given encoding, if the client supports it.
-        #[must_use]
-        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.send_compression_encodings.enable(encoding);
-            self
-        }
-        /// Limits the maximum size of a decoded message.
-        ///
-        /// Default: `4MB`
-        #[must_use]
-        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
-            self.max_decoding_message_size = Some(limit);
-            self
-        }
-        /// Limits the maximum size of an encoded message.
-        ///
-        /// Default: `usize::MAX`
-        #[must_use]
-        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
-            self.max_encoding_message_size = Some(limit);
-            self
-        }
-    }
-    impl<T, B> tonic::codegen::Service<http::Request<B>> for AuthServiceServer<T>
-    where
-        T: AuthService,
-        B: Body + std::marker::Send + 'static,
-        B::Error: Into<StdError> + std::marker::Send + 'static,
-    {
-        type Response = http::Response<tonic::body::Body>;
-        type Error = std::convert::Infallible;
-        type Future = BoxFuture<Self::Response, Self::Error>;
-        fn poll_ready(
-            &mut self,
-            _cx: &mut Context<'_>,
-        ) -> Poll<std::result::Result<(), Self::Error>> {
-            Poll::Ready(Ok(()))
-        }
-        fn call(&mut self, req: http::Request<B>) -> Self::Future {
-            match req.uri().path() {
-                "/komp_ac.auth.AuthService/Register" => {
-                    #[allow(non_camel_case_types)]
-                    struct RegisterSvc<T: AuthService>(pub Arc<T>);
-                    impl<
-                        T: AuthService,
-                    > tonic::server::UnaryService<super::RegisterRequest>
-                    for RegisterSvc<T> {
-                        type Response = super::AuthResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<super::RegisterRequest>,
-                        ) -> Self::Future {
-                            let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as AuthService>::register(&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 = RegisterSvc(inner);
-                        let codec = tonic::codec::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.auth.AuthService/Login" => {
-                    #[allow(non_camel_case_types)]
-                    struct LoginSvc<T: AuthService>(pub Arc<T>);
-                    impl<T: AuthService> tonic::server::UnaryService<super::LoginRequest>
-                    for LoginSvc<T> {
-                        type Response = super::LoginResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<super::LoginRequest>,
-                        ) -> Self::Future {
-                            let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as AuthService>::login(&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 = LoginSvc(inner);
-                        let codec = tonic::codec::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)
-                }
-                _ => {
-                    Box::pin(async move {
-                        let mut response = http::Response::new(
-                            tonic::body::Body::default(),
-                        );
-                        let headers = response.headers_mut();
-                        headers
-                            .insert(
-                                tonic::Status::GRPC_STATUS,
-                                (tonic::Code::Unimplemented as i32).into(),
-                            );
-                        headers
-                            .insert(
-                                http::header::CONTENT_TYPE,
-                                tonic::metadata::GRPC_CONTENT_TYPE,
-                            );
-                        Ok(response)
-                    })
-                }
-            }
-        }
-    }
-    impl<T> Clone for AuthServiceServer<T> {
-        fn clone(&self) -> Self {
-            let inner = self.inner.clone();
-            Self {
-                inner,
-                accept_compression_encodings: self.accept_compression_encodings,
-                send_compression_encodings: self.send_compression_encodings,
-                max_decoding_message_size: self.max_decoding_message_size,
-                max_encoding_message_size: self.max_encoding_message_size,
-            }
-        }
-    }
-    /// Generated gRPC service name
-    pub const SERVICE_NAME: &str = "komp_ac.auth.AuthService";
-    impl<T> tonic::server::NamedService for AuthServiceServer<T> {
-        const NAME: &'static str = SERVICE_NAME;
-    }
-}

common/src/proto/multieko2.common.rs

@@ -1,13 +0,0 @@
-// This file is @generated by prost-build.
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct Empty {}
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct CountResponse {
-    #[prost(int64, tag = "1")]
-    pub count: i64,
-}
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct PositionRequest {
-    #[prost(int64, tag = "1")]
-    pub position: i64,
-}

common/src/proto/multieko2.search.rs

@@ -1,317 +0,0 @@
-// This file is @generated by prost-build.
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct SearchRequest {
-    #[prost(string, tag = "1")]
-    pub table_name: ::prost::alloc::string::String,
-    #[prost(string, tag = "2")]
-    pub query: ::prost::alloc::string::String,
-}
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct SearchResponse {
-    #[prost(message, repeated, tag = "1")]
-    pub hits: ::prost::alloc::vec::Vec<search_response::Hit>,
-}
-/// Nested message and enum types in `SearchResponse`.
-pub mod search_response {
-    #[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct Hit {
-        /// PostgreSQL row ID
-        #[prost(int64, tag = "1")]
-        pub id: i64,
-        #[prost(float, tag = "2")]
-        pub score: f32,
-        #[prost(string, tag = "3")]
-        pub content_json: ::prost::alloc::string::String,
-    }
-}
-/// Generated client implementations.
-pub mod searcher_client {
-    #![allow(
-        unused_variables,
-        dead_code,
-        missing_docs,
-        clippy::wildcard_imports,
-        clippy::let_unit_value,
-    )]
-    use tonic::codegen::*;
-    use tonic::codegen::http::Uri;
-    #[derive(Debug, Clone)]
-    pub struct SearcherClient<T> {
-        inner: tonic::client::Grpc<T>,
-    }
-    impl SearcherClient<tonic::transport::Channel> {
-        /// Attempt to create a new client by connecting to a given endpoint.
-        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
-        where
-            D: TryInto<tonic::transport::Endpoint>,
-            D::Error: Into<StdError>,
-        {
-            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
-            Ok(Self::new(conn))
-        }
-    }
-    impl<T> SearcherClient<T>
-    where
-        T: tonic::client::GrpcService<tonic::body::Body>,
-        T::Error: Into<StdError>,
-        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
-        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
-    {
-        pub fn new(inner: T) -> Self {
-            let inner = tonic::client::Grpc::new(inner);
-            Self { inner }
-        }
-        pub fn with_origin(inner: T, origin: Uri) -> Self {
-            let inner = tonic::client::Grpc::with_origin(inner, origin);
-            Self { inner }
-        }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> SearcherClient<InterceptedService<T, F>>
-        where
-            F: tonic::service::Interceptor,
-            T::ResponseBody: Default,
-            T: tonic::codegen::Service<
-                http::Request<tonic::body::Body>,
-                Response = http::Response<
-                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
-                >,
-            >,
-            <T as tonic::codegen::Service<
-                http::Request<tonic::body::Body>,
-            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
-        {
-            SearcherClient::new(InterceptedService::new(inner, interceptor))
-        }
-        /// Compress requests with the given encoding.
-        ///
-        /// This requires the server to support it otherwise it might respond with an
-        /// error.
-        #[must_use]
-        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.inner = self.inner.send_compressed(encoding);
-            self
-        }
-        /// Enable decompressing responses.
-        #[must_use]
-        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.inner = self.inner.accept_compressed(encoding);
-            self
-        }
-        /// Limits the maximum size of a decoded message.
-        ///
-        /// Default: `4MB`
-        #[must_use]
-        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
-            self.inner = self.inner.max_decoding_message_size(limit);
-            self
-        }
-        /// Limits the maximum size of an encoded message.
-        ///
-        /// Default: `usize::MAX`
-        #[must_use]
-        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
-            self.inner = self.inner.max_encoding_message_size(limit);
-            self
-        }
-        pub async fn search_table(
-            &mut self,
-            request: impl tonic::IntoRequest<super::SearchRequest>,
-        ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.search.Searcher/SearchTable",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("komp_ac.search.Searcher", "SearchTable"));
-            self.inner.unary(req, path, codec).await
-        }
-    }
-}
-/// Generated server implementations.
-pub mod searcher_server {
-    #![allow(
-        unused_variables,
-        dead_code,
-        missing_docs,
-        clippy::wildcard_imports,
-        clippy::let_unit_value,
-    )]
-    use tonic::codegen::*;
-    /// Generated trait containing gRPC methods that should be implemented for use with SearcherServer.
-    #[async_trait]
-    pub trait Searcher: std::marker::Send + std::marker::Sync + 'static {
-        async fn search_table(
-            &self,
-            request: tonic::Request<super::SearchRequest>,
-        ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status>;
-    }
-    #[derive(Debug)]
-    pub struct SearcherServer<T> {
-        inner: Arc<T>,
-        accept_compression_encodings: EnabledCompressionEncodings,
-        send_compression_encodings: EnabledCompressionEncodings,
-        max_decoding_message_size: Option<usize>,
-        max_encoding_message_size: Option<usize>,
-    }
-    impl<T> SearcherServer<T> {
-        pub fn new(inner: T) -> Self {
-            Self::from_arc(Arc::new(inner))
-        }
-        pub fn from_arc(inner: Arc<T>) -> Self {
-            Self {
-                inner,
-                accept_compression_encodings: Default::default(),
-                send_compression_encodings: Default::default(),
-                max_decoding_message_size: None,
-                max_encoding_message_size: None,
-            }
-        }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> InterceptedService<Self, F>
-        where
-            F: tonic::service::Interceptor,
-        {
-            InterceptedService::new(Self::new(inner), interceptor)
-        }
-        /// Enable decompressing requests with the given encoding.
-        #[must_use]
-        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.accept_compression_encodings.enable(encoding);
-            self
-        }
-        /// Compress responses with the given encoding, if the client supports it.
-        #[must_use]
-        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.send_compression_encodings.enable(encoding);
-            self
-        }
-        /// Limits the maximum size of a decoded message.
-        ///
-        /// Default: `4MB`
-        #[must_use]
-        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
-            self.max_decoding_message_size = Some(limit);
-            self
-        }
-        /// Limits the maximum size of an encoded message.
-        ///
-        /// Default: `usize::MAX`
-        #[must_use]
-        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
-            self.max_encoding_message_size = Some(limit);
-            self
-        }
-    }
-    impl<T, B> tonic::codegen::Service<http::Request<B>> for SearcherServer<T>
-    where
-        T: Searcher,
-        B: Body + std::marker::Send + 'static,
-        B::Error: Into<StdError> + std::marker::Send + 'static,
-    {
-        type Response = http::Response<tonic::body::Body>;
-        type Error = std::convert::Infallible;
-        type Future = BoxFuture<Self::Response, Self::Error>;
-        fn poll_ready(
-            &mut self,
-            _cx: &mut Context<'_>,
-        ) -> Poll<std::result::Result<(), Self::Error>> {
-            Poll::Ready(Ok(()))
-        }
-        fn call(&mut self, req: http::Request<B>) -> Self::Future {
-            match req.uri().path() {
-                "/komp_ac.search.Searcher/SearchTable" => {
-                    #[allow(non_camel_case_types)]
-                    struct SearchTableSvc<T: Searcher>(pub Arc<T>);
-                    impl<T: Searcher> tonic::server::UnaryService<super::SearchRequest>
-                    for SearchTableSvc<T> {
-                        type Response = super::SearchResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<super::SearchRequest>,
-                        ) -> Self::Future {
-                            let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as Searcher>::search_table(&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 = SearchTableSvc(inner);
-                        let codec = tonic::codec::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)
-                }
-                _ => {
-                    Box::pin(async move {
-                        let mut response = http::Response::new(
-                            tonic::body::Body::default(),
-                        );
-                        let headers = response.headers_mut();
-                        headers
-                            .insert(
-                                tonic::Status::GRPC_STATUS,
-                                (tonic::Code::Unimplemented as i32).into(),
-                            );
-                        headers
-                            .insert(
-                                http::header::CONTENT_TYPE,
-                                tonic::metadata::GRPC_CONTENT_TYPE,
-                            );
-                        Ok(response)
-                    })
-                }
-            }
-        }
-    }
-    impl<T> Clone for SearcherServer<T> {
-        fn clone(&self) -> Self {
-            let inner = self.inner.clone();
-            Self {
-                inner,
-                accept_compression_encodings: self.accept_compression_encodings,
-                send_compression_encodings: self.send_compression_encodings,
-                max_decoding_message_size: self.max_decoding_message_size,
-                max_encoding_message_size: self.max_encoding_message_size,
-            }
-        }
-    }
-    /// Generated gRPC service name
-    pub const SERVICE_NAME: &str = "komp_ac.search.Searcher";
-    impl<T> tonic::server::NamedService for SearcherServer<T> {
-        const NAME: &'static str = SERVICE_NAME;
-    }
-}

common/src/proto/multieko2.table_script.rs

@@ -1,323 +0,0 @@
-// This file is @generated by prost-build.
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PostTableScriptRequest {
-    #[prost(int64, tag = "1")]
-    pub table_definition_id: i64,
-    #[prost(string, tag = "2")]
-    pub target_column: ::prost::alloc::string::String,
-    #[prost(string, tag = "3")]
-    pub script: ::prost::alloc::string::String,
-    #[prost(string, tag = "4")]
-    pub description: ::prost::alloc::string::String,
-}
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct TableScriptResponse {
-    #[prost(int64, tag = "1")]
-    pub id: i64,
-    #[prost(string, tag = "2")]
-    pub warnings: ::prost::alloc::string::String,
-}
-/// Generated client implementations.
-pub mod table_script_client {
-    #![allow(
-        unused_variables,
-        dead_code,
-        missing_docs,
-        clippy::wildcard_imports,
-        clippy::let_unit_value,
-    )]
-    use tonic::codegen::*;
-    use tonic::codegen::http::Uri;
-    #[derive(Debug, Clone)]
-    pub struct TableScriptClient<T> {
-        inner: tonic::client::Grpc<T>,
-    }
-    impl TableScriptClient<tonic::transport::Channel> {
-        /// Attempt to create a new client by connecting to a given endpoint.
-        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
-        where
-            D: TryInto<tonic::transport::Endpoint>,
-            D::Error: Into<StdError>,
-        {
-            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
-            Ok(Self::new(conn))
-        }
-    }
-    impl<T> TableScriptClient<T>
-    where
-        T: tonic::client::GrpcService<tonic::body::Body>,
-        T::Error: Into<StdError>,
-        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
-        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
-    {
-        pub fn new(inner: T) -> Self {
-            let inner = tonic::client::Grpc::new(inner);
-            Self { inner }
-        }
-        pub fn with_origin(inner: T, origin: Uri) -> Self {
-            let inner = tonic::client::Grpc::with_origin(inner, origin);
-            Self { inner }
-        }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> TableScriptClient<InterceptedService<T, F>>
-        where
-            F: tonic::service::Interceptor,
-            T::ResponseBody: Default,
-            T: tonic::codegen::Service<
-                http::Request<tonic::body::Body>,
-                Response = http::Response<
-                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
-                >,
-            >,
-            <T as tonic::codegen::Service<
-                http::Request<tonic::body::Body>,
-            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
-        {
-            TableScriptClient::new(InterceptedService::new(inner, interceptor))
-        }
-        /// Compress requests with the given encoding.
-        ///
-        /// This requires the server to support it otherwise it might respond with an
-        /// error.
-        #[must_use]
-        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.inner = self.inner.send_compressed(encoding);
-            self
-        }
-        /// Enable decompressing responses.
-        #[must_use]
-        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.inner = self.inner.accept_compressed(encoding);
-            self
-        }
-        /// Limits the maximum size of a decoded message.
-        ///
-        /// Default: `4MB`
-        #[must_use]
-        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
-            self.inner = self.inner.max_decoding_message_size(limit);
-            self
-        }
-        /// Limits the maximum size of an encoded message.
-        ///
-        /// Default: `usize::MAX`
-        #[must_use]
-        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
-            self.inner = self.inner.max_encoding_message_size(limit);
-            self
-        }
-        pub async fn post_table_script(
-            &mut self,
-            request: impl tonic::IntoRequest<super::PostTableScriptRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::TableScriptResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.table_script.TableScript/PostTableScript",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "komp_ac.table_script.TableScript",
-                        "PostTableScript",
-                    ),
-                );
-            self.inner.unary(req, path, codec).await
-        }
-    }
-}
-/// Generated server implementations.
-pub mod table_script_server {
-    #![allow(
-        unused_variables,
-        dead_code,
-        missing_docs,
-        clippy::wildcard_imports,
-        clippy::let_unit_value,
-    )]
-    use tonic::codegen::*;
-    /// Generated trait containing gRPC methods that should be implemented for use with TableScriptServer.
-    #[async_trait]
-    pub trait TableScript: std::marker::Send + std::marker::Sync + 'static {
-        async fn post_table_script(
-            &self,
-            request: tonic::Request<super::PostTableScriptRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::TableScriptResponse>,
-            tonic::Status,
-        >;
-    }
-    #[derive(Debug)]
-    pub struct TableScriptServer<T> {
-        inner: Arc<T>,
-        accept_compression_encodings: EnabledCompressionEncodings,
-        send_compression_encodings: EnabledCompressionEncodings,
-        max_decoding_message_size: Option<usize>,
-        max_encoding_message_size: Option<usize>,
-    }
-    impl<T> TableScriptServer<T> {
-        pub fn new(inner: T) -> Self {
-            Self::from_arc(Arc::new(inner))
-        }
-        pub fn from_arc(inner: Arc<T>) -> Self {
-            Self {
-                inner,
-                accept_compression_encodings: Default::default(),
-                send_compression_encodings: Default::default(),
-                max_decoding_message_size: None,
-                max_encoding_message_size: None,
-            }
-        }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> InterceptedService<Self, F>
-        where
-            F: tonic::service::Interceptor,
-        {
-            InterceptedService::new(Self::new(inner), interceptor)
-        }
-        /// Enable decompressing requests with the given encoding.
-        #[must_use]
-        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.accept_compression_encodings.enable(encoding);
-            self
-        }
-        /// Compress responses with the given encoding, if the client supports it.
-        #[must_use]
-        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.send_compression_encodings.enable(encoding);
-            self
-        }
-        /// Limits the maximum size of a decoded message.
-        ///
-        /// Default: `4MB`
-        #[must_use]
-        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
-            self.max_decoding_message_size = Some(limit);
-            self
-        }
-        /// Limits the maximum size of an encoded message.
-        ///
-        /// Default: `usize::MAX`
-        #[must_use]
-        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
-            self.max_encoding_message_size = Some(limit);
-            self
-        }
-    }
-    impl<T, B> tonic::codegen::Service<http::Request<B>> for TableScriptServer<T>
-    where
-        T: TableScript,
-        B: Body + std::marker::Send + 'static,
-        B::Error: Into<StdError> + std::marker::Send + 'static,
-    {
-        type Response = http::Response<tonic::body::Body>;
-        type Error = std::convert::Infallible;
-        type Future = BoxFuture<Self::Response, Self::Error>;
-        fn poll_ready(
-            &mut self,
-            _cx: &mut Context<'_>,
-        ) -> Poll<std::result::Result<(), Self::Error>> {
-            Poll::Ready(Ok(()))
-        }
-        fn call(&mut self, req: http::Request<B>) -> Self::Future {
-            match req.uri().path() {
-                "/komp_ac.table_script.TableScript/PostTableScript" => {
-                    #[allow(non_camel_case_types)]
-                    struct PostTableScriptSvc<T: TableScript>(pub Arc<T>);
-                    impl<
-                        T: TableScript,
-                    > tonic::server::UnaryService<super::PostTableScriptRequest>
-                    for PostTableScriptSvc<T> {
-                        type Response = super::TableScriptResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<super::PostTableScriptRequest>,
-                        ) -> Self::Future {
-                            let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as TableScript>::post_table_script(&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 = PostTableScriptSvc(inner);
-                        let codec = tonic::codec::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)
-                }
-                _ => {
-                    Box::pin(async move {
-                        let mut response = http::Response::new(
-                            tonic::body::Body::default(),
-                        );
-                        let headers = response.headers_mut();
-                        headers
-                            .insert(
-                                tonic::Status::GRPC_STATUS,
-                                (tonic::Code::Unimplemented as i32).into(),
-                            );
-                        headers
-                            .insert(
-                                http::header::CONTENT_TYPE,
-                                tonic::metadata::GRPC_CONTENT_TYPE,
-                            );
-                        Ok(response)
-                    })
-                }
-            }
-        }
-    }
-    impl<T> Clone for TableScriptServer<T> {
-        fn clone(&self) -> Self {
-            let inner = self.inner.clone();
-            Self {
-                inner,
-                accept_compression_encodings: self.accept_compression_encodings,
-                send_compression_encodings: self.send_compression_encodings,
-                max_decoding_message_size: self.max_decoding_message_size,
-                max_encoding_message_size: self.max_encoding_message_size,
-            }
-        }
-    }
-    /// Generated gRPC service name
-    pub const SERVICE_NAME: &str = "komp_ac.table_script.TableScript";
-    impl<T> tonic::server::NamedService for TableScriptServer<T> {
-        const NAME: &'static str = SERVICE_NAME;
-    }
-}

common/src/proto/multieko2.table_structure.rs

@@ -1,336 +0,0 @@
-// This file is @generated by prost-build.
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GetTableStructureRequest {
-    /// e.g., "default"
-    #[prost(string, tag = "1")]
-    pub profile_name: ::prost::alloc::string::String,
-    /// e.g., "2025_adresar6"
-    #[prost(string, tag = "2")]
-    pub table_name: ::prost::alloc::string::String,
-}
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct TableStructureResponse {
-    #[prost(message, repeated, tag = "1")]
-    pub columns: ::prost::alloc::vec::Vec<TableColumn>,
-}
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct TableColumn {
-    #[prost(string, tag = "1")]
-    pub name: ::prost::alloc::string::String,
-    /// e.g., "TEXT", "BIGINT", "VARCHAR(255)", "TIMESTAMPTZ"
-    #[prost(string, tag = "2")]
-    pub data_type: ::prost::alloc::string::String,
-    #[prost(bool, tag = "3")]
-    pub is_nullable: bool,
-    #[prost(bool, tag = "4")]
-    pub is_primary_key: bool,
-}
-/// Generated client implementations.
-pub mod table_structure_service_client {
-    #![allow(
-        unused_variables,
-        dead_code,
-        missing_docs,
-        clippy::wildcard_imports,
-        clippy::let_unit_value,
-    )]
-    use tonic::codegen::*;
-    use tonic::codegen::http::Uri;
-    #[derive(Debug, Clone)]
-    pub struct TableStructureServiceClient<T> {
-        inner: tonic::client::Grpc<T>,
-    }
-    impl TableStructureServiceClient<tonic::transport::Channel> {
-        /// Attempt to create a new client by connecting to a given endpoint.
-        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
-        where
-            D: TryInto<tonic::transport::Endpoint>,
-            D::Error: Into<StdError>,
-        {
-            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
-            Ok(Self::new(conn))
-        }
-    }
-    impl<T> TableStructureServiceClient<T>
-    where
-        T: tonic::client::GrpcService<tonic::body::Body>,
-        T::Error: Into<StdError>,
-        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
-        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
-    {
-        pub fn new(inner: T) -> Self {
-            let inner = tonic::client::Grpc::new(inner);
-            Self { inner }
-        }
-        pub fn with_origin(inner: T, origin: Uri) -> Self {
-            let inner = tonic::client::Grpc::with_origin(inner, origin);
-            Self { inner }
-        }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> TableStructureServiceClient<InterceptedService<T, F>>
-        where
-            F: tonic::service::Interceptor,
-            T::ResponseBody: Default,
-            T: tonic::codegen::Service<
-                http::Request<tonic::body::Body>,
-                Response = http::Response<
-                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
-                >,
-            >,
-            <T as tonic::codegen::Service<
-                http::Request<tonic::body::Body>,
-            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
-        {
-            TableStructureServiceClient::new(InterceptedService::new(inner, interceptor))
-        }
-        /// Compress requests with the given encoding.
-        ///
-        /// This requires the server to support it otherwise it might respond with an
-        /// error.
-        #[must_use]
-        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.inner = self.inner.send_compressed(encoding);
-            self
-        }
-        /// Enable decompressing responses.
-        #[must_use]
-        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.inner = self.inner.accept_compressed(encoding);
-            self
-        }
-        /// Limits the maximum size of a decoded message.
-        ///
-        /// Default: `4MB`
-        #[must_use]
-        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
-            self.inner = self.inner.max_decoding_message_size(limit);
-            self
-        }
-        /// Limits the maximum size of an encoded message.
-        ///
-        /// Default: `usize::MAX`
-        #[must_use]
-        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
-            self.inner = self.inner.max_encoding_message_size(limit);
-            self
-        }
-        pub async fn get_table_structure(
-            &mut self,
-            request: impl tonic::IntoRequest<super::GetTableStructureRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::TableStructureResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.table_structure.TableStructureService/GetTableStructure",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "komp_ac.table_structure.TableStructureService",
-                        "GetTableStructure",
-                    ),
-                );
-            self.inner.unary(req, path, codec).await
-        }
-    }
-}
-/// Generated server implementations.
-pub mod table_structure_service_server {
-    #![allow(
-        unused_variables,
-        dead_code,
-        missing_docs,
-        clippy::wildcard_imports,
-        clippy::let_unit_value,
-    )]
-    use tonic::codegen::*;
-    /// Generated trait containing gRPC methods that should be implemented for use with TableStructureServiceServer.
-    #[async_trait]
-    pub trait TableStructureService: std::marker::Send + std::marker::Sync + 'static {
-        async fn get_table_structure(
-            &self,
-            request: tonic::Request<super::GetTableStructureRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::TableStructureResponse>,
-            tonic::Status,
-        >;
-    }
-    #[derive(Debug)]
-    pub struct TableStructureServiceServer<T> {
-        inner: Arc<T>,
-        accept_compression_encodings: EnabledCompressionEncodings,
-        send_compression_encodings: EnabledCompressionEncodings,
-        max_decoding_message_size: Option<usize>,
-        max_encoding_message_size: Option<usize>,
-    }
-    impl<T> TableStructureServiceServer<T> {
-        pub fn new(inner: T) -> Self {
-            Self::from_arc(Arc::new(inner))
-        }
-        pub fn from_arc(inner: Arc<T>) -> Self {
-            Self {
-                inner,
-                accept_compression_encodings: Default::default(),
-                send_compression_encodings: Default::default(),
-                max_decoding_message_size: None,
-                max_encoding_message_size: None,
-            }
-        }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> InterceptedService<Self, F>
-        where
-            F: tonic::service::Interceptor,
-        {
-            InterceptedService::new(Self::new(inner), interceptor)
-        }
-        /// Enable decompressing requests with the given encoding.
-        #[must_use]
-        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.accept_compression_encodings.enable(encoding);
-            self
-        }
-        /// Compress responses with the given encoding, if the client supports it.
-        #[must_use]
-        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.send_compression_encodings.enable(encoding);
-            self
-        }
-        /// Limits the maximum size of a decoded message.
-        ///
-        /// Default: `4MB`
-        #[must_use]
-        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
-            self.max_decoding_message_size = Some(limit);
-            self
-        }
-        /// Limits the maximum size of an encoded message.
-        ///
-        /// Default: `usize::MAX`
-        #[must_use]
-        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
-            self.max_encoding_message_size = Some(limit);
-            self
-        }
-    }
-    impl<T, B> tonic::codegen::Service<http::Request<B>>
-    for TableStructureServiceServer<T>
-    where
-        T: TableStructureService,
-        B: Body + std::marker::Send + 'static,
-        B::Error: Into<StdError> + std::marker::Send + 'static,
-    {
-        type Response = http::Response<tonic::body::Body>;
-        type Error = std::convert::Infallible;
-        type Future = BoxFuture<Self::Response, Self::Error>;
-        fn poll_ready(
-            &mut self,
-            _cx: &mut Context<'_>,
-        ) -> Poll<std::result::Result<(), Self::Error>> {
-            Poll::Ready(Ok(()))
-        }
-        fn call(&mut self, req: http::Request<B>) -> Self::Future {
-            match req.uri().path() {
-                "/komp_ac.table_structure.TableStructureService/GetTableStructure" => {
-                    #[allow(non_camel_case_types)]
-                    struct GetTableStructureSvc<T: TableStructureService>(pub Arc<T>);
-                    impl<
-                        T: TableStructureService,
-                    > tonic::server::UnaryService<super::GetTableStructureRequest>
-                    for GetTableStructureSvc<T> {
-                        type Response = super::TableStructureResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<super::GetTableStructureRequest>,
-                        ) -> Self::Future {
-                            let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as TableStructureService>::get_table_structure(
-                                        &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 = GetTableStructureSvc(inner);
-                        let codec = tonic::codec::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)
-                }
-                _ => {
-                    Box::pin(async move {
-                        let mut response = http::Response::new(
-                            tonic::body::Body::default(),
-                        );
-                        let headers = response.headers_mut();
-                        headers
-                            .insert(
-                                tonic::Status::GRPC_STATUS,
-                                (tonic::Code::Unimplemented as i32).into(),
-                            );
-                        headers
-                            .insert(
-                                http::header::CONTENT_TYPE,
-                                tonic::metadata::GRPC_CONTENT_TYPE,
-                            );
-                        Ok(response)
-                    })
-                }
-            }
-        }
-    }
-    impl<T> Clone for TableStructureServiceServer<T> {
-        fn clone(&self) -> Self {
-            let inner = self.inner.clone();
-            Self {
-                inner,
-                accept_compression_encodings: self.accept_compression_encodings,
-                send_compression_encodings: self.send_compression_encodings,
-                max_decoding_message_size: self.max_decoding_message_size,
-                max_encoding_message_size: self.max_encoding_message_size,
-            }
-        }
-    }
-    /// Generated gRPC service name
-    pub const SERVICE_NAME: &str = "komp_ac.table_structure.TableStructureService";
-    impl<T> tonic::server::NamedService for TableStructureServiceServer<T> {
-        const NAME: &'static str = SERVICE_NAME;
-    }
-}

common/src/proto/multieko2.tables_data.rs

@@ -1,797 +0,0 @@
-// This file is @generated by prost-build.
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PostTableDataRequest {
-    #[prost(string, tag = "1")]
-    pub profile_name: ::prost::alloc::string::String,
-    #[prost(string, tag = "2")]
-    pub table_name: ::prost::alloc::string::String,
-    #[prost(map = "string, message", tag = "3")]
-    pub data: ::std::collections::HashMap<
-        ::prost::alloc::string::String,
-        ::prost_types::Value,
-    >,
-}
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PostTableDataResponse {
-    #[prost(bool, tag = "1")]
-    pub success: bool,
-    #[prost(string, tag = "2")]
-    pub message: ::prost::alloc::string::String,
-    #[prost(int64, tag = "3")]
-    pub inserted_id: i64,
-}
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PutTableDataRequest {
-    #[prost(string, tag = "1")]
-    pub profile_name: ::prost::alloc::string::String,
-    #[prost(string, tag = "2")]
-    pub table_name: ::prost::alloc::string::String,
-    #[prost(int64, tag = "3")]
-    pub id: i64,
-    #[prost(map = "string, message", tag = "4")]
-    pub data: ::std::collections::HashMap<
-        ::prost::alloc::string::String,
-        ::prost_types::Value,
-    >,
-}
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PutTableDataResponse {
-    #[prost(bool, tag = "1")]
-    pub success: bool,
-    #[prost(string, tag = "2")]
-    pub message: ::prost::alloc::string::String,
-    #[prost(int64, tag = "3")]
-    pub updated_id: i64,
-}
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct DeleteTableDataRequest {
-    #[prost(string, tag = "1")]
-    pub profile_name: ::prost::alloc::string::String,
-    #[prost(string, tag = "2")]
-    pub table_name: ::prost::alloc::string::String,
-    #[prost(int64, tag = "3")]
-    pub record_id: i64,
-}
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct DeleteTableDataResponse {
-    #[prost(bool, tag = "1")]
-    pub success: bool,
-}
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GetTableDataRequest {
-    #[prost(string, tag = "1")]
-    pub profile_name: ::prost::alloc::string::String,
-    #[prost(string, tag = "2")]
-    pub table_name: ::prost::alloc::string::String,
-    #[prost(int64, tag = "3")]
-    pub id: i64,
-}
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GetTableDataResponse {
-    #[prost(map = "string, string", tag = "1")]
-    pub data: ::std::collections::HashMap<
-        ::prost::alloc::string::String,
-        ::prost::alloc::string::String,
-    >,
-}
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GetTableDataCountRequest {
-    #[prost(string, tag = "1")]
-    pub profile_name: ::prost::alloc::string::String,
-    #[prost(string, tag = "2")]
-    pub table_name: ::prost::alloc::string::String,
-}
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GetTableDataByPositionRequest {
-    #[prost(string, tag = "1")]
-    pub profile_name: ::prost::alloc::string::String,
-    #[prost(string, tag = "2")]
-    pub table_name: ::prost::alloc::string::String,
-    #[prost(int32, tag = "3")]
-    pub position: i32,
-}
-/// Generated client implementations.
-pub mod tables_data_client {
-    #![allow(
-        unused_variables,
-        dead_code,
-        missing_docs,
-        clippy::wildcard_imports,
-        clippy::let_unit_value,
-    )]
-    use tonic::codegen::*;
-    use tonic::codegen::http::Uri;
-    #[derive(Debug, Clone)]
-    pub struct TablesDataClient<T> {
-        inner: tonic::client::Grpc<T>,
-    }
-    impl TablesDataClient<tonic::transport::Channel> {
-        /// Attempt to create a new client by connecting to a given endpoint.
-        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
-        where
-            D: TryInto<tonic::transport::Endpoint>,
-            D::Error: Into<StdError>,
-        {
-            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
-            Ok(Self::new(conn))
-        }
-    }
-    impl<T> TablesDataClient<T>
-    where
-        T: tonic::client::GrpcService<tonic::body::Body>,
-        T::Error: Into<StdError>,
-        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
-        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
-    {
-        pub fn new(inner: T) -> Self {
-            let inner = tonic::client::Grpc::new(inner);
-            Self { inner }
-        }
-        pub fn with_origin(inner: T, origin: Uri) -> Self {
-            let inner = tonic::client::Grpc::with_origin(inner, origin);
-            Self { inner }
-        }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> TablesDataClient<InterceptedService<T, F>>
-        where
-            F: tonic::service::Interceptor,
-            T::ResponseBody: Default,
-            T: tonic::codegen::Service<
-                http::Request<tonic::body::Body>,
-                Response = http::Response<
-                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
-                >,
-            >,
-            <T as tonic::codegen::Service<
-                http::Request<tonic::body::Body>,
-            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
-        {
-            TablesDataClient::new(InterceptedService::new(inner, interceptor))
-        }
-        /// Compress requests with the given encoding.
-        ///
-        /// This requires the server to support it otherwise it might respond with an
-        /// error.
-        #[must_use]
-        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.inner = self.inner.send_compressed(encoding);
-            self
-        }
-        /// Enable decompressing responses.
-        #[must_use]
-        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.inner = self.inner.accept_compressed(encoding);
-            self
-        }
-        /// Limits the maximum size of a decoded message.
-        ///
-        /// Default: `4MB`
-        #[must_use]
-        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
-            self.inner = self.inner.max_decoding_message_size(limit);
-            self
-        }
-        /// Limits the maximum size of an encoded message.
-        ///
-        /// Default: `usize::MAX`
-        #[must_use]
-        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
-            self.inner = self.inner.max_encoding_message_size(limit);
-            self
-        }
-        pub async fn post_table_data(
-            &mut self,
-            request: impl tonic::IntoRequest<super::PostTableDataRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PostTableDataResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.tables_data.TablesData/PostTableData",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("komp_ac.tables_data.TablesData", "PostTableData"),
-                );
-            self.inner.unary(req, path, codec).await
-        }
-        pub async fn put_table_data(
-            &mut self,
-            request: impl tonic::IntoRequest<super::PutTableDataRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PutTableDataResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.tables_data.TablesData/PutTableData",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("komp_ac.tables_data.TablesData", "PutTableData"),
-                );
-            self.inner.unary(req, path, codec).await
-        }
-        pub async fn delete_table_data(
-            &mut self,
-            request: impl tonic::IntoRequest<super::DeleteTableDataRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::DeleteTableDataResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.tables_data.TablesData/DeleteTableData",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "komp_ac.tables_data.TablesData",
-                        "DeleteTableData",
-                    ),
-                );
-            self.inner.unary(req, path, codec).await
-        }
-        pub async fn get_table_data(
-            &mut self,
-            request: impl tonic::IntoRequest<super::GetTableDataRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetTableDataResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.tables_data.TablesData/GetTableData",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new("komp_ac.tables_data.TablesData", "GetTableData"),
-                );
-            self.inner.unary(req, path, codec).await
-        }
-        pub async fn get_table_data_count(
-            &mut self,
-            request: impl tonic::IntoRequest<super::GetTableDataCountRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::super::common::CountResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.tables_data.TablesData/GetTableDataCount",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "komp_ac.tables_data.TablesData",
-                        "GetTableDataCount",
-                    ),
-                );
-            self.inner.unary(req, path, codec).await
-        }
-        pub async fn get_table_data_by_position(
-            &mut self,
-            request: impl tonic::IntoRequest<super::GetTableDataByPositionRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetTableDataResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.tables_data.TablesData/GetTableDataByPosition",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "komp_ac.tables_data.TablesData",
-                        "GetTableDataByPosition",
-                    ),
-                );
-            self.inner.unary(req, path, codec).await
-        }
-    }
-}
-/// Generated server implementations.
-pub mod tables_data_server {
-    #![allow(
-        unused_variables,
-        dead_code,
-        missing_docs,
-        clippy::wildcard_imports,
-        clippy::let_unit_value,
-    )]
-    use tonic::codegen::*;
-    /// Generated trait containing gRPC methods that should be implemented for use with TablesDataServer.
-    #[async_trait]
-    pub trait TablesData: std::marker::Send + std::marker::Sync + 'static {
-        async fn post_table_data(
-            &self,
-            request: tonic::Request<super::PostTableDataRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PostTableDataResponse>,
-            tonic::Status,
-        >;
-        async fn put_table_data(
-            &self,
-            request: tonic::Request<super::PutTableDataRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::PutTableDataResponse>,
-            tonic::Status,
-        >;
-        async fn delete_table_data(
-            &self,
-            request: tonic::Request<super::DeleteTableDataRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::DeleteTableDataResponse>,
-            tonic::Status,
-        >;
-        async fn get_table_data(
-            &self,
-            request: tonic::Request<super::GetTableDataRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetTableDataResponse>,
-            tonic::Status,
-        >;
-        async fn get_table_data_count(
-            &self,
-            request: tonic::Request<super::GetTableDataCountRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::super::common::CountResponse>,
-            tonic::Status,
-        >;
-        async fn get_table_data_by_position(
-            &self,
-            request: tonic::Request<super::GetTableDataByPositionRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::GetTableDataResponse>,
-            tonic::Status,
-        >;
-    }
-    #[derive(Debug)]
-    pub struct TablesDataServer<T> {
-        inner: Arc<T>,
-        accept_compression_encodings: EnabledCompressionEncodings,
-        send_compression_encodings: EnabledCompressionEncodings,
-        max_decoding_message_size: Option<usize>,
-        max_encoding_message_size: Option<usize>,
-    }
-    impl<T> TablesDataServer<T> {
-        pub fn new(inner: T) -> Self {
-            Self::from_arc(Arc::new(inner))
-        }
-        pub fn from_arc(inner: Arc<T>) -> Self {
-            Self {
-                inner,
-                accept_compression_encodings: Default::default(),
-                send_compression_encodings: Default::default(),
-                max_decoding_message_size: None,
-                max_encoding_message_size: None,
-            }
-        }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> InterceptedService<Self, F>
-        where
-            F: tonic::service::Interceptor,
-        {
-            InterceptedService::new(Self::new(inner), interceptor)
-        }
-        /// Enable decompressing requests with the given encoding.
-        #[must_use]
-        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.accept_compression_encodings.enable(encoding);
-            self
-        }
-        /// Compress responses with the given encoding, if the client supports it.
-        #[must_use]
-        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.send_compression_encodings.enable(encoding);
-            self
-        }
-        /// Limits the maximum size of a decoded message.
-        ///
-        /// Default: `4MB`
-        #[must_use]
-        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
-            self.max_decoding_message_size = Some(limit);
-            self
-        }
-        /// Limits the maximum size of an encoded message.
-        ///
-        /// Default: `usize::MAX`
-        #[must_use]
-        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
-            self.max_encoding_message_size = Some(limit);
-            self
-        }
-    }
-    impl<T, B> tonic::codegen::Service<http::Request<B>> for TablesDataServer<T>
-    where
-        T: TablesData,
-        B: Body + std::marker::Send + 'static,
-        B::Error: Into<StdError> + std::marker::Send + 'static,
-    {
-        type Response = http::Response<tonic::body::Body>;
-        type Error = std::convert::Infallible;
-        type Future = BoxFuture<Self::Response, Self::Error>;
-        fn poll_ready(
-            &mut self,
-            _cx: &mut Context<'_>,
-        ) -> Poll<std::result::Result<(), Self::Error>> {
-            Poll::Ready(Ok(()))
-        }
-        fn call(&mut self, req: http::Request<B>) -> Self::Future {
-            match req.uri().path() {
-                "/komp_ac.tables_data.TablesData/PostTableData" => {
-                    #[allow(non_camel_case_types)]
-                    struct PostTableDataSvc<T: TablesData>(pub Arc<T>);
-                    impl<
-                        T: TablesData,
-                    > tonic::server::UnaryService<super::PostTableDataRequest>
-                    for PostTableDataSvc<T> {
-                        type Response = super::PostTableDataResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<super::PostTableDataRequest>,
-                        ) -> Self::Future {
-                            let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as TablesData>::post_table_data(&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 = PostTableDataSvc(inner);
-                        let codec = tonic::codec::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.tables_data.TablesData/PutTableData" => {
-                    #[allow(non_camel_case_types)]
-                    struct PutTableDataSvc<T: TablesData>(pub Arc<T>);
-                    impl<
-                        T: TablesData,
-                    > tonic::server::UnaryService<super::PutTableDataRequest>
-                    for PutTableDataSvc<T> {
-                        type Response = super::PutTableDataResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<super::PutTableDataRequest>,
-                        ) -> Self::Future {
-                            let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as TablesData>::put_table_data(&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 = PutTableDataSvc(inner);
-                        let codec = tonic::codec::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.tables_data.TablesData/DeleteTableData" => {
-                    #[allow(non_camel_case_types)]
-                    struct DeleteTableDataSvc<T: TablesData>(pub Arc<T>);
-                    impl<
-                        T: TablesData,
-                    > tonic::server::UnaryService<super::DeleteTableDataRequest>
-                    for DeleteTableDataSvc<T> {
-                        type Response = super::DeleteTableDataResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<super::DeleteTableDataRequest>,
-                        ) -> Self::Future {
-                            let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as TablesData>::delete_table_data(&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 = DeleteTableDataSvc(inner);
-                        let codec = tonic::codec::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.tables_data.TablesData/GetTableData" => {
-                    #[allow(non_camel_case_types)]
-                    struct GetTableDataSvc<T: TablesData>(pub Arc<T>);
-                    impl<
-                        T: TablesData,
-                    > tonic::server::UnaryService<super::GetTableDataRequest>
-                    for GetTableDataSvc<T> {
-                        type Response = super::GetTableDataResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<super::GetTableDataRequest>,
-                        ) -> Self::Future {
-                            let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as TablesData>::get_table_data(&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 = GetTableDataSvc(inner);
-                        let codec = tonic::codec::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.tables_data.TablesData/GetTableDataCount" => {
-                    #[allow(non_camel_case_types)]
-                    struct GetTableDataCountSvc<T: TablesData>(pub Arc<T>);
-                    impl<
-                        T: TablesData,
-                    > tonic::server::UnaryService<super::GetTableDataCountRequest>
-                    for GetTableDataCountSvc<T> {
-                        type Response = super::super::common::CountResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<super::GetTableDataCountRequest>,
-                        ) -> Self::Future {
-                            let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as TablesData>::get_table_data_count(&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 = GetTableDataCountSvc(inner);
-                        let codec = tonic::codec::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.tables_data.TablesData/GetTableDataByPosition" => {
-                    #[allow(non_camel_case_types)]
-                    struct GetTableDataByPositionSvc<T: TablesData>(pub Arc<T>);
-                    impl<
-                        T: TablesData,
-                    > tonic::server::UnaryService<super::GetTableDataByPositionRequest>
-                    for GetTableDataByPositionSvc<T> {
-                        type Response = super::GetTableDataResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<super::GetTableDataByPositionRequest>,
-                        ) -> Self::Future {
-                            let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as TablesData>::get_table_data_by_position(
-                                        &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 = GetTableDataByPositionSvc(inner);
-                        let codec = tonic::codec::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)
-                }
-                _ => {
-                    Box::pin(async move {
-                        let mut response = http::Response::new(
-                            tonic::body::Body::default(),
-                        );
-                        let headers = response.headers_mut();
-                        headers
-                            .insert(
-                                tonic::Status::GRPC_STATUS,
-                                (tonic::Code::Unimplemented as i32).into(),
-                            );
-                        headers
-                            .insert(
-                                http::header::CONTENT_TYPE,
-                                tonic::metadata::GRPC_CONTENT_TYPE,
-                            );
-                        Ok(response)
-                    })
-                }
-            }
-        }
-    }
-    impl<T> Clone for TablesDataServer<T> {
-        fn clone(&self) -> Self {
-            let inner = self.inner.clone();
-            Self {
-                inner,
-                accept_compression_encodings: self.accept_compression_encodings,
-                send_compression_encodings: self.send_compression_encodings,
-                max_decoding_message_size: self.max_decoding_message_size,
-                max_encoding_message_size: self.max_encoding_message_size,
-            }
-        }
-    }
-    /// Generated gRPC service name
-    pub const SERVICE_NAME: &str = "komp_ac.tables_data.TablesData";
-    impl<T> tonic::server::NamedService for TablesDataServer<T> {
-        const NAME: &'static str = SERVICE_NAME;
-    }
-}

common/src/proto/multieko2.uctovnictvo.rs

@@ -1,721 +0,0 @@
-// This file is @generated by prost-build.
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PostUctovnictvoRequest {
-    #[prost(int64, tag = "1")]
-    pub adresar_id: i64,
-    #[prost(string, tag = "2")]
-    pub c_dokladu: ::prost::alloc::string::String,
-    /// Use string for simplicity, or use google.protobuf.Timestamp for better date handling
-    #[prost(string, tag = "3")]
-    pub datum: ::prost::alloc::string::String,
-    #[prost(string, tag = "4")]
-    pub c_faktury: ::prost::alloc::string::String,
-    #[prost(string, tag = "5")]
-    pub obsah: ::prost::alloc::string::String,
-    #[prost(string, tag = "6")]
-    pub stredisko: ::prost::alloc::string::String,
-    #[prost(string, tag = "7")]
-    pub c_uctu: ::prost::alloc::string::String,
-    #[prost(string, tag = "8")]
-    pub md: ::prost::alloc::string::String,
-    #[prost(string, tag = "9")]
-    pub identif: ::prost::alloc::string::String,
-    #[prost(string, tag = "10")]
-    pub poznanka: ::prost::alloc::string::String,
-    #[prost(string, tag = "11")]
-    pub firma: ::prost::alloc::string::String,
-}
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct UctovnictvoResponse {
-    #[prost(int64, tag = "1")]
-    pub id: i64,
-    #[prost(int64, tag = "2")]
-    pub adresar_id: i64,
-    #[prost(string, tag = "3")]
-    pub c_dokladu: ::prost::alloc::string::String,
-    #[prost(string, tag = "4")]
-    pub datum: ::prost::alloc::string::String,
-    #[prost(string, tag = "5")]
-    pub c_faktury: ::prost::alloc::string::String,
-    #[prost(string, tag = "6")]
-    pub obsah: ::prost::alloc::string::String,
-    #[prost(string, tag = "7")]
-    pub stredisko: ::prost::alloc::string::String,
-    #[prost(string, tag = "8")]
-    pub c_uctu: ::prost::alloc::string::String,
-    #[prost(string, tag = "9")]
-    pub md: ::prost::alloc::string::String,
-    #[prost(string, tag = "10")]
-    pub identif: ::prost::alloc::string::String,
-    #[prost(string, tag = "11")]
-    pub poznanka: ::prost::alloc::string::String,
-    #[prost(string, tag = "12")]
-    pub firma: ::prost::alloc::string::String,
-}
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PutUctovnictvoRequest {
-    #[prost(int64, tag = "1")]
-    pub id: i64,
-    #[prost(int64, tag = "2")]
-    pub adresar_id: i64,
-    #[prost(string, tag = "3")]
-    pub c_dokladu: ::prost::alloc::string::String,
-    #[prost(string, tag = "4")]
-    pub datum: ::prost::alloc::string::String,
-    #[prost(string, tag = "5")]
-    pub c_faktury: ::prost::alloc::string::String,
-    #[prost(string, tag = "6")]
-    pub obsah: ::prost::alloc::string::String,
-    #[prost(string, tag = "7")]
-    pub stredisko: ::prost::alloc::string::String,
-    #[prost(string, tag = "8")]
-    pub c_uctu: ::prost::alloc::string::String,
-    #[prost(string, tag = "9")]
-    pub md: ::prost::alloc::string::String,
-    #[prost(string, tag = "10")]
-    pub identif: ::prost::alloc::string::String,
-    #[prost(string, tag = "11")]
-    pub poznanka: ::prost::alloc::string::String,
-    #[prost(string, tag = "12")]
-    pub firma: ::prost::alloc::string::String,
-}
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct GetUctovnictvoRequest {
-    #[prost(int64, tag = "1")]
-    pub id: i64,
-}
-/// Generated client implementations.
-pub mod uctovnictvo_client {
-    #![allow(
-        unused_variables,
-        dead_code,
-        missing_docs,
-        clippy::wildcard_imports,
-        clippy::let_unit_value,
-    )]
-    use tonic::codegen::*;
-    use tonic::codegen::http::Uri;
-    #[derive(Debug, Clone)]
-    pub struct UctovnictvoClient<T> {
-        inner: tonic::client::Grpc<T>,
-    }
-    impl UctovnictvoClient<tonic::transport::Channel> {
-        /// Attempt to create a new client by connecting to a given endpoint.
-        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
-        where
-            D: TryInto<tonic::transport::Endpoint>,
-            D::Error: Into<StdError>,
-        {
-            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
-            Ok(Self::new(conn))
-        }
-    }
-    impl<T> UctovnictvoClient<T>
-    where
-        T: tonic::client::GrpcService<tonic::body::Body>,
-        T::Error: Into<StdError>,
-        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
-        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
-    {
-        pub fn new(inner: T) -> Self {
-            let inner = tonic::client::Grpc::new(inner);
-            Self { inner }
-        }
-        pub fn with_origin(inner: T, origin: Uri) -> Self {
-            let inner = tonic::client::Grpc::with_origin(inner, origin);
-            Self { inner }
-        }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> UctovnictvoClient<InterceptedService<T, F>>
-        where
-            F: tonic::service::Interceptor,
-            T::ResponseBody: Default,
-            T: tonic::codegen::Service<
-                http::Request<tonic::body::Body>,
-                Response = http::Response<
-                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
-                >,
-            >,
-            <T as tonic::codegen::Service<
-                http::Request<tonic::body::Body>,
-            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
-        {
-            UctovnictvoClient::new(InterceptedService::new(inner, interceptor))
-        }
-        /// Compress requests with the given encoding.
-        ///
-        /// This requires the server to support it otherwise it might respond with an
-        /// error.
-        #[must_use]
-        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.inner = self.inner.send_compressed(encoding);
-            self
-        }
-        /// Enable decompressing responses.
-        #[must_use]
-        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.inner = self.inner.accept_compressed(encoding);
-            self
-        }
-        /// Limits the maximum size of a decoded message.
-        ///
-        /// Default: `4MB`
-        #[must_use]
-        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
-            self.inner = self.inner.max_decoding_message_size(limit);
-            self
-        }
-        /// Limits the maximum size of an encoded message.
-        ///
-        /// Default: `usize::MAX`
-        #[must_use]
-        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
-            self.inner = self.inner.max_encoding_message_size(limit);
-            self
-        }
-        pub async fn post_uctovnictvo(
-            &mut self,
-            request: impl tonic::IntoRequest<super::PostUctovnictvoRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::UctovnictvoResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.uctovnictvo.Uctovnictvo/PostUctovnictvo",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "komp_ac.uctovnictvo.Uctovnictvo",
-                        "PostUctovnictvo",
-                    ),
-                );
-            self.inner.unary(req, path, codec).await
-        }
-        pub async fn get_uctovnictvo(
-            &mut self,
-            request: impl tonic::IntoRequest<super::GetUctovnictvoRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::UctovnictvoResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.uctovnictvo.Uctovnictvo/GetUctovnictvo",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "komp_ac.uctovnictvo.Uctovnictvo",
-                        "GetUctovnictvo",
-                    ),
-                );
-            self.inner.unary(req, path, codec).await
-        }
-        pub async fn get_uctovnictvo_count(
-            &mut self,
-            request: impl tonic::IntoRequest<super::super::common::Empty>,
-        ) -> std::result::Result<
-            tonic::Response<super::super::common::CountResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.uctovnictvo.Uctovnictvo/GetUctovnictvoCount",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "komp_ac.uctovnictvo.Uctovnictvo",
-                        "GetUctovnictvoCount",
-                    ),
-                );
-            self.inner.unary(req, path, codec).await
-        }
-        pub async fn get_uctovnictvo_by_position(
-            &mut self,
-            request: impl tonic::IntoRequest<super::super::common::PositionRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::UctovnictvoResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.uctovnictvo.Uctovnictvo/GetUctovnictvoByPosition",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "komp_ac.uctovnictvo.Uctovnictvo",
-                        "GetUctovnictvoByPosition",
-                    ),
-                );
-            self.inner.unary(req, path, codec).await
-        }
-        pub async fn put_uctovnictvo(
-            &mut self,
-            request: impl tonic::IntoRequest<super::PutUctovnictvoRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::UctovnictvoResponse>,
-            tonic::Status,
-        > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::unknown(
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/komp_ac.uctovnictvo.Uctovnictvo/PutUctovnictvo",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(
-                    GrpcMethod::new(
-                        "komp_ac.uctovnictvo.Uctovnictvo",
-                        "PutUctovnictvo",
-                    ),
-                );
-            self.inner.unary(req, path, codec).await
-        }
-    }
-}
-/// Generated server implementations.
-pub mod uctovnictvo_server {
-    #![allow(
-        unused_variables,
-        dead_code,
-        missing_docs,
-        clippy::wildcard_imports,
-        clippy::let_unit_value,
-    )]
-    use tonic::codegen::*;
-    /// Generated trait containing gRPC methods that should be implemented for use with UctovnictvoServer.
-    #[async_trait]
-    pub trait Uctovnictvo: std::marker::Send + std::marker::Sync + 'static {
-        async fn post_uctovnictvo(
-            &self,
-            request: tonic::Request<super::PostUctovnictvoRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::UctovnictvoResponse>,
-            tonic::Status,
-        >;
-        async fn get_uctovnictvo(
-            &self,
-            request: tonic::Request<super::GetUctovnictvoRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::UctovnictvoResponse>,
-            tonic::Status,
-        >;
-        async fn get_uctovnictvo_count(
-            &self,
-            request: tonic::Request<super::super::common::Empty>,
-        ) -> std::result::Result<
-            tonic::Response<super::super::common::CountResponse>,
-            tonic::Status,
-        >;
-        async fn get_uctovnictvo_by_position(
-            &self,
-            request: tonic::Request<super::super::common::PositionRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::UctovnictvoResponse>,
-            tonic::Status,
-        >;
-        async fn put_uctovnictvo(
-            &self,
-            request: tonic::Request<super::PutUctovnictvoRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::UctovnictvoResponse>,
-            tonic::Status,
-        >;
-    }
-    #[derive(Debug)]
-    pub struct UctovnictvoServer<T> {
-        inner: Arc<T>,
-        accept_compression_encodings: EnabledCompressionEncodings,
-        send_compression_encodings: EnabledCompressionEncodings,
-        max_decoding_message_size: Option<usize>,
-        max_encoding_message_size: Option<usize>,
-    }
-    impl<T> UctovnictvoServer<T> {
-        pub fn new(inner: T) -> Self {
-            Self::from_arc(Arc::new(inner))
-        }
-        pub fn from_arc(inner: Arc<T>) -> Self {
-            Self {
-                inner,
-                accept_compression_encodings: Default::default(),
-                send_compression_encodings: Default::default(),
-                max_decoding_message_size: None,
-                max_encoding_message_size: None,
-            }
-        }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> InterceptedService<Self, F>
-        where
-            F: tonic::service::Interceptor,
-        {
-            InterceptedService::new(Self::new(inner), interceptor)
-        }
-        /// Enable decompressing requests with the given encoding.
-        #[must_use]
-        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.accept_compression_encodings.enable(encoding);
-            self
-        }
-        /// Compress responses with the given encoding, if the client supports it.
-        #[must_use]
-        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.send_compression_encodings.enable(encoding);
-            self
-        }
-        /// Limits the maximum size of a decoded message.
-        ///
-        /// Default: `4MB`
-        #[must_use]
-        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
-            self.max_decoding_message_size = Some(limit);
-            self
-        }
-        /// Limits the maximum size of an encoded message.
-        ///
-        /// Default: `usize::MAX`
-        #[must_use]
-        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
-            self.max_encoding_message_size = Some(limit);
-            self
-        }
-    }
-    impl<T, B> tonic::codegen::Service<http::Request<B>> for UctovnictvoServer<T>
-    where
-        T: Uctovnictvo,
-        B: Body + std::marker::Send + 'static,
-        B::Error: Into<StdError> + std::marker::Send + 'static,
-    {
-        type Response = http::Response<tonic::body::Body>;
-        type Error = std::convert::Infallible;
-        type Future = BoxFuture<Self::Response, Self::Error>;
-        fn poll_ready(
-            &mut self,
-            _cx: &mut Context<'_>,
-        ) -> Poll<std::result::Result<(), Self::Error>> {
-            Poll::Ready(Ok(()))
-        }
-        fn call(&mut self, req: http::Request<B>) -> Self::Future {
-            match req.uri().path() {
-                "/komp_ac.uctovnictvo.Uctovnictvo/PostUctovnictvo" => {
-                    #[allow(non_camel_case_types)]
-                    struct PostUctovnictvoSvc<T: Uctovnictvo>(pub Arc<T>);
-                    impl<
-                        T: Uctovnictvo,
-                    > tonic::server::UnaryService<super::PostUctovnictvoRequest>
-                    for PostUctovnictvoSvc<T> {
-                        type Response = super::UctovnictvoResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<super::PostUctovnictvoRequest>,
-                        ) -> Self::Future {
-                            let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as Uctovnictvo>::post_uctovnictvo(&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 = PostUctovnictvoSvc(inner);
-                        let codec = tonic::codec::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.uctovnictvo.Uctovnictvo/GetUctovnictvo" => {
-                    #[allow(non_camel_case_types)]
-                    struct GetUctovnictvoSvc<T: Uctovnictvo>(pub Arc<T>);
-                    impl<
-                        T: Uctovnictvo,
-                    > tonic::server::UnaryService<super::GetUctovnictvoRequest>
-                    for GetUctovnictvoSvc<T> {
-                        type Response = super::UctovnictvoResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<super::GetUctovnictvoRequest>,
-                        ) -> Self::Future {
-                            let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as Uctovnictvo>::get_uctovnictvo(&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 = GetUctovnictvoSvc(inner);
-                        let codec = tonic::codec::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.uctovnictvo.Uctovnictvo/GetUctovnictvoCount" => {
-                    #[allow(non_camel_case_types)]
-                    struct GetUctovnictvoCountSvc<T: Uctovnictvo>(pub Arc<T>);
-                    impl<
-                        T: Uctovnictvo,
-                    > tonic::server::UnaryService<super::super::common::Empty>
-                    for GetUctovnictvoCountSvc<T> {
-                        type Response = super::super::common::CountResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<super::super::common::Empty>,
-                        ) -> Self::Future {
-                            let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as Uctovnictvo>::get_uctovnictvo_count(&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 = GetUctovnictvoCountSvc(inner);
-                        let codec = tonic::codec::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.uctovnictvo.Uctovnictvo/GetUctovnictvoByPosition" => {
-                    #[allow(non_camel_case_types)]
-                    struct GetUctovnictvoByPositionSvc<T: Uctovnictvo>(pub Arc<T>);
-                    impl<
-                        T: Uctovnictvo,
-                    > tonic::server::UnaryService<super::super::common::PositionRequest>
-                    for GetUctovnictvoByPositionSvc<T> {
-                        type Response = super::UctovnictvoResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<
-                                super::super::common::PositionRequest,
-                            >,
-                        ) -> Self::Future {
-                            let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as Uctovnictvo>::get_uctovnictvo_by_position(
-                                        &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 = GetUctovnictvoByPositionSvc(inner);
-                        let codec = tonic::codec::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.uctovnictvo.Uctovnictvo/PutUctovnictvo" => {
-                    #[allow(non_camel_case_types)]
-                    struct PutUctovnictvoSvc<T: Uctovnictvo>(pub Arc<T>);
-                    impl<
-                        T: Uctovnictvo,
-                    > tonic::server::UnaryService<super::PutUctovnictvoRequest>
-                    for PutUctovnictvoSvc<T> {
-                        type Response = super::UctovnictvoResponse;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::Response>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<super::PutUctovnictvoRequest>,
-                        ) -> Self::Future {
-                            let inner = Arc::clone(&self.0);
-                            let fut = async move {
-                                <T as Uctovnictvo>::put_uctovnictvo(&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 = PutUctovnictvoSvc(inner);
-                        let codec = tonic::codec::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)
-                }
-                _ => {
-                    Box::pin(async move {
-                        let mut response = http::Response::new(
-                            tonic::body::Body::default(),
-                        );
-                        let headers = response.headers_mut();
-                        headers
-                            .insert(
-                                tonic::Status::GRPC_STATUS,
-                                (tonic::Code::Unimplemented as i32).into(),
-                            );
-                        headers
-                            .insert(
-                                http::header::CONTENT_TYPE,
-                                tonic::metadata::GRPC_CONTENT_TYPE,
-                            );
-                        Ok(response)
-                    })
-                }
-            }
-        }
-    }
-    impl<T> Clone for UctovnictvoServer<T> {
-        fn clone(&self) -> Self {
-            let inner = self.inner.clone();
-            Self {
-                inner,
-                accept_compression_encodings: self.accept_compression_encodings,
-                send_compression_encodings: self.send_compression_encodings,
-                max_decoding_message_size: self.max_decoding_message_size,
-                max_encoding_message_size: self.max_encoding_message_size,
-            }
-        }
-    }
-    /// Generated gRPC service name
-    pub const SERVICE_NAME: &str = "komp_ac.uctovnictvo.Uctovnictvo";
-    impl<T> tonic::server::NamedService for UctovnictvoServer<T> {
-        const NAME: &'static str = SERVICE_NAME;
-    }
-}

server/Cargo.toml

@@ -10,10 +10,10 @@ search = { path = "../search" }
 
 anyhow = { workspace = true }
 tantivy = { workspace = true }
+prost = "0.13.5"
 prost-types = { workspace = true }
 chrono = { version = "0.4.40", features = ["serde"] }
 dotenvy = "0.15.7"
-prost = "0.13.5"
 serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.140"
 sqlx = { version = "0.8.5", features = ["chrono", "postgres", "runtime-tokio", "runtime-tokio-native-tls", "rust_decimal", "time", "uuid"] }
@@ -40,6 +40,9 @@ regex = { workspace = true }
 thiserror = { workspace = true }
 steel-decimal = "1.0.0"
 
+[build-dependencies]
+prost-build = "0.14.1"
+
 [lib]
 name = "server"
 path = "src/lib.rs"

server/migrations/20250912195658_create_table_validation_rules.sql

@@ -0,0 +1,15 @@
+-- Add migration script here
+
+CREATE TABLE table_validation_rules (
+    id BIGSERIAL PRIMARY KEY,
+    table_def_id BIGINT NOT NULL
+        REFERENCES table_definitions(id)
+        ON DELETE CASCADE,
+    data_key TEXT NOT NULL,
+    config JSONB NOT NULL,
+    updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE (table_def_id, data_key)
+);
+
+CREATE INDEX idx_table_validation_rules_table
+    ON table_validation_rules (table_def_id);

server/scripts/reset_test_db.sh

@@ -1,9 +1,39 @@
 #!/bin/bash
 # scripts/reset_test_db.sh
 
-DATABASE_URL=${TEST_DATABASE_URL:-"postgres://multi_psql_dev:3@localhost:5432/multi_rust_test"}
+# Load environment variables from .env_test if it exists
+if [ -f .env_test ]; then
+    export $(grep -v '^#' .env_test | xargs)
+fi
 
-echo "Reset db script"
+DATABASE_URL=${TEST_DATABASE_URL:-"postgres://multi_psql_dev:3@localhost:5432/multi_rust_test"}
-yes | sqlx database drop --database-url "$DATABASE_URL"
+echo "Resetting test DB at $DATABASE_URL"
+
+# Check if database exists and who owns it
+DB_NAME=$(echo "$DATABASE_URL" | sed 's|.*/||')
+DB_HOST=$(echo "$DATABASE_URL" | sed 's|.*@||' | sed 's|:.*||')
+DB_PORT=$(echo "$DATABASE_URL" | sed 's|.*:||' | sed 's|/.*||')
+DB_USER=$(echo "$DATABASE_URL" | sed 's|.*://||' | sed 's|:.*||')
+
+# Check database owner (optional info)
+DB_OWNER=$(psql "$DATABASE_URL" -t -c "SELECT pg_catalog.pg_get_userbyid(d.datdba) FROM pg_catalog.pg_database d WHERE d.datname = '$DB_NAME';" 2>/dev/null | xargs)
+if [ ! -z "$DB_OWNER" ]; then
+    echo "Database owner: $DB_OWNER"
+fi
+
+# Force drop database without confirmation
+echo "Dropping database..."
+sqlx database drop --database-url "$DATABASE_URL" --yes 2>/dev/null || {
+    # Fallback: use psql to force drop
+    psql "postgres://$DB_USER@$DB_HOST:$DB_PORT/postgres" -c "DROP DATABASE IF EXISTS \"$DB_NAME\";" 2>/dev/null || true
+}
+
+# Create database
+echo "Creating database..."
 sqlx database create --database-url "$DATABASE_URL"
-echo "Test database reset complete."
+
+# Apply migrations
+echo "Applying migrations..."
+sqlx migrate run --database-url "$DATABASE_URL"
+
+echo "✅ Test database reset and migrated."

server/src/lib.rs

@@ -10,6 +10,7 @@ pub mod table_definition;
 pub mod tables_data;
 pub mod table_script;
 pub mod steel;
+pub mod table_validation;
 
 // Re-export run_server from the inner server module:
 pub use server::run_server;

server/src/server/run.rs

@@ -16,12 +16,14 @@ use crate::server::services::{
 use common::proto::komp_ac::{
     table_structure::table_structure_service_server::TableStructureServiceServer,
     table_definition::table_definition_server::TableDefinitionServer,
+    table_validation::table_validation_service_server::TableValidationServiceServer,
     tables_data::tables_data_server::TablesDataServer,
     table_script::table_script_server::TableScriptServer,
     auth::auth_service_server::AuthServiceServer,
     search2::search2_server::Search2Server,
 };
 use search::{SearcherService, SearcherServer};
+use crate::table_validation::get::service::TableValidationSvc;
 
 pub async fn run_server(db_pool: sqlx::PgPool) -> Result<(), Box<dyn std::error::Error>> {
     // Initialize JWT for authentication
@@ -43,6 +45,7 @@ pub async fn run_server(db_pool: sqlx::PgPool) -> Result<(), Box<dyn std::error:
 
     // Initialize services, passing the indexer sender to the relevant ones
     let table_definition_service = TableDefinitionService { db_pool: db_pool.clone() };
+    let table_validation_service = TableValidationSvc { db: db_pool.clone() };
     let tables_data_service = TablesDataService {
         db_pool: db_pool.clone(),
         indexer_tx: indexer_tx.clone(),
@@ -55,6 +58,7 @@ pub async fn run_server(db_pool: sqlx::PgPool) -> Result<(), Box<dyn std::error:
     Server::builder()
         .add_service(TableStructureServiceServer::new(TableStructureHandler { db_pool: db_pool.clone() }))
         .add_service(TableDefinitionServer::new(table_definition_service))
+        .add_service(TableValidationServiceServer::new(table_validation_service))
         .add_service(TablesDataServer::new(tables_data_service))
         .add_service(TableScriptServer::new(table_script_service))
         .add_service(AuthServiceServer::new(auth_service))

server/src/server/services/mod.rs

@@ -2,6 +2,7 @@
 
 pub mod table_structure_service;
 pub mod table_definition_service;
+pub mod table_validation_service;
 pub mod tables_data_service;
 pub mod table_script_service;
 pub mod auth_service;
@@ -9,6 +10,7 @@ pub mod search2_service;
 
 pub use table_structure_service::TableStructureHandler;
 pub use table_definition_service::TableDefinitionService;
+pub use table_validation_service::*;
 pub use tables_data_service::TablesDataService;
 pub use table_script_service::TableScriptService;
 pub use auth_service::AuthServiceImpl;

server/src/server/services/table_validation_service.rs

@@ -0,0 +1,11 @@
+// src/server/services/table_validation_service.rs
+
+use tonic::transport::Server;
+use sqlx::PgPool;
+
+use common::proto::komp_ac::table_validation::table_validation_service_server::TableValidationServiceServer;
+use crate::table_validation::get::service::TableValidationSvc;
+
+pub fn svc(db: PgPool) -> TableValidationServiceServer<TableValidationSvc> {
+    TableValidationServiceServer::new(TableValidationSvc { db })
+}

server/src/table_definition/handlers/post_table_definition.rs

@@ -351,6 +351,29 @@ async fn execute_table_definition(
         Status::internal(format!("Database error: {}", e))
     })?;
 
+    for col_def in &columns {
+        // Column string looks like "\"name\" TYPE", split out identifier
+        let col_name = col_def.split_whitespace().next().unwrap_or("");
+        let clean_col = col_name.trim_matches('"');
+
+        // Default empty config — currently only character_limits block, none set.
+        let default_cfg = serde_json::json!({ 
+            "character_limits": { "min": 0, "max": 0, "warn_at": null, "count_mode": "CHARS" }
+        });
+
+        sqlx::query!(
+            r#"INSERT INTO table_validation_rules (table_def_id, data_key, config)
+           VALUES ($1, $2, $3)
+           ON CONFLICT (table_def_id, data_key) DO NOTHING"#,
+           table_def.id,
+           clean_col,
+           default_cfg
+        )
+        .execute(&mut **tx)
+        .await
+        .map_err(|e| Status::internal(format!("Failed to insert default validation rule for column {}: {}", clean_col, e)))?;
+    }
+
     for (linked_id, is_required) in links {
         sqlx::query!(
             "INSERT INTO table_definition_links

server/src/table_validation/get/mod.rs

@@ -0,0 +1,2 @@
+// src/table_validation/get/mod.rs
+pub mod service;

server/src/table_validation/get/service.rs

@@ -0,0 +1,109 @@
+// src/table_validation/get/service.rs
+
+use tonic::{Request, Response, Status};
+use sqlx::PgPool;
+use common::proto::komp_ac::table_validation::{
+    table_validation_service_server::TableValidationService,
+    GetTableValidationRequest, TableValidationResponse,
+    UpdateFieldValidationRequest, UpdateFieldValidationResponse,
+    FieldValidation,
+};
+use crate::table_validation::post::repo; // repo still lives in post
+
+pub struct TableValidationSvc {
+    pub db: PgPool,
+}
+
+#[tonic::async_trait]
+impl TableValidationService for TableValidationSvc {
+    async fn get_table_validation(
+        &self,
+        req: Request<GetTableValidationRequest>,
+    ) -> Result<Response<TableValidationResponse>, Status> {
+        let req = req.into_inner();
+
+        // 1. Get table_def_id
+        let table_def_id = repo::get_table_def_id(&self.db, &req.profile_name, &req.table_name)
+            .await
+            .map_err(|_| Status::not_found("Table definition not found"))?;
+
+        // 2. Get validations
+        let rules = repo::get_validations(&self.db, table_def_id)
+            .await
+            .map_err(|e| Status::internal(format!("Failed to fetch rules: {}", e)))?;
+
+        // 3. Parse JSON directly into proto types
+        let mut fields_out = Vec::new();
+        for r in rules {
+            match serde_json::from_value::<FieldValidation>(r.config) {
+                Ok(mut fv) => {
+                    // Set the data_key from the database row
+                    fv.data_key = r.data_key;
+                    
+                    // Skip if limits are all zero
+                    if let Some(lims) = &fv.limits {
+                        if lims.min == 0 && lims.max == 0 && lims.warn_at.is_none() {
+                            continue;
+                        }
+                    }
+                    fields_out.push(fv);
+                }
+                Err(e) => {
+                    tracing::warn!("Invalid JSON for {}: {}", r.data_key, e);
+                    continue;
+                }
+            }
+        }
+
+        Ok(Response::new(TableValidationResponse { fields: fields_out }))
+    }
+
+    async fn update_field_validation(
+        &self,
+        req: Request<UpdateFieldValidationRequest>,
+    ) -> Result<Response<UpdateFieldValidationResponse>, Status> {
+        let req = req.into_inner();
+
+        let table_def_id = repo::get_table_def_id(
+            &self.db, &req.profile_name, &req.table_name,
+        )
+        .await
+        .map_err(|_| Status::not_found("Table definition not found"))?;
+
+        // Check if validation is provided
+        if let Some(validation) = req.validation {
+            // Convert proto FieldValidation directly to JSON
+            let json_value = serde_json::to_value(&validation)
+                .map_err(|e| Status::internal(format!("serialize error: {e}")))?;
+
+            sqlx::query!(
+                r#"
+                INSERT INTO table_validation_rules (
+                    table_def_id, data_key, config, updated_at
+                )
+                VALUES ($1, $2, $3, now())
+                ON CONFLICT (table_def_id, data_key)
+                DO UPDATE SET
+                    config = EXCLUDED.config,
+                    updated_at = now()
+                "#,
+                table_def_id,
+                req.data_key,
+                json_value
+            )
+            .execute(&self.db)
+            .await
+            .map_err(|e| Status::internal(format!("DB error: {e}")))?;
+
+            Ok(Response::new(UpdateFieldValidationResponse {
+                success: true,
+                message: format!(
+                    "Validation rules updated for {}.{} column {}",
+                    req.profile_name, req.table_name, req.data_key
+                ),
+            }))
+        } else {
+            Err(Status::invalid_argument("No validation provided"))
+        }
+    }
+}

server/src/table_validation/mod.rs

@@ -0,0 +1,4 @@
+// src/table_validation/mod.rs
+
+pub mod post;
+pub mod get;

server/src/table_validation/post/mod.rs

@@ -0,0 +1,3 @@
+// src/table_validation/post/mod.rs
+
+pub mod repo;

server/src/table_validation/post/repo.rs

@@ -0,0 +1,52 @@
+// src/table_validation/repo.rs
+
+use sqlx::PgPool;
+use anyhow::Result;
+use serde_json::Value;
+
+pub struct ValidationRuleRow {
+    pub data_key: String,
+    pub config: Value,
+}
+
+pub async fn get_table_def_id(
+    db: &PgPool,
+    profile_name: &str,
+    table_name: &str,
+) -> Result<i64> {
+    let rec = sqlx::query!(
+        r#"
+        SELECT td.id
+        FROM table_definitions td
+        JOIN schemas s ON td.schema_id = s.id
+        WHERE s.name = $1 AND td.table_name = $2
+        "#,
+        profile_name,
+        table_name
+    )
+    .fetch_one(db)
+    .await?;
+
+    Ok(rec.id)
+}
+
+pub async fn get_validations(
+    db: &PgPool,
+    table_def_id: i64,
+) -> Result<Vec<ValidationRuleRow>> {
+    let rows = sqlx::query!(
+        r#"
+        SELECT data_key, config
+        FROM table_validation_rules
+        WHERE table_def_id = $1
+        "#,
+        table_def_id
+    )
+    .fetch_all(db)
+    .await?;
+
+    Ok(rows.into_iter().map(|r| ValidationRuleRow {
+        data_key: r.data_key,
+        config: r.config,
+    }).collect())
+}

server/src/table_validation/post/service.rs

@@ -0,0 +1,18 @@
+// src/table_validation/post/service.rs
+
+use tonic::{Request, Response, Status};
+use sqlx::PgPool;
+use common::proto::komp_ac::table_validation::{
+    UpdateFieldValidationRequest, UpdateFieldValidationResponse,
+};
+use crate::table_validation::post::repo;
+
+pub struct TableValidationUpdateSvc {
+    pub db: PgPool,
+}
+
+impl TableValidationUpdateSvc {
+    pub fn new(db: PgPool) -> Self {
+        Self { db }
+    }
+}