259 lines
8.2 KiB
Rust
259 lines
8.2 KiB
Rust
use crate::errors::NoteStoreError;
|
|
use crate::row_structs::{JustSlugs, NewNote, NewNoteBuilder, NewPage, NewPageBuilder, RawNote, RawPage};
|
|
use friendly_id;
|
|
use lazy_static::lazy_static;
|
|
use regex::Regex;
|
|
use slug::slugify;
|
|
use sqlx;
|
|
use sqlx::{
|
|
sqlite::{Sqlite, SqlitePool},
|
|
Executor,
|
|
};
|
|
use std::sync::Arc;
|
|
|
|
/// A handle to our Sqlite database.
|
|
#[derive(Clone, Debug)]
|
|
pub struct NoteStore(Arc<SqlitePool>);
|
|
|
|
type NoteResult<T> = core::result::Result<T, NoteStoreError>;
|
|
type SqlResult<T> = sqlx::Result<T>;
|
|
|
|
impl NoteStore {
|
|
pub async fn new(url: &str) -> NoteResult<Self> {
|
|
let pool = SqlitePool::connect(url).await?;
|
|
Ok(NoteStore(Arc::new(pool)))
|
|
}
|
|
|
|
// Erase all the data in the database and restore it
|
|
// 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).await.map_err(NoteStoreError::DBError)
|
|
}
|
|
|
|
/// Fetch page by slug
|
|
///
|
|
/// 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
|
|
/// 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
|
|
/// requested page, return a basic NotFound.
|
|
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 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)
|
|
// .bind(page.note_id)
|
|
// .fetch(&tx)
|
|
// .await?;
|
|
tx.commit().await?;
|
|
Ok((page, vec![]))
|
|
}
|
|
|
|
/// Fetch page by title
|
|
///
|
|
/// Supports the use case of the user navigating to a page via
|
|
/// 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
|
|
/// that title is generated automatically.
|
|
pub async fn get_page_by_title(&self, title: &str) -> NoteResult<(RawPage, Vec<RawNote>)> {
|
|
let mut tx = self.0.begin().await?;
|
|
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?)
|
|
}
|
|
Err(sqlx::Error::RowNotFound) => {
|
|
let page = {
|
|
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_page_slug = generate_slug(&mut tx, title).await?;
|
|
let new_page = create_new_page_for(&title, &new_page_slug, new_root_note_id);
|
|
let _ = insert_one_new_page(&mut tx, &new_page).await?;
|
|
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?)
|
|
},
|
|
Err(e) => return Err(NoteStoreError::DBError(e)),
|
|
};
|
|
// Todo: Replace vec with the results of the CTE
|
|
tx.commit().await?;
|
|
return Ok((page, notes));
|
|
}
|
|
}
|
|
|
|
// ___ _ _
|
|
// | _ \_ _(_)_ ____ _| |_ ___
|
|
// | _/ '_| \ V / _` | _/ -_)
|
|
// |_| |_| |_|\_/\__,_|\__\___|
|
|
//
|
|
|
|
// I'm putting a lot of faith in Rust's ability to inline stuff. I'm
|
|
// sure this is okay. But really, this lets the API be clean and
|
|
// coherent and easily readable, and hides away the gnarliness of some
|
|
// of the SQL queries.
|
|
|
|
async fn reset_database<'a, E>(executor: E) -> SqlResult<()>
|
|
where
|
|
E: Executor<'a, Database = Sqlite>
|
|
{
|
|
let initialize_sql = include_str!("sql/initialize_database.sql");
|
|
sqlx::query(initialize_sql).execute(executor).await.map(|_| ())
|
|
}
|
|
|
|
async fn select_page_by_slug<'a, E>(executor: E, slug: &str) -> SqlResult<RawPage>
|
|
where
|
|
E: Executor<'a, Database = Sqlite>
|
|
{
|
|
let select_one_page_by_slug_sql = concat!(
|
|
"SELECT id, title, slug, note_id, creation_date, updated_date, ",
|
|
"lastview_date, deleted_date FROM pages WHERE slug=?;"
|
|
);
|
|
Ok(sqlx::query_as(&select_one_page_by_slug_sql)
|
|
.bind(&slug)
|
|
.fetch_one(executor)
|
|
.await?)
|
|
}
|
|
|
|
async fn select_page_by_title<'a, E>(executor: E, title: &str) -> SqlResult<RawPage>
|
|
where
|
|
E: Executor<'a, Database = Sqlite>,
|
|
{
|
|
let select_one_page_by_title_sql = concat!(
|
|
"SELECT id, title, slug, note_id, creation_date, updated_date, ",
|
|
"lastview_date, deleted_date FROM pages WHERE title=?;"
|
|
);
|
|
Ok(sqlx::query_as(&select_one_page_by_title_sql)
|
|
.bind(&title)
|
|
.fetch_one(executor)
|
|
.await?)
|
|
}
|
|
|
|
async fn select_note_collection_from_root<'a, E>(executor: E, root: i64) -> SqlResult<Vec<RawNote>>
|
|
where
|
|
E: Executor<'a, Database = Sqlite>,
|
|
{
|
|
let 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)
|
|
.await?)
|
|
}
|
|
|
|
async fn insert_one_new_note<'a, E>(executor: E, note: &NewNote) -> SqlResult<i64>
|
|
where
|
|
E: Executor<'a, Database = Sqlite>,
|
|
{
|
|
let insert_one_note_sql = concat!(
|
|
"INSERT INTO notes ( ",
|
|
" uuid, ",
|
|
" content, ",
|
|
" notetype, ",
|
|
" creation_date, ",
|
|
" updated_date, ",
|
|
" lastview_date) ",
|
|
"VALUES (?, ?, ?, ?, ?, ?);"
|
|
);
|
|
|
|
Ok(sqlx::query(insert_one_note_sql)
|
|
.bind(¬e.uuid)
|
|
.bind(¬e.content)
|
|
.bind(¬e.notetype)
|
|
.bind(¬e.creation_date)
|
|
.bind(¬e.updated_date)
|
|
.bind(¬e.lastview_date)
|
|
.execute(executor)
|
|
.await?
|
|
.last_insert_rowid())
|
|
}
|
|
|
|
fn find_maximal_slug(slugs: &Vec<JustSlugs>) -> Option<u32> {
|
|
lazy_static! {
|
|
static ref RE_CAP_NUM: Regex = Regex::new(r"-(\d+)$").unwrap();
|
|
}
|
|
|
|
if slugs.len() == 0 {
|
|
return None;
|
|
}
|
|
|
|
let mut slug_counters: Vec<u32> = slugs
|
|
.iter()
|
|
.filter_map(|slug| RE_CAP_NUM.captures(&slug.slug))
|
|
.map(|cap| cap.get(1).unwrap().as_str().parse::<u32>().unwrap())
|
|
.collect();
|
|
slug_counters.sort_unstable();
|
|
slug_counters.pop()
|
|
}
|
|
|
|
// Given an initial string and an existing collection of slugs,
|
|
// generate a new slug that does not conflict with the current
|
|
// collection.
|
|
async fn generate_slug<'a, E>(executor: E, title: &str) -> SqlResult<String>
|
|
where
|
|
E: Executor<'a, Database = Sqlite>
|
|
{
|
|
lazy_static! {
|
|
static ref RE_STRIP_NUM: Regex = Regex::new(r"-\d+$").unwrap();
|
|
}
|
|
|
|
let initial_slug = slugify(title);
|
|
let sample_slug = RE_STRIP_NUM.replace_all(&initial_slug, "");
|
|
let slug_finder_sql = "SELECT slug FROM pages WHERE slug LIKE '?%';";
|
|
let similar_slugs: Vec<JustSlugs> = sqlx::query_as(&slug_finder_sql)
|
|
.bind(&*sample_slug)
|
|
.fetch_all(executor)
|
|
.await?;
|
|
let maximal_slug = find_maximal_slug(&similar_slugs);
|
|
match maximal_slug {
|
|
None => Ok(initial_slug),
|
|
Some(max_slug) => Ok(format!("{}-{}", initial_slug, max_slug + 1)),
|
|
}
|
|
}
|
|
|
|
async fn insert_one_new_page<'a, E>(executor: E, page: &NewPage) -> SqlResult<i64>
|
|
where
|
|
E: Executor<'a, Database = Sqlite>,
|
|
{
|
|
let insert_one_page_sql = concat!(
|
|
"INSERT INTO pages ( ",
|
|
" slug, ",
|
|
" title, ",
|
|
" note_id, ",
|
|
" creation_date, ",
|
|
" updated_date, ",
|
|
" lastview_date) ",
|
|
"VALUES (?, ?, ?, ?, ?, ?);"
|
|
);
|
|
|
|
Ok(sqlx::query(insert_one_page_sql)
|
|
.bind(&page.slug)
|
|
.bind(&page.title)
|
|
.bind(&page.note_id)
|
|
.bind(&page.creation_date)
|
|
.bind(&page.updated_date)
|
|
.bind(&page.lastview_date)
|
|
.execute(executor)
|
|
.await?
|
|
.last_insert_rowid())
|
|
}
|
|
|
|
fn create_unique_root_note() -> NewNote {
|
|
NewNoteBuilder::default()
|
|
.uuid(friendly_id::create())
|
|
.content("".to_string())
|
|
.notetype("root".to_string())
|
|
.build()
|
|
.unwrap()
|
|
}
|
|
|
|
fn create_new_page_for(title: &str, slug: &str, note_id: i64) -> NewPage {
|
|
NewPageBuilder::default()
|
|
.slug(slug.to_string())
|
|
.title(title.to_string())
|
|
.note_id(note_id)
|
|
.build()
|
|
.unwrap()
|
|
}
|
|
|