Register endpoint, URLs #288 #48gister Endpoint and true URLs

Author: joepio

lib/Cargo.toml

@@ -23,6 +23,7 @@ html2md = { version = "0.2.14", optional = true }
 kuchikiki = { version = "0.8.2", optional = true }
 lol_html = { version = "1", optional = true }
 rand = { version = "0.8" }
+lazy_static = "1"
 regex = "1"
 ring = "0.17.6"
 rio_api = { version = "0.8", optional = true }

lib/src/collections.rs

@@ -416,7 +416,7 @@ pub fn create_collection_resource_for_class(
 
     // Let the Collections collection be the top level item
     let parent = if class.subject == urls::COLLECTION {
-        drive
+        drive.to_string()
     } else {
         format!("{}/collections", drive)
     };

lib/src/commit.rs

@@ -240,7 +240,7 @@ impl Commit {
                     let default_parent = store.get_self_url().ok_or("There is no self_url set, and no parent in the Commit. The commit can not be applied.")?;
                     resource_old.set(
                         urls::PARENT.into(),
-                        Value::AtomicUrl(default_parent),
+                        Value::AtomicUrl(default_parent.to_string()),
                         store,
                     )?;
                 }

lib/src/db.rs

@@ -18,6 +18,7 @@ use std::{
 
 use tracing::{info, instrument};
 use trees::{Method, Operation, Transaction, Tree};
+use url::Url;
 
 use crate::{
     agents::ForAgent,
@@ -79,7 +80,7 @@ pub struct Db {
     /// [Tree::WatchedQueries]
     watched_queries: sled::Tree,
     /// The address where the db will be hosted, e.g. http://localhost/
-    server_url: String,
+    server_url: Url,
     /// Endpoints are checked whenever a resource is requested. They calculate (some properties of) the resource and return it.
     endpoints: Vec<Endpoint>,
     /// Function called whenever a Commit is applied.
@@ -109,7 +110,7 @@ impl Db {
             reference_index,
             query_index,
             prop_val_sub_index,
-            server_url,
+            server_url: Url::parse(&server_url)?,
             watched_queries,
             endpoints: default_endpoints(),
             on_commit: None,
@@ -268,14 +269,15 @@ impl Db {
     }
 
     fn map_sled_item_to_resource(
+        &self,
         item: Result<(sled::IVec, sled::IVec), sled::Error>,
         self_url: String,
         include_external: bool,
     ) -> Option<Resource> {
         let (subject, resource_bin) = item.expect(DB_CORRUPT_MSG);
         let subject: String = String::from_utf8_lossy(&subject).to_string();
 
-        if !include_external && !subject.starts_with(&self_url) {
+        if !include_external && self.is_external_subject(&subject).ok()? {
             return None;
         }
 
@@ -398,7 +400,7 @@ impl Db {
 
         for (i, atom_res) in atoms.enumerate() {
             let atom = atom_res?;
-            if !q.include_external && !atom.subject.starts_with(&self_url) {
+            if !q.include_external && self.is_external_subject(&atom.subject).unwrap() {
                 continue;
             }
 
@@ -660,14 +662,14 @@ impl Storelike for Db {
         Ok(commit_response)
     }
 
-    fn get_server_url(&self) -> &str {
+    fn get_server_url(&self) -> &Url {
         &self.server_url
     }
 
-    // Since the DB is often also the server, this should make sense.
-    // Some edge cases might appear later on (e.g. a slave DB that only stores copies?)
-    fn get_self_url(&self) -> Option<String> {
-        Some(self.get_server_url().into())
+    fn get_self_url(&self) -> Option<&Url> {
+        // Since the DB is often also the server, this should make sense.
+        // Some edge cases might appear later on (e.g. a slave DB that only stores copies?)
+        Some(self.get_server_url())
     }
 
     fn get_default_agent(&self) -> AtomicResult<crate::agents::Agent> {
@@ -686,7 +688,7 @@ impl Storelike for Db {
                 let resource = crate::resources::Resource::from_propvals(propvals, subject.into());
                 Ok(resource)
             }
-            Err(e) => self.handle_not_found(subject, e, None),
+            Err(e) => self.handle_not_found(subject, e),
         }
     }
 
@@ -836,7 +838,7 @@ impl Storelike for Db {
             .expect("No self URL set, is required in DB");
 
         let result = self.resources.into_iter().filter_map(move |item| {
-            Db::map_sled_item_to_resource(item, self_url.clone(), include_external)
+            Db::map_sled_item_to_resource(self, item, self_url.to_string(), include_external)
         });
 
         Box::new(result)
@@ -889,7 +891,8 @@ impl Storelike for Db {
     }
 
     fn populate(&self) -> AtomicResult<()> {
-        crate::populate::populate_all(self)
+        crate::populate::populate_all(self)?;
+        Ok(())
     }
 
     #[instrument(skip(self))]

lib/src/db/query_index.rs

@@ -117,7 +117,7 @@ pub fn query_sorted_indexed(
             let (_q_filter, _val, subject) = parse_collection_members_key(&k)?;
 
             // If no external resources should be included, skip this one if it's an external resource
-            if !q.include_external && !subject.starts_with(&self_url) {
+            if !q.include_external && store.is_external_subject(subject)? {
                 continue;
             }
 

lib/src/endpoints.rs

@@ -83,6 +83,7 @@ pub fn default_endpoints() -> Vec<Endpoint> {
         plugins::files::upload_endpoint(),
         plugins::files::download_endpoint(),
         plugins::export::export_endpoint(),
+        plugins::register::register_endpoint(),
         #[cfg(feature = "html")]
         plugins::bookmark::bookmark_endpoint(),
         plugins::importer::import_endpoint(),

lib/src/plugins/mod.rs

@@ -46,5 +46,6 @@ pub mod files;
 pub mod path;
 pub mod prunetests;
 pub mod query;
+pub mod register;
 pub mod search;
 pub mod versioning;

lib/src/plugins/register.rs

@@ -0,0 +1,73 @@
+//! Creates a new Drive and optionally also an Agent.
+
+use crate::{agents::Agent, endpoints::Endpoint, errors::AtomicResult, urls, Resource, Storelike};
+
+pub fn register_endpoint() -> Endpoint {
+    Endpoint {
+      path: "/register".to_string(),
+      params: [
+        urls::INVITE_PUBKEY.to_string(),
+        urls::NAME.to_string(),
+      ].into(),
+      description: "Allows new users to easily, in one request, make both an Agent and a Drive. This drive will be created at the subdomain of `name`.".to_string(),
+      shortname: "register".to_string(),
+      handle: Some(construct_register_redirect),
+      handle_post: None,
+  }
+}
+
+#[tracing::instrument(skip(store))]
+pub fn construct_register_redirect(
+    url: url::Url,
+    store: &impl Storelike,
+    for_agent: Option<&str>,
+) -> AtomicResult<Resource> {
+    let requested_subject = url.to_string();
+    let mut pub_key = None;
+    let mut name_option = None;
+    for (k, v) in url.query_pairs() {
+        match k.as_ref() {
+            "public-key" | urls::INVITE_PUBKEY => pub_key = Some(v.to_string()),
+            "name" | urls::NAME => name_option = Some(v.to_string()),
+            _ => {}
+        }
+    }
+    if pub_key.is_none() && name_option.is_none() {
+        return register_endpoint().to_resource(store);
+    }
+
+    let name = if let Some(n) = name_option {
+        n
+    } else {
+        return Err("No name provided".into());
+    };
+
+    let mut new_agent = None;
+
+    let drive_creator_agent: String = if let Some(key) = pub_key {
+        let new = Agent::new_from_public_key(store, &key)?.subject;
+        new_agent = Some(new.clone());
+        new
+    } else if let Some(agent) = for_agent {
+        agent.to_string()
+    } else {
+        return Err("No `public-key` provided".into());
+    };
+
+    // Create the new Drive
+    let drive = crate::populate::create_drive(store, Some(&name), &drive_creator_agent, false)?;
+
+    // Construct the Redirect Resource, which might provide the Client with a Subject for his Agent.
+    let mut redirect = Resource::new_instance(urls::REDIRECT, store)?;
+    redirect.set_string(urls::DESTINATION.into(), drive.get_subject(), store)?;
+    if let Some(agent) = new_agent {
+        redirect.set(
+            urls::REDIRECT_AGENT.into(),
+            crate::Value::AtomicUrl(agent),
+            store,
+        )?;
+    }
+    // The front-end requires the @id to be the same as requested
+    redirect.set_subject(requested_subject);
+    Ok(redirect)
+}

lib/src/populate.rs

@@ -9,7 +9,7 @@ use crate::{
     parse::ParseOpts,
     schema::{Class, Property},
     storelike::Query,
-    urls, Storelike, Value,
+    urls, Resource, Storelike, Value,
 };
 
 const DEFAULT_ONTOLOGY_PATH: &str = "defaultOntology";
@@ -153,26 +153,52 @@ pub fn populate_base_models(store: &impl Storelike) -> AtomicResult<()> {
     Ok(())
 }
 
-/// Creates a Drive resource at the base URL. Does not set rights. Use set_drive_rights for that.
-pub fn create_drive(store: &impl Storelike) -> AtomicResult<()> {
-    let self_url = store
-        .get_self_url()
-        .ok_or("No self_url set, cannot populate store with Drive")?;
-    let mut drive = store.get_resource_new(&self_url);
+/// Creates a Drive resource at the base URL if no name is passed.
+#[tracing::instrument(skip(store), level = "info")]
+pub fn create_drive(
+    store: &impl Storelike,
+    drive_name: Option<&str>,
+    for_agent: &str,
+    public_read: bool,
+) -> AtomicResult<Resource> {
+    let mut self_url = if let Some(url) = store.get_self_url() {
+        url.to_owned()
+    } else {
+        return Err("No self URL set. Cannot create drive.".into());
+    };
+    let drive_subject: String = if let Some(name) = drive_name {
+        // Let's make a subdomain
+        let host = self_url.host().expect("No host in server_url");
+        let subdomain_host = format!("{}.{}", name, host);
+        self_url.set_host(Some(&subdomain_host))?;
+        self_url.to_string()
+    } else {
+        self_url.to_string()
+    };
+
+    let mut drive = if drive_name.is_some() {
+        if store.get_resource(&drive_subject).is_ok() {
+            return Err("Drive URL is already taken".into());
+        }
+        Resource::new(drive_subject)
+    } else {
+        // Only for the base URL (of no drive name is passed), we should not check if the drive exists.
+        // This is because we use `create_drive` in the `--initialize` command.
+        store.get_resource_new(&drive_subject)
+    };
     drive.set_class(urls::DRIVE);
-    let server_url = url::Url::parse(store.get_server_url())?;
     drive.set_string(
         urls::NAME.into(),
-        server_url.host_str().ok_or("Can't use current base URL")?,
+        drive_name.unwrap_or_else(|| self_url.host_str().unwrap()),
         store,
     )?;
     drive.save_locally(store)?;
 
-    Ok(())
+    Ok(drive)
 }
 
 pub fn create_default_ontology(store: &impl Storelike) -> AtomicResult<()> {
-    let mut drive = store.get_resource(store.get_server_url())?;
+    let mut drive = store.get_resource(store.get_server_url().as_str())?;
 
     let ontology_subject = format!("{}/{}", drive.get_subject(), DEFAULT_ONTOLOGY_PATH);
 
@@ -209,7 +235,7 @@ pub fn create_default_ontology(store: &impl Storelike) -> AtomicResult<()> {
 /// Adds rights to the default agent to the Drive resource (at the base URL). Optionally give Public Read rights.
 pub fn set_drive_rights(store: &impl Storelike, public_read: bool) -> AtomicResult<()> {
     // Now let's add the agent as the Root user and provide write access
-    let mut drive = store.get_resource(store.get_server_url())?;
+    let mut drive = store.get_resource(store.get_server_url().as_str())?;
     let write_agent = store.get_default_agent()?.subject;
     let read_agent = write_agent.clone();
 
@@ -236,7 +262,9 @@ To use the data in your web apps checkout our client libraries: [@tomic/lib](htt
 Use [@tomic/cli](https://docs.atomicdata.dev/js-cli) to generate typed ontologies inside your code.
 "#, store.get_server_url(), &format!("{}/{}", drive.get_subject(), DEFAULT_ONTOLOGY_PATH)), store)?;
     }
+
     drive.save_locally(store)?;
+
     Ok(())
 }
 
@@ -312,7 +340,11 @@ pub fn populate_importer(store: &crate::Db) -> AtomicResult<()> {
         .ok_or("No self URL in this Store - required for populating importer")?;
     let mut importer = crate::Resource::new(urls::construct_path_import(&base));
     importer.set_class(urls::IMPORTER);
-    importer.set(urls::PARENT.into(), Value::AtomicUrl(base), store)?;
+    importer.set(
+        urls::PARENT.into(),
+        Value::AtomicUrl(base.to_string()),
+        store,
+    )?;
     importer.set(urls::NAME.into(), Value::String("Import".into()), store)?;
     importer.save_locally(store)?;
     Ok(())
@@ -323,7 +355,7 @@ pub fn populate_importer(store: &crate::Db) -> AtomicResult<()> {
 /// Useful for helping a new user get started.
 pub fn populate_sidebar_items(store: &crate::Db) -> AtomicResult<()> {
     let base = store.get_self_url().ok_or("No self_url")?;
-    let mut drive = store.get_resource(&base)?;
+    let mut drive = store.get_resource(base.as_str())?;
     let arr = vec![
         format!("{}/setup", base),
         format!("{}/import", base),
@@ -342,7 +374,13 @@ pub fn populate_all(store: &crate::Db) -> AtomicResult<()> {
     // populate_base_models should be run in init, instead of here, since it will result in infinite loops without
     populate_default_store(store)
         .map_err(|e| format!("Failed to populate default store. {}", e))?;
-    create_drive(store).map_err(|e| format!("Failed to create drive. {}", e))?;
+    create_drive(
+        store,
+        None,
+        &store.get_default_agent().unwrap().subject,
+        true,
+    )
+    .map_err(|e| format!("Failed to create drive. {}", e))?;
     create_default_ontology(store)
         .map_err(|e| format!("Failed to create default ontology. {}", e))?;
     set_drive_rights(store, true)?;

lib/src/resources.rs

@@ -347,13 +347,7 @@ impl Resource {
         let commit_builder = self.get_commit_builder().clone();
         let commit = commit_builder.sign(&agent, store, self)?;
         // If the current client is a server, and the subject is hosted here, don't post
-        let should_post = if let Some(self_url) = store.get_self_url() {
-            !self.subject.starts_with(&self_url)
-        } else {
-            // Current client is not a server, has no own persisted store
-            true
-        };
-        if should_post {
+        if store.is_external_subject(&commit.subject)? {
             crate::client::post_commit(&commit, store)?;
         }
         let opts = CommitOpts {