Add 'spin-serde' crate

This collects some serde tools into a separate crate, avoiding some
inter-crate dependencies.

Signed-off-by: Lann Martin <[email protected]>

Author: lann

Cargo.lock

@@ -7,9 +7,9 @@ edition = { workspace = true }
 [dependencies]
 anyhow = "1.0"
 async-trait = "0.1"
-base64 = "0.21.3"
 ouroboros = "0.18.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 spin-core = { path = "../core" }
+spin-serde = { path = "../serde" }
 thiserror = "1.0"

crates/app/Cargo.toml

@@ -4,6 +4,7 @@ use std::path::PathBuf;
 
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
+use spin_serde::FixedVersion;
 
 use crate::{metadata::MetadataExt, values::ValuesMap};
 
@@ -120,7 +121,7 @@ pub struct ContentRef {
     #[serde(
         default,
         skip_serializing_if = "Option::is_none",
-        with = "serde_base64"
+        with = "spin_serde::base64"
     )]
     pub inline: Option<Vec<u8>>,
     /// If set, the content must have the given SHA-256 digest.
@@ -149,54 +150,3 @@ pub struct Variable {
     #[serde(default, skip_serializing_if = "std::ops::Not::not")]
     pub secret: bool,
 }
-
-/// FixedVersion represents a schema version field with a const value.
-#[derive(Clone, Debug, Default, Serialize, Deserialize)]
-#[serde(into = "usize", try_from = "usize")]
-pub struct FixedVersion<const V: usize>;
-
-impl<const V: usize> From<FixedVersion<V>> for usize {
-    fn from(_: FixedVersion<V>) -> usize {
-        V
-    }
-}
-
-impl<const V: usize> TryFrom<usize> for FixedVersion<V> {
-    type Error = String;
-
-    fn try_from(value: usize) -> Result<Self, Self::Error> {
-        if value != V {
-            return Err(format!("invalid version {} != {}", value, V));
-        }
-        Ok(Self)
-    }
-}
-
-mod serde_base64 {
-    use std::borrow::Cow;
-
-    use base64::{engine::GeneralPurpose, prelude::BASE64_STANDARD_NO_PAD, Engine};
-    use serde::{de, Deserialize, Deserializer, Serializer};
-
-    const BASE64: GeneralPurpose = BASE64_STANDARD_NO_PAD;
-
-    pub fn serialize<S>(bytes: &Option<Vec<u8>>, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match bytes {
-            Some(bytes) => serializer.serialize_str(&BASE64.encode(bytes)),
-            None => serializer.serialize_none(),
-        }
-    }
-
-    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Vec<u8>>, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        match Option::<Cow<str>>::deserialize(deserializer)? {
-            Some(s) => Ok(Some(BASE64.decode(s.as_ref()).map_err(de::Error::custom)?)),
-            None => Ok(None),
-        }
-    }
-}

crates/app/src/locked.rs

@@ -9,7 +9,7 @@ anyhow = "1.0.75"
 indexmap = { version = "1", features = ["serde"] }
 outbound-http = { path = "../outbound-http" }
 serde = { version = "1.0", features = ["derive"] }
-spin-app = { path = "../app" }
+spin-serde = { path = "../serde" }
 thiserror = "1"
 toml = { version = "0.8.0", features = ["preserve_order"] }
 

crates/manifest/Cargo.toml

@@ -102,7 +102,7 @@ fn component_id_from_string(id: String) -> Result<v2::KebabId, Error> {
         .map_err(|err: String| Error::InvalidID { id, reason: err })
 }
 
-fn id_from_string<const DELIM: char>(id: String) -> Result<v2::Id<DELIM>, Error> {
+fn id_from_string<const DELIM: char>(id: String) -> Result<spin_serde::id::Id<DELIM>, Error> {
     id.clone()
         .try_into()
         .map_err(|err: String| Error::InvalidID { id, reason: err })

crates/manifest/src/compat.rs

@@ -16,25 +16,3 @@ pub(crate) struct VersionProbe {
     #[serde(alias = "spin_version")]
     pub spin_manifest_version: toml::Value,
 }
-
-/// Fixed schema version 1; (de)serializes as string "1".
-#[derive(Clone, Debug, Default, Deserialize)]
-#[serde(into = "String", try_from = "String")]
-pub struct FixedStringVersion<const V: usize>;
-
-impl<const V: usize> From<FixedStringVersion<V>> for String {
-    fn from(_: FixedStringVersion<V>) -> String {
-        V.to_string()
-    }
-}
-
-impl<const V: usize> TryFrom<String> for FixedStringVersion<V> {
-    type Error = String;
-
-    fn try_from(value: String) -> Result<Self, Self::Error> {
-        if value.parse() != Ok(V) {
-            return Err(format!("invalid version {value:?} != \"{V}\""));
-        }
-        Ok(Self)
-    }
-}

crates/manifest/src/schema/mod.rs

@@ -1,10 +1,11 @@
 use serde::Deserialize;
 
+use spin_serde::FixedStringVersion;
+
 pub use super::common::{
     ComponentBuildConfig as ComponentBuildConfigV1, ComponentSource as ComponentSourceV1,
     Variable as VariableV1, WasiFilesMount as WasiFilesMountV1,
 };
-use super::FixedStringVersion;
 
 type Map<K, V> = indexmap::IndexMap<K, V>;
 

crates/manifest/src/schema/v1.rs

@@ -1,5 +1,6 @@
 use serde::{Deserialize, Serialize};
-use spin_app::locked::FixedVersion;
+use spin_serde::FixedVersion;
+pub use spin_serde::{KebabId, SnakeId};
 
 pub use super::common::{ComponentBuildConfig, ComponentSource, Variable, WasiFilesMount};
 
@@ -115,70 +116,6 @@ pub struct Component {
     pub build: Option<ComponentBuildConfig>,
 }
 
-/// A "kebab-case" identifier.
-pub type KebabId = Id<'-'>;
-
-/// A "snake_case" identifier.
-pub type SnakeId = Id<'_'>;
-
-/// An ID is a non-empty string containing one or more component model
-/// `word`s separated by a delimiter char.
-#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
-#[serde(into = "String", try_from = "String")]
-pub struct Id<const DELIM: char>(String);
-
-impl<const DELIM: char> std::fmt::Display for Id<DELIM> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-impl<const DELIM: char> AsRef<str> for Id<DELIM> {
-    fn as_ref(&self) -> &str {
-        &self.0
-    }
-}
-
-impl<const DELIM: char> From<Id<DELIM>> for String {
-    fn from(value: Id<DELIM>) -> Self {
-        value.0
-    }
-}
-
-impl<const DELIM: char> TryFrom<String> for Id<DELIM> {
-    type Error = String;
-
-    fn try_from(id: String) -> Result<Self, Self::Error> {
-        if id.is_empty() {
-            return Err("empty".into());
-        }
-        for word in id.split(DELIM) {
-            if word.is_empty() {
-                return Err(format!("{DELIM:?}-separated words must not be empty"));
-            }
-            let mut chars = word.chars();
-            let first = chars.next().unwrap();
-            if !first.is_ascii_alphabetic() {
-                return Err(format!(
-                    "{DELIM:?}-separated words must start with an ASCII letter; got {first:?}"
-                ));
-            }
-            let word_is_uppercase = first.is_ascii_uppercase();
-            for ch in chars {
-                if ch.is_ascii_digit() {
-                } else if !ch.is_ascii_alphanumeric() {
-                    return Err(format!(
-                        "{DELIM:?}-separated words may only contain alphanumeric ASCII; got {ch:?}"
-                    ));
-                } else if ch.is_ascii_uppercase() != word_is_uppercase {
-                    return Err(format!("{DELIM:?}-separated words must be all lowercase or all UPPERCASE; got {word:?}"));
-                }
-            }
-        }
-        Ok(Self(id))
-    }
-}
-
 mod one_or_many {
     use serde::{Deserialize, Deserializer, Serialize, Serializer};
 

crates/manifest/src/schema/v2.rs

@@ -0,0 +1,9 @@
+[package]
+name = "spin-serde"
+version = { workspace = true }
+authors = { workspace = true }
+edition = { workspace = true }
+
+[dependencies]
+base64 = "0.21.4"
+serde = "1.0.189"