@@ -5,12 +5,32 @@ use crate::{
55 events,
66 models:: { ChannelDetailInfo , ChannelInfo , ChannelMembersResponse } ,
77 nostr_convert,
8- relay:: { query_relay, submit_event, submit_event_with_keys} ,
8+ relay:: { query_relay, relay_api_base_url_with_override , submit_event, submit_event_with_keys} ,
99} ;
1010
1111// ── Reads (pure-nostr via /query) ────────────────────────────────────────────
1212
1313const DIRECTORY_PAGE_SIZE : usize = 500 ;
14+ const STARTER_CHANNEL_NAMESPACE : uuid:: Uuid = uuid:: uuid!( "3ce33bea-8f09-5f1b-9c85-8a7d2659e6b0" ) ;
15+
16+ struct StarterChannelSpec {
17+ slug : & ' static str ,
18+ name : & ' static str ,
19+ description : & ' static str ,
20+ }
21+
22+ const STARTER_CHANNELS : & [ StarterChannelSpec ] = & [
23+ StarterChannelSpec {
24+ slug : "general" ,
25+ name : "general" ,
26+ description : "General conversation and community updates." ,
27+ } ,
28+ StarterChannelSpec {
29+ slug : "welcome-everyone" ,
30+ name : "welcome-everyone" ,
31+ description : "Say hi, ask a question, or share what brought you here." ,
32+ } ,
33+ ] ;
1434
1535fn advance_directory_cursor ( filter : & mut serde_json:: Value , page : & [ nostr:: Event ] ) {
1636 let last = page
@@ -445,6 +465,84 @@ fn parse_channel_uuid(channel_id: &str) -> Result<uuid::Uuid, String> {
445465 uuid:: Uuid :: parse_str ( channel_id) . map_err ( |_| format ! ( "invalid channel UUID: {channel_id}" ) )
446466}
447467
468+ fn normalize_channel_name ( name : & str ) -> String {
469+ name. trim ( ) . to_ascii_lowercase ( )
470+ }
471+
472+ fn starter_channel_uuid ( relay_scope : & str , slug : & str ) -> uuid:: Uuid {
473+ let name = format ! ( "starter-channel:v1:{}:{}" , relay_scope. trim( ) , slug) ;
474+ uuid:: Uuid :: new_v5 ( & STARTER_CHANNEL_NAMESPACE , name. as_bytes ( ) )
475+ }
476+
477+ fn is_duplicate_channel_rejection ( error : & str ) -> bool {
478+ error. contains ( "relay rejected event:" ) && error. contains ( "duplicate: channel already exists" )
479+ }
480+
481+ fn is_matching_starter_channel ( channel : & ChannelInfo , spec : & StarterChannelSpec ) -> bool {
482+ normalize_channel_name ( & channel. name ) == normalize_channel_name ( spec. name )
483+ && channel. channel_type == "stream"
484+ && channel. visibility == "open"
485+ && channel. archived_at . is_none ( )
486+ }
487+
488+ fn has_all_starter_channels ( channels : & [ ChannelInfo ] ) -> bool {
489+ STARTER_CHANNELS . iter ( ) . all ( |spec| {
490+ channels
491+ . iter ( )
492+ . any ( |channel| is_matching_starter_channel ( channel, spec) )
493+ } )
494+ }
495+
496+ async fn ensure_starter_channel_memberships (
497+ state : & AppState ,
498+ keys : & nostr:: Keys ,
499+ channels : & mut [ ChannelInfo ] ,
500+ ) -> Result < ( ) , String > {
501+ for spec in STARTER_CHANNELS {
502+ let Some ( channel) = channels
503+ . iter_mut ( )
504+ . find ( |channel| is_matching_starter_channel ( channel, spec) )
505+ else {
506+ continue ;
507+ } ;
508+
509+ if channel. is_member {
510+ continue ;
511+ }
512+
513+ let channel_uuid = parse_channel_uuid ( & channel. id ) ?;
514+ let builder = events:: build_join ( channel_uuid) ?;
515+ submit_event_with_keys ( builder, state, keys, None ) . await ?;
516+ channel. is_member = true ;
517+ }
518+
519+ Ok ( ( ) )
520+ }
521+
522+ async fn fetch_starter_channel_metadata (
523+ state : & AppState ,
524+ channel_ids : & [ String ] ,
525+ ) -> Result < Vec < ChannelInfo > , String > {
526+ if channel_ids. is_empty ( ) {
527+ return Ok ( Vec :: new ( ) ) ;
528+ }
529+
530+ let events = query_relay (
531+ state,
532+ & [ serde_json:: json!( {
533+ "kinds" : [ 39000 ] ,
534+ "#d" : channel_ids,
535+ "limit" : channel_ids. len( ) ,
536+ } ) ] ,
537+ )
538+ . await ?;
539+
540+ events
541+ . iter ( )
542+ . map ( |ev| nostr_convert:: channel_info_from_event ( ev, None , Some ( false ) ) )
543+ . collect ( )
544+ }
545+
448546#[ tauri:: command]
449547pub async fn create_channel (
450548 name : String ,
@@ -510,6 +608,80 @@ pub async fn create_channel(
510608 . ok_or_else ( || "channel created but metadata not yet available" . to_string ( ) )
511609}
512610
611+ #[ tauri:: command]
612+ pub async fn ensure_starter_channels (
613+ state : State < ' _ , AppState > ,
614+ ) -> Result < Vec < ChannelInfo > , String > {
615+ let mut existing_channels = get_channels ( state. clone ( ) ) . await ?;
616+ let relay_scope = relay_api_base_url_with_override ( & state) ;
617+ let creator_keys = state. signing_keys ( ) ?;
618+ let creator_pubkey = creator_keys. public_key ( ) . to_hex ( ) ;
619+ let mut starter_ids = Vec :: with_capacity ( STARTER_CHANNELS . len ( ) ) ;
620+ let mut created_ids = std:: collections:: HashSet :: new ( ) ;
621+
622+ for spec in STARTER_CHANNELS {
623+ if existing_channels
624+ . iter ( )
625+ . any ( |channel| is_matching_starter_channel ( channel, spec) )
626+ {
627+ continue ;
628+ }
629+
630+ let channel_uuid = starter_channel_uuid ( & relay_scope, spec. slug ) ;
631+ let channel_uuid_string = channel_uuid. to_string ( ) ;
632+ starter_ids. push ( channel_uuid_string. clone ( ) ) ;
633+ let builder = events:: build_create_channel (
634+ channel_uuid,
635+ spec. name ,
636+ "open" ,
637+ "stream" ,
638+ Some ( spec. description ) ,
639+ None ,
640+ ) ?;
641+
642+ match submit_event_with_keys ( builder, & state, & creator_keys, None ) . await {
643+ Ok ( _) => {
644+ state. mark_pending_owned_channel ( & creator_pubkey, & channel_uuid_string) ;
645+ created_ids. insert ( channel_uuid_string. clone ( ) ) ;
646+ }
647+ Err ( error) if is_duplicate_channel_rejection ( & error) => {
648+ state. mark_pending_owned_channel ( & creator_pubkey, & channel_uuid_string) ;
649+ }
650+ Err ( error) => return Err ( error) ,
651+ }
652+ }
653+
654+ for _ in 0 ..3 {
655+ let metadata = fetch_starter_channel_metadata ( & state, & starter_ids) . await ?;
656+ for mut channel in metadata {
657+ if created_ids. contains ( & channel. id ) {
658+ channel. is_member = true ;
659+ }
660+ if !existing_channels
661+ . iter ( )
662+ . any ( |existing| existing. id == channel. id )
663+ {
664+ existing_channels. push ( channel) ;
665+ }
666+ }
667+ if has_all_starter_channels ( & existing_channels) {
668+ break ;
669+ }
670+ tokio:: time:: sleep ( std:: time:: Duration :: from_millis ( 150 ) ) . await ;
671+ }
672+
673+ if !has_all_starter_channels ( & existing_channels) {
674+ existing_channels = get_channels ( state. clone ( ) ) . await ?;
675+ }
676+
677+ if !has_all_starter_channels ( & existing_channels) {
678+ return Err ( "starter channels created but metadata not yet available" . to_string ( ) ) ;
679+ }
680+
681+ ensure_starter_channel_memberships ( & state, & creator_keys, & mut existing_channels) . await ?;
682+ Ok ( existing_channels)
683+ }
684+
513685#[ derive( serde:: Deserialize ) ]
514686#[ serde( rename_all = "camelCase" ) ]
515687pub struct UpdateChannelInput {
0 commit comments