Chore/version 0 3 1 0 (#1475)

* feat: move over to workspaces

* chore: Move to libs

* chore:fix(build): Compat

* chore: fixing pr

libs/models/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "models"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+patch-db = { version = "*", path = "../../patch-db/patch-db", features = [
+  "trace",
+] }
+serde = { version = "1.0.*", features = ["derive", "rc"] }
+thiserror = "1.0.*"
+emver = { version = "0.1.6", features = ["serde"] }
+rand = "0.7.*"

libs/models/src/action_id.rs

@@ -0,0 +1,52 @@
+use std::{str::FromStr, path::Path};
+
+use serde::{Serialize, Deserialize};
+
+use crate::{Id, InvalidId};
+
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
+pub struct ActionId<S: AsRef<str> = String>(Id<S>);
+impl FromStr for ActionId {
+    type Err = InvalidId;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(ActionId(Id::try_from(s.to_owned())?))
+    }
+}
+impl From<ActionId> for String {
+    fn from(value: ActionId) -> Self {
+        value.0.into()
+    }
+}
+impl<S: AsRef<str>> AsRef<ActionId<S>> for ActionId<S> {
+    fn as_ref(&self) -> &ActionId<S> {
+        self
+    }
+}
+impl<S: AsRef<str>> std::fmt::Display for ActionId<S> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", &self.0)
+    }
+}
+impl<S: AsRef<str>> AsRef<str> for ActionId<S> {
+    fn as_ref(&self) -> &str {
+        self.0.as_ref()
+    }
+}
+impl<S: AsRef<str>> AsRef<Path> for ActionId<S> {
+    fn as_ref(&self) -> &Path {
+        self.0.as_ref().as_ref()
+    }
+}
+impl<'de, S> Deserialize<'de> for ActionId<S>
+where
+    S: AsRef<str>,
+    Id<S>: Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        Ok(ActionId(serde::Deserialize::deserialize(deserializer)?))
+    }
+}

libs/models/src/health_check_id.rs

@@ -0,0 +1,35 @@
+use std::path::Path;
+
+use serde::{Serialize, Deserialize, Deserializer};
+
+use crate::Id;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
+pub struct HealthCheckId<S: AsRef<str> = String>(Id<S>);
+impl<S: AsRef<str>> std::fmt::Display for HealthCheckId<S> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", &self.0)
+    }
+}
+impl<S: AsRef<str>> AsRef<str> for HealthCheckId<S> {
+    fn as_ref(&self) -> &str {
+        self.0.as_ref()
+    }
+}
+impl<'de, S> Deserialize<'de> for HealthCheckId<S>
+where
+    S: AsRef<str>,
+    Id<S>: Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Ok(HealthCheckId(Deserialize::deserialize(deserializer)?))
+    }
+}
+impl<S: AsRef<str>> AsRef<Path> for HealthCheckId<S> {
+    fn as_ref(&self) -> &Path {
+        self.0.as_ref().as_ref()
+    }
+}

libs/models/src/id.rs

@@ -0,0 +1,75 @@
+use std::borrow::Borrow;
+
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+use crate::{invalid_id::InvalidId, id_unchecked::IdUnchecked};
+
+pub const SYSTEM_ID: Id<&'static str> = Id("x_system");
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Id<S: AsRef<str> = String>(S);
+impl<S: AsRef<str>> Id<S> {
+    pub fn try_from(value: S) -> Result<Self, InvalidId> {
+        if value
+            .as_ref()
+            .chars()
+            .all(|c| c.is_ascii_lowercase() || c == '-')
+        {
+            Ok(Id(value))
+        } else {
+            Err(InvalidId)
+        }
+    }
+}
+impl<'a> Id<&'a str> {
+    pub fn owned(&self) -> Id {
+        Id(self.0.to_owned())
+    }
+}
+impl From<Id> for String {
+    fn from(value: Id) -> Self {
+        value.0
+    }
+}
+impl<S: AsRef<str>> std::ops::Deref for Id<S> {
+    type Target = S;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl<S: AsRef<str>> std::fmt::Display for Id<S> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0.as_ref())
+    }
+}
+impl<S: AsRef<str>> AsRef<str> for Id<S> {
+    fn as_ref(&self) -> &str {
+        self.0.as_ref()
+    }
+}
+impl<S: AsRef<str>> Borrow<str> for Id<S> {
+    fn borrow(&self) -> &str {
+        self.0.as_ref()
+    }
+}
+impl<'de, S> Deserialize<'de> for Id<S>
+where
+    S: AsRef<str>,
+    IdUnchecked<S>: Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let unchecked: IdUnchecked<S> = Deserialize::deserialize(deserializer)?;
+        Id::try_from(unchecked.0).map_err(serde::de::Error::custom)
+    }
+}
+impl<S: AsRef<str>> Serialize for Id<S> {
+    fn serialize<Ser>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error>
+    where
+        Ser: Serializer,
+    {
+        serializer.serialize_str(self.as_ref())
+    }
+}

libs/models/src/id_unchecked.rs

@@ -0,0 +1,56 @@
+use std::borrow::Cow;
+
+use serde::{Deserialize, Deserializer};
+
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct IdUnchecked<S: AsRef<str>>(pub S);
+impl<'de> Deserialize<'de> for IdUnchecked<Cow<'de, str>> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct Visitor;
+        impl<'de> serde::de::Visitor<'de> for Visitor {
+            type Value = IdUnchecked<Cow<'de, str>>;
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                write!(formatter, "a valid ID")
+            }
+            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                Ok(IdUnchecked(Cow::Owned(v.to_owned())))
+            }
+            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                Ok(IdUnchecked(Cow::Owned(v)))
+            }
+            fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                Ok(IdUnchecked(Cow::Borrowed(v)))
+            }
+        }
+        deserializer.deserialize_any(Visitor)
+    }
+}
+impl<'de> Deserialize<'de> for IdUnchecked<String> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Ok(IdUnchecked(String::deserialize(deserializer)?))
+    }
+}
+impl<'de> Deserialize<'de> for IdUnchecked<&'de str> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Ok(IdUnchecked(<&'de str>::deserialize(deserializer)?))
+    }
+}

libs/models/src/interface_id.rs

@@ -0,0 +1,47 @@
+use std::path::Path;
+
+use serde::{Serialize, Deserialize, Deserializer};
+
+use crate::Id;
+
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
+pub struct InterfaceId<S: AsRef<str> = String>(Id<S>);
+impl<S: AsRef<str>> From<Id<S>> for InterfaceId<S> {
+    fn from(id: Id<S>) -> Self {
+        Self(id)
+    }
+}
+impl<S: AsRef<str>> std::fmt::Display for InterfaceId<S> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", &self.0)
+    }
+}
+impl<S: AsRef<str>> std::ops::Deref for InterfaceId<S> {
+    type Target = S;
+    fn deref(&self) -> &Self::Target {
+        &*self.0
+    }
+}
+impl<S: AsRef<str>> AsRef<str> for InterfaceId<S> {
+    fn as_ref(&self) -> &str {
+        self.0.as_ref()
+    }
+}
+impl<'de, S> Deserialize<'de> for InterfaceId<S>
+where
+    S: AsRef<str>,
+    Id<S>: Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Ok(InterfaceId(Deserialize::deserialize(deserializer)?))
+    }
+}
+impl<S: AsRef<str>> AsRef<Path> for InterfaceId<S> {
+    fn as_ref(&self) -> &Path {
+        self.0.as_ref().as_ref()
+    }
+}

libs/models/src/invalid_id.rs

@@ -0,0 +1,4 @@
+
+#[derive(Debug, thiserror::Error)]
+#[error("Invalid ID")]
+pub struct InvalidId;

libs/models/src/lib.rs

@@ -0,0 +1,21 @@
+ mod id;
+ mod invalid_id;
+ mod id_unchecked;
+ mod version;
+ mod volume_id;
+ mod interface_id;
+ mod package_id;
+ mod procedure_name;
+ mod health_check_id;
+ mod action_id;
+
+ pub use id::*;
+ pub use invalid_id::*;
+ pub use id_unchecked::*;
+ pub use version::*;
+ pub use volume_id::*;
+ pub use interface_id::*;
+ pub use package_id::*;
+ pub use procedure_name::*;
+ pub use health_check_id::*;
+ pub use action_id::*;

libs/models/src/package_id.rs

@@ -0,0 +1,85 @@
+use std::{str::FromStr, borrow::Borrow, path::Path};
+
+use serde::{Deserialize, Serialize, Serializer};
+
+use crate::{Id, InvalidId, SYSTEM_ID};
+
+
+pub const SYSTEM_PACKAGE_ID: PackageId<&'static str> = PackageId(SYSTEM_ID);
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct PackageId<S: AsRef<str> = String>(Id<S>);
+impl<'a> PackageId<&'a str> {
+    pub fn owned(&self) -> PackageId {
+        PackageId(self.0.owned())
+    }
+}
+impl FromStr for PackageId {
+    type Err = InvalidId;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(PackageId(Id::try_from(s.to_owned())?))
+    }
+}
+impl From<PackageId> for String {
+    fn from(value: PackageId) -> Self {
+        value.0.into()
+    }
+}
+impl<S: AsRef<str>> From<Id<S>> for PackageId<S> {
+    fn from(id: Id<S>) -> Self {
+        PackageId(id)
+    }
+}
+impl<S: AsRef<str>> std::ops::Deref for PackageId<S> {
+    type Target = S;
+    fn deref(&self) -> &Self::Target {
+        &*self.0
+    }
+}
+impl<S: AsRef<str>> AsRef<PackageId<S>> for PackageId<S> {
+    fn as_ref(&self) -> &PackageId<S> {
+        self
+    }
+}
+impl<S: AsRef<str>> std::fmt::Display for PackageId<S> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", &self.0)
+    }
+}
+impl<S: AsRef<str>> AsRef<str> for PackageId<S> {
+    fn as_ref(&self) -> &str {
+        self.0.as_ref()
+    }
+}
+impl<S: AsRef<str>> Borrow<str> for PackageId<S> {
+    fn borrow(&self) -> &str {
+        self.0.as_ref()
+    }
+}
+impl<S: AsRef<str>> AsRef<Path> for PackageId<S> {
+    fn as_ref(&self) -> &Path {
+        self.0.as_ref().as_ref()
+    }
+}
+impl<'de, S> Deserialize<'de> for PackageId<S>
+where
+    S: AsRef<str>,
+    Id<S>: Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        Ok(PackageId(Deserialize::deserialize(deserializer)?))
+    }
+}
+impl<S> Serialize for PackageId<S>
+where
+    S: AsRef<str>,
+{
+    fn serialize<Ser>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error>
+    where
+        Ser: Serializer,
+    {
+        Serialize::serialize(&self.0, serializer)
+    }
+}

libs/models/src/procedure_name.rs

@@ -0,0 +1,50 @@
+use crate::{PackageId, HealthCheckId, ActionId};
+
+
+#[derive(Debug, Clone)]
+pub enum ProcedureName {
+    Main, // Usually just run container
+    CreateBackup,
+    RestoreBackup,
+    GetConfig,
+    SetConfig,
+    Migration,
+    Properties,
+    Check(PackageId),
+    AutoConfig(PackageId),
+    Health(HealthCheckId),
+    Action(ActionId),
+}
+
+impl ProcedureName {
+    pub fn docker_name(&self) -> Option<String> {
+        match self {
+            ProcedureName::Main => None,
+            ProcedureName::CreateBackup => Some("CreateBackup".to_string()),
+            ProcedureName::RestoreBackup => Some("RestoreBackup".to_string()),
+            ProcedureName::GetConfig => Some("GetConfig".to_string()),
+            ProcedureName::SetConfig => Some("SetConfig".to_string()),
+            ProcedureName::Migration => Some("Migration".to_string()),
+            ProcedureName::Properties => Some(format!("Properties-{}", rand::random::<u64>())),
+            ProcedureName::Health(id) => Some(format!("{}Health", id)),
+            ProcedureName::Action(id) => Some(format!("{}Action", id)),
+            ProcedureName::Check(_) => None,
+            ProcedureName::AutoConfig(_) => None,
+        }
+    }
+    pub fn js_function_name(&self) -> String {
+        match self {
+            ProcedureName::Main => "/main".to_string(),
+            ProcedureName::CreateBackup => "/createBackup".to_string(),
+            ProcedureName::RestoreBackup => "/restoreBackup".to_string(),
+            ProcedureName::GetConfig => "/getConfig".to_string(),
+            ProcedureName::SetConfig => "/setConfig".to_string(),
+            ProcedureName::Migration => "/migration".to_string(),
+            ProcedureName::Properties => "/properties".to_string(),
+            ProcedureName::Health(id) => format!("/health/{}", id),
+            ProcedureName::Action(id) => format!("/action/{}", id),
+            ProcedureName::Check(id) => format!("/dependencies/{}/check", id),
+            ProcedureName::AutoConfig(id) => format!("/dependencies/{}/autoConfigure", id),
+        }
+    }
+}

libs/models/src/version.rs

@@ -0,0 +1,110 @@
+use std::{str::FromStr, ops::Deref};
+use std::hash::{Hash, Hasher};
+
+use patch_db::{HasModel, Model};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+
+#[derive(Debug, Clone)]
+pub struct Version {
+    version: emver::Version,
+    string: String,
+}
+impl Version {
+    pub fn as_str(&self) -> &str {
+        self.string.as_str()
+    }
+    pub fn into_version(self) -> emver::Version {
+        self.version
+    }
+}
+impl std::fmt::Display for Version {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.string)
+    }
+}
+impl std::str::FromStr for Version {
+    type Err = <emver::Version as FromStr>::Err;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(Version {
+            string: s.to_owned(),
+            version: s.parse()?,
+        })
+    }
+}
+impl From<emver::Version> for Version {
+    fn from(v: emver::Version) -> Self {
+        Version {
+            string: v.to_string(),
+            version: v,
+        }
+    }
+}
+impl From<Version> for emver::Version {
+    fn from(v: Version) -> Self {
+        v.version
+    }
+}
+impl Default for Version {
+    fn default() -> Self {
+        Self::from(emver::Version::default())
+    }
+}
+impl Deref for Version {
+    type Target = emver::Version;
+    fn deref(&self) -> &Self::Target {
+        &self.version
+    }
+}
+impl AsRef<emver::Version> for Version {
+    fn as_ref(&self) -> &emver::Version {
+        &self.version
+    }
+}
+impl AsRef<str> for Version {
+    fn as_ref(&self) -> &str {
+        self.as_str()
+    }
+}
+impl PartialEq for Version {
+    fn eq(&self, other: &Version) -> bool {
+        self.version.eq(&other.version)
+    }
+}
+impl Eq for Version {}
+impl PartialOrd for Version {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        self.version.partial_cmp(&other.version)
+    }
+}
+impl Ord for Version {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.version.cmp(&other.version)
+    }
+}
+impl Hash for Version {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.version.hash(state)
+    }
+}
+impl<'de> Deserialize<'de> for Version {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let string = String::deserialize(deserializer)?;
+        let version = emver::Version::from_str(&string).map_err(::serde::de::Error::custom)?;
+        Ok(Self { string, version })
+    }
+}
+impl Serialize for Version {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.string.serialize(serializer)
+    }
+}
+impl HasModel for Version {
+    type Model = Model<Version>;
+}

libs/models/src/volume_id.rs

@@ -0,0 +1,62 @@
+use std::{borrow::Borrow, path::Path};
+
+use serde::{Deserialize, Serialize, Deserializer};
+
+use crate::{Id, IdUnchecked};
+
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum VolumeId<S: AsRef<str> = String> {
+    Backup,
+    Custom(Id<S>),
+}
+impl<S: AsRef<str>> std::fmt::Display for VolumeId<S> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            VolumeId::Backup => write!(f, "BACKUP"),
+            VolumeId::Custom(id) => write!(f, "{}", id),
+        }
+    }
+}
+impl<S: AsRef<str>> AsRef<str> for VolumeId<S> {
+    fn as_ref(&self) -> &str {
+        match self {
+            VolumeId::Backup => "BACKUP",
+            VolumeId::Custom(id) => id.as_ref(),
+        }
+    }
+}
+impl<S: AsRef<str>> Borrow<str> for VolumeId<S> {
+    fn borrow(&self) -> &str {
+        self.as_ref()
+    }
+}
+impl<S: AsRef<str>> AsRef<Path> for VolumeId<S> {
+    fn as_ref(&self) -> &Path {
+        AsRef::<str>::as_ref(self).as_ref()
+    }
+}
+impl<'de, S> Deserialize<'de> for VolumeId<S>
+where
+    S: AsRef<str>,
+    IdUnchecked<S>: Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let unchecked: IdUnchecked<S> = Deserialize::deserialize(deserializer)?;
+        Ok(match unchecked.0.as_ref() {
+            "BACKUP" => VolumeId::Backup,
+            _ => VolumeId::Custom(Id::try_from(unchecked.0).map_err(serde::de::Error::custom)?),
+        })
+    }
+}
+impl<S: AsRef<str>> Serialize for VolumeId<S> {
+    fn serialize<Ser>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error>
+    where
+        Ser: serde::Serializer,
+    {
+        serializer.serialize_str(self.as_ref())
+    }
+}