middleware: difficult to implement map request/response in batches when writing server middleware impls

[niklasad1]

With the new RpcServiceT the BatchResponse is set to MethodResult which is essentially a wrapper of the serialized JSON response but if one needs inspect each individual batch response in batch such as to create a metric for each individual call in the batch that becomes hard.

This prevents to write simple middleware such as:

• Metrics per call
• Easy logging/debugging
• Response ID correlation

To illustrate this have a look the following example:

#[derive(Clone)]
struct Identity<S>(S);

impl<S> RpcServiceT for Identity<S>
where
	S: RpcServiceT<BatchResponse = MethodResponse> + Send + Sync + Clone + 'static,
{
	type MethodResponse = S::MethodResponse;
	type NotificationResponse = S::NotificationResponse;
	type BatchResponse = MethodResponse;

	fn batch<'a>(&self, batch: Batch<'a>) -> impl Future<Output = Self::BatchResponse> + Send + 'a {
		let metrics = HashMap::new();

		for entry in batch.iter() {
			match entry {
				Ok(BatchEntry::Call(c)) => {
					metrics.insert(c.id, Instant::now());
				}
				Ok(BatchEntry::Notification(n)) => continue,
				Err(e) => {
					metrics.insert(e.id, Instant::now());
				}
			}
		}

		async {
			let rp = self.0.batch(batch).await;
                        // need to deserialize JSON to extract the responses and id to match
                        // with our metrics which is annoying
			rp
		}
	}

	fn call<'a>(&self, request: Request<'a>) -> impl Future<Output = Self::MethodResponse> + Send + 'a {
		self.0.call(request)
	}

	fn notification<'a>(&self, n: Notification<'a>) -> impl Future<Output = Self::NotificationResponse> + Send + 'a {
		self.0.notification(n)
	}
}

Thus, I suggest to refactoring this as follows:

1. Introduce a separate type BatchResponse (wrapper of Vec) where the individual responses can be iterated over easily
2. Add response ID to the MethodResponse to make it easy to match a request with a response.

[niklasad1]

I noticed that is possible to hack around by invoking the RpcServiceT:call impl but it is not recommended because
it will "override" additional layers that implements RpcServiceT::batch

#[derive(Clone)]
struct Identity<S>(S);

impl<S> RpcServiceT for Identity<S>
where
	S: RpcServiceT<BatchResponse = MethodResponse, MethodResponse = MethodResponse> + Send + Sync + Clone + 'static,
{
	type MethodResponse = S::MethodResponse;
	type NotificationResponse = S::NotificationResponse;
	type BatchResponse = S::BatchResponse;

	fn batch<'a>(&self, batch: Batch<'a>) -> impl Future<Output = Self::BatchResponse> + Send + 'a {
		println!("identity middleware: batch {batch}");

		let mut rps = jsonrpsee::core::server::BatchResponseBuilder::new_with_limit(usize::MAX);
		let svc = self.0.clone();

		async move {
			for entry in batch {
				match entry {
					Ok(BatchEntry::Call(req)) => {
						let rp = svc.call(req).await;
						if let Err(e) = rps.append(rp) {
							return e;
						}
					}
					Ok(BatchEntry::Notification(_)) => continue,
					Err(err) => {
						let (err, id) = err.into_parts();
						if let Err(e) = rps.append(MethodResponse::error(id, err)) {
							return e;
						}
					}
				}
			}

			MethodResponse::from_batch(rps.finish())
		}
	}

	fn call<'a>(&self, request: Request<'a>) -> impl Future<Output = Self::MethodResponse> + Send + 'a {
		self.0.call(request)
	}

	fn notification<'a>(&self, n: Notification<'a>) -> impl Future<Output = Self::NotificationResponse> + Send + 'a {
		self.0.notification(n)
	}
}