From 8a83d802d3752bc482144afa36d32d86cef03f13 Mon Sep 17 00:00:00 2001 From: "Elf M. Sternberg" Date: Thu, 12 Nov 2020 08:48:57 -0800 Subject: [PATCH] REFACTOR Kasten -> Page I don't speak German, and I kept getting confused about which was which. Let's just call it what it is, and worry about presentation later. --- server/nm-store/src/lib.rs | 14 +-- server/nm-store/src/store/private.rs | 102 +++++++++--------- .../src/store/sql/initialize_database.sql | 28 ++--- ... => select_notes_backreferencing_page.sql} | 4 +- server/nm-store/src/store/store.rs | 42 ++++---- server/nm-store/src/structs.rs | 34 +++--- 6 files changed, 112 insertions(+), 112 deletions(-) rename server/nm-store/src/store/sql/{select_notes_backreferencing_kasten.sql => select_notes_backreferencing_page.sql} (93%) diff --git a/server/nm-store/src/lib.rs b/server/nm-store/src/lib.rs index e1e125b..4b0ec21 100644 --- a/server/nm-store/src/lib.rs +++ b/server/nm-store/src/lib.rs @@ -5,7 +5,7 @@ mod structs; pub use crate::errors::NoteStoreError; pub use crate::store::NoteStore; -pub use crate::structs::{Note, NoteKind, NoteRelationship, KastenRelationship}; +pub use crate::structs::{Note, NoteKind, NoteRelationship, PageRelationship}; #[cfg(test)] @@ -29,8 +29,8 @@ mod tests { #[tokio::test(threaded_scheduler)] async fn fetching_unfound_page_by_slug_works() { let storagepool = fresh_inmemory_database().await; - let foundkasten = storagepool.get_kasten_by_slug("nonexistent-kasten").await; - assert!(foundkasten.is_err()); + let foundpage = storagepool.get_page_by_slug("nonexistent-page").await; + assert!(foundpage.is_err()); } // Request for the page by title. If the page exists, return it. @@ -42,7 +42,7 @@ mod tests { let title = "Nonexistent Page"; let now = chrono::Utc::now(); let storagepool = fresh_inmemory_database().await; - let newpageresult = storagepool.get_kasten_by_title(&title).await; + let newpageresult = storagepool.get_page_by_title(&title).await; assert!(newpageresult.is_ok(), "{:?}", newpageresult); let (newpages, _) = newpageresult.unwrap(); @@ -52,7 +52,7 @@ mod tests { assert_eq!(newpage.content, title, "{:?}", newpage.content); assert_eq!(newpage.id, "nonexistent-page"); - assert_eq!(newpage.kind, NoteKind::Kasten); + assert_eq!(newpage.kind, NoteKind::Page); assert!((newpage.creation_date - now).num_minutes() < 1); assert!((newpage.updated_date - now).num_minutes() < 1); assert!((newpage.lastview_date - now).num_minutes() < 1); @@ -70,7 +70,7 @@ mod tests { async fn can_nest_notes() { let title = "Nonexistent Page"; let storagepool = fresh_inmemory_database().await; - let newpageresult = storagepool.get_kasten_by_title(&title).await; + let newpageresult = storagepool.get_page_by_title(&title).await; assert!(newpageresult.is_ok(), "{:?}", newpageresult); let (newpages, _) = newpageresult.unwrap(); @@ -100,7 +100,7 @@ mod tests { assert!(note4_id.is_ok(), "{:?}", note4_id); let _note4_id = note4_id.unwrap(); - let newpageresult = storagepool.get_kasten_by_title(&title).await; + let newpageresult = storagepool.get_page_by_title(&title).await; assert!(newpageresult.is_ok(), "{:?}", newpageresult); let (newpages, _) = newpageresult.unwrap(); diff --git a/server/nm-store/src/store/private.rs b/server/nm-store/src/store/private.rs index e5aa345..18ae54d 100644 --- a/server/nm-store/src/store/private.rs +++ b/server/nm-store/src/store/private.rs @@ -20,7 +20,7 @@ type SqlResult = sqlx::Result; // of the SQL queries. lazy_static! { - static ref SELECT_KASTEN_BY_TITLE_SQL: String = str::replace( + static ref SELECT_PAGE_BY_TITLE_SQL: String = str::replace( include_str!("sql/select_notes_by_parameter.sql"), "QUERYPARAMETER", "notes.content" @@ -28,7 +28,7 @@ lazy_static! { } lazy_static! { - static ref SELECT_KASTEN_BY_ID_SQL: String = str::replace( + static ref SELECT_PAGE_BY_ID_SQL: String = str::replace( include_str!("sql/select_notes_by_parameter.sql"), "QUERYPARAMETER", "notes.id" @@ -36,8 +36,8 @@ lazy_static! { } lazy_static! { - static ref SELECT_NOTES_BACKREFENCING_KASTEN_SQL: &'static str = - include_str!("sql/select_notes_backreferencing_kasten.sql"); + static ref SELECT_NOTES_BACKREFENCING_PAGE_SQL: &'static str = + include_str!("sql/select_notes_backreferencing_page.sql"); } // ___ _ @@ -63,53 +63,53 @@ where // |_|\___|\__\__|_||_| |_|\_\__,_/__/\__\___|_||_| // -// Select the requested kasten via its id. This is fairly rare; -// kastens should usually be picked up via their title, but if you're -// navigating to an instance, this is how you specify the kasten in a +// Select the requested page via its id. This is fairly rare; +// pages should usually be picked up via their title, but if you're +// navigating to an instance, this is how you specify the page in a // URL. The return value is an array of Note objects; it is the // responsibility of client code to restructure these into a tree-like // object. // // Recommended: Clients should update the URL whenever changing -// kasten. -pub(crate) async fn select_kasten_by_slug<'a, E>(executor: E, slug: &NoteId) -> SqlResult> +// page. +pub(crate) async fn select_page_by_slug<'a, E>(executor: E, slug: &NoteId) -> SqlResult> where E: Executor<'a, Database = Sqlite>, { - let r: Vec = sqlx::query_as(&SELECT_KASTEN_BY_ID_SQL) + let r: Vec = sqlx::query_as(&SELECT_PAGE_BY_ID_SQL) .bind(&**slug) .fetch_all(executor) .await?; Ok(r.into_iter().map(|z| Note::from(z)).collect()) } -// Fetch the kasten by title. The return value is an array of Note +// Fetch the page by title. The return value is an array of Note // objects; it is the responsibility of client code to restructure // these into a tree-like object. -pub(crate) async fn select_kasten_by_title<'a, E>(executor: E, title: &str) -> SqlResult> +pub(crate) async fn select_page_by_title<'a, E>(executor: E, title: &str) -> SqlResult> where E: Executor<'a, Database = Sqlite>, { - let r: Vec = sqlx::query_as(&SELECT_KASTEN_BY_TITLE_SQL) + let r: Vec = sqlx::query_as(&SELECT_PAGE_BY_TITLE_SQL) .bind(&title) .fetch_all(executor) .await?; Ok(r.into_iter().map(|z| Note::from(z)).collect()) } -// Fetch all backreferences to a kasten. The return value is an array -// of arrays, and inside each array is a list from a root kasten to -// the note that references the give kasten. Clients may choose how +// Fetch all backreferences to a page. The return value is an array +// of arrays, and inside each array is a list from a root page to +// the note that references the give page. Clients may choose how // they want to display that collection. -pub(crate) async fn select_backreferences_for_kasten<'a, E>( +pub(crate) async fn select_backreferences_for_page<'a, E>( executor: E, - kasten_id: &NoteId, + page_id: &NoteId, ) -> SqlResult> where E: Executor<'a, Database = Sqlite>, { - let r: Vec = sqlx::query_as(&SELECT_NOTES_BACKREFENCING_KASTEN_SQL) - .bind(&**kasten_id) + let r: Vec = sqlx::query_as(&SELECT_NOTES_BACKREFENCING_PAGE_SQL) + .bind(&**page_id) .fetch_all(executor) .await?; Ok(r.into_iter().map(|z| Note::from(z)).collect()) @@ -122,7 +122,7 @@ where // // Inserts a single note into the notes table. That is all. -pub(crate) async fn insert_note<'a, E>(executor: E, zettle: &NewNote) -> SqlResult +pub(crate) async fn insert_note<'a, E>(executor: E, note: &NewNote) -> SqlResult where E: Executor<'a, Database = Sqlite>, { @@ -133,15 +133,15 @@ where ); let _ = sqlx::query(insert_one_note_sql) - .bind(&zettle.id) - .bind(&zettle.content) - .bind(zettle.kind.to_string()) - .bind(&zettle.creation_date) - .bind(&zettle.updated_date) - .bind(&zettle.lastview_date) + .bind(¬e.id) + .bind(¬e.content) + .bind(note.kind.to_string()) + .bind(¬e.creation_date) + .bind(¬e.updated_date) + .bind(¬e.lastview_date) .execute(executor) .await?; - Ok(zettle.id.clone()) + Ok(note.id.clone()) } // Inserts a single note into the notes table. That is all. @@ -211,7 +211,7 @@ where static ref RE_STRIP_NUM: Regex = Regex::new(r"-\d+$").unwrap(); static ref SLUG_FINDER_SQL: String = format!( "SELECT id FROM notes WHERE kind = '{}' AND id LIKE '?%';", - NoteKind::Kasten.to_string() + NoteKind::Page.to_string() ); } @@ -228,13 +228,13 @@ where }) } -// A helper function: given a title and a slug, create a KastenType +// A helper function: given a title and a slug, create a PageType // note. -pub(crate) fn create_zettlekasten(title: &str, slug: &str) -> NewNote { +pub(crate) fn create_page(title: &str, slug: &str) -> NewNote { NewNoteBuilder::default() .id(slug.to_string()) .content(title.to_string()) - .kind(NoteKind::Kasten) + .kind(NoteKind::Page) .build() .unwrap() } @@ -387,7 +387,7 @@ where // |_|\_\___/\__\___| \__\___/ |_|\_\__,_/__/\__\___|_||_| |_|_\___|_\__,_|\__|_\___/_||_/__/_||_|_| .__/__/ // |_| -pub(crate) async fn insert_bulk_note_to_kasten_relationships<'a, E>( +pub(crate) async fn insert_bulk_note_to_page_relationships<'a, E>( executor: E, note_id: &NoteId, references: &[NoteId], @@ -399,9 +399,9 @@ where return Ok(()); } - let insert_pattern = format!("(?, ?, '{}')", KastenRelationshipKind::Kasten.to_string()); + let insert_pattern = format!("(?, ?, '{}')", PageRelationshipKind::Page.to_string()); let insert_note_page_references_sql = - "INSERT INTO note_kasten_relationships (note_id, kasten_id, kind) VALUES ".to_string() + "INSERT INTO note_page_relationships (note_id, page_id, kind) VALUES ".to_string() + &[insert_pattern.as_str()] .repeat(references.len()) .join(", ") + &";".to_string(); @@ -414,16 +414,16 @@ where request.execute(executor).await.map(|_| ()) } -pub(crate) async fn delete_bulk_note_to_kasten_relationships<'a, E>( +pub(crate) async fn delete_bulk_note_to_page_relationships<'a, E>( executor: E, note_id: &NoteId, ) -> SqlResult<()> where E: Executor<'a, Database = Sqlite>, { - let delete_note_to_kasten_relationship_sql = - "DELETE FROM note_kasten_relationships WHERE and note_id = ?;"; - let _ = sqlx::query(delete_note_to_kasten_relationship_sql) + let delete_note_to_page_relationship_sql = + "DELETE FROM note_page_relationships WHERE and note_id = ?;"; + let _ = sqlx::query(delete_note_to_page_relationship_sql) .bind(&**note_id) .execute(executor) .await?; @@ -450,7 +450,7 @@ pub(crate) fn diff_references( // Returns all the (Id, title) pairs found in the database out of a // list of titles. Used by insert_note and update_note_content to // find the ids of all the references in a given document. -pub(crate) async fn find_all_kasten_from_list_of_references<'a, E>( +pub(crate) async fn find_all_page_from_list_of_references<'a, E>( executor: E, references: &[String], ) -> SqlResult> @@ -464,7 +464,7 @@ where lazy_static! { static ref SELECT_ALL_REFERENCES_FOR_SQL_BASE: String = format!( "SELECT id, content FROM notes WHERE kind = '{}' AND content IN (", - NoteKind::Kasten.to_string() + NoteKind::Page.to_string() ); } @@ -511,7 +511,7 @@ where } } -pub(crate) async fn delete_note_to_kasten_relationships<'a, E>( +pub(crate) async fn delete_note_to_page_relationships<'a, E>( executor: E, note_id: &NoteId, ) -> SqlResult<()> @@ -519,14 +519,14 @@ where E: Executor<'a, Database = Sqlite>, { lazy_static! { - static ref DELETE_NOTE_TO_KASTEN_RELATIONSHIPS_SQL: String = format!( + static ref DELETE_NOTE_TO_PAGE_RELATIONSHIPS_SQL: String = format!( "DELETE FROM note_relationships WHERE kind in ('{}', '{}') AND parent_id = ?;", - KastenRelationshipKind::Kasten.to_string(), - KastenRelationshipKind::Unacked.to_string() + PageRelationshipKind::Page.to_string(), + PageRelationshipKind::Unacked.to_string() ); } - let _ = sqlx::query(&DELETE_NOTE_TO_KASTEN_RELATIONSHIPS_SQL) + let _ = sqlx::query(&DELETE_NOTE_TO_PAGE_RELATIONSHIPS_SQL) .bind(&**note_id) .execute(executor) .await?; @@ -588,17 +588,17 @@ pub(crate) async fn validate_or_generate_all_found_references( let mut tx = txi.begin().await?; let found_references = - find_all_kasten_from_list_of_references(&mut tx, &references).await?; + find_all_page_from_list_of_references(&mut tx, &references).await?; let new_references = diff_references(&references, &found_references); - let mut new_zettlekasten: Vec = vec![]; + let mut new_page: Vec = vec![]; for one_reference in new_references.iter() { let slug = generate_slug(&mut tx, one_reference).await?; - new_zettlekasten.push(create_zettlekasten(&one_reference, &slug)); + new_page.push(create_page(&one_reference, &slug)); } - let _ = bulk_insert_notes(&mut tx, &new_zettlekasten).await?; + let _ = bulk_insert_notes(&mut tx, &new_page).await?; let mut all_reference_ids: Vec = found_references.iter().map(|r| NoteId(r.id.clone())).collect(); - all_reference_ids.append(&mut new_zettlekasten.iter().map(|r| NoteId(r.id.clone())).collect()); + all_reference_ids.append(&mut new_page.iter().map(|r| NoteId(r.id.clone())).collect()); tx.commit().await?; Ok(all_reference_ids) } diff --git a/server/nm-store/src/store/sql/initialize_database.sql b/server/nm-store/src/store/sql/initialize_database.sql index 66ee2c2..aa0a3b5 100644 --- a/server/nm-store/src/store/sql/initialize_database.sql +++ b/server/nm-store/src/store/sql/initialize_database.sql @@ -1,6 +1,6 @@ DROP TABLE IF EXISTS notes; DROP TABLE IF EXISTS note_relationships; -DROP TABLE IF EXISTS note_kasten_relationships; +DROP TABLE IF EXISTS note_page_relationships; DROP TABLE IF EXISTS favorites; CREATE TABLE notes ( @@ -21,9 +21,9 @@ CREATE TABLE favorites ( FOREIGN KEY (id) REFERENCES notes (id) ON DELETE CASCADE ); --- This table represents the forest of data relating a kasten to its +-- This table represents the forest of data relating a page to its -- collections of notes. The root is itself "a note," but the content --- of that note will always be just the title of the kasten. +-- of that note will always be just the title of the page. -- CREATE TABLE note_relationships ( note_id TEXT NOT NULL, @@ -37,22 +37,22 @@ CREATE TABLE note_relationships ( CHECK (note_id <> parent_id) ); --- This table represents the graph of data relating notes to kastens. +-- This table represents the graph of data relating notes to pages. -- -CREATE TABLE note_kasten_relationships ( +CREATE TABLE note_page_relationships ( note_id TEXT NOT NULL, - kasten_id TEXT NOT NULL, + page_id TEXT NOT NULL, kind TEXT NOT NULL, -- If either note disappears, we want all the edges to disappear as well. FOREIGN KEY (note_id) REFERENCES notes (id) ON DELETE CASCADE, - FOREIGN KEY (kasten_id) REFERENCES notes (id) ON DELETE CASCADE, - UNIQUE (note_id, kasten_id), - CHECK (note_id <> kasten_id) + FOREIGN KEY (page_id) REFERENCES notes (id) ON DELETE CASCADE, + UNIQUE (note_id, page_id), + CHECK (note_id <> page_id) ); -- A fabulous constraint. This index prevents us from saying that --- if a note points to a kasten, the kasten may not point to a --- note. Now, it's absolutely required that a kasten_id point to --- a KastenType note; the content should be a title only. -CREATE UNIQUE INDEX note_kasten_unique_idx - ON note_kasten_relationships (MIN(note_id, kasten_id), MAX(note_id, kasten_id)); +-- if a note points to a page, the page may not point to a +-- note. Now, it's absolutely required that a page_id point to +-- a PageType note; the content should be a title only. +CREATE UNIQUE INDEX note_page_unique_idx + ON note_page_relationships (MIN(note_id, page_id), MAX(note_id, page_id)); diff --git a/server/nm-store/src/store/sql/select_notes_backreferencing_kasten.sql b/server/nm-store/src/store/sql/select_notes_backreferencing_page.sql similarity index 93% rename from server/nm-store/src/store/sql/select_notes_backreferencing_kasten.sql rename to server/nm-store/src/store/sql/select_notes_backreferencing_page.sql index 32b1962..1d630de 100644 --- a/server/nm-store/src/store/sql/select_notes_backreferencing_kasten.sql +++ b/server/nm-store/src/store/sql/select_notes_backreferencing_page.sql @@ -45,8 +45,8 @@ FROM ( ON note_parents.id = note_relationships.parent_id WHERE notes.id IN (SELECT note_id - FROM note_kasten_relationships - WHERE kasten_id = ?) -- IMPORTANT: THIS IS THE PARAMETER + FROM note_page_relationships + WHERE page_id = ?) -- IMPORTANT: THIS IS THE PARAMETER UNION SELECT DISTINCT diff --git a/server/nm-store/src/store/store.rs b/server/nm-store/src/store/store.rs index c9cd8ea..3232096 100644 --- a/server/nm-store/src/store/store.rs +++ b/server/nm-store/src/store/store.rs @@ -10,7 +10,7 @@ //! sense in the future to separate the decomposition of the note //! content into a higher layer. //! -//! Notesmachine storage notes consist of two items: Note and Kasten. +//! Notesmachine storage notes consist of two items: Note and Page. //! This distinction is somewhat arbitrary, as structurally these two //! items are stored in the same table. //! @@ -65,7 +65,7 @@ pub struct NoteStore(Arc); pub type NoteResult = core::result::Result; // After wrestling for a while with the fact that 'box' is a reserved -// word in Rust, I decided to just go with Note (note) and Kasten +// word in Rust, I decided to just go with Note (note) and Page // (box). impl NoteStore { @@ -92,16 +92,16 @@ impl NoteStore { /// 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, Vec)> { - let kasten = select_kasten_by_slug(&*self.0, &NoteId(slug.to_string())).await?; - if kasten.is_empty() { + pub async fn get_page_by_slug(&self, slug: &str) -> NoteResult<(Vec, Vec)> { + let page = select_page_by_slug(&*self.0, &NoteId(slug.to_string())).await?; + if page.is_empty() { return Err(NoteStoreError::NotFound); } - let note_id = NoteId(kasten[0].id.clone()); + let note_id = NoteId(page[0].id.clone()); Ok(( - kasten, - select_backreferences_for_kasten(&*self.0, ¬e_id).await?, + page, + select_backreferences_for_page(&*self.0, ¬e_id).await?, )) } @@ -112,17 +112,17 @@ impl NoteStore { /// doesn't, we go out and make it. Since we know it doesn't exist, /// we also know no backreferences to it exist, so in that case you /// get back two empty vecs. - pub async fn get_kasten_by_title(&self, title: &str) -> NoteResult<(Vec, Vec)> { + pub async fn get_page_by_title(&self, title: &str) -> NoteResult<(Vec, Vec)> { if title.len() == 0 { return Err(NoteStoreError::NotFound); } - let kasten = select_kasten_by_title(&*self.0, title).await?; - if kasten.len() > 0 { - let note_id = NoteId(kasten[0].id.clone()); + let page = select_page_by_title(&*self.0, title).await?; + if page.len() > 0 { + let note_id = NoteId(page[0].id.clone()); return Ok(( - kasten, - select_backreferences_for_kasten(&*self.0, ¬e_id).await?, + page, + select_backreferences_for_page(&*self.0, ¬e_id).await?, )); } @@ -136,11 +136,11 @@ impl NoteStore { let mut tx = self.0.begin().await?; let slug = generate_slug(&mut tx, title).await?; - let zettlekasten = create_zettlekasten(&title, &slug); - let _ = insert_note(&mut tx, &zettlekasten).await?; + let page = create_page(&title, &slug); + let _ = insert_note(&mut tx, &page).await?; tx.commit().await?; - Ok((vec![Note::from(zettlekasten)], vec![])) + Ok((vec![Note::from(page)], vec![])) } pub async fn add_note( @@ -202,9 +202,9 @@ impl NoteStore { let mut tx = self.0.begin().await?; let _ = update_note_content(&mut tx, ¬e_id, &content).await?; - let _ = delete_bulk_note_to_kasten_relationships(&mut tx, ¬e_id).await?; + let _ = delete_bulk_note_to_page_relationships(&mut tx, ¬e_id).await?; let known_reference_ids = validate_or_generate_all_found_references(&mut tx, &references).await?; - let _ = insert_bulk_note_to_kasten_relationships(&mut tx, ¬e_id, &known_reference_ids) + let _ = insert_bulk_note_to_page_relationships(&mut tx, ¬e_id, &known_reference_ids) .await?; tx.commit().await?; Ok(()) @@ -223,7 +223,7 @@ impl NoteStore { // The big one: if zero parents report having an interest in this note, then it, // *and any sub-relationships*, go away. if count_existing_note_relationships(&mut tx, ¬e_id).await? == 0 { - let _ = delete_note_to_kasten_relationships(&mut tx, ¬e_id).await?; + let _ = delete_note_to_page_relationships(&mut tx, ¬e_id).await?; let _ = delete_note(&mut tx, ¬e_id).await?; } tx.commit().await?; @@ -278,7 +278,7 @@ impl NoteStore { make_room_for_new_note(&mut tx, &parent_id, location).await?; insert_note_to_note_relationship(&mut tx, &parent_id, ¬e_id, location, &kind).await?; let known_reference_ids = validate_or_generate_all_found_references(&mut tx, &references).await?; - let _ = insert_bulk_note_to_kasten_relationships(&mut tx, ¬e_id, &known_reference_ids) + let _ = insert_bulk_note_to_page_relationships(&mut tx, ¬e_id, &known_reference_ids) .await?; tx.commit().await?; Ok(note_id.to_string()) diff --git a/server/nm-store/src/structs.rs b/server/nm-store/src/structs.rs index 493b5e2..663a546 100644 --- a/server/nm-store/src/structs.rs +++ b/server/nm-store/src/structs.rs @@ -4,8 +4,8 @@ use friendly_id; use shrinkwraprs::Shrinkwrap; use sqlx::{self, FromRow}; -// Kasten is German for "Box," and is used both because this is -// supposed to be a Zettlekasten, and because "Box" is a heavily +// Page is German for "Box," and is used both because this is +// supposed to be a Page, and because "Box" is a heavily // reserved word in Rust. So, for that matter, are "crate" and // "cargo," "cell," and so forth. If I'd wanted to go the Full // Noguchi, I guess I could have used "envelope." @@ -60,7 +60,7 @@ pub(crate) struct ParentId(pub String); build_conversion_enums!( NoteKind, - "box" => Kasten, + "box" => Page, "note" => Note, "resource" => Resource, ); @@ -78,8 +78,8 @@ build_conversion_enums!( ); build_conversion_enums!( - KastenRelationshipKind, - "kasten" => Kasten, + PageRelationshipKind, + "page" => Page, "unacked" => Unacked, "cancelled" => Cancelled, ); @@ -136,7 +136,7 @@ impl From for Note { /// A new Note object as it's inserted into the system. It has no /// parent or location information; those are data relative to the /// parent, and must be provided by the client. In the case of a -/// Kasten, no location or parent is necessary. +/// Page, no location or parent is necessary. #[derive(Clone, Debug, Builder)] pub struct NewNote { #[builder(default = r#"friendly_id::create()"#)] @@ -155,8 +155,8 @@ pub struct NewNote { } impl From for Note { - /// Only used for building new kastens, so the decision- making is - /// limited to kasten-level things, like pointing to self and + /// Only used for building new pages, so the decision- making is + /// limited to page-level things, like pointing to self and /// having a location of zero. fn from(note: NewNote) -> Self { Self { @@ -217,25 +217,25 @@ impl From for NoteRelationship { } #[derive(Clone, Debug, FromRow)] -pub(crate) struct KastenRelationshipRow { +pub(crate) struct PageRelationshipRow { pub note_id: String, - pub kasten_id: String, + pub page_id: String, pub kind: String, } #[derive(Clone, Debug)] -pub struct KastenRelationship { +pub struct PageRelationship { pub note_id: String, - pub kasten_id: String, - pub kind: KastenRelationshipKind, + pub page_id: String, + pub kind: PageRelationshipKind, } -impl From for KastenRelationship { - fn from(rel: KastenRelationshipRow) -> Self { +impl From for PageRelationship { + fn from(rel: PageRelationshipRow) -> Self { Self { - kasten_id: rel.kasten_id, + page_id: rel.page_id, note_id: rel.note_id, - kind: KastenRelationshipKind::from(rel.kind), + kind: PageRelationshipKind::from(rel.kind), } } }