Add page notes panel

crates/ely_domain/src/note.rs

@@ -0,0 +1,228 @@
+use std::time::SystemTime;
+
+use crate::{DomainError, NoteId, ProfileId, SpaceId, TabId, UrlText};
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum NoteTarget {
+    Url(UrlText),
+    Tab(TabId),
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct NoteEntry {
+    id: NoteId,
+    profile_id: ProfileId,
+    space_id: SpaceId,
+    target: NoteTarget,
+    title: String,
+    source_url: UrlText,
+    body: String,
+    created_at: SystemTime,
+    updated_at: SystemTime,
+}
+
+impl NoteEntry {
+    pub fn new(
+        profile_id: ProfileId,
+        space_id: SpaceId,
+        target: NoteTarget,
+        title: impl Into<String>,
+        source_url: UrlText,
+        body: impl Into<String>,
+        now: SystemTime,
+    ) -> Result<Self, DomainError> {
+        let title = non_empty_text("note title", title.into())?;
+        let body = normalize_body(body.into())?;
+
+        Ok(Self {
+            id: NoteId::new(),
+            profile_id,
+            space_id,
+            target,
+            title,
+            source_url,
+            body,
+            created_at: now,
+            updated_at: now,
+        })
+    }
+
+    #[must_use]
+    pub fn id(&self) -> &NoteId {
+        &self.id
+    }
+
+    #[must_use]
+    pub fn profile_id(&self) -> &ProfileId {
+        &self.profile_id
+    }
+
+    #[must_use]
+    pub fn space_id(&self) -> &SpaceId {
+        &self.space_id
+    }
+
+    #[must_use]
+    pub fn target(&self) -> &NoteTarget {
+        &self.target
+    }
+
+    #[must_use]
+    pub fn target_label(&self) -> &'static str {
+        match &self.target {
+            NoteTarget::Url(_) => "URL note",
+            NoteTarget::Tab(_) => "Tab note",
+        }
+    }
+
+    #[must_use]
+    pub fn title(&self) -> &str {
+        &self.title
+    }
+
+    #[must_use]
+    pub fn source_url(&self) -> &UrlText {
+        &self.source_url
+    }
+
+    #[must_use]
+    pub fn display_url(&self) -> String {
+        self.source_url.display_url()
+    }
+
+    #[must_use]
+    pub fn body(&self) -> &str {
+        &self.body
+    }
+
+    #[must_use]
+    pub fn created_at(&self) -> SystemTime {
+        self.created_at
+    }
+
+    #[must_use]
+    pub fn updated_at(&self) -> SystemTime {
+        self.updated_at
+    }
+
+    pub fn update(
+        &mut self,
+        title: impl Into<String>,
+        source_url: UrlText,
+        body: impl Into<String>,
+        updated_at: SystemTime,
+    ) -> Result<(), DomainError> {
+        self.title = non_empty_text("note title", title.into())?;
+        self.source_url = source_url;
+        self.body = normalize_body(body.into())?;
+        self.updated_at = updated_at;
+        Ok(())
+    }
+}
+
+fn normalize_body(value: String) -> Result<String, DomainError> {
+    let normalized = value.replace("\r\n", "\n").replace('\r', "\n");
+    non_empty_text("note body", normalized)
+}
+
+fn non_empty_text(field: &'static str, value: String) -> Result<String, DomainError> {
+    let trimmed = value.trim();
+    if trimmed.is_empty() {
+        return Err(DomainError::EmptyField { field });
+    }
+    Ok(trimmed.to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use std::time::{Duration, SystemTime};
+
+    use super::{NoteEntry, NoteTarget};
+    use crate::{DomainError, ProfileId, SpaceId, TabId, UrlText};
+
+    #[test]
+    fn creates_url_note_with_markdown_body() -> Result<(), DomainError> {
+        let now = SystemTime::UNIX_EPOCH + Duration::from_secs(10);
+        let source_url = UrlText::parse("https://example.com/article")?;
+        let note = NoteEntry::new(
+            ProfileId::new(),
+            SpaceId::new(),
+            NoteTarget::Url(source_url.clone()),
+            "Example",
+            source_url,
+            " # Heading\r\n- item ",
+            now,
+        )?;
+
+        assert_eq!(note.title(), "Example");
+        assert_eq!(note.body(), "# Heading\n- item");
+        assert_eq!(note.target_label(), "URL note");
+        assert_eq!(note.created_at(), now);
+        assert_eq!(note.updated_at(), now);
+        Ok(())
+    }
+
+    #[test]
+    fn creates_tab_note_target() -> Result<(), DomainError> {
+        let tab_id = TabId::new();
+        let note = NoteEntry::new(
+            ProfileId::new(),
+            SpaceId::new(),
+            NoteTarget::Tab(tab_id.clone()),
+            "Example",
+            UrlText::parse("https://example.com/tab")?,
+            "- detail",
+            SystemTime::UNIX_EPOCH,
+        )?;
+
+        assert_eq!(note.target(), &NoteTarget::Tab(tab_id));
+        assert_eq!(note.target_label(), "Tab note");
+        Ok(())
+    }
+
+    #[test]
+    fn rejects_empty_body() -> Result<(), DomainError> {
+        let source_url = UrlText::parse("https://example.com")?;
+        let result = NoteEntry::new(
+            ProfileId::new(),
+            SpaceId::new(),
+            NoteTarget::Url(source_url.clone()),
+            "Example",
+            source_url,
+            "  ",
+            SystemTime::UNIX_EPOCH,
+        );
+
+        assert_eq!(result, Err(DomainError::EmptyField { field: "note body" }));
+        Ok(())
+    }
+
+    #[test]
+    fn updates_body_and_timestamp() -> Result<(), DomainError> {
+        let created_at = SystemTime::UNIX_EPOCH + Duration::from_secs(10);
+        let updated_at = created_at + Duration::from_secs(30);
+        let mut note = NoteEntry::new(
+            ProfileId::new(),
+            SpaceId::new(),
+            NoteTarget::Url(UrlText::parse("https://example.com/old")?),
+            "Old",
+            UrlText::parse("https://example.com/old")?,
+            "first",
+            created_at,
+        )?;
+
+        note.update(
+            "New",
+            UrlText::parse("https://example.com/new")?,
+            " second\rline ",
+            updated_at,
+        )?;
+
+        assert_eq!(note.title(), "New");
+        assert_eq!(note.source_url().as_str(), "https://example.com/new");
+        assert_eq!(note.body(), "second\nline");
+        assert_eq!(note.created_at(), created_at);
+        assert_eq!(note.updated_at(), updated_at);
+        Ok(())
+    }
+}