Add Rust domain kernel and wire contracts

crates/remora-contracts/src/wire.rs

@@ -0,0 +1,242 @@
+use std::fmt;
+
+use serde::{Deserialize, Deserializer, Serialize, Serializer, de::Error as _};
+use time::{OffsetDateTime, format_description::well_known::Rfc3339};
+
+pub const MAX_SAFE_INTEGER: u64 = 9_007_199_254_740_991;
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[serde(transparent)]
+pub struct NullableDto<T>(pub Option<T>);
+
+pub(crate) fn optional_nullable<'de, D, T>(
+    deserializer: D,
+) -> Result<Option<NullableDto<T>>, D::Error>
+where
+    D: Deserializer<'de>,
+    T: Deserialize<'de>,
+{
+    NullableDto::deserialize(deserializer).map(Some)
+}
+
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct SafeIntegerDto(u64);
+
+impl SafeIntegerDto {
+    pub fn new(value: u64) -> Result<Self, WireValueError> {
+        if value > MAX_SAFE_INTEGER {
+            return Err(WireValueError::SafeInteger);
+        }
+        Ok(Self(value))
+    }
+
+    #[must_use]
+    pub const fn get(self) -> u64 {
+        self.0
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct SignedSafeIntegerDto(i64);
+
+impl SignedSafeIntegerDto {
+    pub fn new(value: i64) -> Result<Self, WireValueError> {
+        if value.unsigned_abs() > MAX_SAFE_INTEGER {
+            return Err(WireValueError::SafeInteger);
+        }
+        Ok(Self(value))
+    }
+
+    #[must_use]
+    pub const fn get(self) -> i64 {
+        self.0
+    }
+}
+
+impl Serialize for SignedSafeIntegerDto {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_i64(self.0)
+    }
+}
+
+impl<'de> Deserialize<'de> for SignedSafeIntegerDto {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Self::new(i64::deserialize(deserializer)?).map_err(D::Error::custom)
+    }
+}
+
+impl Serialize for SafeIntegerDto {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_u64(self.0)
+    }
+}
+
+impl<'de> Deserialize<'de> for SafeIntegerDto {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Self::new(u64::deserialize(deserializer)?).map_err(D::Error::custom)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct PositiveIntegerDto(SafeIntegerDto);
+
+impl PositiveIntegerDto {
+    pub fn new(value: u64) -> Result<Self, WireValueError> {
+        let value = SafeIntegerDto::new(value)?;
+        if value.get() == 0 {
+            return Err(WireValueError::PositiveInteger);
+        }
+        Ok(Self(value))
+    }
+
+    #[must_use]
+    pub const fn get(self) -> u64 {
+        self.0.get()
+    }
+}
+
+impl Serialize for PositiveIntegerDto {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_u64(self.get())
+    }
+}
+
+impl<'de> Deserialize<'de> for PositiveIntegerDto {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Self::new(u64::deserialize(deserializer)?).map_err(D::Error::custom)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
+pub struct SchemaVersionDto;
+
+impl Serialize for SchemaVersionDto {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_u8(1)
+    }
+}
+
+impl<'de> Deserialize<'de> for SchemaVersionDto {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        if u8::deserialize(deserializer)? != 1 {
+            return Err(D::Error::custom("unsupported schema version"));
+        }
+        Ok(Self)
+    }
+}
+
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct CursorDto(String);
+
+impl CursorDto {
+    pub fn parse(value: impl Into<String>) -> Result<Self, WireValueError> {
+        let value = value.into();
+        if !(16..=2048).contains(&value.chars().count()) {
+            return Err(WireValueError::Cursor);
+        }
+        Ok(Self(value))
+    }
+
+    #[must_use]
+    pub fn as_str(&self) -> &str {
+        &self.0
+    }
+}
+
+impl Serialize for CursorDto {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(&self.0)
+    }
+}
+
+impl<'de> Deserialize<'de> for CursorDto {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Self::parse(String::deserialize(deserializer)?).map_err(D::Error::custom)
+    }
+}
+
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct DateTimeDto(String);
+
+impl DateTimeDto {
+    pub fn parse(value: impl Into<String>) -> Result<Self, WireValueError> {
+        let value = value.into();
+        OffsetDateTime::parse(&value, &Rfc3339).map_err(|_| WireValueError::DateTime)?;
+        Ok(Self(value))
+    }
+
+    #[must_use]
+    pub fn as_str(&self) -> &str {
+        &self.0
+    }
+}
+
+impl Serialize for DateTimeDto {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(&self.0)
+    }
+}
+
+impl<'de> Deserialize<'de> for DateTimeDto {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Self::parse(String::deserialize(deserializer)?).map_err(D::Error::custom)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum WireValueError {
+    SafeInteger,
+    PositiveInteger,
+    Cursor,
+    DateTime,
+}
+
+impl fmt::Display for WireValueError {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let message = match self {
+            Self::SafeInteger => "integer exceeds the interoperable JSON range",
+            Self::PositiveInteger => "expected a positive integer",
+            Self::Cursor => "invalid cursor length",
+            Self::DateTime => "invalid RFC 3339 date-time",
+        };
+        formatter.write_str(message)
+    }
+}
+
+impl std::error::Error for WireValueError {}