split out note's content into separate entity, WIP

src/entities/entity_constructor.js

@@ -1,4 +1,5 @@
 const Note = require('../entities/note');
+const NoteContent = require('../entities/note_content');
 const NoteRevision = require('../entities/note_revision');
 const Link = require('../entities/link');
 const Branch = require('../entities/branch');
@@ -12,6 +13,7 @@ const ENTITY_NAME_TO_ENTITY = {
     "attributes": Attribute,
     "branches": Branch,
     "notes": Note,
+    "note_contents": NoteContent,
     "note_revisions": NoteRevision,
     "recent_notes": RecentNote,
     "options": Option,
@@ -48,6 +50,9 @@ function createEntityFromRow(row) {
     else if (row.branchId) {
         entity = new Branch(row);
     }
+    else if (row.noteContentId) {
+        entity = new NoteContent(row);
+    }
     else if (row.noteId) {
         entity = new Note(row);
     }

src/entities/note.js

@@ -19,7 +19,6 @@ const RELATION_DEFINITION = 'relation-definition';
  * @property {string} type - one of "text", "code", "file" or "render"
  * @property {string} mime - MIME type, e.g. "text/html"
  * @property {string} title - note title
- * @property {string} content - note content - e.g. HTML text for text notes, file payload for files
  * @property {boolean} isProtected - true if note is protected
  * @property {boolean} isDeleted - true if note is deleted
  * @property {string} dateCreated
@@ -30,7 +29,7 @@ const RELATION_DEFINITION = 'relation-definition';
 class Note extends Entity {
     static get entityName() { return "notes"; }
     static get primaryKeyName() { return "noteId"; }
-    static get hashedProperties() { return ["noteId", "title", "content", "type", "isProtected", "isDeleted"]; }
+    static get hashedProperties() { return ["noteId", "title", "type", "isProtected", "isDeleted"]; }
 
     /**
      * @param row - object containing database row from "notes" table
@@ -54,26 +53,18 @@ class Note extends Entity {
                 // saving ciphertexts in case we do want to update protected note outside of protected session
                 // (which is allowed)
                 this.titleCipherText = this.title;
-                this.contentCipherText = this.content;
-
                 this.title = "[protected]";
-                this.content = "";
             }
         }
-
-        this.setContent(this.content);
     }
 
-    setContent(content) {
-        this.content = content;
-
-        // if parsing below is not successful then there's no jsonContent as opposed to still having the old unupdated ones
-        delete this.jsonContent;
-
-        try {
-            this.jsonContent = JSON.parse(this.content);
+    /** @returns {Promise<NoteContent>} */
+    async getNoteContent() {
+        if (!this.noteContent) {
+            this.noteContent = await repository.getEntity(`SELECT * FROM note_contents WHERE noteId = ?`, [this.noteId]);
         }
-        catch(e) {}
+
+        return this.noteContent;
     }
 
     /** @returns {boolean} true if this note is the root of the note tree. Root note has "root" noteId */

src/entities/note_content.js

@@ -0,0 +1,82 @@
+"use strict";
+
+const Entity = require('./entity');
+const protectedSessionService = require('../services/protected_session');
+const repository = require('../services/repository');
+
+/**
+ * This represents a Note which is a central object in the Trilium Notes project.
+ *
+ * @property {string} noteContentId - primary key
+ * @property {string} noteId - reference to owning note
+ * @property {boolean} isProtected - true if note content is protected
+ * @property {blob} content - note content - e.g. HTML text for text notes, file payload for files
+ *
+ * @extends Entity
+ */
+class NoteContent extends Entity {
+    static get entityName() {
+        return "note_contents";
+    }
+
+    static get primaryKeyName() {
+        return "noteContentId";
+    }
+
+    static get hashedProperties() {
+        return ["noteContentId", "noteId", "isProtected", "content"];
+    }
+
+    /**
+     * @param row - object containing database row from "note_contents" table
+     */
+    constructor(row) {
+        super(row);
+
+        this.isProtected = !!this.isProtected;
+        /* true if content (meaning any kind of potentially encrypted content) is either not encrypted
+         * or encrypted, but with available protected session (so effectively decrypted) */
+        this.isContentAvailable = true;
+
+        // check if there's noteContentId, otherwise this is a new entity which wasn't encrypted yet
+        if (this.isProtected && this.noteContentId) {
+            this.isContentAvailable = protectedSessionService.isProtectedSessionAvailable();
+
+            if (this.isContentAvailable) {
+                protectedSessionService.decryptNoteContent(this);
+            }
+            else {
+                // saving ciphertexts in case we do want to update protected note outside of protected session
+                // (which is allowed)
+                this.contentCipherText = this.content;
+                this.content = "";
+            }
+        }
+    }
+
+    /**
+     * @returns {Promise<Note>}
+     */
+    async getNote() {
+        return await repository.getNote(this.noteId);
+    }
+
+    // cannot be static!
+    updatePojo(pojo) {
+        if (pojo.isProtected) {
+            if (this.isContentAvailable) {
+                protectedSessionService.encryptNoteContent(pojo);
+            }
+            else {
+                // updating protected note outside of protected session means we will keep original ciphertext
+                pojo.content = pojo.contentCipherText;
+            }
+        }
+
+        delete pojo.jsonContent;
+        delete pojo.isContentAvailable;
+        delete pojo.contentCipherText;
+    }
+}
+
+module.exports = NoteContent;