release 0.42.5

package.json

@@ -2,7 +2,7 @@
   "name": "trilium",
   "productName": "Trilium Notes",
   "description": "Trilium Notes",
-  "version": "0.42.3",
+  "version": "0.42.5",
   "license": "AGPL-3.0-only",
   "main": "electron.js",
   "bin": {

src/public/app/dialogs/clone_to.js

@@ -39,13 +39,14 @@ export async function showDialog(noteIds) {
 }
 
 async function cloneNotesTo(notePath) {
-    const targetNoteId = treeService.getNoteIdFromNotePath(notePath);
+    const {noteId, parentNoteId} = treeService.getNoteIdAndParentIdFromNotePath(notePath);
+    const targetBranchId = await treeCache.getBranchId(parentNoteId, noteId);
 
     for (const cloneNoteId of clonedNoteIds) {
-        await branchService.cloneNoteTo(cloneNoteId, targetNoteId, $clonePrefix.val());
+        await branchService.cloneNoteTo(cloneNoteId, targetBranchId, $clonePrefix.val());
 
         const clonedNote = await treeCache.getNote(cloneNoteId);
-        const targetNote = await treeCache.getNote(targetNoteId);
+        const targetNote = await treeCache.getBranch(targetBranchId).getNote();
 
         toastService.showMessage(`Note "${clonedNote.title}" has been cloned into ${targetNote.title}`);
     }
@@ -64,4 +65,4 @@ $form.on('submit', () => {
     }
 
     return false;
-});
+});

src/public/app/dialogs/move_to.js

@@ -32,10 +32,11 @@ export async function showDialog(branchIds) {
     noteAutocompleteService.showRecentNotes($noteAutoComplete);
 }
 
-async function moveNotesTo(parentNoteId) {
-    await branchService.moveToParentNote(movedBranchIds, parentNoteId);
+async function moveNotesTo(parentBranchId) {
+    await branchService.moveToParentNote(movedBranchIds, parentBranchId);
 
-    const parentNote = await treeCache.getNote(parentNoteId);
+    const parentBranch = treeCache.getBranch(parentBranchId);
+    const parentNote = await parentBranch.getNote();
 
     toastService.showMessage(`Selected notes have been moved into ${parentNote.title}`);
 }
@@ -46,13 +47,12 @@ $form.on('submit', () => {
     if (notePath) {
         $dialog.modal('hide');
 
-        const noteId = treeService.getNoteIdFromNotePath(notePath);
-
-        moveNotesTo(noteId);
+        const {noteId, parentNoteId} = treeService.getNoteIdAndParentIdFromNotePath(notePath);
+        treeCache.getBranchId(parentNoteId, noteId).then(branchId => moveNotesTo(branchId));
     }
     else {
         console.error("No path to move to.");
     }
 
     return false;
-});
+});

src/public/app/dialogs/options/advanced.js

@@ -24,6 +24,13 @@ const TPL = `
 <p>This action will create a new copy of the database and anonymise it (remove all note content and leave only structure and metadata)
     for sharing online for debugging purposes without fear of leaking your personal data.</p>
 
+<h4>Backup database</h4>
+
+<button id="backup-database-button" class="btn">Backup database</button>
+
+<br/>
+<br/>
+
 <h4>Vacuum database</h4>
 
 <p>This will rebuild database which will typically result in smaller database file. No data will be actually changed.</p>
@@ -37,6 +44,7 @@ export default class AdvancedOptions {
         this.$forceFullSyncButton = $("#force-full-sync-button");
         this.$fillSyncRowsButton = $("#fill-sync-rows-button");
         this.$anonymizeButton = $("#anonymize-button");
+        this.$backupDatabaseButton = $("#backup-database-button");
         this.$vacuumDatabaseButton = $("#vacuum-database-button");
         this.$findAndFixConsistencyIssuesButton = $("#find-and-fix-consistency-issues-button");
 
@@ -58,16 +66,22 @@ export default class AdvancedOptions {
             toastService.showMessage("Created anonymized database");
         });
 
+        this.$backupDatabaseButton.on('click', async () => {
+            const {backupFile} = await server.post('database/backup-database');
+
+            toastService.showMessage("Database has been backed up to " + backupFile, 10000);
+        });
+
         this.$vacuumDatabaseButton.on('click', async () => {
-            await server.post('cleanup/vacuum-database');
+            await server.post('database/vacuum-database');
 
             toastService.showMessage("Database has been vacuumed");
         });
 
         this.$findAndFixConsistencyIssuesButton.on('click', async () => {
-            await server.post('cleanup/find-and-fix-consistency-issues');
+            await server.post('database/find-and-fix-consistency-issues');
 
             toastService.showMessage("Consistency issues should be fixed.");
         });
     }
-}
+}

src/public/app/services/branches.js

@@ -45,7 +45,7 @@ async function moveAfterBranch(branchIdsToMove, afterBranchId) {
     }
 }
 
-async function moveToParentNote(branchIdsToMove, newParentNoteId) {
+async function moveToParentNote(branchIdsToMove, newParentBranchId) {
     branchIdsToMove = filterRootNote(branchIdsToMove);
 
     for (const branchIdToMove of branchIdsToMove) {
@@ -56,7 +56,7 @@ async function moveToParentNote(branchIdsToMove, newParentNoteId) {
             continue;
         }
 
-        const resp = await server.put(`branches/${branchIdToMove}/move-to/${newParentNoteId}`);
+        const resp = await server.put(`branches/${branchIdToMove}/move-to/${newParentBranchId}`);
 
         if (!resp.success) {
             alert(resp.message);
@@ -198,8 +198,8 @@ ws.subscribeToMessages(async message => {
     }
 });
 
-async function cloneNoteTo(childNoteId, parentNoteId, prefix) {
-    const resp = await server.put('notes/' + childNoteId + '/clone-to/' + parentNoteId, {
+async function cloneNoteTo(childNoteId, parentBranchId, prefix) {
+    const resp = await server.put(`notes/${childNoteId}/clone-to/${parentBranchId}`, {
         prefix: prefix
     });
 
@@ -225,4 +225,4 @@ export default {
     moveNodeUpInHierarchy,
     cloneNoteAfter,
     cloneNoteTo
-};
+};

src/public/app/services/clipboard.js

@@ -33,13 +33,13 @@ async function pasteAfter(afterBranchId) {
     }
 }
 
-async function pasteInto(parentNoteId) {
+async function pasteInto(parentBranchId) {
     if (isClipboardEmpty()) {
         return;
     }
 
     if (clipboardMode === 'cut') {
-        await branchService.moveToParentNote(clipboardBranchIds, parentNoteId);
+        await branchService.moveToParentNote(clipboardBranchIds, parentBranchId);
 
         clipboardBranchIds = [];
         clipboardMode = null;
@@ -50,7 +50,7 @@ async function pasteInto(parentNoteId) {
         for (const clipboardBranch of clipboardBranches) {
             const clipboardNote = await clipboardBranch.getNote();
 
-            await branchService.cloneNoteTo(clipboardNote.noteId, parentNoteId);
+            await branchService.cloneNoteTo(clipboardNote.noteId, parentBranchId);
         }
 
         // copy will keep clipboardBranchIds and clipboardMode so it's possible to paste into multiple places
@@ -89,4 +89,4 @@ export default {
     cut,
     copy,
     isClipboardEmpty
-}
+}

src/public/app/services/tab_manager.js

@@ -238,7 +238,7 @@ export default class TabManager extends Component {
         }
 
         this.tabsUpdate.scheduleUpdate();
-        
+
         this.setCurrentNotePathToHash();
     }
 
@@ -249,6 +249,9 @@ export default class TabManager extends Component {
             return;
         }
 
+        // close dangling autocompletes after closing the tab
+        $(".aa-input").autocomplete("close");
+
         await this.triggerEvent('beforeTabRemove', {tabId});
 
         if (this.tabContexts.length <= 1) {
@@ -267,9 +270,6 @@ export default class TabManager extends Component {
 
         this.children = this.children.filter(tc => tc.tabId !== tabId);
 
-        // remove dangling autocompletes after closing the tab
-        $(".algolia-autocomplete").remove();
-
         this.triggerEvent('tabRemoved', {tabId});
 
         this.tabsUpdate.scheduleUpdate();
@@ -346,4 +346,4 @@ export default class TabManager extends Component {
             }
         }
     }
-}
+}

src/public/app/services/ws.js

@@ -165,6 +165,10 @@ async function consumeSyncData() {
             utils.reloadApp();
         }
 
+        for (const syncRow of nonProcessedSyncRows) {
+            processedSyncIds.add(syncRow.id);
+        }
+
         lastProcessedSyncId = Math.max(lastProcessedSyncId, allSyncRows[allSyncRows.length - 1].id);
     }
 

src/public/app/widgets/note_tree.js

@@ -265,6 +265,7 @@ export default class NoteTreeWidget extends TabAwareWidget {
 
                     const notes = this.getSelectedOrActiveNodes(node).map(node => ({
                         noteId: node.data.noteId,
+                        branchId: node.data.branchId,
                         title: node.title
                     }));
 
@@ -304,17 +305,28 @@ export default class NoteTreeWidget extends TabAwareWidget {
                         });
                     }
                     else {
+                        const jsonStr = dataTransfer.getData("text");
+                        let notes = null;
+
+                        try {
+                            notes = JSON.parse(jsonStr);
+                        }
+                        catch (e) {
+                            console.error(`Cannot parse ${jsonStr} into notes for drop`);
+                            return;
+                        }
+
                         // This function MUST be defined to enable dropping of items on the tree.
                         // data.hitMode is 'before', 'after', or 'over'.
 
-                        const selectedBranchIds = this.getSelectedOrActiveNodes().map(node => node.data.branchId);
+                        const selectedBranchIds = notes.map(note => note.branchId);
 
                         if (data.hitMode === "before") {
                             branchService.moveBeforeBranch(selectedBranchIds, node.data.branchId);
                         } else if (data.hitMode === "after") {
                             branchService.moveAfterBranch(selectedBranchIds, node.data.branchId);
                         } else if (data.hitMode === "over") {
-                            branchService.moveToParentNote(selectedBranchIds, node.data.noteId);
+                            branchService.moveToParentNote(selectedBranchIds, node.data.branchId);
                         } else {
                             throw new Error("Unknown hitMode=" + data.hitMode);
                         }
@@ -571,13 +583,18 @@ export default class NoteTreeWidget extends TabAwareWidget {
 
     /** @return {FancytreeNode[]} */
     getSelectedOrActiveNodes(node = null) {
-        const notes = this.getSelectedNodes(true);
+        const nodes = this.getSelectedNodes(true);
 
-        if (notes.length === 0) {
-            notes.push(node ? node : this.getActiveNode());
+        // the node you start dragging should be included even if not selected
+        if (node && !nodes.find(n => n.key === node.key)) {
+            nodes.push(node);
         }
 
-        return notes;
+        if (nodes.length === 0) {
+            nodes.push(this.getActiveNode());
+        }
+
+        return nodes;
     }
 
     async setExpandedStatusForSubtree(node, isExpanded) {
@@ -729,6 +746,7 @@ export default class NoteTreeWidget extends TabAwareWidget {
         node.icon = this.getIcon(note, isFolder);
         node.extraClasses = this.getExtraClasses(note);
         node.title = (branch.prefix ? (branch.prefix + " - ") : "") + note.title;
+        node.setExpanded(branch.isExpanded, {noEvents:true});
         node.renderTitle();
     }
 
@@ -1062,7 +1080,7 @@ export default class NoteTreeWidget extends TabAwareWidget {
         const toNode = node.getPrevSibling();
 
         if (toNode !== null) {
-            branchService.moveToParentNote([node.data.branchId], toNode.data.noteId);
+            branchService.moveToParentNote([node.data.branchId], toNode.data.branchId);
         }
     }
 
@@ -1147,7 +1165,7 @@ export default class NoteTreeWidget extends TabAwareWidget {
     }
 
     pasteNotesFromClipboardCommand({node}) {
-        clipboard.pasteInto(node.data.noteId);
+        clipboard.pasteInto(node.data.branchId);
     }
 
     pasteNotesAfterFromClipboard({node}) {

src/public/app/widgets/type_widgets/file.js

@@ -5,17 +5,23 @@ import TypeWidget from "./type_widget.js";
 
 const TPL = `
 <div class="note-detail-file note-detail-printable">
+    <style>
+        .file-table td {
+            overflow-wrap: anywhere;
+        }
+    </style>
+
     <table class="file-table">
         <tr>
-            <th nowrap>Note ID:</th>
+            <th>Note ID:</th>
             <td class="file-note-id"></td>
-            <th nowrap>Original file name:</th>
+            <th>Original file name:</th>
             <td class="file-filename"></td>
         </tr>
         <tr>
-            <th nowrap>File type:</th>
+            <th>File type:</th>
             <td class="file-filetype"></td>
-            <th nowrap>File size:</th>
+            <th>File size:</th>
             <td class="file-filesize"></td>
         </tr>
     </table>
@@ -94,7 +100,7 @@ export default class FileTypeWidget extends TypeWidget {
                 toastService.showError("Upload of a new file revision failed.");
             }
         });
-        
+
         return this.$widget;
     }
 
@@ -130,4 +136,4 @@ export default class FileTypeWidget extends TypeWidget {
     getFileUrl() {
         return utils.getUrlForDownload("api/notes/" + this.noteId + "/download");
     }
-}
+}

src/routes/api/branches.js

@@ -14,25 +14,33 @@ const TaskContext = require('../../services/task_context');
  */
 
 async function moveBranchToParent(req) {
-    const {branchId, parentNoteId} = req.params;
+    const {branchId, parentBranchId} = req.params;
 
+    const parentBranch = await repository.getBranch(parentBranchId);
     const branchToMove = await repository.getBranch(branchId);
 
-    if (branchToMove.parentNoteId === parentNoteId) {
+    if (!parentBranch || !branchToMove) {
+        return [400, `One or both branches ${branchId}, ${parentBranchId} have not been found`];
+    }
+
+    if (branchToMove.parentNoteId === parentBranch.noteId) {
         return { success: true }; // no-op
     }
 
-    const validationResult = await treeService.validateParentChild(parentNoteId, branchToMove.noteId, branchId);
+    const validationResult = await treeService.validateParentChild(parentBranch.noteId, branchToMove.noteId, branchId);
 
     if (!validationResult.success) {
         return [200, validationResult];
     }
 
-    const maxNotePos = await sql.getValue('SELECT MAX(notePosition) FROM branches WHERE parentNoteId = ? AND isDeleted = 0', [parentNoteId]);
+    const maxNotePos = await sql.getValue('SELECT MAX(notePosition) FROM branches WHERE parentNoteId = ? AND isDeleted = 0', [parentBranch.noteId]);
     const newNotePos = maxNotePos === null ? 0 : maxNotePos + 10;
 
-    const newBranch = branchToMove.createClone(parentNoteId, newNotePos);
-    newBranch.isExpanded = true;
+    // expanding so that the new placement of the branch is immediately visible
+    parentBranch.isExpanded = true;
+    await parentBranch.save();
+
+    const newBranch = branchToMove.createClone(parentBranch.noteId, newNotePos);
     await newBranch.save();
 
     branchToMove.isDeleted = true;
@@ -178,4 +186,4 @@ module.exports = {
     setExpandedForSubtree,
     deleteBranch,
     setPrefix
-};
+};

src/routes/api/cloning.js

@@ -3,10 +3,10 @@
 const cloningService = require('../../services/cloning');
 
 async function cloneNoteToParent(req) {
-    const {noteId, parentNoteId} = req.params;
+    const {noteId, parentBranchId} = req.params;
     const {prefix} = req.body;
 
-    return await cloningService.cloneNoteToParent(noteId, parentNoteId, prefix);
+    return await cloningService.cloneNoteToParent(noteId, parentBranchId, prefix);
 }
 
 async function cloneNoteAfter(req) {
@@ -18,4 +18,4 @@ async function cloneNoteAfter(req) {
 module.exports = {
     cloneNoteToParent,
     cloneNoteAfter
-};
+};

src/routes/api/database.js

@@ -2,8 +2,15 @@
 
 const sql = require('../../services/sql');
 const log = require('../../services/log');
+const backupService = require('../../services/backup');
 const consistencyChecksService = require('../../services/consistency_checks');
 
+async function backupDatabase() {
+    return {
+        backupFile: await backupService.backupNow("now")
+    };
+}
+
 async function vacuumDatabase() {
     await sql.execute("VACUUM");
 
@@ -15,6 +22,7 @@ async function findAndFixConsistencyIssues() {
 }
 
 module.exports = {
+    backupDatabase,
     vacuumDatabase,
     findAndFixConsistencyIssues
-};
+};

src/routes/api/login.js

@@ -16,7 +16,7 @@ const ApiToken = require('../../entities/api_token');
 
 async function loginSync(req) {
     if (!await sqlInit.schemaExists()) {
-        return [400, { message: "DB schema does not exist, can't sync." }];
+        return [500, { message: "DB schema does not exist, can't sync." }];
     }
 
     const timestampStr = req.body.timestamp;
@@ -27,7 +27,7 @@ async function loginSync(req) {
 
     // login token is valid for 5 minutes
     if (Math.abs(timestamp.getTime() - now.getTime()) > 5 * 60 * 1000) {
-        return [400, { message: 'Auth request time is out of sync, please check that both client and server have correct time.' }];
+        return [401, { message: 'Auth request time is out of sync, please check that both client and server have correct time.' }];
     }
 
     const syncVersion = req.body.syncVersion;
@@ -102,4 +102,4 @@ module.exports = {
     loginSync,
     loginToProtectedSession,
     token
-};
+};

src/routes/routes.js

@@ -25,7 +25,7 @@ const importRoute = require('./api/import');
 const setupApiRoute = require('./api/setup');
 const sqlRoute = require('./api/sql');
 const anonymizationRoute = require('./api/anonymization');
-const cleanupRoute = require('./api/cleanup');
+const databaseRoute = require('./api/database');
 const imageRoute = require('./api/image');
 const attributesRoute = require('./api/attributes');
 const scriptRoute = require('./api/script');
@@ -123,7 +123,7 @@ function register(app) {
     apiRoute(POST, '/api/tree/load', treeApiRoute.load);
     apiRoute(PUT, '/api/branches/:branchId/set-prefix', branchesApiRoute.setPrefix);
 
-    apiRoute(PUT, '/api/branches/:branchId/move-to/:parentNoteId', branchesApiRoute.moveBranchToParent);
+    apiRoute(PUT, '/api/branches/:branchId/move-to/:parentBranchId', branchesApiRoute.moveBranchToParent);
     apiRoute(PUT, '/api/branches/:branchId/move-before/:beforeBranchId', branchesApiRoute.moveBranchBeforeNote);
     apiRoute(PUT, '/api/branches/:branchId/move-after/:afterBranchId', branchesApiRoute.moveBranchAfterNote);
     apiRoute(PUT, '/api/branches/:branchId/expanded/:expanded', branchesApiRoute.setExpanded);
@@ -152,7 +152,7 @@ function register(app) {
 
     apiRoute(GET, '/api/edited-notes/:date', noteRevisionsApiRoute.getEditedNotesOnDate);
 
-    apiRoute(PUT, '/api/notes/:noteId/clone-to/:parentNoteId', cloningApiRoute.cloneNoteToParent);
+    apiRoute(PUT, '/api/notes/:noteId/clone-to/:parentBranchId', cloningApiRoute.cloneNoteToParent);
     apiRoute(PUT, '/api/notes/:noteId/clone-after/:afterBranchId', cloningApiRoute.cloneNoteAfter);
 
     route(GET, '/api/notes/:branchId/export/:type/:format/:version/:taskId', [auth.checkApiAuthOrElectron], exportRoute.exportBranch);
@@ -222,10 +222,13 @@ function register(app) {
     apiRoute(POST, '/api/sql/execute', sqlRoute.execute);
     apiRoute(POST, '/api/anonymization/anonymize', anonymizationRoute.anonymize);
 
-    // VACUUM requires execution outside of transaction
-    route(POST, '/api/cleanup/vacuum-database', [auth.checkApiAuthOrElectron, csrfMiddleware], cleanupRoute.vacuumDatabase, apiResultHandler, false);
+    // backup requires execution outside of transaction
+    route(POST, '/api/database/backup-database', [auth.checkApiAuthOrElectron, csrfMiddleware], databaseRoute.backupDatabase, apiResultHandler, false);
 
-    route(POST, '/api/cleanup/find-and-fix-consistency-issues', [auth.checkApiAuthOrElectron, csrfMiddleware], cleanupRoute.findAndFixConsistencyIssues, apiResultHandler, false);
+    // VACUUM requires execution outside of transaction
+    route(POST, '/api/database/vacuum-database', [auth.checkApiAuthOrElectron, csrfMiddleware], databaseRoute.vacuumDatabase, apiResultHandler, false);
+
+    route(POST, '/api/database/find-and-fix-consistency-issues', [auth.checkApiAuthOrElectron, csrfMiddleware], databaseRoute.findAndFixConsistencyIssues, apiResultHandler, false);
 
     apiRoute(POST, '/api/script/exec', scriptRoute.exec);
     apiRoute(POST, '/api/script/run/:noteId', scriptRoute.run);
@@ -267,4 +270,4 @@ function register(app) {
 
 module.exports = {
     register
-};
+};

src/services/backup.js

@@ -28,14 +28,43 @@ async function periodBackup(optionName, fileName, periodInSeconds) {
     }
 }
 
+const BACKUP_ATTEMPT_COUNT = 50;
+
 async function backupNow(name) {
+    const sql = require('./sql');
+
     // we don't want to backup DB in the middle of sync with potentially inconsistent DB state
-    await syncMutexService.doExclusively(async () => {
+    return await syncMutexService.doExclusively(async () => {
         const backupFile = `${dataDir.BACKUP_DIR}/backup-${name}.db`;
 
-        fs.copySync(dataDir.DOCUMENT_PATH, backupFile);
+        try {
+            fs.unlinkSync(backupFile);
+        }
+        catch (e) {} // unlink throws exception if the file did not exist
 
-        log.info("Created backup at " + backupFile);
+        let success = false;
+        let attemptCount = 0
+
+        for (; attemptCount < BACKUP_ATTEMPT_COUNT && !success; attemptCount++) {
+            try {
+                await sql.executeNoWrap(`VACUUM INTO '${backupFile}'`);
+                success++;
+            }
+            catch (e) {
+                log.info(`Backup attempt ${attemptCount + 1} failed with "${e.message}", retrying...`);
+            }
+            // we re-try since VACUUM is very picky and it can't run if there's any other query currently running
+            // which is difficult to guarantee so we just re-try
+        }
+
+        if (attemptCount === BACKUP_ATTEMPT_COUNT) {
+            log.error(`Creating backup ${backupFile} failed`);
+        }
+        else {
+            log.info("Created backup at " + backupFile);
+        }
+
+        return backupFile;
     });
 }
 
@@ -44,12 +73,12 @@ if (!fs.existsSync(dataDir.BACKUP_DIR)) {
 }
 
 sqlInit.dbReady.then(() => {
-    setInterval(cls.wrap(regularBackup), 60 * 60 * 1000);
+    setInterval(cls.wrap(regularBackup), 4 * 60 * 60 * 1000);
 
-    // kickoff backup immediately
-    setTimeout(cls.wrap(regularBackup), 1000);
+    // kickoff first backup soon after start up
+    setTimeout(cls.wrap(regularBackup), 5 * 60 * 1000);
 });
 
 module.exports = {
     backupNow
-};
+};

src/services/build.js

@@ -1 +1 @@
-module.exports = { buildDate:"2020-05-20T08:54:55+02:00", buildRevision: "04c573e212db06e1dd60c74707e40f6912c85aab" };
+module.exports = { buildDate:"2020-05-31T23:33:30+02:00", buildRevision: "8c88ce6f651c3df1cd97925e5b8e3281ca4b1665" };

src/services/cloning.js

@@ -9,12 +9,14 @@ const Branch = require('../entities/branch');
 const TaskContext = require("./task_context.js");
 const utils = require('./utils');
 
-async function cloneNoteToParent(noteId, parentNoteId, prefix) {
-    if (await isNoteDeleted(noteId) || await isNoteDeleted(parentNoteId)) {
+async function cloneNoteToParent(noteId, parentBranchId, prefix) {
+    const parentBranch = await repository.getBranch(parentBranchId);
+
+    if (await isNoteDeleted(noteId) || await isNoteDeleted(parentBranch.noteId)) {
         return { success: false, message: 'Note is deleted.' };
     }
 
-    const validationResult = await treeService.validateParentChild(parentNoteId, noteId);
+    const validationResult = await treeService.validateParentChild(parentBranch.noteId, noteId);
 
     if (!validationResult.success) {
         return validationResult;
@@ -22,12 +24,13 @@ async function cloneNoteToParent(noteId, parentNoteId, prefix) {
 
     const branch = await new Branch({
         noteId: noteId,
-        parentNoteId: parentNoteId,
+        parentNoteId: parentBranch.noteId,
         prefix: prefix,
         isExpanded: 0
     }).save();
 
-    await sql.execute("UPDATE branches SET isExpanded = 1 WHERE noteId = ?", [parentNoteId]);
+    parentBranch.isExpanded = true; // the new target should be expanded so it immediately shows up to the user
+    await parentBranch.save();
 
     return { success: true, branchId: branch.branchId };
 }
@@ -111,4 +114,4 @@ module.exports = {
     ensureNoteIsAbsentFromParent,
     toggleNoteInParent,
     cloneNoteAfter
-};
+};

src/services/notes.js

@@ -662,7 +662,9 @@ async function scanForLinks(note) {
         const content = await note.getContent();
         const newContent = await saveLinks(note, content);
 
-        await note.setContent(newContent);
+        if (content !== newContent) {
+            await note.setContent(newContent);
+        }
     }
     catch (e) {
         log.error(`Could not scan for links note ${note.noteId}: ${e.message} ${e.stack}`);

src/services/sql.js

@@ -153,6 +153,10 @@ async function execute(query, params = []) {
     return await wrap(async db => db.run(query, ...params), query);
 }
 
+async function executeNoWrap(query, params = []) {
+    await dbConnection.run(query, ...params);
+}
+
 async function executeMany(query, params) {
     // essentially just alias
     await getManyRows(query, params);
@@ -264,6 +268,7 @@ module.exports = {
     getMap,
     getColumn,
     execute,
+    executeNoWrap,
     executeMany,
     executeScript,
     transactional,