Do not use unwrap and reduce serialization times

[l-7-l]

Bug Description:

1. serde serialize should not unwrap:
   

   manticoresearch-rust/src/apis/request.rs

   Line 73 in 121a76d

   self.serialized_body = Some(serde_json::to_string(&param).unwrap());

2. Would it be better to use generics for the doc field of InsertDocumentRequest to avoid serializing twice?

   manticoresearch-rust/src/models/insert_document_request.rs

   Line 28 in 121a76d

   pub doc: serde_json::Value,

Maybe the following code will work

InsertDocumentRequest with generic:

use crate::models;
use serde::{Deserialize, Serialize};

/// InsertDocumentRequest : Object containing data for inserting a new document into the table
#[derive(Clone, Debug, Serialize)]
pub struct InsertDocumentRequest<'a, T> {
    /// Name of the table to insert the document into
    pub table: &'a str,
    /// Name of the cluster to insert the document into
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cluster: Option<&'a str>,
    /// Document ID. If not provided, an ID will be auto-generated
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<i64>,
    /// Object containing document data
    pub doc: &'a T,
}

impl<'a, T> InsertDocumentRequest<'a, T> {
    /// Object containing data for inserting a new document into the table
    pub fn new(table: &'a str, doc: &'a T) -> InsertDocumentRequest<'a, T> {
        InsertDocumentRequest {
            table,
            cluster: None,
            id: None,
            doc,
        }
    }
}

IndexApiClient use generic without trait:

/*
 * Manticore Search Client
 *
 * Сlient for Manticore Search.
 *
 * The version of the OpenAPI document: 5.0.0
 * Contact: info@manticoresearch.com
 * Generated by: https://openapi-generator.tech
*/

use std::borrow::Borrow;
#[allow(unused_imports)]
use std::option::Option;
use std::pin::Pin;
use std::sync::Arc;

use futures::Future;
use hyper::{self, Method};
use hyper_util::client::legacy::connect::Connect;
use serde::Serialize;

use super::request::Request;
use super::{configuration, Error};
use crate::models::{
    BulkResponse, DeleteDocumentRequest, DeleteResponse, InsertDocumentRequest,
    ReplaceDocumentRequest, SuccessResponse, UpdateResponse,
};

pub struct IndexApiClient<C: Connect>
where
    C: Clone + std::marker::Send + Sync + 'static,
{
    configuration: Arc<configuration::Configuration<C>>,
}

impl<C: Connect> IndexApiClient<C>
where
    C: Clone + std::marker::Send + Sync,
{
    pub fn new(configuration: Arc<configuration::Configuration<C>>) -> IndexApiClient<C> {
        IndexApiClient { configuration }
    }
}

impl<C: Connect> IndexApiClient<C>
where
    C: Clone + std::marker::Send + Sync,
{
    #[allow(unused_mut)]
    pub async fn bulk<'a, T>(
        &self,
        docs: &[InsertDocumentRequest<'a, T>],
    ) -> Result<BulkResponse, Error>
    where
        T: Serialize,
    {
        let mut buffer = Vec::new();
        for x in docs.iter() {
            if !buffer.is_empty() {
                buffer.push(b'\n');
            }

            serde_json::to_writer(&mut buffer, x)?;
        }

        let body = String::from_utf8(buffer).unwrap_or_default();

        Request::new(Method::POST, "/bulk")
            .with_body_string(body)
            .execute(&self.configuration)
            .await
    }

    pub async fn bulk_str<T: Into<String>>(&self, doc: T) -> Result<BulkResponse, Error> {
        Request::new(Method::POST, "/bulk")
            .with_body_string(doc.into())
            .execute(&self.configuration)
            .await
    }

    #[allow(unused_mut)]
    pub async fn delete(
        &self,
        delete_document_request: &DeleteDocumentRequest,
    ) -> Result<DeleteResponse, Error> {
        Request::new(Method::POST, "/delete")
            .with_body_param(delete_document_request)?
            .execute(&self.configuration)
            .await
    }

    #[allow(unused_mut)]
    pub async fn insert<'a, T: Serialize>(
        &self,
        insert_document_request: &InsertDocumentRequest<'a, T>,
    ) -> Result<SuccessResponse, Error> {
        Request::new(Method::POST, "/insert")
            .with_body_param(insert_document_request)?
            .execute(&self.configuration)
            .await
    }

    #[allow(unused_mut)]
    pub async fn partial_replace(
        &self,
        table: &str,
        id: i64,
        replace_document_request: &ReplaceDocumentRequest,
    ) -> Result<UpdateResponse, Error> {
        Request::new(Method::POST, "/{table}/_update/{id}")
            .with_path_param("table".to_string(), table.to_string())
            .with_path_param("id".to_string(), id.to_string())
            .with_body_param(replace_document_request)?
            .execute(&self.configuration)
            .await
    }

    #[allow(unused_mut)]
    pub async fn replace<'a, T: Serialize>(
        &self,
        insert_document_request: &InsertDocumentRequest<'a, T>,
    ) -> Result<SuccessResponse, Error> {
        Request::new(Method::POST, "/replace")
            .with_body_param(insert_document_request)?
            .execute(&self.configuration)
            .await
    }

    #[allow(unused_mut)]
    pub async fn update(
        &self,
        update_document_request: &DeleteDocumentRequest,
    ) -> Result<UpdateResponse, Error> {
        Request::new(Method::POST, "/update")
            .with_body_param(update_document_request)?
            .execute(&self.configuration)
            .await
    }
}

SearchApiClient with trait

/*
 * Manticore Search Client
 *
 * Сlient for Manticore Search.
 *
 * The version of the OpenAPI document: 5.0.0
 * Contact: info@manticoresearch.com
 * Generated by: https://openapi-generator.tech
 */

use std::borrow::Borrow;
#[allow(unused_imports)]
use std::option::Option;
use std::pin::Pin;
use std::sync::Arc;

use futures::Future;
use hyper;
use hyper_util::client::legacy::connect::Connect;

use super::request as __internal_request;
use super::{configuration, Error};
use crate::models;

pub struct SearchApiClient<C: Connect>
where
    C: Clone + std::marker::Send + Sync + 'static,
{
    configuration: Arc<configuration::Configuration<C>>,
}

impl<C: Connect> SearchApiClient<C>
where
    C: Clone + std::marker::Send + Sync,
{
    pub fn new(configuration: Arc<configuration::Configuration<C>>) -> SearchApiClient<C> {
        SearchApiClient { configuration }
    }
}

pub trait SearchApi: Send + Sync {
    fn autocomplete(
        &self,
        autocomplete_request: &models::AutocompleteRequest,
    ) -> Result<Pin<Box<dyn Future<Output = Result<Vec<serde_json::Value>, Error>> + Send>>, Error>;
    fn percolate(
        &self,
        table: &str,
        percolate_request: &models::PercolateRequest,
    ) -> Result<
        Pin<Box<dyn Future<Output = Result<crate::models::SearchResponse, Error>> + Send>>,
        Error,
    >;
    fn search(
        &self,
        search_request: &models::SearchRequest,
    ) -> Result<
        Pin<Box<dyn Future<Output = Result<crate::models::SearchResponse, Error>> + Send>>,
        Error,
    >;
}

impl<C: Connect> SearchApi for SearchApiClient<C>
where
    C: Clone + std::marker::Send + Sync,
{
    #[allow(unused_mut)]
    fn autocomplete(
        &self,
        autocomplete_request: &models::AutocompleteRequest,
    ) -> Result<Pin<Box<dyn Future<Output = Result<Vec<serde_json::Value>, Error>> + Send>>, Error>
    {
        let mut req =
            __internal_request::Request::new(hyper::Method::POST, "/autocomplete".to_string());
        req = req.with_body_param(autocomplete_request)?;

        Ok(req.execute(&self.configuration))
    }

    #[allow(unused_mut)]
    fn percolate(
        &self,
        table: &str,
        percolate_request: &models::PercolateRequest,
    ) -> Result<
        Pin<Box<dyn Future<Output = Result<crate::models::SearchResponse, Error>> + Send>>,
        Error,
    > {
        let mut req =
            __internal_request::Request::new(hyper::Method::POST, "/pq/{table}/search".to_string());

        req.with_path_param("table".to_string(), table.to_string())
            .with_body_param(percolate_request)
            .map(|x| x.execute(&self.configuration))
    }

    #[allow(unused_mut)]
    fn search(
        &self,
        search_request: &models::SearchRequest,
    ) -> Result<
        Pin<Box<dyn Future<Output = Result<crate::models::SearchResponse, Error>> + Send>>,
        Error,
    > {
        let mut req = __internal_request::Request::new(hyper::Method::POST, "/search".to_string());
        req.with_body_param(search_request)
            .map(|x| x.execute(&self.configuration))
    }
}

Manticore Search Version:

x

Client Version:

1

Have you tried the latest development version of Manticore Search and the client?

Yes

Internal Checklist:

^{To be completed by the assignee. Check off tasks that have been completed or are not applicable.}

• Implementation completed
• Tests developed
• Documentation updated
• Documentation reviewed

[Nick-S-2018]

@l-7-l
Thanks for bringing up the issue. Unfortunately, there isn't much we can do about it. We use an automatic OpenAPI-based generator to build all our clients, and your proposal would require changes in the generator itself. If you're interested in this, you may want to create a related issue for the Rust client there

[l-7-l]

@Nick-S-2018
Hi, Thank you for your patience and great work. Given the maturity of the current implementation, is continued use of the OpenAPI generator justified for incremental API changes? Manual maintenance may prove more efficient. I'd be happy to submit a PR.

[Nick-S-2018]

Hi,
Thank you for wanting to help. The problem is that we don't have enough expertise to support all our clients for different languages manually.
Maybe, you would like to create your fork for the Typescript client then? If it performs better than our current version we would add it to our documentation as a recommended alternative.

[github-actions]

Thanks for the update! However, the internal checklist is not yet complete. A Manticore team member will close this issue once everything is checked off. 🛠️

[l-7-l]

@Nick-S-2018 it seems still use unwrap, this will crash the whole service for users

[l-7-l]

and_then(move |response| {
let status = response.status();
if !status.is_success() {
futures::future::err::<U, Error>(Error::from((
status,
response.into_body(),
)))
.boxed()
} else if no_return_type {
// This is a hack; if there's no_ret_type, U is (), but serde_json gives an
// error when deserializing "" into (), so deserialize 'null' into it
// instead.
// An alternate option would be to require U: Default, and then return
// U::default() here instead since () implements that, but then we'd
// need to impl default for all models.
futures::future::ok::<U, Error>(
serde_json::from_str("null").expect("serde null value"), // this will break the service of users
)
.boxed()

[sanikolaev]

would like to create your fork for the Typescript client then?

@l-7-l Nick meant a fork for the Rust client here.

[sanikolaev]

@Nick-S-2018 it seems still use unwrap, this will crash the whole service for users

@l-7-l why did you close the issue?

[l-7-l]

@Nick-S-2018 it seems still use unwrap, this will crash the whole service for users

@l-7-l why did you close the issue?

@sanikolaev Sorry, I shouldn't have closed it. Nick mentioned earlier that I need to create a related repository here 。

would like to create your fork for the Typescript client then?

@l-7-l Nick meant a fork for the Rust client here.

I'm using my custom client, maybe I'll release it after it's verified。But the existing official client is really not suitable for production use.