Crate restructuring

http-client/src/client.rs

@@ -27,8 +27,8 @@
 use crate::transport::HttpTransportClient;
 use crate::types::{
 	traits::{Client, SubscriptionClient},
-	v2::{Id, NotificationSer, ParamsSer, RequestSer, Response, RpcError},
-	CertificateStore, Error, RequestIdManager, Subscription, TEN_MB_SIZE_BYTES,
+	CertificateStore, Error, Id, NotificationSer, ParamsSer, RequestIdManager, RequestSer, Response, RpcError,
+	Subscription, TEN_MB_SIZE_BYTES,
 };
 use async_trait::async_trait;
 use fnv::FnvHashMap;

http-client/src/tests.rs

@@ -25,9 +25,9 @@
 // DEALINGS IN THE SOFTWARE.
 
 use crate::types::{
+	error::{Error, ErrorCode, ErrorObject, RpcError},
 	traits::Client,
-	v2::{ErrorCode, ErrorObject, ParamsSer, RpcError},
-	Error, JsonValue,
+	JsonValue, ParamsSer,
 };
 use crate::HttpClientBuilder;
 use jsonrpsee_test_utils::helpers::*;

http-server/src/response.rs

@@ -26,7 +26,8 @@
 
 //! Contains common builders for hyper responses.
 
-use crate::types::v2::{ErrorCode, Id, RpcError, TwoPointZero};
+use crate::types::error::{ErrorCode, RpcError};
+use crate::types::{Id, TwoPointZero};
 
 const JSON: &str = "application/json; charset=utf-8";
 const TEXT: &str = "text/plain";

http-server/src/server.rs

@@ -33,10 +33,9 @@ use hyper::{
 	Error as HyperError,
 };
 use jsonrpsee_types::{
-	error::{Error, GenericTransportError},
+	error::{Error, ErrorCode, GenericTransportError},
 	middleware::Middleware,
-	v2::{ErrorCode, Id, Notification, Request},
-	TEN_MB_SIZE_BYTES,
+	Id, Notification, Request, TEN_MB_SIZE_BYTES,
 };
 use jsonrpsee_utils::http_helpers::read_body;
 use jsonrpsee_utils::server::{

proc-macros/src/render_client.rs

@@ -165,12 +165,12 @@ impl RpcDescription {
 						quote! { (#param, #value) }
 					});
 					quote! {
-						Some(types::v2::ParamsSer::Map(
-								std::collections::BTreeMap::<&str, #serde_json::Value>::from(
-									[#(#params),*]
-									)
+						Some(types::ParamsSer::Map(
+							std::collections::BTreeMap::<&str, #serde_json::Value>::from(
+								[#(#params),*]
 								)
 							)
+						)
 					}
 				}
 				ParamKind::Array => {

types/src/client.rs

@@ -24,7 +24,7 @@
 // IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
-use crate::{error::SubscriptionClosedError, v2::SubscriptionId, Error};
+use crate::{error::SubscriptionClosedError, Error, SubscriptionId};
 use core::marker::PhantomData;
 use futures_channel::{mpsc, oneshot};
 use futures_util::{future::FutureExt, sink::SinkExt, stream::StreamExt};

types/src/v2/mod.rs → types/src/error/mod.rs

@@ -25,17 +25,13 @@
 // DEALINGS IN THE SOFTWARE.
 
 //! Types to handle in- and outgoing JSON-RPC requests and subscriptions according to the [spec](https://www.jsonrpc.org/specification).
+/// Error type.
+
+/// Main `Error` type.
+mod error;
 
 /// JSON-RPC error related types.
-pub mod error;
-/// JSON_RPC params related types.
-pub mod params;
-/// JSON-RPC request object related types
-pub mod request;
-/// JSON-RPC response object related types.
-pub mod response;
+pub mod rpc;
 
-pub use error::{ErrorCode, ErrorObject, RpcError};
-pub use params::{Id, Params, ParamsSequence, ParamsSer, SubscriptionId, TwoPointZero};
-pub use request::{InvalidRequest, Notification, NotificationSer, Request, RequestSer};
-pub use response::{Response, SubscriptionPayload, SubscriptionResponse};
+pub use error::{CallError, Error, GenericTransportError, SubscriptionClosedError};
+pub use rpc::{ErrorCode, ErrorObject, RpcError};

types/src/v2/error.rs → types/src/error/rpc.rs

@@ -24,7 +24,7 @@
 // IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
-use crate::v2::params::{Id, TwoPointZero};
+use crate::params::{Id, TwoPointZero};
 use beef::Cow;
 use serde::de::Deserializer;
 use serde::ser::Serializer;

types/src/lib.rs

@@ -34,9 +34,6 @@ extern crate alloc;
 /// Ten megabytes.
 pub const TEN_MB_SIZE_BYTES: u32 = 10 * 1024 * 1024;
 
-/// JSON-RPC v2.0 specification related types.
-pub mod v2;
-
 /// Error type.
 pub mod error;
 
@@ -49,10 +46,20 @@ pub mod traits;
 /// Middleware trait and implementation.
 pub mod middleware;
 
+/// JSON_RPC params related types.
+pub mod params;
+
+/// JSON-RPC request object related types
+pub mod request;
+
+/// JSON-RPC response object related types.
+pub mod response;
+
 pub use async_trait::async_trait;
 pub use beef::Cow;
 pub use client::*;
-pub use error::{CallError, Error};
+pub use error::{CallError, Error, RpcError};
+pub use params::{Id, Params, ParamsSequence, ParamsSer, SubscriptionId, TwoPointZero};
 pub use serde::{de::DeserializeOwned, Serialize};
 pub use serde_json::{
 	to_value as to_json_value, value::to_raw_value as to_json_raw_value, value::RawValue as JsonRawValue,
@@ -70,3 +77,6 @@ pub mod __reexports {
 
 /// JSON-RPC result.
 pub type RpcResult<T> = std::result::Result<T, Error>;
+
+pub use request::{InvalidRequest, Notification, NotificationSer, Request, RequestSer};
+pub use response::{Response, SubscriptionPayload, SubscriptionResponse};

types/src/v2/params.rs → types/src/params.rs

@@ -199,7 +199,7 @@ impl<'a> ParamsSequence<'a> {
 	/// Parse the next parameter to type `T`
 	///
 	/// ```
-	/// # use jsonrpsee_types::v2::params::Params;
+	/// # use jsonrpsee_types::params::Params;
 	/// let params = Params::new(Some(r#"[true, 10, "foo"]"#));
 	/// let mut seq = params.sequence();
 	///
@@ -226,7 +226,7 @@ impl<'a> ParamsSequence<'a> {
 	/// The result will be `None` for `null`, and for missing values in the supplied JSON array.
 	///
 	/// ```
-	/// # use jsonrpsee_types::v2::params::Params;
+	/// # use jsonrpsee_types::params::Params;
 	/// let params = Params::new(Some(r#"[1, 2, null]"#));
 	/// let mut seq = params.sequence();
 	///
@@ -358,7 +358,7 @@ impl<'a> Id<'a> {
 #[cfg(test)]
 mod test {
 	use super::{Cow, Id, JsonValue, Params, ParamsSer, SubscriptionId, TwoPointZero};
-	use crate::v2::response::SubscriptionPayload;
+	use crate::response::SubscriptionPayload;
 
 	#[test]
 	fn id_deserialization() {

types/src/v2/request.rs → types/src/request.rs

@@ -27,7 +27,7 @@
 //! Types to handle JSON-RPC requests according to the [spec](https://www.jsonrpc.org/specification#request-object).
 //! Some types come with a "*Ser" variant that implements [`serde::Serialize`]; these are used in the client.
 
-use crate::v2::params::{Id, ParamsSer, TwoPointZero};
+use crate::params::{Id, ParamsSer, TwoPointZero};
 use beef::Cow;
 use serde::{Deserialize, Serialize};
 use serde_json::value::RawValue;

types/src/v2/response.rs → types/src/response.rs

@@ -26,10 +26,8 @@
 
 //! Types pertaining to JSON-RPC responses.
 
-use crate::v2::{
-	params::{Id, SubscriptionId, TwoPointZero},
-	request::Notification,
-};
+use crate::params::{Id, SubscriptionId, TwoPointZero};
+use crate::request::Notification;
 use serde::{Deserialize, Serialize};
 
 /// JSON-RPC successful response object as defined in the [spec](https://www.jsonrpc.org/specification#response_object).

types/src/traits.rs

@@ -24,7 +24,7 @@
 // IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
-use crate::v2::ParamsSer;
+use crate::ParamsSer;
 use crate::{Error, Subscription};
 use async_trait::async_trait;
 use serde::de::DeserializeOwned;

utils/src/client.rs

@@ -28,7 +28,7 @@
 
 #[doc(hidden)]
 pub mod __reexports {
-	pub use jsonrpsee_types::{to_json_value, v2::ParamsSer};
+	pub use jsonrpsee_types::{to_json_value, ParamsSer};
 }
 
 #[macro_export]

utils/src/server/helpers.rs

@@ -26,13 +26,11 @@
 
 use futures_channel::mpsc;
 use futures_util::stream::StreamExt;
-use jsonrpsee_types::error::{CallError, Error};
-use jsonrpsee_types::to_json_raw_value;
-use jsonrpsee_types::v2::error::{OVERSIZED_RESPONSE_CODE, OVERSIZED_RESPONSE_MSG};
-use jsonrpsee_types::v2::{
-	error::{CALL_EXECUTION_FAILED_CODE, UNKNOWN_ERROR_CODE},
-	ErrorCode, ErrorObject, Id, InvalidRequest, Response, RpcError, TwoPointZero,
-};
+use jsonrpsee_types::error::rpc::{CALL_EXECUTION_FAILED_CODE, UNKNOWN_ERROR_CODE};
+use jsonrpsee_types::error::rpc::{OVERSIZED_RESPONSE_CODE, OVERSIZED_RESPONSE_MSG};
+use jsonrpsee_types::error::{CallError, Error, ErrorCode, ErrorObject, RpcError};
+use jsonrpsee_types::{to_json_raw_value, Id, TwoPointZero};
+use jsonrpsee_types::{InvalidRequest, Response};
 use serde::Serialize;
 
 use std::io;

utils/src/server/rpc_module.rs

@@ -29,16 +29,13 @@ use crate::server::resource_limiting::{ResourceGuard, ResourceTable, ResourceVec
 use beef::Cow;
 use futures_channel::{mpsc, oneshot};
 use futures_util::{future::BoxFuture, FutureExt, StreamExt};
+use jsonrpsee_types::error::rpc::{invalid_subscription_err, CALL_EXECUTION_FAILED_CODE};
 use jsonrpsee_types::to_json_raw_value;
-use jsonrpsee_types::v2::error::{invalid_subscription_err, CALL_EXECUTION_FAILED_CODE};
 use jsonrpsee_types::{
-	error::{Error, SubscriptionClosedError},
+	error::{Error, ErrorCode, SubscriptionClosedError},
 	traits::ToRpcParams,
-	v2::{
-		ErrorCode, Id, Params, Request, Response, SubscriptionId as RpcSubscriptionId, SubscriptionPayload,
-		SubscriptionResponse, TwoPointZero,
-	},
-	DeserializeOwned,
+	DeserializeOwned, Id, Params, Request, Response, SubscriptionId as RpcSubscriptionId, SubscriptionPayload,
+	SubscriptionResponse, TwoPointZero,
 };
 
 use parking_lot::Mutex;
@@ -782,7 +779,7 @@ impl TestSubscription {
 	/// # Panics
 	///
 	/// If the decoding the value as `T` fails.
-	pub async fn next<T: DeserializeOwned>(&mut self) -> Option<(T, jsonrpsee_types::v2::SubscriptionId)> {
+	pub async fn next<T: DeserializeOwned>(&mut self) -> Option<(T, RpcSubscriptionId)> {
 		let raw = self.rx.next().await?;
 		let val: SubscriptionResponse<T> =
 			serde_json::from_str(&raw).expect("valid response in TestSubscription::next()");
@@ -799,7 +796,6 @@ impl Drop for TestSubscription {
 #[cfg(test)]
 mod tests {
 	use super::*;
-	use jsonrpsee_types::v2;
 	use serde::Deserialize;
 	use std::collections::HashMap;
 
@@ -980,7 +976,7 @@ mod tests {
 		for i in (0..=2).rev() {
 			let (val, id) = my_sub.next::<char>().await.unwrap();
 			assert_eq!(val, std::char::from_digit(i, 10).unwrap());
-			assert_eq!(id, v2::params::SubscriptionId::Num(my_sub.subscription_id()));
+			assert_eq!(id, RpcSubscriptionId::Num(my_sub.subscription_id()));
 		}
 
 		// The subscription is now closed by the server.
@@ -1007,7 +1003,7 @@ mod tests {
 		let mut my_sub: TestSubscription = module.test_subscription("my_sub", Vec::<()>::new()).await;
 		let (val, id) = my_sub.next::<String>().await.unwrap();
 		assert_eq!(&val, "lo");
-		assert_eq!(id, v2::params::SubscriptionId::Num(my_sub.subscription_id()));
+		assert_eq!(id, RpcSubscriptionId::Num(my_sub.subscription_id()));
 
 		// close the subscription to ensure it doesn't return any items.
 		my_sub.close();

ws-client/src/client.rs

@@ -27,9 +27,9 @@
 use crate::transport::{Receiver as WsReceiver, Sender as WsSender, WsHandshakeError, WsTransportClientBuilder};
 use crate::types::{
 	traits::{Client, SubscriptionClient},
-	v2::{Id, Notification, NotificationSer, ParamsSer, RequestSer, Response, RpcError, SubscriptionResponse},
-	BatchMessage, CertificateStore, Error, FrontToBack, RegisterNotificationMessage, RequestIdManager, RequestMessage,
-	Subscription, SubscriptionKind, SubscriptionMessage, TEN_MB_SIZE_BYTES,
+	BatchMessage, CertificateStore, Error, FrontToBack, Id, Notification, NotificationSer, ParamsSer,
+	RegisterNotificationMessage, RequestIdManager, RequestMessage, RequestSer, Response, RpcError, Subscription,
+	SubscriptionKind, SubscriptionMessage, SubscriptionResponse, TEN_MB_SIZE_BYTES,
 };
 use crate::{
 	helpers::{

ws-client/src/helpers.rs

@@ -26,10 +26,9 @@
 
 use crate::manager::{RequestManager, RequestStatus};
 use crate::transport::Sender as WsSender;
-use crate::types::v2::{
-	Id, Notification, ParamsSer, RequestSer, Response, RpcError, SubscriptionId, SubscriptionResponse,
-};
-use crate::types::{Error, RequestMessage};
+use crate::types::{Error, RequestMessage, RpcError};
+use crate::types::{Id, ParamsSer, SubscriptionId};
+use crate::types::{Notification, RequestSer, Response, SubscriptionResponse};
 use futures::channel::{mpsc, oneshot};
 use serde_json::Value as JsonValue;
 use std::time::Duration;

ws-client/src/manager.rs

@@ -32,7 +32,7 @@
 //!    > **Note**: The spec allow number, string or null but this crate only supports numbers.
 //!    - SubscriptionId: unique ID generated by server
 
-use crate::types::{v2::SubscriptionId, Error, JsonValue};
+use crate::types::{Error, JsonValue, SubscriptionId};
 use fnv::FnvHashMap;
 use futures::channel::{mpsc, oneshot};
 use std::collections::hash_map::{Entry, HashMap};
@@ -308,7 +308,7 @@ impl RequestManager {
 mod tests {
 	use super::{Error, RequestManager};
 	use futures::channel::{mpsc, oneshot};
-	use jsonrpsee_types::v2::SubscriptionId;
+	use jsonrpsee_types::SubscriptionId;
 	use serde_json::Value as JsonValue;
 
 	#[test]

ws-client/src/tests.rs

@@ -26,9 +26,9 @@
 
 #![cfg(test)]
 use crate::types::{
+	error::{Error, ErrorCode, ErrorObject, RpcError},
 	traits::{Client, SubscriptionClient},
-	v2::{ErrorCode, ErrorObject, ParamsSer, RpcError},
-	Error, Subscription,
+	ParamsSer, Subscription,
 };
 use crate::WsClientBuilder;
 use jsonrpsee_test_utils::helpers::*;

ws-server/src/server.rs

@@ -30,12 +30,8 @@ use std::pin::Pin;
 use std::task::{Context, Poll};
 
 use crate::future::{FutureDriver, ServerHandle, StopMonitor};
-use crate::types::{
-	error::Error,
-	middleware::Middleware,
-	v2::{ErrorCode, Id, Request},
-	TEN_MB_SIZE_BYTES,
-};
+use crate::types::error::{Error, ErrorCode};
+use crate::types::{middleware::Middleware, Id, Request, TEN_MB_SIZE_BYTES};
 use futures_channel::mpsc;
 use futures_util::future::join_all;
 use futures_util::future::FutureExt;

ws-server/src/tests.rs

@@ -27,16 +27,16 @@
 #![cfg(test)]
 
 use crate::types::error::{CallError, Error};
-use crate::types::v2::{self, Response, RpcError};
 use crate::types::DeserializeOwned;
+use crate::types::{self, Response, RpcError};
 use crate::{future::ServerHandle, RpcModule, WsServerBuilder};
 use anyhow::anyhow;
 use futures_util::future::join;
 use jsonrpsee_test_utils::helpers::*;
 use jsonrpsee_test_utils::mocks::{Id, TestContext, WebSocketTestClient, WebSocketTestError};
 use jsonrpsee_test_utils::TimeoutFutureExt;
+use jsonrpsee_types::error::rpc::invalid_subscription_err;
 use jsonrpsee_types::to_json_raw_value;
-use jsonrpsee_types::v2::error::invalid_subscription_err;
 use serde_json::Value as JsonValue;
 use std::{fmt, net::SocketAddr, time::Duration};
 use tracing_subscriber::{EnvFilter, FmtSubscriber};
@@ -611,7 +611,7 @@ async fn unsubscribe_twice_should_indicate_error() {
 	let sub_id = to_json_raw_value(&sub_id).unwrap();
 
 	let err = Some(to_json_raw_value(&format!("Invalid subscription ID={}", sub_id)).unwrap());
-	assert_eq!(unsub_2_err, RpcError::new(invalid_subscription_err(err.as_deref()), v2::Id::Number(2)));
+	assert_eq!(unsub_2_err, RpcError::new(invalid_subscription_err(err.as_deref()), types::Id::Number(2)));
 }
 
 #[tokio::test]
@@ -624,5 +624,5 @@ async fn unsubscribe_wrong_sub_id_type() {
 		client.send_request_text(call("unsubscribe_hello", vec!["string_is_not_supported"], Id::Num(0))).await.unwrap();
 	let unsub_2_err: RpcError = serde_json::from_str(&unsub).unwrap();
 	let err = Some(to_json_raw_value(&"Invalid subscription ID type, must be integer").unwrap());
-	assert_eq!(unsub_2_err, RpcError::new(invalid_subscription_err(err.as_deref()), v2::Id::Number(0)));
+	assert_eq!(unsub_2_err, RpcError::new(invalid_subscription_err(err.as_deref()), types::Id::Number(0)));
 }