reya/lume
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: use specta for commands (#192)

Browse Source 
* feat: add tauri-specta

* refactor: system library

* chore: format
This commit is contained in:
雨宮蓮
2024-05-25 15:21:40 +07:00
committed by GitHub
parent 7449000f5f
commit bba324ea53
92 changed files with 2164 additions and 2071 deletions
Download Patch File Download Diff File Expand all files Collapse all files

72
src-tauri/src/nostr/event.rs
View File

@@ -4,6 +4,7 @@ use std::{str::FromStr, time::Duration};
use tauri::State;
#[tauri::command]
#[specta::specta]
pub async fn get_event(id: &str, state: State<'_, Nostr>) -> Result<String, String> {
let client = &state.client;
let event_id: Option<EventId> = match Nip19::from_bech32(id) {
@@ -49,7 +50,8 @@ pub async fn get_event(id: &str, state: State<'_, Nostr>) -> Result<String, Stri
}
#[tauri::command]
pub async fn get_thread(id: &str, state: State<'_, Nostr>) -> Result<Vec<Event>, String> {
#[specta::specta]
pub async fn get_replies(id: &str, state: State<'_, Nostr>) -> Result<Vec<String>, String> {
let client = &state.client;
match EventId::from_hex(id) {
@@ -57,7 +59,7 @@ pub async fn get_thread(id: &str, state: State<'_, Nostr>) -> Result<Vec<Event>,
let filter = Filter::new().kinds(vec![Kind::TextNote]).event(event_id);
match client.get_events_of(vec![filter], None).await {
Ok(events) => Ok(events),
Ok(events) => Ok(events.into_iter().map(|ev| ev.as_json()).collect()),
Err(err) => Err(err.to_string()),
}
}
@@ -66,12 +68,12 @@ pub async fn get_thread(id: &str, state: State<'_, Nostr>) -> Result<Vec<Event>,
}
#[tauri::command]
#[specta::specta]
pub async fn get_events_by(
public_key: &str,
limit: usize,
as_of: Option<&str>,
state: State<'_, Nostr>,
) -> Result<Vec<Event>, String> {
) -> Result<Vec<String>, String> {
let client = &state.client;
match PublicKey::from_str(public_key) {
@@ -83,11 +85,11 @@ pub async fn get_events_by(
let filter = Filter::new()
.kinds(vec![Kind::TextNote, Kind::Repost])
.author(author)
.limit(limit)
.limit(20)
.until(until);
match client.get_events_of(vec![filter], None).await {
Ok(events) => Ok(events),
Ok(events) => Ok(events.into_iter().map(|ev| ev.as_json()).collect()),
Err(err) => Err(err.to_string()),
}
}
@@ -96,12 +98,12 @@ pub async fn get_events_by(
}
#[tauri::command]
#[specta::specta]
pub async fn get_local_events(
pubkeys: Vec<String>,
limit: usize,
until: Option<&str>,
state: State<'_, Nostr>,
) -> Result<Vec<Event>, String> {
) -> Result<Vec<String>, String> {
let client = &state.client;
let as_of = match until {
Some(until) => Timestamp::from_str(until).unwrap(),
@@ -119,7 +121,7 @@ pub async fn get_local_events(
.collect();
let filter = Filter::new()
.kinds(vec![Kind::TextNote, Kind::Repost])
.limit(limit)
.limit(20)
.authors(authors)
.until(as_of);
@@ -127,17 +129,17 @@ pub async fn get_local_events(
.get_events_of(vec![filter], Some(Duration::from_secs(8)))
.await
{
Ok(events) => Ok(events),
Ok(events) => Ok(events.into_iter().map(|ev| ev.as_json()).collect()),
Err(err) => Err(err.to_string()),
}
}
#[tauri::command]
#[specta::specta]
pub async fn get_global_events(
limit: usize,
until: Option<&str>,
state: State<'_, Nostr>,
) -> Result<Vec<Event>, String> {
) -> Result<Vec<String>, String> {
let client = &state.client;
let as_of = match until {
Some(until) => Timestamp::from_str(until).unwrap(),
@@ -146,25 +148,25 @@ pub async fn get_global_events(
let filter = Filter::new()
.kinds(vec![Kind::TextNote, Kind::Repost])
.limit(limit)
.limit(20)
.until(as_of);
match client
.get_events_of(vec![filter], Some(Duration::from_secs(8)))
.await
{
Ok(events) => Ok(events),
Ok(events) => Ok(events.into_iter().map(|ev| ev.as_json()).collect()),
Err(err) => Err(err.to_string()),
}
}
#[tauri::command]
#[specta::specta]
pub async fn get_hashtag_events(
hashtags: Vec<&str>,
limit: usize,
until: Option<&str>,
state: State<'_, Nostr>,
) -> Result<Vec<Event>, String> {
) -> Result<Vec<String>, String> {
let client = &state.client;
let as_of = match until {
Some(until) => Timestamp::from_str(until).unwrap(),
@@ -172,45 +174,18 @@ pub async fn get_hashtag_events(
};
let filter = Filter::new()
.kinds(vec![Kind::TextNote, Kind::Repost])
.limit(limit)
.limit(20)
.until(as_of)
.hashtags(hashtags);
match client.get_events_of(vec![filter], None).await {
Ok(events) => Ok(events),
Err(err) => Err(err.to_string()),
}
}
#[tauri::command]
pub async fn get_group_events(
list: Vec<&str>,
limit: usize,
until: Option<&str>,
state: State<'_, Nostr>,
) -> Result<Vec<Event>, String> {
let client = &state.client;
let as_of = match until {
Some(until) => Timestamp::from_str(until).unwrap(),
None => Timestamp::now(),
};
let authors: Vec<PublicKey> = list
.into_iter()
.map(|hex| PublicKey::from_hex(hex).unwrap())
.collect();
let filter = Filter::new()
.kinds(vec![Kind::TextNote, Kind::Repost])
.limit(limit)
.until(as_of)
.authors(authors);
match client.get_events_of(vec![filter], None).await {
Ok(events) => Ok(events),
Ok(events) => Ok(events.into_iter().map(|ev| ev.as_json()).collect()),
Err(err) => Err(err.to_string()),
}
}
#[tauri::command]
#[specta::specta]
pub async fn publish(
content: &str,
tags: Vec<Vec<&str>>,
@@ -226,12 +201,13 @@ pub async fn publish(
}
#[tauri::command]
pub async fn repost(raw: &str, state: State<'_, Nostr>) -> Result<EventId, String> {
#[specta::specta]
pub async fn repost(raw: &str, state: State<'_, Nostr>) -> Result<String, String> {
let client = &state.client;
let event = Event::from_json(raw).unwrap();
match client.repost(&event, None).await {
Ok(event_id) => Ok(event_id),
Ok(event_id) => Ok(event_id.to_string()),
Err(err) => Err(err.to_string()),
}
}

14
src-tauri/src/nostr/keys.rs
View File

@@ -2,17 +2,20 @@ use crate::Nostr;
use keyring::Entry;
use keyring_search::{Limit, List, Search};
use nostr_sdk::prelude::*;
use serde::Serialize;
use specta::Type;
use std::str::FromStr;
use std::time::Duration;
use tauri::State;
#[derive(serde::Serialize)]
#[derive(Serialize, Type)]
pub struct Account {
npub: String,
nsec: String,
}
#[tauri::command]
#[specta::specta]
pub fn get_accounts() -> Result<String, String> {
let search = Search::new().unwrap();
let results = search.by("Account", "nostr_secret");
@@ -24,6 +27,7 @@ pub fn get_accounts() -> Result<String, String> {
}
#[tauri::command]
#[specta::specta]
pub fn create_account() -> Result<Account, ()> {
let keys = Keys::generate();
let public_key = keys.public_key();
@@ -38,6 +42,7 @@ pub fn create_account() -> Result<Account, ()> {
}
#[tauri::command]
#[specta::specta]
pub async fn save_account(
nsec: &str,
password: &str,
@@ -80,6 +85,7 @@ pub async fn save_account(
}
#[tauri::command]
#[specta::specta]
pub async fn load_account(npub: &str, state: State<'_, Nostr>) -> Result<bool, String> {
let client = &state.client;
let keyring = Entry::new(&npub, "nostr_secret").unwrap();
@@ -165,6 +171,7 @@ pub async fn load_account(npub: &str, state: State<'_, Nostr>) -> Result<bool, S
}
#[tauri::command]
#[specta::specta]
pub async fn nostr_connect(
npub: &str,
uri: &str,
@@ -203,6 +210,7 @@ pub async fn nostr_connect(
}
#[tauri::command(async)]
#[specta::specta]
pub fn get_encrypted_key(npub: &str, password: &str) -> Result<String, String> {
let keyring = Entry::new(npub, "nostr_secret").unwrap();
@@ -221,6 +229,7 @@ pub fn get_encrypted_key(npub: &str, password: &str) -> Result<String, String> {
}
#[tauri::command]
#[specta::specta]
pub fn event_to_bech32(id: &str, relays: Vec<String>) -> Result<String, ()> {
let event_id = EventId::from_hex(id).unwrap();
let event = Nip19Event::new(event_id, relays);
@@ -229,6 +238,7 @@ pub fn event_to_bech32(id: &str, relays: Vec<String>) -> Result<String, ()> {
}
#[tauri::command]
#[specta::specta]
pub fn user_to_bech32(key: &str, relays: Vec<String>) -> Result<String, ()> {
let pubkey = PublicKey::from_str(key).unwrap();
let profile = Nip19Profile::new(pubkey, relays).unwrap();
@@ -237,6 +247,7 @@ pub fn user_to_bech32(key: &str, relays: Vec<String>) -> Result<String, ()> {
}
#[tauri::command]
#[specta::specta]
pub fn to_npub(hex: &str) -> Result<String, ()> {
let public_key = PublicKey::from_str(hex).unwrap();
let npub = Nip19::Pubkey(public_key);
@@ -245,6 +256,7 @@ pub fn to_npub(hex: &str) -> Result<String, ()> {
}
#[tauri::command]
#[specta::specta]
pub async fn verify_nip05(key: &str, nip05: &str) -> Result<bool, String> {
match PublicKey::from_str(key) {
Ok(public_key) => {

103
src-tauri/src/nostr/metadata.rs
View File

@@ -6,6 +6,7 @@ use tauri::{Manager, State};
use url::Url;
#[tauri::command]
#[specta::specta]
pub fn run_notification(accounts: Vec<String>, app: tauri::AppHandle) -> Result<(), ()> {
tauri::async_runtime::spawn(async move {
let window = app.get_window("main").unwrap();
@@ -49,11 +50,12 @@ pub fn run_notification(accounts: Vec<String>, app: tauri::AppHandle) -> Result<
}
#[tauri::command]
#[specta::specta]
pub async fn get_activities(
account: &str,
kind: &str,
state: State<'_, Nostr>,
) -> Result<Vec<Event>, String> {
) -> Result<Vec<String>, String> {
let client = &state.client;
if let Ok(pubkey) = PublicKey::from_str(account) {
@@ -65,7 +67,7 @@ pub async fn get_activities(
.until(Timestamp::now());
match client.get_events_of(vec![filter], None).await {
Ok(events) => Ok(events),
Ok(events) => Ok(events.into_iter().map(|ev| ev.as_json()).collect()),
Err(err) => Err(err.to_string()),
}
} else {
@@ -77,6 +79,7 @@ pub async fn get_activities(
}
#[tauri::command]
#[specta::specta]
pub async fn friend_to_friend(npub: &str, state: State<'_, Nostr>) -> Result<bool, String> {
let client = &state.client;
@@ -114,7 +117,8 @@ pub async fn friend_to_friend(npub: &str, state: State<'_, Nostr>) -> Result<boo
}
#[tauri::command]
pub async fn get_current_user_profile(state: State<'_, Nostr>) -> Result<Metadata, String> {
#[specta::specta]
pub async fn get_current_user_profile(state: State<'_, Nostr>) -> Result<String, String> {
let client = &state.client;
let signer = client.signer().await.unwrap();
let public_key = signer.public_key().await.unwrap();
@@ -130,7 +134,7 @@ pub async fn get_current_user_profile(state: State<'_, Nostr>) -> Result<Metadat
Ok(events) => {
if let Some(event) = events.first() {
if let Ok(metadata) = Metadata::from_json(&event.content) {
Ok(metadata)
Ok(metadata.as_json())
} else {
Err("Parse metadata failed".into())
}
@@ -143,7 +147,8 @@ pub async fn get_current_user_profile(state: State<'_, Nostr>) -> Result<Metadat
}
#[tauri::command]
pub async fn get_profile(id: &str, state: State<'_, Nostr>) -> Result<Metadata, String> {
#[specta::specta]
pub async fn get_profile(id: &str, state: State<'_, Nostr>) -> Result<String, String> {
let client = &state.client;
let public_key: Option<PublicKey> = match Nip19::from_bech32(id) {
Ok(val) => match val {
@@ -166,13 +171,13 @@ pub async fn get_profile(id: &str, state: State<'_, Nostr>) -> Result<Metadata,
if let Ok(events) = query {
if let Some(event) = events.first() {
if let Ok(metadata) = Metadata::from_json(&event.content) {
Ok(metadata)
Ok(metadata.as_json())
} else {
Err("Parse metadata failed".into())
}
} else {
let rand_metadata = Metadata::new();
Ok(rand_metadata)
Ok(rand_metadata.as_json())
}
} else {
Err("Get metadata failed".into())
@@ -183,6 +188,7 @@ pub async fn get_profile(id: &str, state: State<'_, Nostr>) -> Result<Metadata,
}
#[tauri::command]
#[specta::specta]
pub async fn set_contact_list(pubkeys: Vec<&str>, state: State<'_, Nostr>) -> Result<bool, String> {
let client = &state.client;
let contact_list: Vec<Contact> = pubkeys
@@ -197,6 +203,7 @@ pub async fn set_contact_list(pubkeys: Vec<&str>, state: State<'_, Nostr>) -> Re
}
#[tauri::command]
#[specta::specta]
pub async fn get_contact_list(state: State<'_, Nostr>) -> Result<Vec<String>, String> {
let client = &state.client;
@@ -218,6 +225,7 @@ pub async fn get_contact_list(state: State<'_, Nostr>) -> Result<Vec<String>, St
}
#[tauri::command]
#[specta::specta]
pub async fn create_profile(
name: &str,
display_name: &str,
@@ -228,7 +236,7 @@ pub async fn create_profile(
lud16: &str,
website: &str,
state: State<'_, Nostr>,
) -> Result<EventId, String> {
) -> Result<String, String> {
let client = &state.client;
let mut metadata = Metadata::new()
.name(name)
@@ -250,68 +258,71 @@ pub async fn create_profile(
}
if let Ok(event_id) = client.set_metadata(&metadata).await {
Ok(event_id)
Ok(event_id.to_string())
} else {
Err("Create profile failed".into())
}
}
#[tauri::command]
#[specta::specta]
pub async fn follow(
id: &str,
alias: Option<&str>,
state: State<'_, Nostr>,
) -> Result<EventId, String> {
) -> Result<String, String> {
let client = &state.client;
let public_key = PublicKey::from_str(id).unwrap();
let contact = Contact::new(public_key, None, alias);
let contact = Contact::new(public_key, None, alias); // #TODO: Add relay_url
let contact_list = client.get_contact_list(Some(Duration::from_secs(10))).await;
if let Ok(mut old_list) = contact_list {
old_list.push(contact);
let new_list = old_list.into_iter();
match contact_list {
Ok(mut old_list) => {
old_list.push(contact);
let new_list = old_list.into_iter();
if let Ok(event_id) = client.set_contact_list(new_list).await {
Ok(event_id)
} else {
Err("Follow failed".into())
match client.set_contact_list(new_list).await {
Ok(event_id) => Ok(event_id.to_string()),
Err(err) => Err(err.to_string()),
}
}
} else {
Err("Follow failed".into())
Err(err) => Err(err.to_string()),
}
}
#[tauri::command]
pub async fn unfollow(id: &str, state: State<'_, Nostr>) -> Result<EventId, String> {
#[specta::specta]
pub async fn unfollow(id: &str, state: State<'_, Nostr>) -> Result<String, String> {
let client = &state.client;
let public_key = PublicKey::from_str(id).unwrap();
let contact_list = client.get_contact_list(Some(Duration::from_secs(10))).await;
if let Ok(mut old_list) = contact_list {
let index = old_list
.iter()
.position(|x| x.public_key == public_key)
.unwrap();
old_list.remove(index);
match contact_list {
Ok(mut old_list) => {
let index = old_list
.iter()
.position(|x| x.public_key == public_key)
.unwrap();
old_list.remove(index);
let new_list = old_list.into_iter();
let new_list = old_list.into_iter();
if let Ok(event_id) = client.set_contact_list(new_list).await {
Ok(event_id)
} else {
Err("Follow failed".into())
match client.set_contact_list(new_list).await {
Ok(event_id) => Ok(event_id.to_string()),
Err(err) => Err(err.to_string()),
}
}
} else {
Err("Follow failed".into())
Err(err) => Err(err.to_string()),
}
}
#[tauri::command]
#[specta::specta]
pub async fn set_nstore(
key: &str,
content: &str,
state: State<'_, Nostr>,
) -> Result<EventId, String> {
) -> Result<String, String> {
let client = &state.client;
match client.signer().await {
@@ -323,7 +334,7 @@ pub async fn set_nstore(
let builder = EventBuilder::new(Kind::ApplicationSpecificData, encrypted, vec![tag]);
match client.send_event_builder(builder).await {
Ok(event_id) => Ok(event_id),
Ok(event_id) => Ok(event_id.to_string()),
Err(err) => Err(err.to_string()),
}
}
@@ -332,6 +343,7 @@ pub async fn set_nstore(
}
#[tauri::command]
#[specta::specta]
pub async fn get_nstore(key: &str, state: State<'_, Nostr>) -> Result<String, String> {
let client = &state.client;
@@ -366,6 +378,7 @@ pub async fn get_nstore(key: &str, state: State<'_, Nostr>) -> Result<String, St
}
#[tauri::command]
#[specta::specta]
pub async fn set_nwc(uri: &str, state: State<'_, Nostr>) -> Result<bool, String> {
let client = &state.client;
@@ -385,6 +398,7 @@ pub async fn set_nwc(uri: &str, state: State<'_, Nostr>) -> Result<bool, String>
}
#[tauri::command]
#[specta::specta]
pub async fn load_nwc(state: State<'_, Nostr>) -> Result<bool, String> {
let client = &state.client;
let keyring = Entry::new("Lume Secret Storage", "NWC").unwrap();
@@ -404,7 +418,8 @@ pub async fn load_nwc(state: State<'_, Nostr>) -> Result<bool, String> {
}
#[tauri::command]
pub async fn get_balance() -> Result<u64, String> {
#[specta::specta]
pub async fn get_balance() -> Result<String, String> {
let keyring = Entry::new("Lume Secret Storage", "NWC").unwrap();
match keyring.get_password() {
@@ -412,7 +427,7 @@ pub async fn get_balance() -> Result<u64, String> {
let uri = NostrWalletConnectURI::from_str(&val).unwrap();
if let Ok(nwc) = NWC::new(uri).await {
if let Ok(balance) = nwc.get_balance().await {
Ok(balance)
Ok(balance.to_string())
} else {
Err("Get balance failed".into())
}
@@ -425,9 +440,10 @@ pub async fn get_balance() -> Result<u64, String> {
}
#[tauri::command]
#[specta::specta]
pub async fn zap_profile(
id: &str,
amount: u64,
amount: &str,
message: &str,
state: State<'_, Nostr>,
) -> Result<bool, String> {
@@ -446,8 +462,9 @@ pub async fn zap_profile(
if let Some(recipient) = public_key {
let details = ZapDetails::new(ZapType::Public).message(message);
let num = amount.parse::<u64>().unwrap();
if (client.zap(recipient, amount, Some(details)).await).is_ok() {
if (client.zap(recipient, num, Some(details)).await).is_ok() {
Ok(true)
} else {
Err("Zap profile failed".into())
@@ -458,9 +475,10 @@ pub async fn zap_profile(
}
#[tauri::command]
#[specta::specta]
pub async fn zap_event(
id: &str,
amount: u64,
amount: &str,
message: &str,
state: State<'_, Nostr>,
) -> Result<bool, String> {
@@ -479,8 +497,9 @@ pub async fn zap_event(
if let Some(recipient) = event_id {
let details = ZapDetails::new(ZapType::Public).message(message);
let num = amount.parse::<u64>().unwrap();
if (client.zap(recipient, amount, Some(details)).await).is_ok() {
if (client.zap(recipient, num, Some(details)).await).is_ok() {
Ok(true)
} else {
Err("Zap event failed".into())

7
src-tauri/src/nostr/relay.rs
View File

@@ -1,8 +1,10 @@
use crate::Nostr;
use nostr_sdk::prelude::*;
use serde::Serialize;
use specta::Type;
use tauri::State;
#[derive(serde::Serialize)]
#[derive(Serialize, Type)]
pub struct Relays {
connected: Vec<String>,
read: Option<Vec<String>>,
@@ -11,6 +13,7 @@ pub struct Relays {
}
#[tauri::command]
#[specta::specta]
pub async fn get_relays(state: State<'_, Nostr>) -> Result<Relays, ()> {
let client = &state.client;
@@ -73,6 +76,7 @@ pub async fn get_relays(state: State<'_, Nostr>) -> Result<Relays, ()> {
}
#[tauri::command]
#[specta::specta]
pub async fn connect_relay(relay: &str, state: State<'_, Nostr>) -> Result<bool, ()> {
let client = &state.client;
if let Ok(status) = client.add_relay(relay).await {
@@ -89,6 +93,7 @@ pub async fn connect_relay(relay: &str, state: State<'_, Nostr>) -> Result<bool,
}
#[tauri::command]
#[specta::specta]
pub async fn remove_relay(relay: &str, state: State<'_, Nostr>) -> Result<bool, ()> {
let client = &state.client;
if let Ok(_) = client.remove_relay(relay).await {