CLI should use Agent in requests - get #986

CHANGELOG.md

@@ -5,6 +5,12 @@ By far most changes relate to `atomic-server`, so if not specified, assume the c
 **Changes to JS assets (including the front-end and JS libraries) are not shown here**, but in [`/browser/CHANGELOG`](/browser/CHANGELOG.md).
 See [STATUS.md](server/STATUS.md) to learn more about which features will remain stable.
 
+## UNRELEASED
+
+- CLI should use Agent in requests - get #986
+- Search endpoint throws error for websocket requests #1047
+- Fix search in CLI / atomic_lib #958
+
 ## [v0.40.2]
 
 - fix property sort order when importing + add tests #980

cli/src/get.rs

@@ -0,0 +1,16 @@
+use crate::{print::print_resource, Context, SerializeOptions};
+use atomic_lib::{errors::AtomicResult, Storelike};
+
+pub fn get_resource(
+    context: &mut Context,
+    subject: &str,
+    serialize: &SerializeOptions,
+) -> AtomicResult<()> {
+    context.read_config();
+
+    let store = &mut context.store;
+    let fetched = store.fetch_resource(subject, store.get_default_agent().ok().as_ref())?;
+    print_resource(context, &fetched, serialize)?;
+
+    Ok(())
+}

cli/src/main.rs

@@ -8,8 +8,8 @@ use dirs::home_dir;
 use std::{cell::RefCell, path::PathBuf, sync::Mutex};
 
 mod commit;
+mod get;
 mod new;
-mod path;
 mod print;
 mod search;
 
@@ -45,9 +45,9 @@ enum Commands {
         Visit https://docs.atomicdata.dev/core/paths.html for more info about paths. \
     ")]
     Get {
-        /// The subject URL, shortname or path to be fetched
-        #[arg(required = true, num_args = 1..)]
-        path: Vec<String>,
+        /// The subject URL
+        #[arg(required = true)]
+        subject: String,
 
         /// Serialization format
         #[arg(long, value_enum, default_value = "pretty")]
@@ -98,18 +98,27 @@ enum Commands {
         /// The search query
         #[arg(required = true)]
         query: String,
+        /// Subject URL of the parent Resource to filter by
+        #[arg(long)]
+        parent: Option<String>,
+        /// Serialization format
+        #[arg(long, value_enum, default_value = "pretty")]
+        as_: SerializeOptions,
     },
     /// List all bookmarks
     List,
     /// Validates the store
     #[command(hide = true)]
     Validate,
+    /// Print the current agent
+    Agent,
 }
 
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum)]
 pub enum SerializeOptions {
     Pretty,
     Json,
+    JsonAd,
     NTriples,
 }
 
@@ -118,6 +127,7 @@ impl Into<Format> for SerializeOptions {
         match self {
             SerializeOptions::Pretty => Format::Pretty,
             SerializeOptions::Json => Format::Json,
+            SerializeOptions::JsonAd => Format::JsonAd,
             SerializeOptions::NTriples => Format::NTriples,
         }
     }
@@ -151,6 +161,7 @@ impl Context {
             name: None,
             public_key: generate_public_key(&write_ctx.private_key).public,
         });
+        self.store.set_server_url(&write_ctx.server);
         write_ctx
     }
 }
@@ -238,8 +249,8 @@ fn exec_command(context: &mut Context) -> AtomicResult<()> {
                 return Err("Feature not available. Compile with `native` feature.".into());
             }
         }
-        Commands::Get { path, as_ } => {
-            path::get_path(context, &path, &as_)?;
+        Commands::Get { subject, as_ } => {
+            get::get_resource(context, &subject, &as_)?;
         }
         Commands::List => {
             list(context);
@@ -257,12 +268,16 @@ fn exec_command(context: &mut Context) -> AtomicResult<()> {
         } => {
             commit::set(context, &subject, &property, &value)?;
         }
-        Commands::Search { query } => {
-            search::search(context, query)?;
+        Commands::Search { query, parent, as_ } => {
+            search::search(context, query, parent, &as_)?;
         }
         Commands::Validate => {
             validate(context);
         }
+        Commands::Agent => {
+            let agent = context.read_config();
+            println!("{}", agent.agent);
+        }
     };
     Ok(())
 }

cli/src/search.rs

@@ -1,29 +1,27 @@
-use atomic_lib::{errors::AtomicResult, urls, Storelike};
+use atomic_lib::{errors::AtomicResult, Storelike};
 
-pub fn search(context: &crate::Context, query: String) -> AtomicResult<()> {
+use crate::print::print_resource;
+
+pub fn search(
+    context: &crate::Context,
+    query: String,
+    parent: Option<String>,
+    serialize: &crate::SerializeOptions,
+) -> AtomicResult<()> {
+    context.read_config();
     let opts = atomic_lib::client::search::SearchOpts {
         limit: Some(10),
         include: Some(true),
+        parents: Some(vec![parent.unwrap_or_default()]),
         ..Default::default()
     };
-    let subject = atomic_lib::client::search::build_search_subject(
-        &context.read_config().server,
-        &query,
-        opts,
-    );
-    let resource = context.store.get_resource(&subject)?;
-    let members = resource
-        .get(urls::ENDPOINT_RESULTS)
-        .expect("No members?")
-        .to_subjects(None)
-        .unwrap();
-    if members.is_empty() {
-        println!("No results found.");
-        println!("URL: {}", subject);
+    let resources = context.store.search(&query, opts)?;
+    if resources.is_empty() {
+        println!("No results found for query: {}", query);
         return Ok(());
     } else {
-        for member in members {
-            println!("{}", member);
+        for member in resources {
+            print_resource(context, &member, serialize)?;
         }
     }
     Ok(())

lib/defaults/default_store.json

@@ -710,7 +710,7 @@
     },
     {
         "@id": "https://atomicdata.dev/properties/published-at",
-        "https://atomicdata.dev/properties/datatype": "https://atomicdata.dev/datatypes/timestamp",
+        "https://atomicdata.dev/properties/datatype": "https://atomicdata.dev/datatypes/date",
         "https://atomicdata.dev/properties/description": "DateTime at which an item is made public.",
         "https://atomicdata.dev/properties/isA": [
             "https://atomicdata.dev/classes/Property"

lib/src/agents.rs

@@ -85,7 +85,7 @@ impl Agent {
     pub fn new(name: Option<&str>, store: &impl Storelike) -> AtomicResult<Agent> {
         let keypair = generate_keypair()?;
 
-        Ok(Agent::new_from_private_key(name, store, &keypair.private))
+        Agent::new_from_private_key(name, store, &keypair.private)
     }
 
     /// Creates a new Agent on this server, using the server's Server URL.
@@ -94,16 +94,16 @@ impl Agent {
         name: Option<&str>,
         store: &impl Storelike,
         private_key: &str,
-    ) -> Agent {
+    ) -> AtomicResult<Agent> {
         let keypair = generate_public_key(private_key);
 
-        Agent {
+        Ok(Agent {
             private_key: Some(keypair.private),
             public_key: keypair.public.clone(),
-            subject: format!("{}/agents/{}", store.get_server_url(), keypair.public),
+            subject: format!("{}/agents/{}", store.get_server_url()?, keypair.public),
             name: name.map(|x| x.to_owned()),
             created_at: crate::utils::now(),
-        }
+        })
     }
 
     /// Creates a new Agent on this server, using the server's Server URL.
@@ -114,7 +114,7 @@ impl Agent {
         Ok(Agent {
             private_key: None,
             public_key: public_key.into(),
-            subject: format!("{}/agents/{}", store.get_server_url(), public_key),
+            subject: format!("{}/agents/{}", store.get_server_url()?, public_key),
             name: None,
             created_at: crate::utils::now(),
         })
@@ -211,6 +211,19 @@ pub fn verify_public_key(public_key: &str) -> AtomicResult<()> {
     Ok(())
 }
 
+impl From<Agent> for ForAgent {
+    fn from(agent: Agent) -> Self {
+        agent.subject.into()
+    }
+}
+
+impl<'a> From<&'a Agent> for ForAgent {
+    fn from(agent: &'a Agent) -> Self {
+        let subject: String = agent.subject.clone();
+        subject.into()
+    }
+}
+
 #[cfg(test)]
 mod test {
     #[cfg(test)]

lib/src/client/helpers.rs

@@ -54,18 +54,33 @@ pub fn fetch_body(
     if !url.starts_with("http") {
         return Err(format!("Could not fetch url '{}', must start with http.", url).into());
     }
-    if let Some(agent) = client_agent {
-        get_authentication_headers(url, agent)?;
-    }
 
-    let agent = ureq::builder()
+    let client = ureq::builder()
         .timeout(std::time::Duration::from_secs(2))
         .build();
-    let resp = agent
-        .get(url)
-        .set("Accept", content_type)
-        .call()
-        .map_err(|e| format!("Error when server tried fetching {} : {}", url, e))?;
+
+    let mut req = client.get(url);
+    if let Some(agent) = client_agent {
+        let headers = get_authentication_headers(url, agent)?;
+        for (key, value) in headers {
+            req = req.set(key.as_str(), value.as_str());
+        }
+    }
+
+    let resp = match req.set("Accept", content_type).call() {
+        Ok(response) => response,
+        Err(ureq::Error::Status(status, response)) => {
+            let body = response
+                .into_string()
+                .unwrap_or_else(|_| "<failed to read response body>".to_string());
+            return Err(format!(
+                "Error when fetching {}: Status: {}. Body: {}",
+                url, status, body
+            )
+            .into());
+        }
+        Err(e) => return Err(format!("Error when fetching {}: {}", url, e).into()),
+    };
     let status = resp.status();
     let body = resp
         .into_string()