notesmachine/server/nm-store/src/store.rs

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

//! # Storage layer for Notesmachine
//!
//! This library implements the core functionality of Notesmachine and
//! describes that functionality to a storage layer.  There's a bit of
//! intermingling in here which can't be helped, although it may make
//! sense in the future to separate the decomposition of the note
//! content into a higher layer.
//!
//! Notesmachine storage notes consist of two items: Zettle and Kasten.
//! This distinction is somewhat arbitrary, as structurally these two
//! items are stored in the same table.
//!
//! - Boxes have titles (and date metadata)
//! - Notes have content and a type (and date metadata)
//! - Notes are stored in boxes
//!   - Notes are positioned with respect to other notes.
//!   - There are two positions:
//!     - Siblings, creating lists
//!     - Children, creating trees like this one
//! - Notes may have references (pointers) to other boxes
//! - Notes may be moved around
//! - Notes may be deleted
//! - Boxes may be deleted
//! - When a box is renamed, every reference to that box is auto-edited to
//!   reflect the change. If a box is renamed to match an existing box, the
//!   notes in both boxes are merged.
//!   
//! Note-to-note relationships form trees, and are kept in a SQL database of
//! (`parent_id`, `child_id`, `position`, `relationship_type`). The
//! `position` is a monotonic index on the parent (that is, every pair
//! (`parent_id`, `position`) must be unique).  The `relationship_type` is
//! an enum and can specify that the relationship is *original*,
//! *embedding*, or *referencing*.  An embedded or referenced note may be
//! read/write or read-only with respect to the original, but there is only
//! one original note at any time.
//!
//! Note-to-box relationships form a graph, and are kept in the SQL database
//! as a collection of *edges* from the note to the box (and naturally
//! vice-versa).
//!
//! - Decision: When an original note is deleted, do all references and
//!   embeddings also get deleted, or is the oldest one elevated to be a new
//!   "original"?  Or is that something the user may choose?
//!
//! - Decision: Should the merging issue be handled at this layer, or would
//!   it make sense to move this to a higher layer, and only provide the
//!   hooks for it here?
//!

use crate::errors::NoteStoreError;
use crate::store_private::*;
use crate::structs::*;
use sqlx::sqlite::SqlitePool;
use std::cmp;
use std::collections::HashMap;
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>;

// After wrestling for a while with the fact that 'box' is a reserved
// word in Rust, I decided to just go with Zettle (note) and Kasten
// (box).
	
impl NoteStore {
	/// Initializes a new instance of the note store.  Note that the
	/// note store holds an Arc internally; this code is (I think)
	/// safe to Send.
	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_kasten_by_slug(&self, slug: &str) -> NoteResult<Vec<RawZettle>> {
		Ok(select_kasten_by_slug(&*self.0, slug).await?)
	}

    pub async fn get_kasten_by_title(&self, title: &str) -> NoteResult<Vec<RawZettle>> {
        let kasten = select_page_by_title(&mut tx, title).await?;
		if kasten.len() > 0 {
			return kasten
		}

        let mut tx = self.0.begin().await?;
		let new slug = generate_slug(&mut tx, title).await?;
		let new zettlekasten = create_unique_zettlekasten(&title, &slug);
		let _ = insert_zettle(&zettlekasten).await?;
		tx.commit().await?;

		Ok(vec![zettlekasten])
	}

	pub async fn insert_zettle(
		&self,
		note: &NewNote,
		parent_note_id: &str,
		location: i64
	) -> NoteResult<String> {
		let note = {
			let mut new_note = note.clone();
			new_note.id = friendly_id::create();
			new_note
		};
		
		let references = build_references(&note.content);

		let mut tx = self.0.begin().await?;
		let location = cmp::min(
			assert_max_child_position_for_note(&mut tx, parent_note_id).await? + 1,
			location);

		insert_one_new_note(&mut tx, &note).await?;
		make_room_for_new_note(&mut tx, parent_id, location).await?;
		insert_note_to_note_relationship(&mut tx, parent_id, note.id, location, "note");

		let found_references = find_all_page_references_for(&mut tx, &references).await?;
        let mut known_reference_ids: Vec<PageId> = Vec::new();
        for one_reference in new_references.iter() {
			let new slug = generate_slug(&mut tx, one_reference).await?;
			let new zettlekasten = create_unique_zettlekasten(&one_reference, &slug);
			let _ = insert_zettle(&zettlekasten).await?;
			known_reference_ids.push(slug);
		}

        known_reference_ids.append(&mut found_references.iter().map(|r| PageId(r.id)).collect());
        let _ = insert_note_to_page_relationships(&mut tx, new_note_id, &known_reference_ids).await?;
		tx.commit().await?;
		Ok(note.id);
	}
	
}