feat: add relay feeds

src-tauri/src/commands/event.rs

@@ -201,6 +201,44 @@ pub async fn get_all_events_by_hashtags(
     Ok(alt_events)
 }
 
+#[tauri::command]
+#[specta::specta]
+pub async fn get_all_events_from(
+    url: String,
+    until: Option<String>,
+    state: State<'_, Nostr>,
+) -> Result<Vec<RichEvent>, String> {
+    let client = &state.client;
+
+    let _ = client.add_read_relay(&url).await;
+    let _ = client.connect_relay(&url).await;
+
+    let as_of = match until {
+        Some(until) => Timestamp::from_str(&until).map_err(|err| err.to_string())?,
+        None => Timestamp::now(),
+    };
+
+    let filter = Filter::new()
+        .kinds(vec![Kind::TextNote, Kind::Repost])
+        .limit(FETCH_LIMIT)
+        .until(as_of);
+
+    let mut events = Events::new(&[filter.clone()]);
+
+    let mut rx = client
+        .stream_events_from(vec![url], vec![filter], Some(Duration::from_secs(3)))
+        .await
+        .map_err(|e| e.to_string())?;
+
+    while let Some(event) = rx.next().await {
+        events.insert(event);
+    }
+
+    let alt_events = process_event(client, events, false).await;
+
+    Ok(alt_events)
+}
+
 #[tauri::command]
 #[specta::specta]
 pub async fn get_local_events(

src-tauri/src/commands/metadata.rs

@@ -3,7 +3,7 @@ use nostr_sdk::prelude::*;
 use serde::{Deserialize, Serialize};
 use specta::Type;
 use std::{str::FromStr, time::Duration};
-use tauri::{Emitter, Manager, State};
+use tauri::State;
 
 use crate::{common::process_event, Nostr, RichEvent, FETCH_LIMIT};
 
@@ -147,7 +147,6 @@ pub async fn set_group(
     image: Option<String>,
     users: Vec<String>,
     state: State<'_, Nostr>,
-    handle: tauri::AppHandle,
 ) -> Result<String, String> {
     let client = &state.client;
     let public_keys: Vec<PublicKey> = users
@@ -181,25 +180,7 @@ pub async fn set_group(
         .map_err(|err| err.to_string())?;
 
     match client.send_event(event).await {
-        Ok(output) => {
-            // Sync event
-            tauri::async_runtime::spawn(async move {
-                let state = handle.state::<Nostr>();
-                let client = &state.client;
-
-                let filter = Filter::new()
-                    .kinds(vec![Kind::TextNote, Kind::Repost])
-                    .authors(public_keys)
-                    .limit(500);
-
-                if let Ok(report) = client.sync(filter, &SyncOptions::default()).await {
-                    println!("Received: {}", report.received.len());
-                    handle.emit("synchronized", ()).unwrap();
-                };
-            });
-
-            Ok(output.to_hex())
-        }
+        Ok(output) => Ok(output.to_hex()),
         Err(err) => Err(err.to_string()),
     }
 }
@@ -296,7 +277,6 @@ pub async fn set_interest(
     image: Option<String>,
     hashtags: Vec<String>,
     state: State<'_, Nostr>,
-    handle: tauri::AppHandle,
 ) -> Result<String, String> {
     let client = &state.client;
     let label = title.to_lowercase().replace(" ", "-");
@@ -320,25 +300,7 @@ pub async fn set_interest(
         .map_err(|err| err.to_string())?;
 
     match client.send_event(event).await {
-        Ok(output) => {
-            // Sync event
-            tauri::async_runtime::spawn(async move {
-                let state = handle.state::<Nostr>();
-                let client = &state.client;
-
-                let filter = Filter::new()
-                    .kinds(vec![Kind::TextNote, Kind::Repost])
-                    .hashtags(hashtags)
-                    .limit(500);
-
-                if let Ok(report) = client.sync(filter, &SyncOptions::default()).await {
-                    println!("Received: {}", report.received.len());
-                    handle.emit("synchronized", ()).unwrap();
-                };
-            });
-
-            Ok(output.to_hex())
-        }
+        Ok(output) => Ok(output.to_hex()),
         Err(err) => Err(err.to_string()),
     }
 }

src-tauri/src/commands/relay.rs

@@ -1,4 +1,3 @@
-use crate::Nostr;
 use nostr_sdk::prelude::*;
 use serde::Serialize;
 use specta::Type;
@@ -9,6 +8,8 @@ use std::{
 };
 use tauri::{path::BaseDirectory, Manager, State};
 
+use crate::{Nostr, FETCH_LIMIT};
+
 #[derive(Serialize, Type)]
 pub struct Relays {
     connected: Vec<String>,
@@ -94,31 +95,59 @@ pub async fn get_relays(id: String, state: State<'_, Nostr>) -> Result<Relays, S
 
 #[tauri::command]
 #[specta::specta]
-pub async fn connect_relay(relay: &str, state: State<'_, Nostr>) -> Result<bool, String> {
+pub async fn get_all_relays(
+    until: Option<String>,
+    state: State<'_, Nostr>,
+) -> Result<Vec<String>, String> {
     let client = &state.client;
-    let status = client.add_relay(relay).await.map_err(|e| e.to_string())?;
 
-    if status {
-        client
-            .connect_relay(relay)
-            .await
-            .map_err(|e| e.to_string())?;
-    }
+    let as_of = match until {
+        Some(until) => Timestamp::from_str(&until).unwrap_or(Timestamp::now()),
+        None => Timestamp::now(),
+    };
+
+    let filter = Filter::new()
+        .kind(Kind::RelayList)
+        .limit(FETCH_LIMIT)
+        .until(as_of);
+
+    let events = client
+        .database()
+        .query(vec![filter])
+        .await
+        .map_err(|e| e.to_string())?;
+
+    let alt_events: Vec<String> = events.iter().map(|ev| ev.as_json()).collect();
+
+    Ok(alt_events)
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn is_relay_connected(relay: String, state: State<'_, Nostr>) -> Result<bool, String> {
+    let client = &state.client;
+    let status = client.add_relay(&relay).await.map_err(|e| e.to_string())?;
 
     Ok(status)
 }
 
 #[tauri::command]
 #[specta::specta]
-pub async fn remove_relay(relay: &str, state: State<'_, Nostr>) -> Result<bool, String> {
+pub async fn connect_relay(relay: String, state: State<'_, Nostr>) -> Result<(), String> {
     let client = &state.client;
+    let _ = client.add_relay(&relay).await;
+    let _ = client.connect_relay(&relay).await;
 
-    client
-        .force_remove_relay(relay)
-        .await
-        .map_err(|e| e.to_string())?;
+    Ok(())
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn remove_relay(relay: String, state: State<'_, Nostr>) -> Result<(), String> {
+    let client = &state.client;
+    let _ = client.force_remove_relay(relay).await;
 
-    Ok(true)
+    Ok(())
 }
 
 #[tauri::command]
@@ -140,7 +169,7 @@ pub fn get_bootstrap_relays(app: tauri::AppHandle) -> Result<Vec<String>, String
 
 #[tauri::command]
 #[specta::specta]
-pub fn save_bootstrap_relays(relays: &str, app: tauri::AppHandle) -> Result<(), String> {
+pub fn set_bootstrap_relays(relays: String, app: tauri::AppHandle) -> Result<(), String> {
     let relays_path = app
         .path()
         .resolve("resources/relays.txt", BaseDirectory::Resource)

src-tauri/src/main.rs

@@ -5,7 +5,7 @@
 
 #[cfg(target_os = "macos")]
 use border::WebviewWindowExt as BorderWebviewWindowExt;
-use commands::{account::*, event::*, metadata::*, relay::*, sync::*, window::*};
+use commands::{account::*, event::*, metadata::*, relay::*, window::*};
 use common::{get_all_accounts, parse_event};
 use nostr_sdk::prelude::{Profile as DatabaseProfile, *};
 use serde::{Deserialize, Serialize};
@@ -71,13 +71,13 @@ fn main() {
     tracing_subscriber::fmt::init();
 
     let builder = Builder::<tauri::Wry>::new().commands(collect_commands![
-        sync_account,
-        is_account_sync,
         get_relays,
+        get_all_relays,
+        is_relay_connected,
         connect_relay,
         remove_relay,
         get_bootstrap_relays,
-        save_bootstrap_relays,
+        set_bootstrap_relays,
         get_accounts,
         watch_account,
         import_account,
@@ -116,6 +116,7 @@ fn main() {
         get_all_events_by_author,
         get_all_events_by_authors,
         get_all_events_by_hashtags,
+        get_all_events_from,
         get_local_events,
         get_global_events,
         search,

src/commands.gen.ts

@@ -5,39 +5,39 @@
 
 
 export const commands = {
-async syncAccount(id: string, reader: TAURI_CHANNEL<number>) : Promise<Result<null, string>> {
+async getRelays(id: string) : Promise<Result<Relays, string>> {
     try {
-    return { status: "ok", data: await TAURI_INVOKE("sync_account", { id, reader }) };
+    return { status: "ok", data: await TAURI_INVOKE("get_relays", { id }) };
 } catch (e) {
     if(e instanceof Error) throw e;
     else return { status: "error", error: e  as any };
 }
 },
-async isAccountSync(id: string) : Promise<Result<boolean, string>> {
+async getAllRelays(until: string | null) : Promise<Result<string[], string>> {
     try {
-    return { status: "ok", data: await TAURI_INVOKE("is_account_sync", { id }) };
+    return { status: "ok", data: await TAURI_INVOKE("get_all_relays", { until }) };
 } catch (e) {
     if(e instanceof Error) throw e;
     else return { status: "error", error: e  as any };
 }
 },
-async getRelays(id: string) : Promise<Result<Relays, string>> {
+async isRelayConnected(relay: string) : Promise<Result<boolean, string>> {
     try {
-    return { status: "ok", data: await TAURI_INVOKE("get_relays", { id }) };
+    return { status: "ok", data: await TAURI_INVOKE("is_relay_connected", { relay }) };
 } catch (e) {
     if(e instanceof Error) throw e;
     else return { status: "error", error: e  as any };
 }
 },
-async connectRelay(relay: string) : Promise<Result<boolean, string>> {
+async connectRelay(relay: string) : Promise<Result<null, string>> {
     try {
     return { status: "ok", data: await TAURI_INVOKE("connect_relay", { relay }) };
 } catch (e) {
     if(e instanceof Error) throw e;
     else return { status: "error", error: e  as any };
 }
 },
-async removeRelay(relay: string) : Promise<Result<boolean, string>> {
+async removeRelay(relay: string) : Promise<Result<null, string>> {
     try {
     return { status: "ok", data: await TAURI_INVOKE("remove_relay", { relay }) };
 } catch (e) {
@@ -53,9 +53,9 @@ async getBootstrapRelays() : Promise<Result<string[], string>> {
     else return { status: "error", error: e  as any };
 }
 },
-async saveBootstrapRelays(relays: string) : Promise<Result<null, string>> {
+async setBootstrapRelays(relays: string) : Promise<Result<null, string>> {
     try {
-    return { status: "ok", data: await TAURI_INVOKE("save_bootstrap_relays", { relays }) };
+    return { status: "ok", data: await TAURI_INVOKE("set_bootstrap_relays", { relays }) };
 } catch (e) {
     if(e instanceof Error) throw e;
     else return { status: "error", error: e  as any };
@@ -360,6 +360,14 @@ async getAllEventsByHashtags(hashtags: string[], until: string | null) : Promise
     else return { status: "error", error: e  as any };
 }
 },
+async getAllEventsFrom(url: string, until: string | null) : Promise<Result<RichEvent[], string>> {
+    try {
+    return { status: "ok", data: await TAURI_INVOKE("get_all_events_from", { url, until }) };
+} catch (e) {
+    if(e instanceof Error) throw e;
+    else return { status: "error", error: e  as any };
+}
+},
 async getLocalEvents(until: string | null) : Promise<Result<RichEvent[], string>> {
     try {
     return { status: "ok", data: await TAURI_INVOKE("get_local_events", { until }) };
@@ -523,7 +531,6 @@ export type NewWindow = { label: string; title: string; url: string; width: numb
 export type Relays = { connected: string[]; read: string[] | null; write: string[] | null; both: string[] | null }
 export type RichEvent = { raw: string; parsed: Meta | null }
 export type Settings = { resize_service: boolean; content_warning: boolean; display_avatar: boolean; display_zap_button: boolean; display_repost_button: boolean; display_media: boolean }
-export type TAURI_CHANNEL<TSend> = null
 
 /** tauri-specta globals **/
 

src/components/column.tsx

@@ -40,7 +40,7 @@ export function Column({ column }: { column: LumeColumn }) {
 				/>
 				<div ref={ref} className="flex-1 size-full">
 					<div className="size-full flex flex-col items-center justify-center">
-						<div className="text-red-500 text-sm break-all">
+						<div className="invisible text-red-500 text-sm break-all">
 							{error?.length ? error : null}
 						</div>
 					</div>

src/components/repost.tsx

@@ -14,6 +14,8 @@ export const RepostNote = memo(function RepostNote({
 }) {
 	const { isLoading, isError, data } = useEvent(event.repostId, event.content);
 
+	console.log("Repost: ", event);
+
 	return (
 		<Note.Root className={cn("", className)}>
 			{isLoading ? (