feat: impl json-rpc types, routing, deserializers

Introduce foundational JSON-RPC types, deserialization,
and an initial swing at a POC method API for the project
and package.

Author: ethangreen-dev

src/main.rs

@@ -29,6 +29,7 @@ mod error;
 mod game;
 mod package;
 mod project;
+mod server;
 mod ts;
 mod ui;
 mod util;

src/server/method.rs

@@ -0,0 +1,147 @@
+use std::fmt::Display;
+use std::str::FromStr;
+
+use serde::{Deserialize, Serialize};
+
+#[derive(thiserror::Error, Debug, PartialEq, Eq)]
+pub enum Error {
+    #[error("The method '{0}' is malformed or otherwise invalid.")]
+    BadMethod(String),
+    #[error("The method '{0}' is invalid.")]
+    InvalidMethodName(String),
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
+pub enum Method {
+    Project(ProjectMethod),
+    Package(PackageMethod),
+}
+
+impl Display for Method {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        panic!("Invalid use, Method cannot be serialized (despite it being possible to do so).");
+    }
+}
+
+/// Method namespace registration.
+impl FromStr for Method {
+    type Err = Error;
+
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        let mut split = value.split('/');
+        let (namespace, name) = (
+            split.next().ok_or_else(|| Error::BadMethod(value.into()))?,
+            split.next().ok_or_else(|| Error::BadMethod(value.into()))?,
+        );
+
+        // Route namespaces to the appropriate enum variants for construction.
+        Ok(match namespace {
+            "project" => Self::Project(ProjectMethod::from_str(&name)?),
+            "package" => Self::Package(PackageMethod::from_str(&name)?),
+            x => Err(Error::InvalidMethodName(x.into()))?,
+        })
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
+pub enum ProjectMethod {
+    /// Set the project directory context. This locks the project, if it exists.
+    SetContext,
+    /// Release the project directory context. This unlocks the project, if a lock exists.
+    ReleaseContext,
+    /// Get project metadata.
+    GetMetadata,
+    /// Add one or more packages to the project.
+    AddPackages,
+    /// Remove one or more packages from the project.
+    RemovePackages,
+    /// Get a list of currently installed packages.
+    GetPackages,
+    /// Determine if the current context is a valid project.
+    IsValid,
+}
+
+impl FromStr for ProjectMethod {
+    type Err = Error;
+
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        Ok(match value {
+            "set_context" => Self::SetContext,
+            "release_context" => Self::ReleaseContext,
+            "get_metadata" => Self::GetMetadata,
+            "add_packages" => Self::AddPackages,
+            "remove_packages" => Self::RemovePackages,
+            "get_packages" => Self::GetPackages,
+            "is_valid" => Self::IsValid,
+            x => Err(Error::InvalidMethodName(x.into()))?,
+        })
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
+pub enum PackageMethod {
+    /// Get metadata about this package.
+    GetMetadata,
+    /// Determine if the package exists within the cache.
+    IsCached,
+}
+
+impl FromStr for PackageMethod {
+    type Err = Error;
+
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        Ok(match value {
+            "get_metadata" => Self::GetMetadata,
+            "is_cached" => Self::IsCached,
+            x => Err(Error::InvalidMethodName(x.into()))?,
+        })
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_namespace_resolve() {
+        let method = "project/set_context";
+        let resolved = Method::from_str(method).unwrap();
+        assert_eq!(resolved, Method::Project(ProjectMethod::SetContext));
+
+        let method = "project/release_context";
+        let resolved = Method::from_str(method).unwrap();
+        assert_eq!(resolved, Method::Project(ProjectMethod::ReleaseContext));
+
+        // Assert that methods with invalid structure are caught.
+        let method = "null";
+        let resolved = Method::from_str(method);
+        assert!(resolved.is_err());
+        assert!(matches!(resolved.err().unwrap(), Error::BadMethod(..)));
+
+        // Assert that invalid methods with correct structure are caught.
+        let method = "null/null";
+        let resolved = Method::from_str(method);
+        assert!(resolved.is_err());
+        assert!(matches!(
+            resolved.err().unwrap(),
+            Error::InvalidMethodName(..),
+        ));
+
+        // Assert that name resolution can handle bad names.
+        let name = "null";
+        let resolved = ProjectMethod::from_str(name);
+        assert!(resolved.is_err());
+        assert!(matches!(
+            resolved.err().unwrap(),
+            Error::InvalidMethodName(..),
+        ));
+
+        let name = "null";
+        let resolved = PackageMethod::from_str(name);
+        assert!(resolved.is_err());
+        assert!(matches!(
+            resolved.err().unwrap(),
+            Error::InvalidMethodName(..),
+        ));
+    }
+}

src/server/mod.rs

@@ -0,0 +1,8 @@
+mod method;
+mod proto;
+
+/// The daemon's entrypoint. This is a psuedo event loop which does the following in step:
+/// 1. Read JSON-RPC input(s) from stdin.
+/// 2. Route each input.
+/// 3. Serialize the output and write to stdout.
+pub async fn start() {}

src/server/proto.rs

@@ -0,0 +1,104 @@
+use std::str::FromStr;
+
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use serde_with::{serde_as, DisplayFromStr};
+
+use crate::server::method::Method;
+
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    #[error("The provided message '{0}' could not be parsed as JSON.")]
+    InvalidMessage(String),
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
+#[serde(untagged)]
+pub enum Message {
+    Request(Request),
+    Response(Response),
+}
+
+impl Message {
+    pub fn from_json(json: &str) -> Result<Self, Error> {
+        serde_json::from_str::<Message>(json).map_err(|e| Error::InvalidMessage(e.to_string()))
+    }
+}
+
+/// This FromStr wrapper is here specifically for serde_with deserialization.
+impl FromStr for Message {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Message::from_json(s)
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
+#[serde(untagged)]
+pub enum Id {
+    Int(isize),
+    String(String),
+}
+
+#[serde_as]
+#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
+pub struct Request {
+    /// An identifier which, as per the JSON-RPC spec, can either be an integer
+    /// or string. We use an untagged enum to allow serde to transparenly parse these types.
+    pub id: Id,
+
+    /// This field is deserialized into a Method enum variant via Method::from_str.
+    /// Unfortunately this means that errors returned from Method::from_str are lost.
+    #[serde_as(as = "DisplayFromStr")]
+    pub method: Method,
+
+    /// This field is null for notifications.
+    #[serde(default = "Value::default")]
+    #[serde(skip_serializing_if = "Value::is_null")]
+    pub params: Value,
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
+pub struct Response {
+    pub id: Id,
+    pub content: Option<Value>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct ErrorMessage {
+    pub id: Id,
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::server::method::{PackageMethod, ProjectMethod};
+
+    #[test]
+    fn test_request_deserialize() {
+        let request = "{ \"id\": 1, \"method\": \"project/set_context\" }";
+        let de = Message::from_str(request).unwrap();
+        let cmp = Request {
+            id: Id::Int(1),
+            method: Method::Project(ProjectMethod::SetContext),
+            params: Value::Null,
+        };
+        assert_eq!(de, Message::Request(cmp));
+
+        let request = "{ \"id\": \"oksamies\", \"method\": \"package/get_metadata\" }";
+        let de = Message::from_str(request).unwrap();
+        let cmp = Request {
+            id: Id::String(String::from("oksamies")),
+            method: Method::Package(PackageMethod::GetMetadata),
+            params: Value::Null,
+        };
+        assert_eq!(de, Message::Request(cmp));
+
+        // At this point the error is pretty obfuscated behind serde_json::Error, so we just
+        // check to see if an error was returned.
+        let request = "{ \"id\": \"oksamies\", \"method\": \"null/null\" }";
+        let de: Result<Request, serde_json::Error> = serde_json::from_str(request);
+        assert!(de.is_err());
+    }
+}