Typing Ergonomics for Docs and Authors Client

[Zyell]

When implementing user code that needs to type a parameter that should be either a Doc or Author Client, it currently requires adding quic-rpc as a dependency. The following example shows the current situation:

use iroh_docs::rpc::client::authors::Client;
use iroh_docs::rpc::client::docs::Doc;
use iroh_docs::rpc::proto::{Request, Response};
use quic_rpc::transport::flume::FlumeConnector;

pub struct ApplicationClient {
    // ... //
    blobs: iroh_blobs::rpc::client::blobs::MemClient,
    docs: iroh_docs::rpc::client::docs::MemClient,
}

impl ApplicationClient {
    // ... //
    fn authors(
        &self,
    ) -> Client<FlumeConnector<Response, Request>> {
        self.docs.authors()
    }
    
    async fn create_doc(
        &self,
    ) -> anyhow::Result<Doc<FlumeConnector<Response, Request>>> {
        self.docs.create().await
    }
}

Both the Doc and Blobs Clients have a special type declared to avoid having to make quic-rpc a hard dependency in user code. Could such types be created for both Doc and the Author Client?

[matheus23]

Could such types be created for both Doc and the Author Client?

That's one solution, the other would be to use BoxedConnector for the in-memory clients.
The Client and Doc types already have a default for their generic parameter that is set to BoxedConnector. This would plug in nicely.

[Zyell]

Could such types be created for both Doc and the Author Client?

That's one solution, the other would be to use BoxedConnector for the in-memory clients. The Client and Doc types already have a default for their generic parameter that is set to BoxedConnector. This would plug in nicely.

@matheus23 I was returning to this after the holidays and I'm not sure I understand what you mean by using the BoxedConnector for the in-memory clients. I see that the Docs client has:

/// Type alias for a memory-backed client.
pub type MemClient =
    Client<FlumeConnector<crate::rpc::proto::Response, crate::rpc::proto::Request>>;

/// Iroh docs client.
#[derive(Debug, Clone)]
#[repr(transparent)]
pub struct Client<C = BoxedConnector<RpcService>> {
    pub(super) rpc: quic_rpc::RpcClient<RpcService, C>,
}

while the document handle has:

/// Document handle
#[derive(Debug, Clone)]
pub struct Doc<C: Connector<RpcService> = BoxedConnector<RpcService>>(Arc<DocInner<C>>)
where
    C: quic_rpc::Connector<RpcService>;

What change are you suggesting with the BoxedConnector to avoid having to may quic-rpc a hard dependency? I'm happy to work on this issue, just want to understand your suggestion first.

[matheus23]

What change are you suggesting with the BoxedConnector to avoid having to may quic-rpc a hard dependency? I'm happy to work on this issue, just want to understand your suggestion first.

My thinking was to change MemClient to be

/// Type alias for a memory-backed client.
pub type MemClient = Client<BoxedConnector<RpcService>>;

And change the code for .client() accordingly (so it's boxing the flume connector).

This way, the default type parameter of Client and Doc match up with the return value of .client(), thus you don't need a quic-rpc dependency to name these types.

That said, boxing incurs overhead, perhaps we just re-export useful types/add type aliases. @rklaehn what do you think would make most sense?

[TotalKrill]

Ran in to this as well, I would be fine with just having a re-export of quic_rpc, it would play quite nice with RustAnalyzers code suggestions