patch of Add MemoryCredentialSession and app password example · round #0 · pull #2 · nonbinary.computer/jacquard

+58

crates/jacquard/src/client.rs

···

       1048
       1048
        
               Self::unauthenticated()

     

       1049
       1049
        
           }

     

       1050
       1050
        
       }

     

       1051
       1051
       +
       

     

       1052
       1052
       +
       /// MemoryCredentialSession: credential session with in memory store and identity resolver

     

       1053
       1053
       +
       pub type MemoryCredentialSession = CredentialSession<

     

       1054
       1054
       +
           MemorySessionStore<SessionKey, AtpSession>,

     

       1055
       1055
       +
           jacquard_identity::PublicResolver,

     

       1056
       1056
       +
       >;

     

       1057
       1057
       +
       

     

       1058
       1058
       +
       impl MemoryCredentialSession {

     

       1059
       1059
       +
           /// Create an unauthenticated MemoryCredentialSession.

     

       1060
       1060
       +
           ///

     

       1061
       1061
       +
           /// Uses an in memory store and a public resolver.

     

       1062
       1062
       +
           /// Equivalent to a BasicClient that isn't wrapped in Agent

     

       1063
       1063
       +
           fn unauthenticated() -> Self {

     

       1064
       1064
       +
               use std::sync::Arc;

     

       1065
       1065
       +
               let http = reqwest::Client::new();

     

       1066
       1066
       +
               let resolver = jacquard_identity::PublicResolver::new(http, Default::default());

     

       1067
       1067
       +
               let store = MemorySessionStore::default();

     

       1068
       1068
       +
               CredentialSession::new(Arc::new(store), Arc::new(resolver))

     

       1069
       1069
       +
           }

     

       1070
       1070
       +
       

     

       1071
       1071
       +
           /// Create a MemoryCredentialSession and authenticate with the provided details

     

       1072
       1072
       +
           ///

     

       1073
       1073
       +
           /// - `identifier`: handle (preferred), DID, or `https://` PDS base URL.

     

       1074
       1074
       +
           /// - `session_id`: optional session label; defaults to "session".

     

       1075
       1075
       +
           /// - Persists and activates the session, and updates the base endpoint to the user's PDS.

     

       1076
       1076
       +
           ///

     

       1077
       1077
       +
           /// # Example

     

       1078
       1078
       +
           /// ```no_run

     

       1079
       1079
       +
           /// # use jacquard::client::BasicClient;

     

       1080
       1080
       +
           /// # use jacquard::types::string::AtUri;

     

       1081
       1081
       +
           /// # use jacquard_api::app_bsky::feed::post::Post;

     

       1082
       1082
       +
           /// use crate::jacquard::client::{Agent, AgentSessionExt};

     

       1083
       1083
       +
           /// # #[tokio::main]

     

       1084
       1084
       +
           /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {

     

       1085
       1085
       +
           /// let (session, _) = MemoryCredentialSession::authenticated(identifier, password, None);

     

       1086
       1086
       +
           /// let agent = Agent::from(session);

     

       1087
       1087
       +
           /// let output = agent.create_record::<Post>(post, None).await?;

     

       1088
       1088
       +
           /// # Ok(())

     

       1089
       1089
       +
           /// # }

     

       1090
       1090
       +
           /// ```

     

       1091
       1091
       +
           async fn authenticated(

     

       1092
       1092
       +
               identifier: CowStr<'_>,

     

       1093
       1093
       +
               password: CowStr<'_>,

     

       1094
       1094
       +
               session_id: Option<CowStr<'_>>,

     

       1095
       1095
       +
           ) -> Result<(Self, AtpSession), ClientError> {

     

       1096
       1096
       +
               let session = MemoryCredentialSession::unauthenticated();

     

       1097
       1097
       +
               let auth = session

     

       1098
       1098
       +
                   .login(identifier, password, session_id, None, None)

     

       1099
       1099
       +
                   .await?;

     

       1100
       1100
       +
               Ok((session, auth))

     

       1101
       1101
       +
           }

     

       1102
       1102
       +
       }

     

       1103
       1103
       +
       

     

       1104
       1104
       +
       impl Default for MemoryCredentialSession {

     

       1105
       1105
       +
           fn default() -> Self {

     

       1106
       1106
       +
               MemoryCredentialSession::unauthenticated()

     

       1107
       1107
       +
           }

     

       1108
       1108
       +
       }

+27 -6

crates/jacquard/Cargo.toml

···

       17
       17
        
       # Minimal API bindings

     

       18
       18
        
       api = ["jacquard-api/minimal"]

     

       19
       19
        
       # Bluesky API bindings

     

       20
       20
       -
       api_bluesky = ["api", "jacquard-api/bluesky" ]

     

       20
       20
       +
       api_bluesky = ["api", "jacquard-api/bluesky"]

     

       21
       21
        
       # Bluesky API bindings, plus a curated selection of community lexicons

     

       22
       22
       -
       api_full = ["api", "jacquard-api/bluesky", "jacquard-api/other", "jacquard-api/lexicon_community"]

     

       22
       22
       +
       api_full = [

     

       23
       23
       +
           "api",

     

       24
       24
       +
           "jacquard-api/bluesky",

     

       25
       25
       +
           "jacquard-api/other",

     

       26
       26
       +
           "jacquard-api/lexicon_community",

     

       27
       27
       +
       ]

     

       23
       28
        
       # All captured generated lexicon API bindings

     

       24
       29
        
       api_all = ["api_full", "jacquard-api/ufos"]

     

       25
       30
        
       

     

       26
       31
        
       # Propagate loopback to oauth (server + browser helper)

     

       27
       32
        
       loopback = ["jacquard-oauth/loopback", "jacquard-oauth/browser-open"]

     

       28
       33
        
       # Enable tracing instrumentation

     

       29
       29
       -
       tracing = ["dep:tracing", "jacquard-common/tracing", "jacquard-oauth/tracing", "jacquard-identity/tracing"]

     

       34
       34
       +
       tracing = [

     

       35
       35
       +
           "dep:tracing",

     

       36
       36
       +
           "jacquard-common/tracing",

     

       37
       37
       +
           "jacquard-oauth/tracing",

     

       38
       38
       +
           "jacquard-identity/tracing",

     

       39
       39
       +
       ]

     

       30
       40
        
       dns = ["jacquard-identity/dns"]

     

       31
       41
        
       streaming = ["jacquard-common/streaming"]

     

       32
       42
        
       websocket = ["jacquard-common/websocket"]

     
···

       83
       93
        
       path = "../../examples/streaming_download.rs"

     

       84
       94
        
       required-features = ["api_bluesky", "streaming"]

     

       85
       95
        
       

     

       96
       96
       +
       [[example]]

     

       97
       97
       +
       name = "app_password_create_post"

     

       98
       98
       +
       path = "../../examples/app_password_create_post.rs"

     

       99
       99
       +
       required-features = ["api_bluesky"]

     

       100
       100
       +
       

     

       86
       101
        
       

     

       87
       102
        
       [dependencies]

     

       88
       103
        
       jacquard-api = { version = "0.5", path = "../jacquard-api" }

     

       89
       89
       -
       jacquard-common = { version = "0.5", path = "../jacquard-common", features = ["reqwest-client"] }

     

       104
       104
       +
       jacquard-common = { version = "0.5", path = "../jacquard-common", features = [

     

       105
       105
       +
           "reqwest-client",

     

       106
       106
       +
       ] }

     

       90
       107
        
       jacquard-oauth = { version = "0.5", path = "../jacquard-oauth" }

     

       91
       108
        
       jacquard-derive = { version = "0.5", path = "../jacquard-derive", optional = true }

     

       92
       109
        
       jacquard-identity = { version = "0.5", path = "../jacquard-identity" }

     
···

       112
       129
        
       tracing = { workspace = true, optional = true }

     

       113
       130
        
       

     

       114
       131
        
       [target.'cfg(not(target_arch = "wasm32"))'.dependencies]

     

       115
       115
       -
       reqwest = { workspace = true, features = ["http2", "system-proxy", "rustls-tls"] }

     

       132
       132
       +
       reqwest = { workspace = true, features = [

     

       133
       133
       +
           "http2",

     

       134
       134
       +
           "system-proxy",

     

       135
       135
       +
           "rustls-tls",

     

       136
       136
       +
       ] }

     

       116
       137
        
       tokio = { workspace = true, features = ["macros", "rt-multi-thread", "fs"] }

     

       117
       138
        
       

     

       118
       139
        
       [target.'cfg(target_family = "wasm")'.dependencies]

     
···

       123
       144
        
       miette = { workspace = true, features = ["fancy"] }

     

       124
       145
        
       

     

       125
       146
        
       [package.metadata.docs.rs]

     

       126
       126
       -
       features = [ "api_all", "derive", "dns", "loopback" ]

     

       147
       147
       +
       features = ["api_all", "derive", "dns", "loopback"]

+49

examples/app_password_create_post.rs

···

       1
       1
       +
       use clap::Parser;

     

       2
       2
       +
       use jacquard::CowStr;

     

       3
       3
       +
       use jacquard::api::app_bsky::feed::post::Post;

     

       4
       4
       +
       use jacquard::client::{Agent, AgentSessionExt, MemoryCredentialSession};

     

       5
       5
       +
       use jacquard::types::string::Datetime;

     

       6
       6
       +
       

     

       7
       7
       +
       #[derive(Parser, Debug)]

     

       8
       8
       +
       #[command(author, version, about = "Create a simple post")]

     

       9
       9
       +
       struct Args {

     

       10
       10
       +
           /// Handle (e.g., alice.bsky.social) or DID

     

       11
       11
       +
           input: CowStr<'static>,

     

       12
       12
       +
       

     

       13
       13
       +
           /// App Password

     

       14
       14
       +
           password: CowStr<'static>,

     

       15
       15
       +
       

     

       16
       16
       +
           /// Post text

     

       17
       17
       +
           #[arg(short, long)]

     

       18
       18
       +
           text: String,

     

       19
       19
       +
       }

     

       20
       20
       +
       

     

       21
       21
       +
       #[tokio::main]

     

       22
       22
       +
       async fn main() -> miette::Result<()> {

     

       23
       23
       +
           let args = Args::parse();

     

       24
       24
       +
       

     

       25
       25
       +
           let (session, auth) =

     

       26
       26
       +
               MemoryCredentialSession::authenticated(args.input, args.password, None).await?;

     

       27
       27
       +
           println!("Signed in as {}", auth.handle);

     

       28
       28
       +
       

     

       29
       29
       +
           let agent: Agent<_> = Agent::from(session);

     

       30
       30
       +
       

     

       31
       31
       +
           // Create a simple text post using the Agent convenience method

     

       32
       32
       +
           let post = Post {

     

       33
       33
       +
               text: CowStr::from(args.text),

     

       34
       34
       +
               created_at: Datetime::now(),

     

       35
       35
       +
               embed: None,

     

       36
       36
       +
               entities: None,

     

       37
       37
       +
               facets: None,

     

       38
       38
       +
               labels: None,

     

       39
       39
       +
               langs: None,

     

       40
       40
       +
               reply: None,

     

       41
       41
       +
               tags: None,

     

       42
       42
       +
               extra_data: Default::default(),

     

       43
       43
       +
           };

     

       44
       44
       +
       

     

       45
       45
       +
           let output = agent.create_record(post, None).await?;

     

       46
       46
       +
           println!("✓ Created post: {}", output.uri);

     

       47
       47
       +
       

     

       48
       48
       +
           Ok(())

     

       49
       49
       +
       }