// This file is @generated by prost-build. /// Insert a new row. #[derive(Clone, PartialEq, ::prost::Message)] pub struct PostTableDataRequest { /// Required. Profile (PostgreSQL schema) name that owns the table. /// Must exist in the schemas table. #[prost(string, tag = "1")] pub profile_name: ::prost::alloc::string::String, /// Required. Logical table (definition) name within the profile. /// Must exist in table_definitions for the given profile. #[prost(string, tag = "2")] pub table_name: ::prost::alloc::string::String, /// Required. Key-value data for columns to insert. /// /// Allowed keys: /// /// * User-defined columns from the table definition /// * System/FK columns: /// • "deleted" (BOOLEAN), optional; default FALSE if not provided /// • one BIGINT per link, named by whoever declared it /// • "account" (required, non-null slash-delimited account string) on /// ACCOUNTING-enabled tables /// /// Type expectations by SQL type: /// /// * TEXT: string value; empty string is treated as NULL /// * BOOLEAN: bool value /// * TIMESTAMPTZ: ISO 8601/RFC 3339 string (parsed to TIMESTAMPTZ) /// * INTEGER: number with no fractional part and within i32 range /// * BIGINT: number with no fractional part and within i64 range /// * NUMERIC(p,s): string representation only; empty string becomes NULL /// (numbers for NUMERIC are rejected to avoid precision loss) /// /// Script validation rules: /// /// * If a script exists for a target column, that column MUST be present here, /// and its provided value MUST equal the script’s computed value (type-aware /// comparison, e.g., decimals are compared numerically). /// /// Notes: /// /// * Unknown/invalid column names are rejected /// * Some application-specific validations may apply (e.g., max length for /// certain fields like "telefon") #[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 PostAccountingTableDataRequest { #[prost(message, optional, tag = "1")] pub row: ::core::option::Option, #[prost(message, optional, tag = "2")] pub exchange_rate_selection: ::core::option::Option< super::ecb::ExchangeRateSelection, >, } /// Insert response. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct PostTableDataResponse { /// True if the insert succeeded. #[prost(bool, tag = "1")] pub success: bool, /// Human-readable message. #[prost(string, tag = "2")] pub message: ::prost::alloc::string::String, /// The id of the inserted row. #[prost(int64, tag = "3")] pub inserted_id: i64, /// Revision committed for the inserted row. #[prost(int64, tag = "4")] pub row_revision: i64, /// Journal created or updated by automatic accounting, when applicable. #[prost(int64, optional, tag = "5")] pub journal_id: ::core::option::Option, } /// One row in a bulk insert request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct PostTableDataBulkRow { /// Required. Same data payload as PostTableDataRequest.data. #[prost(map = "string, message", tag = "1")] pub data: ::std::collections::HashMap< ::prost::alloc::string::String, ::prost_types::Value, >, } /// Bulk insert request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct PostTableDataBulkRequest { /// Required. Profile (PostgreSQL schema) name that owns the table. #[prost(string, tag = "1")] pub profile_name: ::prost::alloc::string::String, /// Required. Logical table (definition) name within the profile. #[prost(string, tag = "2")] pub table_name: ::prost::alloc::string::String, /// Required. Rows to insert. Must contain at least 1 and at most 10,000 rows. #[prost(message, repeated, tag = "3")] pub rows: ::prost::alloc::vec::Vec, } /// Bulk insert response. #[derive(Clone, PartialEq, ::prost::Message)] pub struct PostTableDataBulkResponse { /// True if all rows were inserted successfully. #[prost(bool, tag = "1")] pub success: bool, /// Human-readable message. #[prost(string, tag = "2")] pub message: ::prost::alloc::string::String, /// Per-row responses from the underlying PostTableData logic, in request order. #[prost(message, repeated, tag = "3")] pub responses: ::prost::alloc::vec::Vec, } /// Update an existing row. #[derive(Clone, PartialEq, ::prost::Message)] pub struct PutTableDataRequest { /// Required. Profile (schema) name. #[prost(string, tag = "1")] pub profile_name: ::prost::alloc::string::String, /// Required. Table name within the profile. #[prost(string, tag = "2")] pub table_name: ::prost::alloc::string::String, /// Required. Id of the row to update. #[prost(int64, tag = "3")] pub id: i64, /// Required. Columns to update (same typing rules as PostTableDataRequest.data). /// "account" may be omitted, but cannot be null when supplied. /// /// Special script rules: /// /// * If a script targets column X and X is included here, the value for X must /// equal the script’s result (type-aware). /// * If X is not included here but the update would cause the script’s result /// to change compared to the current stored value, the update is rejected with /// FAILED_PRECONDITION, instructing the caller to include X explicitly. /// /// Passing an empty map results in a no-op success response. #[prost(map = "string, message", tag = "4")] pub data: ::std::collections::HashMap< ::prost::alloc::string::String, ::prost_types::Value, >, /// Required. Revision returned when this row was loaded or last saved. #[prost(int64, tag = "5")] pub expected_revision: i64, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct PutAccountingTableDataRequest { #[prost(message, optional, tag = "1")] pub update: ::core::option::Option, #[prost(message, optional, tag = "2")] pub exchange_rate_selection: ::core::option::Option< super::ecb::ExchangeRateSelection, >, #[prost(bool, tag = "3")] pub confirmed: bool, #[prost(string, repeated, tag = "4")] pub expected_affected_profiles: ::prost::alloc::vec::Vec< ::prost::alloc::string::String, >, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct PutTableDataConfirmedRequest { #[prost(message, optional, tag = "1")] pub update: ::core::option::Option, #[prost(string, repeated, tag = "2")] pub expected_affected_profiles: ::prost::alloc::vec::Vec< ::prost::alloc::string::String, >, } /// Update response. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct PutTableDataResponse { /// True if the update succeeded (or no-op on empty data). #[prost(bool, tag = "1")] pub success: bool, /// Human-readable message. #[prost(string, tag = "2")] pub message: ::prost::alloc::string::String, /// The id of the updated row. #[prost(int64, tag = "3")] pub updated_id: i64, /// Revision committed for the updated row. #[prost(int64, tag = "4")] pub row_revision: i64, /// Journal updated by automatic accounting, when applicable. #[prost(int64, optional, tag = "5")] pub journal_id: ::core::option::Option, } #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct TableUpdateImpactRequest { #[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, Eq, Hash, ::prost::Message)] pub struct TableUpdateImpactResponse { #[prost(string, repeated, tag = "1")] pub affected_profiles: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ArchiveTableDataRequest { #[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(int64, tag = "4")] pub expected_revision: i64, } #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ArchiveTableDataResponse { #[prost(bool, tag = "1")] pub success: bool, #[prost(int64, tag = "2")] pub archived_version: i64, #[prost(string, tag = "3")] pub archived_at: ::prost::alloc::string::String, #[prost(string, repeated, tag = "4")] pub affected_profiles: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, #[prost(int64, tag = "5")] pub current_version: i64, #[prost(int64, tag = "6")] pub row_revision: i64, } /// Soft-delete a single row. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct DeleteTableDataRequest { /// Required. Profile (schema) name. #[prost(string, tag = "1")] pub profile_name: ::prost::alloc::string::String, /// Required. Table name within the profile. #[prost(string, tag = "2")] pub table_name: ::prost::alloc::string::String, /// Required. Row id to soft-delete. #[prost(int64, tag = "3")] pub record_id: i64, /// Required. Revision returned when this row was loaded or last saved. #[prost(int64, tag = "4")] pub expected_revision: i64, } /// Soft-delete response. #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct DeleteTableDataResponse { /// True when the row was successfully marked deleted. #[prost(bool, tag = "1")] pub success: bool, } /// Fetch a single non-deleted row by id. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct GetTableDataRequest { /// Required. Profile (schema) name. #[prost(string, tag = "1")] pub profile_name: ::prost::alloc::string::String, /// Required. Table name within the profile. #[prost(string, tag = "2")] pub table_name: ::prost::alloc::string::String, /// Required. Id of the row to fetch. #[prost(int64, tag = "3")] pub id: i64, } #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct GetTableDataVersionRequest { #[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(int64, tag = "4")] pub version: i64, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct ResolvedTableLinkVersion { #[prost(int64, tag = "1")] pub version: i64, #[prost(map = "string, string", tag = "2")] pub data: ::std::collections::HashMap< ::prost::alloc::string::String, ::prost::alloc::string::String, >, #[prost(string, repeated, tag = "3")] pub row_display_values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, #[prost(string, repeated, tag = "4")] pub row_display_columns: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct ResolvedTableLinkUpdate { #[prost(int64, tag = "1")] pub version: i64, #[prost(map = "string, string", tag = "2")] pub data: ::std::collections::HashMap< ::prost::alloc::string::String, ::prost::alloc::string::String, >, #[prost(string, repeated, tag = "3")] pub row_display_values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, #[prost(string, repeated, tag = "4")] pub changed_fields: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct ResolvedTableLink { #[prost(int64, tag = "1")] pub id: i64, #[prost(message, optional, tag = "2")] pub saved: ::core::option::Option, #[prost(enumeration = "ResolvedTableLinkStatus", tag = "3")] pub status: i32, #[prost(message, optional, tag = "4")] pub newer: ::core::option::Option, } /// Row payload: all columns returned as strings. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GetTableDataResponse { /// Map of column_name → stringified value for: /// /// * id, deleted /// * all user-defined columns from the table definition /// * one column per link, named by whoever declared it /// * account for ACCOUNTING-enabled tables /// /// All values are returned as TEXT via col::TEXT and COALESCEed to empty string /// (NULL becomes ""). The row is returned only if deleted = FALSE. #[prost(map = "string, string", tag = "1")] pub data: ::std::collections::HashMap< ::prost::alloc::string::String, ::prost::alloc::string::String, >, /// Configured human-readable values for this row, in display order. A value /// is empty when its column is NULL/empty; an empty list means the row is /// identified by its id alone. #[prost(string, repeated, tag = "2")] pub row_display_values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, #[prost(string, repeated, tag = "3")] pub row_display_columns: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Links keyed by their public column name. Each value contains the row as /// saved by this record and, when the caller may read the target table, its /// newest available state. Restricted links contain only the target table's /// configured display columns. #[prost(map = "string, message", tag = "4")] pub resolved_links: ::std::collections::HashMap< ::prost::alloc::string::String, ResolvedTableLink, >, /// The generation returned by this response. Zero is never returned. #[prost(int64, tag = "5")] pub row_version: i64, /// Active journal containing this row's automatic accounting line, when the /// table is ACCOUNTING-enabled and the row has been posted. #[prost(int64, optional, tag = "6")] pub journal_id: ::core::option::Option, } /// Count non-deleted rows. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct GetTableDataCountRequest { /// Required. Profile (schema) name. #[prost(string, tag = "1")] pub profile_name: ::prost::alloc::string::String, /// Required. Table name within the profile. #[prost(string, tag = "2")] pub table_name: ::prost::alloc::string::String, } /// Fetch by ordinal position among non-deleted rows (1-based). #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct GetTableDataByPositionRequest { /// Required. Profile (schema) name. #[prost(string, tag = "1")] pub profile_name: ::prost::alloc::string::String, /// Required. Table name within the profile. #[prost(string, tag = "2")] pub table_name: ::prost::alloc::string::String, /// Required. 1-based position by id ascending among rows with deleted = FALSE. #[prost(int32, tag = "3")] pub position: i32, } /// A link resolved exactly as the source row stored it, together with the /// target row's current state. The physical companion version column remains /// an internal implementation detail. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum ResolvedTableLinkStatus { Current = 0, Superseded = 1, Unavailable = 2, Deleted = 3, /// The source row may expose the FK and the target's configured display /// columns, but the caller may not read the target table itself. Restricted = 4, } impl ResolvedTableLinkStatus { /// 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::Current => "CURRENT", Self::Superseded => "SUPERSEDED", Self::Unavailable => "UNAVAILABLE", Self::Deleted => "DELETED", Self::Restricted => "RESTRICTED", } } /// Creates an enum from field names used in the ProtoBuf definition. pub fn from_str_name(value: &str) -> ::core::option::Option { match value { "CURRENT" => Some(Self::Current), "SUPERSEDED" => Some(Self::Superseded), "UNAVAILABLE" => Some(Self::Unavailable), "DELETED" => Some(Self::Deleted), "RESTRICTED" => Some(Self::Restricted), _ => None, } } } /// 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; /// Read and write row data for user-defined tables inside profiles (schemas). /// Operations are performed against the physical PostgreSQL table that /// corresponds to the logical table definition and are scoped by profile /// (schema). Deletions are soft (set deleted = true). Typed binding and /// script-based validation are enforced consistently. #[derive(Debug, Clone)] pub struct TablesDataClient { inner: tonic::client::Grpc, } impl TablesDataClient { /// Attempt to create a new client by connecting to a given endpoint. pub async fn connect(dst: D) -> Result where D: TryInto, D::Error: Into, { let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; Ok(Self::new(conn)) } } impl TablesDataClient where T: tonic::client::GrpcService, T::Error: Into, T::ResponseBody: Body + std::marker::Send + 'static, ::Error: Into + 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( inner: T, interceptor: F, ) -> TablesDataClient> where F: tonic::service::Interceptor, T::ResponseBody: Default, T: tonic::codegen::Service< http::Request, Response = http::Response< >::ResponseBody, >, >, , >>::Error: Into + 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 } /// Insert a new row into a table with strict type binding and script validation. /// /// Behavior: /// /// * Validates that profile (schema) exists and table is defined for it /// * Validates provided columns exist (user-defined or allowed system/FK columns) /// * For columns targeted by scripts in this table, the client MUST provide the /// value, and it MUST equal the script’s calculated value (compared type-safely) /// * Binds values with correct SQL types, rejects invalid formats/ranges /// * Inserts the row and returns the new id; queues search indexing (best effort) /// * If the physical table is missing but the definition exists, returns INTERNAL pub async fn post_table_data( &mut self, request: impl tonic::IntoRequest, ) -> std::result::Result< tonic::Response, tonic::Status, > { self.inner .ready() .await .map_err(|e| { tonic::Status::unknown( format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/komp_ac.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 } /// Insert an ACCOUNTING-enabled source row with an explicit exchange-rate /// treatment for the journal line created from it. pub async fn post_accounting_table_data( &mut self, request: impl tonic::IntoRequest, ) -> std::result::Result< tonic::Response, tonic::Status, > { self.inner .ready() .await .map_err(|e| { tonic::Status::unknown( format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/komp_ac.tables_data.TablesData/PostAccountingTableData", ); let mut req = request.into_request(); req.extensions_mut() .insert( GrpcMethod::new( "komp_ac.tables_data.TablesData", "PostAccountingTableData", ), ); self.inner.unary(req, path, codec).await } /// Insert multiple rows by applying PostTableData behavior to each row. /// /// Behavior: /// /// * Accepts 1..10,000 rows in one gRPC request /// * Processes rows in request order /// * Each row is inserted through the same validation, script execution, /// typed binding, database insert, and indexing path as PostTableData /// * Stops at the first failing row and returns that row's gRPC error code /// with row index context; rows inserted before the failure remain inserted pub async fn post_table_data_bulk( &mut self, request: impl tonic::IntoRequest, ) -> std::result::Result< tonic::Response, tonic::Status, > { self.inner .ready() .await .map_err(|e| { tonic::Status::unknown( format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/komp_ac.tables_data.TablesData/PostTableDataBulk", ); let mut req = request.into_request(); req.extensions_mut() .insert( GrpcMethod::new( "komp_ac.tables_data.TablesData", "PostTableDataBulk", ), ); self.inner.unary(req, path, codec).await } /// Update existing row data with strict type binding and script validation. /// /// Behavior: /// /// * Validates profile and table, and that the record exists /// * If request data is empty, returns success without changing the row /// * For columns targeted by scripts: /// • If included in update, provided value must equal the script result /// • If not included, update must not cause the script result to differ /// from the current stored value; otherwise FAILED_PRECONDITION is returned /// * Binds values with correct SQL types; rejects invalid formats/ranges /// * Updates the row and returns the id; queues search indexing (best effort) pub async fn put_table_data( &mut self, request: impl tonic::IntoRequest, ) -> std::result::Result< tonic::Response, tonic::Status, > { self.inner .ready() .await .map_err(|e| { tonic::Status::unknown( format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/komp_ac.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 put_accounting_table_data( &mut self, request: impl tonic::IntoRequest, ) -> std::result::Result< tonic::Response, tonic::Status, > { self.inner .ready() .await .map_err(|e| { tonic::Status::unknown( format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/komp_ac.tables_data.TablesData/PutAccountingTableData", ); let mut req = request.into_request(); req.extensions_mut() .insert( GrpcMethod::new( "komp_ac.tables_data.TablesData", "PutAccountingTableData", ), ); self.inner.unary(req, path, codec).await } /// Performs a PUT after the user explicitly accepted changing a referenced version. pub async fn put_table_data_confirmed( &mut self, request: impl tonic::IntoRequest, ) -> std::result::Result< tonic::Response, tonic::Status, > { self.inner .ready() .await .map_err(|e| { tonic::Status::unknown( format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/komp_ac.tables_data.TablesData/PutTableDataConfirmed", ); let mut req = request.into_request(); req.extensions_mut() .insert( GrpcMethod::new( "komp_ac.tables_data.TablesData", "PutTableDataConfirmed", ), ); self.inner.unary(req, path, codec).await } /// Lists profiles whose rows currently point at this row version. pub async fn get_table_update_impact( &mut self, request: impl tonic::IntoRequest, ) -> std::result::Result< tonic::Response, tonic::Status, > { self.inner .ready() .await .map_err(|e| { tonic::Status::unknown( format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/komp_ac.tables_data.TablesData/GetTableUpdateImpact", ); let mut req = request.into_request(); req.extensions_mut() .insert( GrpcMethod::new( "komp_ac.tables_data.TablesData", "GetTableUpdateImpact", ), ); self.inner.unary(req, path, codec).await } /// Snapshots the current version of a row and advances its version. /// Existing references remain immutable; new references use the new version. pub async fn archive_table_data( &mut self, request: impl tonic::IntoRequest, ) -> std::result::Result< tonic::Response, tonic::Status, > { self.inner .ready() .await .map_err(|e| { tonic::Status::unknown( format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/komp_ac.tables_data.TablesData/ArchiveTableData", ); let mut req = request.into_request(); req.extensions_mut() .insert( GrpcMethod::new("komp_ac.tables_data.TablesData", "ArchiveTableData"), ); self.inner.unary(req, path, codec).await } /// Soft-delete a single record (sets deleted = true) if it exists and is not already deleted. /// /// Behavior: /// /// * Validates profile and table definition /// * Updates only rows with deleted = false /// * success = true means a row was actually changed; false means nothing to delete /// * If the physical table is missing but the definition exists, returns INTERNAL pub async fn delete_table_data( &mut self, request: impl tonic::IntoRequest, ) -> std::result::Result< tonic::Response, tonic::Status, > { self.inner .ready() .await .map_err(|e| { tonic::Status::unknown( format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/komp_ac.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 } /// Fetch a single non-deleted row by id as textified values. /// /// Behavior: /// /// * Validates profile and table definition /// * Returns all columns as strings (COALESCE(col::TEXT, '') AS col) /// including: id, deleted, row_revision, all user-defined columns, and FK columns /// named by whoever declared each link, plus "account" on /// ACCOUNTING-enabled tables /// * Fails with NOT_FOUND if record does not exist or is soft-deleted /// * If the physical table is missing but the definition exists, returns INTERNAL pub async fn get_table_data( &mut self, request: impl tonic::IntoRequest, ) -> std::result::Result< tonic::Response, tonic::Status, > { self.inner .ready() .await .map_err(|e| { tonic::Status::unknown( format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/komp_ac.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 } /// Fetches one exact version of a row. pub async fn get_table_data_version( &mut self, request: impl tonic::IntoRequest, ) -> std::result::Result< tonic::Response, tonic::Status, > { self.inner .ready() .await .map_err(|e| { tonic::Status::unknown( format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/komp_ac.tables_data.TablesData/GetTableDataVersion", ); let mut req = request.into_request(); req.extensions_mut() .insert( GrpcMethod::new( "komp_ac.tables_data.TablesData", "GetTableDataVersion", ), ); self.inner.unary(req, path, codec).await } /// Count non-deleted rows in a table. /// /// Behavior: /// /// * Validates profile and table definition /// * Returns komp_ac.common.CountResponse.count with rows where deleted = FALSE /// * If the physical table is missing but the definition exists, returns INTERNAL pub async fn get_table_data_count( &mut self, request: impl tonic::IntoRequest, ) -> std::result::Result< tonic::Response, tonic::Status, > { self.inner .ready() .await .map_err(|e| { tonic::Status::unknown( format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/komp_ac.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 } /// Fetch the N-th non-deleted row by id order (1-based), then return its full data. /// /// Behavior: /// /// * position is 1-based (position = 1 → first row by id ASC with deleted = FALSE) /// * Returns NOT_FOUND if position is out of bounds /// * Otherwise identical to GetTableData for the selected id pub async fn get_table_data_by_position( &mut self, request: impl tonic::IntoRequest, ) -> std::result::Result< tonic::Response, tonic::Status, > { self.inner .ready() .await .map_err(|e| { tonic::Status::unknown( format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/komp_ac.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 { /// Insert a new row into a table with strict type binding and script validation. /// /// Behavior: /// /// * Validates that profile (schema) exists and table is defined for it /// * Validates provided columns exist (user-defined or allowed system/FK columns) /// * For columns targeted by scripts in this table, the client MUST provide the /// value, and it MUST equal the script’s calculated value (compared type-safely) /// * Binds values with correct SQL types, rejects invalid formats/ranges /// * Inserts the row and returns the new id; queues search indexing (best effort) /// * If the physical table is missing but the definition exists, returns INTERNAL async fn post_table_data( &self, request: tonic::Request, ) -> std::result::Result< tonic::Response, tonic::Status, >; /// Insert an ACCOUNTING-enabled source row with an explicit exchange-rate /// treatment for the journal line created from it. async fn post_accounting_table_data( &self, request: tonic::Request, ) -> std::result::Result< tonic::Response, tonic::Status, >; /// Insert multiple rows by applying PostTableData behavior to each row. /// /// Behavior: /// /// * Accepts 1..10,000 rows in one gRPC request /// * Processes rows in request order /// * Each row is inserted through the same validation, script execution, /// typed binding, database insert, and indexing path as PostTableData /// * Stops at the first failing row and returns that row's gRPC error code /// with row index context; rows inserted before the failure remain inserted async fn post_table_data_bulk( &self, request: tonic::Request, ) -> std::result::Result< tonic::Response, tonic::Status, >; /// Update existing row data with strict type binding and script validation. /// /// Behavior: /// /// * Validates profile and table, and that the record exists /// * If request data is empty, returns success without changing the row /// * For columns targeted by scripts: /// • If included in update, provided value must equal the script result /// • If not included, update must not cause the script result to differ /// from the current stored value; otherwise FAILED_PRECONDITION is returned /// * Binds values with correct SQL types; rejects invalid formats/ranges /// * Updates the row and returns the id; queues search indexing (best effort) async fn put_table_data( &self, request: tonic::Request, ) -> std::result::Result< tonic::Response, tonic::Status, >; async fn put_accounting_table_data( &self, request: tonic::Request, ) -> std::result::Result< tonic::Response, tonic::Status, >; /// Performs a PUT after the user explicitly accepted changing a referenced version. async fn put_table_data_confirmed( &self, request: tonic::Request, ) -> std::result::Result< tonic::Response, tonic::Status, >; /// Lists profiles whose rows currently point at this row version. async fn get_table_update_impact( &self, request: tonic::Request, ) -> std::result::Result< tonic::Response, tonic::Status, >; /// Snapshots the current version of a row and advances its version. /// Existing references remain immutable; new references use the new version. async fn archive_table_data( &self, request: tonic::Request, ) -> std::result::Result< tonic::Response, tonic::Status, >; /// Soft-delete a single record (sets deleted = true) if it exists and is not already deleted. /// /// Behavior: /// /// * Validates profile and table definition /// * Updates only rows with deleted = false /// * success = true means a row was actually changed; false means nothing to delete /// * If the physical table is missing but the definition exists, returns INTERNAL async fn delete_table_data( &self, request: tonic::Request, ) -> std::result::Result< tonic::Response, tonic::Status, >; /// Fetch a single non-deleted row by id as textified values. /// /// Behavior: /// /// * Validates profile and table definition /// * Returns all columns as strings (COALESCE(col::TEXT, '') AS col) /// including: id, deleted, row_revision, all user-defined columns, and FK columns /// named by whoever declared each link, plus "account" on /// ACCOUNTING-enabled tables /// * Fails with NOT_FOUND if record does not exist or is soft-deleted /// * If the physical table is missing but the definition exists, returns INTERNAL async fn get_table_data( &self, request: tonic::Request, ) -> std::result::Result< tonic::Response, tonic::Status, >; /// Fetches one exact version of a row. async fn get_table_data_version( &self, request: tonic::Request, ) -> std::result::Result< tonic::Response, tonic::Status, >; /// Count non-deleted rows in a table. /// /// Behavior: /// /// * Validates profile and table definition /// * Returns komp_ac.common.CountResponse.count with rows where deleted = FALSE /// * If the physical table is missing but the definition exists, returns INTERNAL async fn get_table_data_count( &self, request: tonic::Request, ) -> std::result::Result< tonic::Response, tonic::Status, >; /// Fetch the N-th non-deleted row by id order (1-based), then return its full data. /// /// Behavior: /// /// * position is 1-based (position = 1 → first row by id ASC with deleted = FALSE) /// * Returns NOT_FOUND if position is out of bounds /// * Otherwise identical to GetTableData for the selected id async fn get_table_data_by_position( &self, request: tonic::Request, ) -> std::result::Result< tonic::Response, tonic::Status, >; } /// Read and write row data for user-defined tables inside profiles (schemas). /// Operations are performed against the physical PostgreSQL table that /// corresponds to the logical table definition and are scoped by profile /// (schema). Deletions are soft (set deleted = true). Typed binding and /// script-based validation are enforced consistently. #[derive(Debug)] pub struct TablesDataServer { inner: Arc, accept_compression_encodings: EnabledCompressionEncodings, send_compression_encodings: EnabledCompressionEncodings, max_decoding_message_size: Option, max_encoding_message_size: Option, } impl TablesDataServer { pub fn new(inner: T) -> Self { Self::from_arc(Arc::new(inner)) } pub fn from_arc(inner: Arc) -> 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( inner: T, interceptor: F, ) -> InterceptedService 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 tonic::codegen::Service> for TablesDataServer where T: TablesData, B: Body + std::marker::Send + 'static, B::Error: Into + std::marker::Send + 'static, { type Response = http::Response; type Error = std::convert::Infallible; type Future = BoxFuture; fn poll_ready( &mut self, _cx: &mut Context<'_>, ) -> Poll> { Poll::Ready(Ok(())) } fn call(&mut self, req: http::Request) -> Self::Future { match req.uri().path() { "/komp_ac.tables_data.TablesData/PostTableData" => { #[allow(non_camel_case_types)] struct PostTableDataSvc(pub Arc); impl< T: TablesData, > tonic::server::UnaryService for PostTableDataSvc { type Response = super::PostTableDataResponse; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { ::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_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, send_compression_encodings, ) .apply_max_message_size_config( max_decoding_message_size, max_encoding_message_size, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/komp_ac.tables_data.TablesData/PostAccountingTableData" => { #[allow(non_camel_case_types)] struct PostAccountingTableDataSvc(pub Arc); impl< T: TablesData, > tonic::server::UnaryService for PostAccountingTableDataSvc { type Response = super::PostTableDataResponse; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, request: tonic::Request< super::PostAccountingTableDataRequest, >, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { ::post_accounting_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 = PostAccountingTableDataSvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, send_compression_encodings, ) .apply_max_message_size_config( max_decoding_message_size, max_encoding_message_size, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/komp_ac.tables_data.TablesData/PostTableDataBulk" => { #[allow(non_camel_case_types)] struct PostTableDataBulkSvc(pub Arc); impl< T: TablesData, > tonic::server::UnaryService for PostTableDataBulkSvc { type Response = super::PostTableDataBulkResponse; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { ::post_table_data_bulk(&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 = PostTableDataBulkSvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, send_compression_encodings, ) .apply_max_message_size_config( max_decoding_message_size, max_encoding_message_size, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/komp_ac.tables_data.TablesData/PutTableData" => { #[allow(non_camel_case_types)] struct PutTableDataSvc(pub Arc); impl< T: TablesData, > tonic::server::UnaryService for PutTableDataSvc { type Response = super::PutTableDataResponse; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { ::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_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, send_compression_encodings, ) .apply_max_message_size_config( max_decoding_message_size, max_encoding_message_size, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/komp_ac.tables_data.TablesData/PutAccountingTableData" => { #[allow(non_camel_case_types)] struct PutAccountingTableDataSvc(pub Arc); impl< T: TablesData, > tonic::server::UnaryService for PutAccountingTableDataSvc { type Response = super::PutTableDataResponse; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { ::put_accounting_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 = PutAccountingTableDataSvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, send_compression_encodings, ) .apply_max_message_size_config( max_decoding_message_size, max_encoding_message_size, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/komp_ac.tables_data.TablesData/PutTableDataConfirmed" => { #[allow(non_camel_case_types)] struct PutTableDataConfirmedSvc(pub Arc); impl< T: TablesData, > tonic::server::UnaryService for PutTableDataConfirmedSvc { type Response = super::PutTableDataResponse; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { ::put_table_data_confirmed(&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 = PutTableDataConfirmedSvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, send_compression_encodings, ) .apply_max_message_size_config( max_decoding_message_size, max_encoding_message_size, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/komp_ac.tables_data.TablesData/GetTableUpdateImpact" => { #[allow(non_camel_case_types)] struct GetTableUpdateImpactSvc(pub Arc); impl< T: TablesData, > tonic::server::UnaryService for GetTableUpdateImpactSvc { type Response = super::TableUpdateImpactResponse; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { ::get_table_update_impact(&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 = GetTableUpdateImpactSvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, send_compression_encodings, ) .apply_max_message_size_config( max_decoding_message_size, max_encoding_message_size, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/komp_ac.tables_data.TablesData/ArchiveTableData" => { #[allow(non_camel_case_types)] struct ArchiveTableDataSvc(pub Arc); impl< T: TablesData, > tonic::server::UnaryService for ArchiveTableDataSvc { type Response = super::ArchiveTableDataResponse; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { ::archive_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 = ArchiveTableDataSvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, send_compression_encodings, ) .apply_max_message_size_config( max_decoding_message_size, max_encoding_message_size, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/komp_ac.tables_data.TablesData/DeleteTableData" => { #[allow(non_camel_case_types)] struct DeleteTableDataSvc(pub Arc); impl< T: TablesData, > tonic::server::UnaryService for DeleteTableDataSvc { type Response = super::DeleteTableDataResponse; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { ::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_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, send_compression_encodings, ) .apply_max_message_size_config( max_decoding_message_size, max_encoding_message_size, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/komp_ac.tables_data.TablesData/GetTableData" => { #[allow(non_camel_case_types)] struct GetTableDataSvc(pub Arc); impl< T: TablesData, > tonic::server::UnaryService for GetTableDataSvc { type Response = super::GetTableDataResponse; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { ::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_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, send_compression_encodings, ) .apply_max_message_size_config( max_decoding_message_size, max_encoding_message_size, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/komp_ac.tables_data.TablesData/GetTableDataVersion" => { #[allow(non_camel_case_types)] struct GetTableDataVersionSvc(pub Arc); impl< T: TablesData, > tonic::server::UnaryService for GetTableDataVersionSvc { type Response = super::GetTableDataResponse; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { ::get_table_data_version(&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 = GetTableDataVersionSvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, send_compression_encodings, ) .apply_max_message_size_config( max_decoding_message_size, max_encoding_message_size, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/komp_ac.tables_data.TablesData/GetTableDataCount" => { #[allow(non_camel_case_types)] struct GetTableDataCountSvc(pub Arc); impl< T: TablesData, > tonic::server::UnaryService for GetTableDataCountSvc { type Response = super::super::common::CountResponse; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { ::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_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, send_compression_encodings, ) .apply_max_message_size_config( max_decoding_message_size, max_encoding_message_size, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/komp_ac.tables_data.TablesData/GetTableDataByPosition" => { #[allow(non_camel_case_types)] struct GetTableDataByPositionSvc(pub Arc); impl< T: TablesData, > tonic::server::UnaryService for GetTableDataByPositionSvc { type Response = super::GetTableDataResponse; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { ::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_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( accept_compression_encodings, send_compression_encodings, ) .apply_max_message_size_config( max_decoding_message_size, max_encoding_message_size, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } _ => { 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 Clone for TablesDataServer { 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 tonic::server::NamedService for TablesDataServer { const NAME: &'static str = SERVICE_NAME; } }