chore: velocity enforcement

Makefile

@@ -8,7 +8,7 @@ start-deps:
 	docker compose up -d integration-deps
 
 setup-db:
-	cd cala-ledger && cargo sqlx migrate run
+	cd cala-ledger && cargo sqlx migrate run || cargo sqlx migrate run
 	cd cala-server && cargo sqlx migrate run --ignore-missing
 
 reset-deps: clean-deps start-deps setup-db

cala-cel-interpreter/src/cel_type.rs

@@ -11,8 +11,9 @@ pub enum CelType {
     Bool,
     Null,
 
-    // Addons
+    // Abstract
     Date,
+    Timestamp,
     Uuid,
     Decimal,
 }

cala-cel-interpreter/src/context/decimal.rs

@@ -1,6 +1,6 @@
 use lazy_static::lazy_static;
 
-use std::collections::HashMap;
+use std::{borrow::Cow, collections::HashMap};
 
 use crate::builtins;
 
@@ -10,11 +10,11 @@ lazy_static! {
     pub static ref CEL_CONTEXT: CelContext = {
         let mut idents = HashMap::new();
         idents.insert(
-            SELF_PACKAGE_NAME.to_string(),
+            SELF_PACKAGE_NAME,
             ContextItem::Function(Box::new(builtins::decimal::cast)),
         );
         idents.insert(
-            "Add".to_string(),
+            Cow::Borrowed("Add"),
             ContextItem::Function(Box::new(builtins::decimal::add)),
         );
         CelContext { idents }

cala-cel-interpreter/src/context/mod.rs

@@ -1,42 +1,42 @@
 mod decimal;
 
-use std::collections::HashMap;
+use std::{borrow::Cow, collections::HashMap};
 
 use crate::{builtins, error::*, value::*};
 
-const SELF_PACKAGE_NAME: &str = "self";
+const SELF_PACKAGE_NAME: Cow<'static, str> = Cow::Borrowed("self");
 
 type CelFunction = Box<dyn Fn(Vec<CelValue>) -> Result<CelValue, CelError> + Sync>;
 #[derive(Debug)]
 pub struct CelContext {
-    idents: HashMap<String, ContextItem>,
+    idents: HashMap<Cow<'static, str>, ContextItem>,
 }
 
 impl CelContext {
-    pub fn add_variable(&mut self, name: impl Into<String>, value: impl Into<CelValue>) {
+    pub fn add_variable(&mut self, name: impl Into<Cow<'static, str>>, value: impl Into<CelValue>) {
         self.idents
             .insert(name.into(), ContextItem::Value(value.into()));
     }
 
     pub fn new() -> Self {
         let mut idents = HashMap::new();
         idents.insert(
-            "date".to_string(),
+            Cow::Borrowed("date"),
             ContextItem::Function(Box::new(builtins::date)),
         );
         idents.insert(
-            "uuid".to_string(),
+            Cow::Borrowed("uuid"),
             ContextItem::Function(Box::new(builtins::uuid)),
         );
         idents.insert(
-            "decimal".to_string(),
+            Cow::Borrowed("decimal"),
             ContextItem::Package(&decimal::CEL_CONTEXT),
         );
         Self { idents }
     }
 
     pub(crate) fn package_self(&self) -> Result<&ContextItem, CelError> {
-        self.lookup(SELF_PACKAGE_NAME)
+        self.lookup(&SELF_PACKAGE_NAME)
     }
 
     pub(crate) fn lookup(&self, name: &str) -> Result<&ContextItem, CelError> {

cala-cel-interpreter/src/interpreter.rs

@@ -156,6 +156,7 @@ fn evaluate_member<'a>(
     use ast::Member::*;
     match member {
         Attribute(name) => match target {
+            EvalType::Value(CelValue::Map(map)) => Ok(EvalType::Value(map.get(name))),
             EvalType::ContextItem(ContextItem::Value(CelValue::Map(map))) => {
                 Ok(EvalType::Value(map.get(name)))
             }
@@ -379,10 +380,12 @@ mod tests {
 
     #[test]
     fn lookup() {
-        let expression = "params.hello".parse::<CelExpression>().unwrap();
-        let mut context = CelContext::new();
+        let expression = "params.hello.world".parse::<CelExpression>().unwrap();
+        let mut hello = CelMap::new();
+        hello.insert("world", 42);
         let mut params = CelMap::new();
-        params.insert("hello", 42);
+        params.insert("hello", hello);
+        let mut context = CelContext::new();
         context.add_variable("params", params);
         assert_eq!(expression.evaluate(&context).unwrap(), CelValue::Int(42));
     }

cala-cel-interpreter/src/value.rs

@@ -1,5 +1,5 @@
 use cel_parser::{ast::Literal, Expression};
-use chrono::NaiveDate;
+use chrono::{DateTime, NaiveDate, Utc};
 use rust_decimal::Decimal;
 use uuid::Uuid;
 
@@ -25,9 +25,10 @@ pub enum CelValue {
     Bool(bool),
     Null,
 
-    // Addons
+    // Abstract
     Decimal(Decimal),
     Date(NaiveDate),
+    Timestamp(DateTime<Utc>),
     Uuid(Uuid),
 }
 
@@ -226,6 +227,7 @@ impl From<&CelValue> for CelType {
             CelValue::Decimal(_) => CelType::Decimal,
             CelValue::Date(_) => CelType::Date,
             CelValue::Uuid(_) => CelType::Uuid,
+            CelValue::Timestamp(_) => CelType::Timestamp,
         }
     }
 }
@@ -269,6 +271,22 @@ impl<'a> TryFrom<&'a CelValue> for &'a Decimal {
     }
 }
 
+impl<'a> TryFrom<CelResult<'a>> for bool {
+    type Error = ResultCoercionError;
+
+    fn try_from(CelResult { expr, val }: CelResult) -> Result<Self, Self::Error> {
+        if let CelValue::Bool(b) = val {
+            Ok(b)
+        } else {
+            Err(ResultCoercionError::BadCoreTypeCoercion(
+                format!("{expr:?}"),
+                CelType::from(&val),
+                CelType::Bool,
+            ))
+        }
+    }
+}
+
 impl<'a> TryFrom<CelResult<'a>> for NaiveDate {
     type Error = ResultCoercionError;
 
@@ -285,6 +303,22 @@ impl<'a> TryFrom<CelResult<'a>> for NaiveDate {
     }
 }
 
+impl<'a> TryFrom<CelResult<'a>> for DateTime<Utc> {
+    type Error = ResultCoercionError;
+
+    fn try_from(CelResult { expr, val }: CelResult) -> Result<Self, Self::Error> {
+        if let CelValue::Timestamp(d) = val {
+            Ok(d)
+        } else {
+            Err(ResultCoercionError::BadCoreTypeCoercion(
+                format!("{expr:?}"),
+                CelType::from(&val),
+                CelType::Timestamp,
+            ))
+        }
+    }
+}
+
 impl<'a> TryFrom<CelResult<'a>> for Uuid {
     type Error = ResultCoercionError;
 

cala-ledger-core-types/src/entry.rs

@@ -18,3 +18,21 @@ pub struct EntryValues {
     pub direction: DebitOrCredit,
     pub description: Option<String>,
 }
+
+mod cel {
+    use cel_interpreter::{CelMap, CelValue};
+
+    impl From<&super::EntryValues> for CelValue {
+        fn from(entry: &super::EntryValues) -> Self {
+            let mut map = CelMap::new();
+            map.insert("id", entry.id);
+            map.insert("entry_type", entry.entry_type.clone());
+            map.insert("sequence", CelValue::UInt(entry.sequence as u64));
+            map.insert("layer", entry.layer);
+            map.insert("direction", entry.direction);
+            map.insert("units", entry.units);
+            map.insert("currency", entry.currency);
+            map.into()
+        }
+    }
+}

cala-ledger-core-types/src/primitives.rs

@@ -57,6 +57,15 @@ impl<'a> TryFrom<CelResult<'a>> for DebitOrCredit {
     }
 }
 
+impl From<DebitOrCredit> for CelValue {
+    fn from(v: DebitOrCredit) -> Self {
+        match v {
+            DebitOrCredit::Debit => "DEBIT".into(),
+            DebitOrCredit::Credit => "CREDIT".into(),
+        }
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq, Eq, sqlx::Type)]
 #[sqlx(type_name = "Status", rename_all = "snake_case")]
 #[serde(rename_all = "snake_case")]
@@ -108,6 +117,16 @@ impl Default for Layer {
     }
 }
 
+impl From<Layer> for CelValue {
+    fn from(l: Layer) -> Self {
+        match l {
+            Layer::Settled => "SETTLED".into(),
+            Layer::Pending => "PENDING".into(),
+            Layer::Encumbrance => "ENCUMBRANCE".into(),
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy, Eq, Serialize, Deserialize)]
 #[serde(try_from = "String")]
 #[serde(into = "&str")]
@@ -131,6 +150,12 @@ impl std::fmt::Display for Currency {
     }
 }
 
+impl From<Currency> for CelValue {
+    fn from(c: Currency) -> Self {
+        c.code().into()
+    }
+}
+
 impl std::hash::Hash for Currency {
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
         self.code().hash(state);

cala-ledger-core-types/src/transaction.rs

@@ -15,3 +15,22 @@ pub struct TransactionValues {
     pub description: Option<String>,
     pub metadata: Option<serde_json::Value>,
 }
+
+mod cel {
+    use cel_interpreter::{CelMap, CelValue};
+
+    impl From<&super::TransactionValues> for CelValue {
+        fn from(tx: &super::TransactionValues) -> Self {
+            let mut map = CelMap::new();
+            map.insert("id", tx.id);
+            map.insert("journal_id", tx.journal_id);
+            map.insert("tx_template_id", tx.tx_template_id);
+            map.insert("effective", tx.effective);
+            map.insert("correlation_id", tx.correlation_id.clone());
+            if let Some(metadata) = &tx.metadata {
+                map.insert("metadata", metadata.clone());
+            }
+            map.into()
+        }
+    }
+}

cala-ledger-core-types/src/velocity/balance.rs

@@ -0,0 +1,34 @@
+use rust_decimal::Decimal;
+
+use crate::{balance::BalanceSnapshot, primitives::*};
+
+#[derive(Debug, Clone, sqlx::Type, PartialEq, Eq, Hash)]
+#[sqlx(transparent)]
+pub struct Window(serde_json::Value);
+
+impl Window {
+    pub fn inner(&self) -> &serde_json::Value {
+        &self.0
+    }
+}
+
+impl From<serde_json::Map<String, serde_json::Value>> for Window {
+    fn from(map: serde_json::Map<String, serde_json::Value>) -> Self {
+        Window(map.into())
+    }
+}
+
+impl From<serde_json::Value> for Window {
+    fn from(map: serde_json::Value) -> Self {
+        Window(map)
+    }
+}
+
+pub struct VelocityBalance {
+    pub control_id: VelocityControlId,
+    pub limit_id: VelocityLimitId,
+    pub spent: Decimal,
+    pub remaining: Decimal,
+    pub currency: Currency,
+    pub balance: BalanceSnapshot,
+}

cala-ledger-core-types/src/velocity/limit.rs

@@ -33,4 +33,6 @@ pub struct BalanceLimit {
     pub layer: CelExpression,
     pub amount: CelExpression,
     pub enforcement_direction: CelExpression,
+    pub start: Option<CelExpression>,
+    pub end: Option<CelExpression>,
 }

cala-ledger-core-types/src/velocity/mod.rs

@@ -1,5 +1,7 @@
+mod balance;
 mod control;
 mod limit;
 
+pub use balance::*;
 pub use control::*;
 pub use limit::*;