elf
/
notesmachine
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

FEAT: It is now theoretically possible to add a nested note.

This commit is contained in:
Elf M. Sternberg 2020-10-11 12:14:44 -07:00
parent 1b36183edb
commit 380d3f4a7c
2 changed files with 306 additions and 218 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

123
server/nm-store/src/row_structs.rs
View File

@ -5,87 +5,92 @@ use sqlx::{self, FromRow};
#[derive(Clone, Serialize, Deserialize, Debug, FromRow)] #[derive(Clone, Serialize, Deserialize, Debug, FromRow)]
pub struct RawPage { pub struct RawPage {
pub id: i64, pub id: i64,
pub slug: String, pub slug: String,
pub title: String, pub title: String,
pub note_id: i64, pub note_id: i64,
pub creation_date: DateTime<Utc>, pub creation_date: DateTime<Utc>,
pub updated_date: DateTime<Utc>, pub updated_date: DateTime<Utc>,
pub lastview_date: DateTime<Utc>, pub lastview_date: DateTime<Utc>,
pub deleted_date: Option<DateTime<Utc>>, pub deleted_date: Option<DateTime<Utc>>,
} }
#[derive(Clone, Serialize, Deserialize, Debug, FromRow)] #[derive(Clone, Serialize, Deserialize, Debug, FromRow)]
pub struct RawNote { pub struct RawNote {
pub id: i64, pub id: i64,
pub uuid: String, pub uuid: String,
pub parent_id: i64, pub parent_id: i64,
pub parent_uuid: String, pub parent_uuid: String,
pub content: String, pub content: String,
pub position: i64, pub position: i64,
pub notetype: String, pub notetype: String,
pub creation_date: DateTime<Utc>, pub creation_date: DateTime<Utc>,
pub updated_date: DateTime<Utc>, pub updated_date: DateTime<Utc>,
pub lastview_date: DateTime<Utc>, pub lastview_date: DateTime<Utc>,
pub deleted_date: Option<DateTime<Utc>>, pub deleted_date: Option<DateTime<Utc>>,
} }
#[derive(Clone, Serialize, Deserialize, Debug, Builder)] #[derive(Clone, Serialize, Deserialize, Debug, Builder)]
pub struct NewPage { pub struct NewPage {
pub slug: String, pub slug: String,
pub title: String, pub title: String,
pub note_id: i64, pub note_id: i64,
#[builder(default = r#"chrono::Utc::now()"#)] #[builder(default = r#"chrono::Utc::now()"#)]
pub creation_date: DateTime<Utc>, pub creation_date: DateTime<Utc>,
#[builder(default = r#"chrono::Utc::now()"#)] #[builder(default = r#"chrono::Utc::now()"#)]
pub updated_date: DateTime<Utc>, pub updated_date: DateTime<Utc>,
#[builder(default = r#"chrono::Utc::now()"#)] #[builder(default = r#"chrono::Utc::now()"#)]
pub lastview_date: DateTime<Utc>, pub lastview_date: DateTime<Utc>,
#[builder(default = r#"None"#)] #[builder(default = r#"None"#)]
pub deleted_date: Option<DateTime<Utc>>, pub deleted_date: Option<DateTime<Utc>>,
} }
#[derive(Clone, Serialize, Deserialize, Debug, Builder)] #[derive(Clone, Serialize, Deserialize, Debug, Builder)]
pub struct NewNote { pub struct NewNote {
pub uuid: String, pub uuid: String,
pub content: String, pub content: String,
#[builder(default = r#""note".to_string()"#)] #[builder(default = r#""note".to_string()"#)]
pub notetype: String, pub notetype: String,
#[builder(default = r#"chrono::Utc::now()"#)] #[builder(default = r#"chrono::Utc::now()"#)]
pub creation_date: DateTime<Utc>, pub creation_date: DateTime<Utc>,
#[builder(default = r#"chrono::Utc::now()"#)] #[builder(default = r#"chrono::Utc::now()"#)]
pub updated_date: DateTime<Utc>, pub updated_date: DateTime<Utc>,
#[builder(default = r#"chrono::Utc::now()"#)] #[builder(default = r#"chrono::Utc::now()"#)]
pub lastview_date: DateTime<Utc>, pub lastview_date: DateTime<Utc>,
#[builder(default = r#"None"#)] #[builder(default = r#"None"#)]
pub deleted_date: Option<DateTime<Utc>>, pub deleted_date: Option<DateTime<Utc>>,
} }
#[derive(Clone, Serialize, Deserialize, Debug, FromRow)] #[derive(Clone, Serialize, Deserialize, Debug, FromRow)]
pub(crate) struct JustSlugs { pub(crate) struct JustSlugs {
pub slug: String, pub slug: String,
} }
#[derive(Clone, Serialize, Deserialize, Debug, FromRow)] #[derive(Clone, Serialize, Deserialize, Debug, FromRow)]
pub struct JustTitles { pub(crate) struct JustTitles {
title: String, title: String,
}
#[derive(Clone, Serialize, Deserialize, Debug, FromRow)]
pub(crate) struct JustId {
pub id: i64,
} }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
#[test] #[test]
fn can_build_new_note() { fn can_build_new_note() {
let now = chrono::Utc::now(); let now = chrono::Utc::now();
let newnote = NewNoteBuilder::default() let newnote = NewNoteBuilder::default()
.uuid("foo".to_string()) .uuid("foo".to_string())
.content("bar".to_string()) .content("bar".to_string())
.build() .build()
.unwrap(); .unwrap();
assert!((newnote.creation_date - now).num_minutes() < 1); assert!((newnote.creation_date - now).num_minutes() < 1);
assert!((newnote.updated_date - now).num_minutes() < 1); assert!((newnote.updated_date - now).num_minutes() < 1);
assert!((newnote.lastview_date - now).num_minutes() < 1); assert!((newnote.lastview_date - now).num_minutes() < 1);
assert!(newnote.deleted_date.is_none()); assert!(newnote.deleted_date.is_none());
} }
} }

401
server/nm-store/src/store.rs
View File

@ -1,13 +1,15 @@
use crate::errors::NoteStoreError; use crate::errors::NoteStoreError;
use crate::row_structs::{JustSlugs, NewNote, NewNoteBuilder, NewPage, NewPageBuilder, RawNote, RawPage}; use crate::row_structs::{
JustId, JustSlugs, NewNote, NewNoteBuilder, NewPage, NewPageBuilder, RawNote, RawPage,
};
use friendly_id; use friendly_id;
use lazy_static::lazy_static; use lazy_static::lazy_static;
use regex::Regex; use regex::Regex;
use slug::slugify; use slug::slugify;
use sqlx; use sqlx;
use sqlx::{ use sqlx::{
sqlite::{Sqlite, SqlitePool}, sqlite::{Sqlite, SqlitePool},
Executor, Executor,
}; };
use std::sync::Arc; use std::sync::Arc;
@ -19,51 +21,56 @@ type NoteResult<T> = core::result::Result<T, NoteStoreError>;
type SqlResult<T> = sqlx::Result<T>; type SqlResult<T> = sqlx::Result<T>;
impl NoteStore { impl NoteStore {
pub async fn new(url: &str) -> NoteResult<Self> { pub async fn new(url: &str) -> NoteResult<Self> {
let pool = SqlitePool::connect(url).await?; let pool = SqlitePool::connect(url).await?;
Ok(NoteStore(Arc::new(pool))) Ok(NoteStore(Arc::new(pool)))
} }
// Erase all the data in the database and restore it // Erase all the data in the database and restore it
// to its original empty form. Do not use unless you // to its original empty form. Do not use unless you
// really, really want that to happen. // really, really want that to happen.
pub async fn reset_database(&self) -> NoteResult<()> { pub async fn reset_database(&self) -> NoteResult<()> {
reset_database(&*self.0).await.map_err(NoteStoreError::DBError) reset_database(&*self.0)
} .await
.map_err(NoteStoreError::DBError)
}
/// Fetch page by slug /// Fetch page by slug
/// ///
/// Supports the use case of the user navigating to a known place /// Supports the use case of the user navigating to a known place
/// via a bookmark or other URL. Since the title isn't clear from /// via a bookmark or other URL. Since the title isn't clear from
/// the slug, the slug is insufficient to generate a new page, so /// the slug, the slug is insufficient to generate a new page, so
/// this use case says that in the event of a failure to find the /// this use case says that in the event of a failure to find the
/// requested page, return a basic NotFound. /// requested page, return a basic NotFound.
pub async fn get_page_by_slug(&self, slug: &str) -> NoteResult<(RawPage, Vec<RawNote>)> { pub async fn get_page_by_slug(&self, slug: &str) -> NoteResult<(RawPage, Vec<RawNote>)> {
// let select_note_collection_for_root = include_str!("sql/select_note_collection_for_root.sql"); // let select_note_collection_for_root = include_str!("sql/select_note_collection_for_root.sql");
let mut tx = self.0.begin().await?; let mut tx = self.0.begin().await?;
let page = select_page_by_slug(&mut tx, slug).await?; let page = select_page_by_slug(&mut tx, slug).await?;
// let notes = sqlx::query_as(select_note_collection_for_root) // let notes = sqlx::query_as(select_note_collection_for_root)
// .bind(page.note_id) // .bind(page.note_id)
// .fetch(&tx) // .fetch(&tx)
// .await?; // .await?;
tx.commit().await?; tx.commit().await?;
Ok((page, vec![])) Ok((page, vec![]))
} }
/// Fetch page by title /// Fetch page by title
/// ///
/// Supports the use case of the user navigating to a page via /// Supports the use case of the user navigating to a page via
/// the page's formal title. Since the title is the key reference /// the page's formal title. Since the title is the key reference
/// of the system, if no page with that title is found, a page with /// of the system, if no page with that title is found, a page with
/// that title is generated automatically. /// that title is generated automatically.
pub async fn get_page_by_title(&self, title: &str) -> NoteResult<(RawPage, Vec<RawNote>)> { pub async fn get_page_by_title(&self, title: &str) -> NoteResult<(RawPage, Vec<RawNote>)> {
let mut tx = self.0.begin().await?; let mut tx = self.0.begin().await?;
let (page, notes) = match select_page_by_title(&mut tx, title).await { let (page, notes) = match select_page_by_title(&mut tx, title).await {
Ok(page) => { Ok(page) => {
let note_id = page.note_id; 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) => { Err(sqlx::Error::RowNotFound) => {
let page = { let page = {
let new_root_note = create_unique_root_note(); let new_root_note = create_unique_root_note();
let new_root_note_id = insert_one_new_note(&mut tx, &new_root_note).await?; let new_root_note_id = insert_one_new_note(&mut tx, &new_root_note).await?;
@ -73,14 +80,33 @@ impl NoteStore {
select_page_by_title(&mut tx, &title).await? select_page_by_title(&mut tx, &title).await?
}; };
let note_id = page.note_id; let note_id = page.note_id;
(page, select_note_collection_from_root(&mut tx, note_id).await?) (
}, page,
Err(e) => return Err(NoteStoreError::DBError(e)), select_note_collection_from_root(&mut tx, note_id).await?,
}; )
// Todo: Replace vec with the results of the CTE }
Err(e) => return Err(NoteStoreError::DBError(e)),
};
tx.commit().await?; tx.commit().await?;
return Ok((page, notes)); Ok((page, notes))
} }
pub async fn insert_nested_note(
&self,
note: NewNote,
parent_note_uuid: &str,
position: i32,
) -> NoteResult<String> {
let mut new_note = note.clone();
new_note.uuid = friendly_id::create();
let mut tx = self.0.begin().await?;
let parent_id = select_note_id_for_uuid(&mut tx, parent_note_uuid).await?;
let new_note_id = insert_one_new_note(&mut tx, &new_note).await?;
let _ = make_room_for_new_note(&mut tx, parent_id, position).await?;
let _ = insert_note_note_relationship(&mut tx, parent_id, new_note_id, position).await?;
tx.commit().await?;
Ok(new_note.uuid)
}
} }
// ___ _ _ // ___ _ _
@ -96,94 +122,152 @@ impl NoteStore {
async fn reset_database<'a, E>(executor: E) -> SqlResult<()> async fn reset_database<'a, E>(executor: E) -> SqlResult<()>
where where
E: Executor<'a, Database = Sqlite> E: Executor<'a, Database = Sqlite>,
{ {
let initialize_sql = include_str!("sql/initialize_database.sql"); let initialize_sql = include_str!("sql/initialize_database.sql");
sqlx::query(initialize_sql).execute(executor).await.map(|_| ()) sqlx::query(initialize_sql)
.execute(executor)
.await
.map(|_| ())
} }
async fn select_page_by_slug<'a, E>(executor: E, slug: &str) -> SqlResult<RawPage> async fn select_page_by_slug<'a, E>(executor: E, slug: &str) -> SqlResult<RawPage>
where where
E: Executor<'a, Database = Sqlite> E: Executor<'a, Database = Sqlite>,
{ {
let select_one_page_by_slug_sql = concat!( let select_one_page_by_slug_sql = concat!(
"SELECT id, title, slug, note_id, creation_date, updated_date, ", "SELECT id, title, slug, note_id, creation_date, updated_date, ",
"lastview_date, deleted_date FROM pages WHERE slug=?;" "lastview_date, deleted_date FROM pages WHERE slug=?;"
); );
Ok(sqlx::query_as(&select_one_page_by_slug_sql) Ok(sqlx::query_as(&select_one_page_by_slug_sql)
.bind(&slug) .bind(&slug)
.fetch_one(executor) .fetch_one(executor)
.await?) .await?)
} }
async fn select_page_by_title<'a, E>(executor: E, title: &str) -> SqlResult<RawPage> async fn select_page_by_title<'a, E>(executor: E, title: &str) -> SqlResult<RawPage>
where where
E: Executor<'a, Database = Sqlite>, E: Executor<'a, Database = Sqlite>,
{ {
let select_one_page_by_title_sql = concat!( let select_one_page_by_title_sql = concat!(
"SELECT id, title, slug, note_id, creation_date, updated_date, ", "SELECT id, title, slug, note_id, creation_date, updated_date, ",
"lastview_date, deleted_date FROM pages WHERE title=?;" "lastview_date, deleted_date FROM pages WHERE title=?;"
); );
Ok(sqlx::query_as(&select_one_page_by_title_sql) Ok(sqlx::query_as(&select_one_page_by_title_sql)
.bind(&title) .bind(&title)
.fetch_one(executor) .fetch_one(executor)
.await?) .await?)
}
async fn select_note_id_for_uuid<'a, E>(executor: E, uuid: &str) -> SqlResult<i64>
where
E: Executor<'a, Database = Sqlite>,
{
let select_note_id_for_uuid_sql = "SELECT id FROM notes WHERE uuid = ?";
let id: JustId = sqlx::query_as(&select_note_id_for_uuid_sql)
.bind(&uuid)
.fetch_one(executor)
.await?;
Ok(id.id)
}
async fn make_room_for_new_note<'a, E>(executor: E, parent_id: i64, position: i32) -> SqlResult<()>
where
E: Executor<'a, Database = Sqlite>,
{
let make_room_for_new_note_sql = concat!(
"UPDATE note_relationships ",
"SET position = position + 1 ",
"WHERE position >= ? and parent_id = ?;"
);
sqlx::query(make_room_for_new_note_sql)
.bind(&position)
.bind(&parent_id)
.execute(executor)
.await
.map(|_| ())
}
async fn insert_note_note_relationship<'a, E>(
executor: E,
parent_id: i64,
note_id: i64,
position: i32,
) -> SqlResult<()>
where
E: Executor<'a, Database = Sqlite>,
{
let insert_note_note_relationship_sql = concat!(
"INSERT INTO note_relationships (parent_id, note_id, position, nature) ",
"values (?, ?, ?, ?)"
);
sqlx::query(insert_note_note_relationship_sql)
.bind(&parent_id)
.bind(&note_id)
.bind(&position)
.bind("note")
.execute(executor)
.await
.map(|_| ())
} }
async fn select_note_collection_from_root<'a, E>(executor: E, root: i64) -> SqlResult<Vec<RawNote>> async fn select_note_collection_from_root<'a, E>(executor: E, root: i64) -> SqlResult<Vec<RawNote>>
where where
E: Executor<'a, Database = Sqlite>, E: Executor<'a, Database = Sqlite>,
{ {
let select_note_collection_from_root_sql = include_str!("sql/select_note_collection_from_root.sql"); let select_note_collection_from_root_sql =
Ok(sqlx::query_as(&select_note_collection_from_root_sql) include_str!("sql/select_note_collection_from_root.sql");
.bind(&root) Ok(sqlx::query_as(&select_note_collection_from_root_sql)
.fetch_all(executor) .bind(&root)
.await?) .fetch_all(executor)
.await?)
} }
async fn insert_one_new_note<'a, E>(executor: E, note: &NewNote) -> SqlResult<i64> async fn insert_one_new_note<'a, E>(executor: E, note: &NewNote) -> SqlResult<i64>
where where
E: Executor<'a, Database = Sqlite>, E: Executor<'a, Database = Sqlite>,
{ {
let insert_one_note_sql = concat!( let insert_one_note_sql = concat!(
"INSERT INTO notes ( ", "INSERT INTO notes ( ",
" uuid, ", " uuid, ",
" content, ", " content, ",
" notetype, ", " notetype, ",
" creation_date, ", " creation_date, ",
" updated_date, ", " updated_date, ",
" lastview_date) ", " lastview_date) ",
"VALUES (?, ?, ?, ?, ?, ?);" "VALUES (?, ?, ?, ?, ?, ?);"
); );
Ok(sqlx::query(insert_one_note_sql) Ok(sqlx::query(insert_one_note_sql)
.bind(&note.uuid) .bind(&note.uuid)
.bind(&note.content) .bind(&note.content)
.bind(&note.notetype) .bind(&note.notetype)
.bind(&note.creation_date) .bind(&note.creation_date)
.bind(&note.updated_date) .bind(&note.updated_date)
.bind(&note.lastview_date) .bind(&note.lastview_date)
.execute(executor) .execute(executor)
.await? .await?
.last_insert_rowid()) .last_insert_rowid())
} }
fn find_maximal_slug(slugs: &Vec<JustSlugs>) -> Option<u32> { fn find_maximal_slug(slugs: &Vec<JustSlugs>) -> Option<u32> {
lazy_static! { lazy_static! {
static ref RE_CAP_NUM: Regex = Regex::new(r"-(\d+)$").unwrap(); static ref RE_CAP_NUM: Regex = Regex::new(r"-(\d+)$").unwrap();
} }
if slugs.len() == 0 { if slugs.len() == 0 {
return None; return None;
} }
let mut slug_counters: Vec<u32> = slugs let mut slug_counters: Vec<u32> = slugs
.iter() .iter()
.filter_map(|slug| RE_CAP_NUM.captures(&slug.slug)) .filter_map(|slug| RE_CAP_NUM.captures(&slug.slug))
.map(|cap| cap.get(1).unwrap().as_str().parse::<u32>().unwrap()) .map(|cap| cap.get(1).unwrap().as_str().parse::<u32>().unwrap())
.collect(); .collect();
slug_counters.sort_unstable(); slug_counters.sort_unstable();
slug_counters.pop() slug_counters.pop()
} }
// Given an initial string and an existing collection of slugs, // Given an initial string and an existing collection of slugs,
@ -191,68 +275,67 @@ fn find_maximal_slug(slugs: &Vec<JustSlugs>) -> Option<u32> {
// collection. // collection.
async fn generate_slug<'a, E>(executor: E, title: &str) -> SqlResult<String> async fn generate_slug<'a, E>(executor: E, title: &str) -> SqlResult<String>
where where
E: Executor<'a, Database = Sqlite> E: Executor<'a, Database = Sqlite>,
{ {
lazy_static! { lazy_static! {
static ref RE_STRIP_NUM: Regex = Regex::new(r"-\d+$").unwrap(); static ref RE_STRIP_NUM: Regex = Regex::new(r"-\d+$").unwrap();
} }
let initial_slug = slugify(title); let initial_slug = slugify(title);
let sample_slug = RE_STRIP_NUM.replace_all(&initial_slug, ""); let sample_slug = RE_STRIP_NUM.replace_all(&initial_slug, "");
let slug_finder_sql = "SELECT slug FROM pages WHERE slug LIKE '?%';"; let slug_finder_sql = "SELECT slug FROM pages WHERE slug LIKE '?%';";
let similar_slugs: Vec<JustSlugs> = sqlx::query_as(&slug_finder_sql) let similar_slugs: Vec<JustSlugs> = sqlx::query_as(&slug_finder_sql)
.bind(&*sample_slug) .bind(&*sample_slug)
.fetch_all(executor) .fetch_all(executor)
.await?; .await?;
let maximal_slug = find_maximal_slug(&similar_slugs); let maximal_slug = find_maximal_slug(&similar_slugs);
match maximal_slug { match maximal_slug {
None => Ok(initial_slug), None => Ok(initial_slug),
Some(max_slug) => Ok(format!("{}-{}", initial_slug, max_slug + 1)), Some(max_slug) => Ok(format!("{}-{}", initial_slug, max_slug + 1)),
} }
} }
async fn insert_one_new_page<'a, E>(executor: E, page: &NewPage) -> SqlResult<i64> async fn insert_one_new_page<'a, E>(executor: E, page: &NewPage) -> SqlResult<i64>
where where
E: Executor<'a, Database = Sqlite>, E: Executor<'a, Database = Sqlite>,
{ {
let insert_one_page_sql = concat!( let insert_one_page_sql = concat!(
"INSERT INTO pages ( ", "INSERT INTO pages ( ",
" slug, ", " slug, ",
" title, ", " title, ",
" note_id, ", " note_id, ",
" creation_date, ", " creation_date, ",
" updated_date, ", " updated_date, ",
" lastview_date) ", " lastview_date) ",
"VALUES (?, ?, ?, ?, ?, ?);" "VALUES (?, ?, ?, ?, ?, ?);"
); );
Ok(sqlx::query(insert_one_page_sql) Ok(sqlx::query(insert_one_page_sql)
.bind(&page.slug) .bind(&page.slug)
.bind(&page.title) .bind(&page.title)
.bind(&page.note_id) .bind(&page.note_id)
.bind(&page.creation_date) .bind(&page.creation_date)
.bind(&page.updated_date) .bind(&page.updated_date)
.bind(&page.lastview_date) .bind(&page.lastview_date)
.execute(executor) .execute(executor)
.await? .await?
.last_insert_rowid()) .last_insert_rowid())
} }
fn create_unique_root_note() -> NewNote { fn create_unique_root_note() -> NewNote {
NewNoteBuilder::default() NewNoteBuilder::default()
.uuid(friendly_id::create()) .uuid(friendly_id::create())
.content("".to_string()) .content("".to_string())
.notetype("root".to_string()) .notetype("root".to_string())
.build() .build()
.unwrap() .unwrap()
} }
fn create_new_page_for(title: &str, slug: &str, note_id: i64) -> NewPage { fn create_new_page_for(title: &str, slug: &str, note_id: i64) -> NewPage {
NewPageBuilder::default() NewPageBuilder::default()
.slug(slug.to_string()) .slug(slug.to_string())
.title(title.to_string()) .title(title.to_string())
.note_id(note_id) .note_id(note_id)
.build() .build()
.unwrap() .unwrap()
} }