1 files changed, 8 insertions, 32 deletions

diff --git a/lampada/src/lib.rs b/lampada/src/lib.rs
index 6b6cbe8..d1d451e 100644
--- a/lampada/src/lib.rs
+++ b/lampada/src/lib.rs
@@ -12,6 +12,7 @@ pub use connection::write::WriteMessage;
 pub use connection::SupervisorSender;
 use error::ConnectionError;
 use futures::{future::Fuse, FutureExt};
+use jid::{BareJID, FullJID};
 use luz::JID;
 use stanza::client::{
     iq::{self, Iq, IqType},
@@ -36,24 +37,18 @@ pub mod error;
 #[derive(Clone)]
 pub struct Connected {
     // full jid will stay stable across reconnections
-    jid: JID,
+    jid: FullJID,
     write_handle: WriteHandle,
-    // the server jid
-    server: JID,
 }
 
 impl Connected {
-    pub fn jid(&self) -> &JID {
+    pub fn jid(&self) -> &FullJID {
         &self.jid
     }
 
     pub fn write_handle(&self) -> &WriteHandle {
         &self.write_handle
     }
-
-    pub fn server(&self) -> &JID {
-        &self.server
-    }
 }
 
 /// everything that a particular xmpp client must implement
@@ -227,34 +222,17 @@ where
                                 .await;
                         }
                         None => {
-                            let mut jid = self.jid.clone();
-                            let mut domain = jid.domainpart.clone();
                             // TODO: check what happens upon reconnection with same resource (this is probably what one wants to do and why jid should be mutated from a bare jid to one with a resource)
                             let streams_result =
-                                luz::connect_and_login(&mut jid, &*self.password, &mut domain)
-                                    .await;
-                            let server: JID = match domain.parse() {
-                                Ok(j) => j,
-                                Err(e) => {
-                                    self.logic
-                                        .clone()
-                                        .handle_connection_error(ConnectionError::InvalidServerJID(
-                                            e.clone(),
-                                        ))
-                                        .await;
-                                    sender.send(Err(ConnectionError::InvalidServerJID(e)));
-                                    continue;
-                                }
-                            };
+                                luz::connect_and_login(&self.jid, &*self.password).await;
                             match streams_result {
-                                Ok(s) => {
+                                Ok((s, full_jid)) => {
                                     debug!("ok stream result");
                                     let (shutdown_send, shutdown_recv) = oneshot::channel::<()>();
                                     let (writer, supervisor) = SupervisorHandle::new(
                                         s,
                                         shutdown_send,
-                                        jid.clone(),
-                                        server.clone(),
+                                        full_jid.clone(),
                                         self.password.clone(),
                                         self.logic.clone(),
                                     );
@@ -262,18 +240,16 @@ where
                                     let shutdown_recv = shutdown_recv.fuse();
                                     self.connection_supervisor_shutdown = shutdown_recv;
 
-                                    let resource = jid.resourcepart.clone().expect("client somehow connected without binding");
                                     let connected = Connected {
-                                        jid,
+                                        jid: full_jid.clone(),
                                         write_handle: writer,
-                                        server,
                                     };
 
                                     self.logic.clone().handle_connect(connected.clone()).await;
 
                                     self.connected = Some((connected, supervisor));
                                     // REMEMBER TO NOTIFY IT@S GOOD
-                                    sender.send(Ok(resource));
+                                    sender.send(Ok(full_jid.resourcepart));
                                 }
                                 Err(e) => {
                                     tracing::error!("error: {}", e);