receiving initial messages!

enostr/src/client/message.rs

@@ -1,4 +1,5 @@
-use crate::{Event, Filter}
+use crate::{Event, Filter};
+use serde_json::json;
 
 /// Messages sent by clients, received by relays
 #[derive(Debug, Eq, PartialEq)]
@@ -16,8 +17,8 @@ pub enum ClientMessage {
 }
 
 impl ClientMessage {
-    pub fn event(ev: Event) -> Self {
-        ClientMessage::Event {ev}
+    pub fn event(event: Event) -> Self {
+        ClientMessage::Event { event }
     }
 
     pub fn req(sub_id: String, filters: Vec<Filter>) -> Self {
@@ -31,11 +32,8 @@ impl ClientMessage {
     pub fn to_json(&self) -> String {
         match self {
             Self::Event { event } => json!(["EVENT", event]).to_string(),
-            Self::Req {
-                subscription_id,
-                filters,
-            } => {
-                let mut json = json!(["REQ", subscription_id]);
+            Self::Req { sub_id, filters } => {
+                let mut json = json!(["REQ", sub_id]);
                 let mut filters = json!(filters);
 
                 if let Some(json) = json.as_array_mut() {
@@ -46,7 +44,7 @@ impl ClientMessage {
 
                 json.to_string()
             }
-            Self::Close { subscription_id } => json!(["CLOSE", subscription_id]).to_string(),
+            Self::Close { sub_id } => json!(["CLOSE", sub_id]).to_string(),
         }
     }
 }

enostr/src/client/mod.rs

@@ -1 +1,3 @@
 mod message;
+
+pub use message::ClientMessage;

enostr/src/filter.rs

@@ -21,3 +21,58 @@ pub struct Filter {
     #[serde(skip_serializing_if = "Option::is_none")]
     limit: Option<u16>,
 }
+
+impl Filter {
+    pub fn new() -> Filter {
+        Filter {
+            ids: None,
+            authors: None,
+            kinds: None,
+            events: None,
+            pubkeys: None,
+            since: None,
+            until: None,
+            limit: None,
+        }
+    }
+
+    pub fn ids(mut self, ids: Vec<String>) -> Self {
+        self.ids = Some(ids);
+        self
+    }
+
+    pub fn authors(mut self, authors: Vec<String>) -> Self {
+        self.authors = Some(authors);
+        self
+    }
+
+    pub fn kinds(mut self, kinds: Vec<u64>) -> Self {
+        self.kinds = Some(kinds);
+        self
+    }
+
+    pub fn events(mut self, events: Vec<String>) -> Self {
+        self.events = Some(events);
+        self
+    }
+
+    pub fn pubkeys(mut self, pubkeys: Vec<String>) -> Self {
+        self.pubkeys = Some(pubkeys);
+        self
+    }
+
+    pub fn since(mut self, since: u64) -> Self {
+        self.since = Some(since);
+        self
+    }
+
+    pub fn until(mut self, until: u64) -> Self {
+        self.until = Some(until);
+        self
+    }
+
+    pub fn limit(mut self, limit: u16) -> Self {
+        self.limit = Some(limit);
+        self
+    }
+}

enostr/src/lib.rs

@@ -1,12 +1,15 @@
+mod client;
 mod error;
 mod event;
 mod filter;
 mod relay;
 
+pub use client::ClientMessage;
 pub use error::Error;
 pub use event::Event;
 pub use filter::Filter;
-pub use relay::pool::RelayPool;
+pub use relay::message::{RelayEvent, RelayMessage};
+pub use relay::pool::{PoolEvent, RelayPool};
 pub use relay::Relay;
 
 pub type Result<T> = std::result::Result<T, error::Error>;

enostr/src/relay/mod.rs

@@ -1,6 +1,6 @@
-use ewebsock::{WsReceiver, WsSender};
+use ewebsock::{WsMessage, WsReceiver, WsSender};
 
-use crate::Result;
+use crate::{ClientMessage, Filter, Result};
 use std::fmt;
 use std::hash::{Hash, Hasher};
 
@@ -57,4 +57,10 @@ impl Relay {
             status,
         })
     }
+
+    pub fn subscribe(&mut self, subid: String, filters: Vec<Filter>) {
+        let cmd = ClientMessage::req(subid, filters);
+        let txt = WsMessage::Text(cmd.to_json());
+        self.sender.send(txt);
+    }
 }

enostr/src/relay/pool.rs

@@ -4,13 +4,13 @@ use crate::Result;
 use tracing::error;
 
 #[derive(Debug)]
-pub struct PoolMessage<'a> {
-    relay: &'a str,
-    event: RelayEvent,
+pub struct PoolEvent<'a> {
+    pub relay: &'a str,
+    pub event: RelayEvent,
 }
 
 pub struct RelayPool {
-    relays: Vec<Relay>,
+    pub relays: Vec<Relay>,
 }
 
 impl Default for RelayPool {
@@ -47,12 +47,12 @@ impl RelayPool {
         Ok(())
     }
 
-    pub fn try_recv(&self) -> Option<PoolMessage<'_>> {
+    pub fn try_recv(&self) -> Option<PoolEvent<'_>> {
         for relay in &self.relays {
             if let Some(msg) = relay.receiver.try_recv() {
                 match msg.try_into() {
                     Ok(event) => {
-                        return Some(PoolMessage {
+                        return Some(PoolEvent {
                             event,
                             relay: &relay.url,
                         });