Refactored session id.

src/action/message.rs

@@ -99,6 +99,7 @@ impl From<Update> for MsgAction {
 impl From<UserAction> for MsgAction {
     fn from(value: UserAction) -> Self {
         match value {
+            UserAction::Addition(data) => Self::Addition(data),
             UserAction::CreateDocument(data) => Self::Create(data),
             UserAction::Query(data) => Self::Query(data),
         }

src/action/user.rs

@@ -1,12 +1,19 @@
-use super::{DocDef, FieldType, Query};
+use super::{Addition, DocDef, FieldType, Query};
 use crate::{message::MessageAction, name::NameType};
 
 #[derive(Clone, Debug)]
 pub enum UserAction {
+    Addition(Addition),
     CreateDocument(DocDef),
     Query(Query),
 }
 
+impl From<Addition> for UserAction {
+    fn from(value: Addition) -> Self {
+        Self::Addition(value)
+    }
+}
+
 impl From<DocDef> for UserAction {
     fn from(value: DocDef) -> Self {
         Self::CreateDocument(value)
@@ -22,6 +29,7 @@ impl From<Query> for UserAction {
 impl MessageAction for UserAction {
     fn doc_name(&self) -> &NameType {
         match self {
+            Self::Addition(data) => data.doc_name(),
             Self::CreateDocument(data) => data.doc_name(),
             Self::Query(data) => data.doc_name(),
         }

src/document/session.rs

@@ -233,7 +233,6 @@ mod sessions {
             _ => unreachable!("got {:?}, should have gotten records", action),
         }
     }
-    */
 
     #[test]
     #[ignore]
@@ -256,6 +255,7 @@ mod sessions {
             _ => unreachable!("got {:?}, should have been an error", action),
         }
     }
+    */
 
     #[test]
     fn expire_should_update_on_successful_query() {

src/lib.rs

@@ -39,40 +39,31 @@ impl MoreThanText {
         Self { queue: queue }
     }
 
-    fn recursive_session_request(
+    fn new_session() -> UserAction {
-        &mut self,
+        Addition::new(Session::doc_names()[0].clone()).into()
-        rx: Receiver<Message>,
+    }
-        action: MsgAction,
+
-        msg: Message,
+    fn recursive_message_request<UA>(&mut self, action: UA) -> Uuid
-    ) -> Uuid {
+    where
-        let reply = msg.response(action);
+        UA: Into<UserAction>,
-        self.queue.send(reply);
+    {
-        let result = rx.recv().unwrap();
+        match self.records(action) {
-        match result.get_action() {
+            Ok(data) => {
-            MsgAction::Records(data) => {
                 if data.len() == 0 {
-                    self.recursive_session_request(
+                    self.recursive_message_request(MoreThanText::new_session())
-                        rx,
-                        Addition::new(Session::doc_names()[0].clone()).into(),
-                        msg,
-                    )
                 } else {
                     let rec = data.iter().last().unwrap();
-                    let field = rec.get(Name::english("id")).unwrap();
+                    match rec.get(Name::english("id")).unwrap() {
-                    match field {
+                        Field::Uuid(id) => id,
-                        Field::Uuid(result) => result,
+                        _ => unreachable!("should always return uuid"),
-                        _ => unreachable!("should only receive uuid"),
                     }
                 }
             }
-            _ => unreachable!("session queries should always return"),
+            Err(_) => self.recursive_message_request(MoreThanText::new_session()),
         }
     }
 
     pub fn validate_session(&mut self, session: Option<String>) -> Uuid {
-        let (tx, rx) = channel();
-        let sender_id = self.queue.add_sender(tx);
-        let new_session: MsgAction = Addition::new(Session::doc_names()[0].clone()).into();
         let action = match session {
             Some(data) => match Uuid::try_from(data.as_str()) {
                 Ok(id) => {
@@ -84,24 +75,11 @@ impl MoreThanText {
                     query.add(Name::english("id"), calc);
                     query.into()
                 }
-                Err(_) => new_session,
+                Err(_) => MoreThanText::new_session(),
             },
-            None => new_session,
+            None => MoreThanText::new_session(),
         };
-        let doc_name = Name::english("session");
+        self.recursive_message_request(action)
-        let msg = Message::new(action.clone());
-        let msg_id = msg.get_message_id();
-        let path = Path::new(
-            Include::Just(msg_id.clone()),
-            Include::Just(doc_name.clone().into()),
-            Include::Just(Action::Records),
-        );
-        let reg_msg = Register::new(sender_id.clone(), RegMsg::AddRoute(path));
-        self.queue.send(msg.forward(NameType::None, reg_msg));
-        rx.recv().unwrap(); // Wait for completion.
-        let output = self.recursive_session_request(rx, action, msg);
-        self.queue.remove_sender(&sender_id);
-        output
     }
 
     pub fn records<UA>(&mut self, request: UA) -> Result<Records, MTTError>

tests/lib_session_test.rs

@@ -1,14 +1,17 @@
 use chrono::{DateTime, Utc};
 use morethantext::{
-    action::{CalcValue, Calculation, Field, FieldType, Operand, Query, Record},
+    action::{Addition, CalcValue, Calculation, Field, FieldType, Operand, Query, Record},
     MTTError, MoreThanText, Name,
 };
 use std::time::Duration;
 use uuid::Uuid;
 
+fn doc_name() -> Name {
+    Name::english("session")
+}
+
 fn get_session(mtt: &mut MoreThanText, id: &Uuid) -> Result<Record, MTTError> {
-    let doc_name = Name::english("session");
+    let mut qry = Query::new(doc_name());
-    let mut qry = Query::new(doc_name);
     let mut calc = Calculation::new(Operand::Equal);
     calc.add_value(CalcValue::Existing(FieldType::Uuid))
         .unwrap();
@@ -72,3 +75,18 @@ fn is_expiration_date_set_in_the_future() {
         _ => unreachable!("got {:?} should have been date time", holder),
     };
 }
+
+#[test]
+#[ignore = "hangs without completing"]
+fn are_session_ids_unique_on_update() {
+    let mut mtt = MoreThanText::new();
+    let id = mtt.validate_session(None);
+    let mut addition = Addition::new(doc_name());
+    addition.add_field(Name::english("id"), id);
+    match mtt.records(addition) {
+        Ok(data) => unreachable!("got {:?} should have been error", data),
+        Err(err) => match err {
+            _ => unreachable!("got {:?}, should have been not unique", err),
+        },
+    }
+}