FEAT: Move note now works.

server/nm-store/src/lib.rs

@@ -38,25 +38,70 @@ mod tests {
     #[tokio::test(threaded_scheduler)]
     async fn fetching_unfound_page_by_title_works() {
         let title = "Nonexistent Page";
-        let _now = chrono::Utc::now();
+        let now = chrono::Utc::now();
         let storagepool = fresh_inmemory_database().await;
         let newpageresult = storagepool.get_page_by_title(&title).await;
 
         assert!(newpageresult.is_ok(), "{:?}", newpageresult);
-        let (newpage, _newnotes) = newpageresult.unwrap();
+        let (newpage, newnotes) = newpageresult.unwrap();
 
         assert_eq!(newpage.title, title, "{:?}", newpage.title);
         assert_eq!(newpage.slug, "nonexistent-page");
+
+        assert_eq!(newnotes.len(), 1);
+        assert_eq!(newnotes[0].notetype, "root");
+        assert_eq!(newpage.note_id, newnotes[0].id);
+
+        assert!((newpage.creation_date - now).num_minutes() < 1);
+        assert!((newpage.updated_date - now).num_minutes() < 1);
+        assert!((newpage.lastview_date - now).num_minutes() < 1);
+        assert!(newpage.deleted_date.is_none());
     }
 
-    // 		// TODO: This should be 1, not 0
+    fn make_new_note(content: &str) -> row_structs::NewNote {
-    // 		assert_eq!(newnotes.len(), 0);
+        row_structs::NewNoteBuilder::default()
-    // 		// assert_eq!(newnotes[0].notetype, "root");
+            .content(content.to_string())
-    // 		// assert_eq!(newpage.note_id, newnotes[0].id);
+            .build()
-    //
+            .unwrap()
-    // 		assert!((newpage.creation_date - now).num_minutes() < 1.0);
+    }
-    // 		assert!((newpage.updated_date - now).num_minutes() < 1.0);
+
-    // 		assert!((newpage.lastview_date - now).num_minutes() < 1.0);
+    #[tokio::test(threaded_scheduler)]
-    // 		assert!(newpage.deleted_date.is_none());
+    async fn can_nest_notes() {
-    // 	}
+        let title = "Nonexistent Page";
+        let storagepool = fresh_inmemory_database().await;
+        let newpageresult = storagepool.get_page_by_title(&title).await;
+        let (_newpage, newnotes) = newpageresult.unwrap();
+
+        let root = &newnotes[0];
+
+        let note1 = make_new_note("1");
+        let note1_uuid = storagepool.insert_nested_note(&note1, &root.uuid, 0).await;
+        assert!(note1_uuid.is_ok(), "{:?}", note1_uuid);
+        let note1_uuid = note1_uuid.unwrap();
+
+        let note2 = make_new_note("2");
+        let note2_uuid = storagepool.insert_nested_note(&note2, &root.uuid, 0).await;
+        assert!(note2_uuid.is_ok(), "{:?}", note2_uuid);
+        let note2_uuid = note2_uuid.unwrap();
+
+        let note3 = make_new_note("3");
+        let note3_uuid = storagepool.insert_nested_note(&note3, &note1_uuid, 0).await;
+        assert!(note3_uuid.is_ok(), "{:?}", note3_uuid);
+        let note3_uuid = note3_uuid.unwrap();
+
+        let note4 = make_new_note("4");
+        let note4_uuid = storagepool.insert_nested_note(&note4, &note2_uuid, 0).await;
+        assert!(note4_uuid.is_ok(), "{:?}", note4_uuid);
+        let note4_uuid = note4_uuid.unwrap();
+
+        let newpageresult = storagepool.get_page_by_title(&title).await;
+        let (newpage, newnotes) = newpageresult.unwrap();
+
+        assert_eq!(newpage.title, title, "{:?}", newpage.title);
+        assert_eq!(newpage.slug, "nonexistent-page");
+
+        assert_eq!(newnotes.len(), 5);
+        assert_eq!(newnotes[0].notetype, "root");
+        assert_eq!(newpage.note_id, newnotes[0].id);
+    }
 }

server/nm-store/src/row_structs.rs

@@ -47,6 +47,7 @@ pub struct NewPage {
 
 #[derive(Clone, Serialize, Deserialize, Debug, Builder)]
 pub struct NewNote {
+    #[builder(default = r#""".to_string()"#)]
     pub uuid: String,
     pub content: String,
     #[builder(default = r#""note".to_string()"#)]
@@ -76,6 +77,14 @@ pub(crate) struct JustId {
     pub id: i64,
 }
 
+#[derive(Clone, Serialize, Deserialize, Debug, FromRow)]
+pub(crate) struct NoteRelationship {
+    pub parent_id: i64,
+    pub note_id: i64,
+    pub position: i64,
+    pub nature: String,
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

server/nm-store/src/store.rs

@@ -1,15 +1,17 @@
 use crate::errors::NoteStoreError;
 use crate::row_structs::{
-	JustId, JustSlugs, NewNote, NewNoteBuilder, NewPage, NewPageBuilder, RawNote, RawPage,
+    JustId, JustSlugs, NewNote, NewNoteBuilder, NewPage,
+	NewPageBuilder, NoteRelationship, RawNote, RawPage,
 };
 use friendly_id;
 use lazy_static::lazy_static;
+use std::collections::HashMap;
 use regex::Regex;
 use slug::slugify;
 use sqlx;
 use sqlx::{
-	sqlite::{Sqlite, SqlitePool},
+    sqlite::{Sqlite, SqlitePool, SqliteRow},
-	Executor,
+    Done, Executor, Row
 };
 use std::sync::Arc;
 
@@ -30,9 +32,7 @@ impl NoteStore {
     // to its original empty form.  Do not use unless you
     // really, really want that to happen.
     pub async fn reset_database(&self) -> NoteResult<()> {
-		reset_database(&*self.0)
+        reset_database(&*self.0).await.map_err(NoteStoreError::DBError)
-			.await
-			.map_err(NoteStoreError::DBError)
     }
 
     /// Fetch page by slug
@@ -46,12 +46,10 @@ impl NoteStore {
         //		let select_note_collection_for_root = include_str!("sql/select_note_collection_for_root.sql");
         let mut tx = self.0.begin().await?;
         let page = select_page_by_slug(&mut tx, slug).await?;
-		//		let notes = sqlx::query_as(select_note_collection_for_root)
+		let note_id = page.note_id;
-		//			.bind(page.note_id)
+		let notes = select_note_collection_from_root(&mut tx, note_id).await?;
-		//			.fetch(&tx)
-		//			.await?;
         tx.commit().await?;
-		Ok((page, vec![]))
+        Ok((page, notes))
     }
 
     /// Fetch page by title
@@ -65,10 +63,7 @@ impl NoteStore {
         let (page, notes) = match select_page_by_title(&mut tx, title).await {
             Ok(page) => {
                 let note_id = page.note_id;
-				(
+                (page, select_note_collection_from_root(&mut tx, note_id).await?)
-					page,
-					select_note_collection_from_root(&mut tx, note_id).await?,
-				)
             }
             Err(sqlx::Error::RowNotFound) => {
                 let page = {
@@ -80,10 +75,7 @@ impl NoteStore {
                     select_page_by_title(&mut tx, &title).await?
                 };
                 let note_id = page.note_id;
-				(
+                (page, select_note_collection_from_root(&mut tx, note_id).await?)
-					page,
-					select_note_collection_from_root(&mut tx, note_id).await?,
-				)
             }
             Err(e) => return Err(NoteStoreError::DBError(e)),
         };
@@ -91,11 +83,13 @@ impl NoteStore {
         Ok((page, notes))
     }
 
+	// TODO: Make sure the position is sane.
+	/// Insert a note as the child of an existing note, at a set position.
     pub async fn insert_nested_note(
         &self,
-		note: NewNote,
+        note: &NewNote,
         parent_note_uuid: &str,
-		position: i32,
+        position: i64,
     ) -> NoteResult<String> {
         let mut new_note = note.clone();
         new_note.uuid = friendly_id::create();
@@ -107,8 +101,71 @@ impl NoteStore {
         tx.commit().await?;
         Ok(new_note.uuid)
     }
-}
 
+	// TODO: Make sure the new position is sane.
+	/// Move a note from one location to another.
+    pub async fn move_note(
+        &self,
+        note_uuid: &str,
+        old_parent_uuid: &str,
+        new_parent_uuid: &str,
+        new_position: i64,
+    ) -> NoteResult<()> {
+        let sample = vec![note_uuid, old_parent_uuid, new_parent_uuid];
+        let mut tx = self.0.begin().await?;
+        let found_id_vec = bulk_select_ids_for_note_uuids(&mut tx, &sample)
+			.await?;
+
+		let found_ids: HashMap<String, i64> = found_id_vec
+			.into_iter()
+			.collect();
+
+        if found_ids.len() != 3 {
+            return Err(NoteStoreError::NotFound);
+        }
+
+        let old_parent_id = *found_ids.get(old_parent_uuid).unwrap();
+        let new_parent_id = *found_ids.get(new_parent_uuid).unwrap();
+        let note_id = *found_ids.get(note_uuid).unwrap();
+
+        let old_note_position = get_note_note_relationship(&mut tx, old_parent_id, note_id)
+            .await?
+            .position;
+
+        let _ = delete_note_note_relationship(&mut tx, old_parent_id, note_id).await?;
+        let _ = close_hole_for_deleted_note(&mut tx, old_parent_id, old_note_position).await?;
+        let _ = make_room_for_new_note(&mut tx, new_parent_id, new_position).await?;
+        let _ = insert_note_note_relationship(&mut tx, new_parent_id, note_id, new_position).await?;
+		tx.commit().await?;
+		Ok(())
+    }
+
+	/// Embed or reference a note from a different location.
+	pub async fn reference_or_embed_note(
+		&self,
+        note_uuid: &str,
+        new_parent_uuid: &str,
+        new_position: i64,
+		new_nature: &str) -> NoteResult<()> {
+		todo!()
+	}
+
+	/// Delete a note
+	pub async fn delete_note(
+		&self,
+		note_uuid: &str,
+		note_parent_uuid: &str) -> NoteResult<()> {
+		todo!()
+	}
+
+	/// Update a note's content
+	pub async fn update_note_content(
+		&self,
+		note_uuid: &str,
+		content: &str) -> NoteResult<()> {
+		todo!()
+	}
+}
 //  ___     _          _
 // | _ \_ _(_)_ ____ _| |_ ___
 // |  _/ '_| \ V / _` |  _/ -_)
@@ -125,10 +182,7 @@ where
     E: Executor<'a, Database = Sqlite>,
 {
     let initialize_sql = include_str!("sql/initialize_database.sql");
-	sqlx::query(initialize_sql)
+    sqlx::query(initialize_sql).execute(executor).await.map(|_| ())
-		.execute(executor)
-		.await
-		.map(|_| ())
 }
 
 async fn select_page_by_slug<'a, E>(executor: E, slug: &str) -> SqlResult<RawPage>
@@ -171,7 +225,7 @@ where
     Ok(id.id)
 }
 
-async fn make_room_for_new_note<'a, E>(executor: E, parent_id: i64, position: i32) -> SqlResult<()>
+async fn make_room_for_new_note<'a, E>(executor: E, parent_id: i64, position: i64) -> SqlResult<()>
 where
     E: Executor<'a, Database = Sqlite>,
 {
@@ -189,12 +243,7 @@ where
         .map(|_| ())
 }
 
-async fn insert_note_note_relationship<'a, E>(
+async fn insert_note_note_relationship<'a, E>(executor: E, parent_id: i64, note_id: i64, position: i64) -> SqlResult<()>
-	executor: E,
-	parent_id: i64,
-	note_id: i64,
-	position: i32,
-) -> SqlResult<()>
 where
     E: Executor<'a, Database = Sqlite>,
 {
@@ -217,8 +266,7 @@ async fn select_note_collection_from_root<'a, E>(executor: E, root: i64) -> SqlR
 where
     E: Executor<'a, Database = Sqlite>,
 {
-	let select_note_collection_from_root_sql =
+    let select_note_collection_from_root_sql = include_str!("sql/select_note_collection_from_root.sql");
-		include_str!("sql/select_note_collection_from_root.sql");
     Ok(sqlx::query_as(&select_note_collection_from_root_sql)
         .bind(&root)
         .fetch_all(executor)
@@ -322,6 +370,87 @@ where
         .last_insert_rowid())
 }
 
+async fn bulk_select_ids_for_note_uuids<'a, E>(executor: E, ids: &Vec<&str>) -> SqlResult<Vec<(String, i64)>>
+where
+    E: Executor<'a, Database = Sqlite>,
+{
+    let bulk_select_ids_for_note_uuids_sql = 
+        "SELECT uuid, id FROM notes WHERE uuid IN (".to_string() +
+        &["?",].repeat(ids.len()).join(",") +
+        &");".to_string();
+
+    let mut request = sqlx::query(&bulk_select_ids_for_note_uuids_sql);
+    for id in ids.iter() {
+        request = request.bind(id);
+    }
+    Ok(request
+       .try_map(|row: SqliteRow| {
+		   let l = row.try_get::<String, _>(0)?;
+		   let r = row.try_get::<i64, _>(1)?;
+		   Ok((l, r)) })
+       .fetch_all(executor)
+       .await?
+       .into_iter()
+       .collect())
+}
+
+async fn get_note_note_relationship<'a, E>(executor: E, parent_id: i64, note_id: i64) -> SqlResult<NoteRelationship>
+where
+    E: Executor<'a, Database = Sqlite>,
+{
+    let get_note_note_relationship_sql = concat!(
+        "SELECT parent_id, note_id, position, nature ",
+        "FROM note_relationships ",
+        "WHERE parent_id = ? and note_id = ? ",
+        "LIMIT 1"
+    );
+    sqlx::query_as(get_note_note_relationship_sql)
+        .bind(&parent_id)
+        .bind(&note_id)
+        .fetch_one(executor)
+        .await
+}
+
+async fn delete_note_note_relationship<'a, E>(executor: E, parent_id: i64, note_id: i64) -> SqlResult<()>
+where
+    E: Executor<'a, Database = Sqlite>,
+{
+    let delete_note_note_relationship_sql = concat!(
+        "DELETE FROM note_relationships ",
+        "WHERE parent_id = ? and note_id = ? "
+    );
+
+    let count = sqlx::query(delete_note_note_relationship_sql)
+        .bind(&parent_id)
+        .bind(&note_id)
+        .execute(executor)
+        .await?
+        .rows_affected();
+
+    match count {
+        1 => Ok(()),
+        _ => Err(sqlx::Error::RowNotFound),
+    }
+}
+
+async fn close_hole_for_deleted_note<'a, E>(executor: E, parent_id: i64, position: i64) -> SqlResult<()>
+where
+    E: Executor<'a, Database = Sqlite>,
+{
+    let close_hole_for_deleted_note_sql = concat!(
+        "UPDATE note_relationships ",
+        "SET position = position - 1 ",
+        "WHERE position > ? and parent_id = ?;"
+    );
+
+    sqlx::query(close_hole_for_deleted_note_sql)
+        .bind(&position)
+        .bind(&parent_id)
+        .execute(executor)
+        .await
+        .map(|_| ())
+}
+
 fn create_unique_root_note() -> NewNote {
     NewNoteBuilder::default()
         .uuid(friendly_id::create())