Merge remote-tracking branch 'origin/better-sqlite3'

# Conflicts:
#	libraries/ckeditor/ckeditor.js
#	libraries/ckeditor/ckeditor.js.map
#	package-lock.json
#	package.json
#	src/public/app/services/utils.js
#	src/public/app/widgets/type_widgets/editable_text.js
#	src/services/utils.js

src/routes/api/export.js

@@ -23,7 +23,11 @@ async function exportBranch(req, res) {
 
     try {
         if (type === 'subtree' && (format === 'html' || format === 'markdown')) {
+            const start = Date.now();
+
             await zipExportService.exportToZip(taskContext, branch, format, res);
+
+            console.log("Export took", Date.now() - start, "ms");
         }
         else if (type === 'single') {
             await singleExportService.exportSingleNote(taskContext, branch, format, res);

src/routes/api/import.js

@@ -51,7 +51,11 @@ async function importToBranch(req) {
         if (extension === '.tar' && options.explodeArchives) {
             note = await tarImportService.importTar(taskContext, file.buffer, parentNote);
         } else if (extension === '.zip' && options.explodeArchives) {
+            const start = Date.now();
+
             note = await zipImportService.importZip(taskContext, file.buffer, parentNote);
+
+            console.log("Import took", Date.now() - start, "ms");
         } else if (extension === '.opml' && options.explodeArchives) {
             note = await opmlImportService.importOpml(taskContext, file.buffer, parentNote);
         } else if (extension === '.enex' && options.explodeArchives) {

src/routes/api/login.js

@@ -68,7 +68,7 @@ async function loginToProtectedSession(req) {
     const protectedSessionId = protectedSessionService.setDataKey(decryptedDataKey);
 
     // this is set here so that event handlers have access to the protected session
-    cls.namespace.set('protectedSessionId', protectedSessionId);
+    cls.set('protectedSessionId', protectedSessionId);
 
     await eventService.emit(eventService.ENTER_PROTECTED_SESSION);
 

src/routes/api/recent_changes.js

@@ -8,69 +8,55 @@ const noteCacheService = require('../../services/note_cache/note_cache.js');
 async function getRecentChanges(req) {
     const {ancestorNoteId} = req.params;
 
-    const noteRows = await sql.getRows(
-        `
-        SELECT * FROM (
-            SELECT note_revisions.noteId,
-                   note_revisions.noteRevisionId,
-                   note_revisions.dateLastEdited AS date
-            FROM note_revisions
-            ORDER BY note_revisions.dateLastEdited DESC
-        )
-        UNION ALL SELECT * FROM (
-            SELECT 
-                   notes.noteId,
-                   NULL AS noteRevisionId,
-                   dateModified AS date 
-            FROM notes 
-            ORDER BY dateModified DESC
-        )
-        ORDER BY date DESC`);
+    let recentChanges = [];
 
-    const recentChanges = [];
+    const noteRevisions = await sql.getRows(`
+        SELECT 
+            notes.noteId,
+            notes.isDeleted AS current_isDeleted,
+            notes.deleteId AS current_deleteId,
+            notes.isErased AS current_isErased,
+            notes.title AS current_title,
+            notes.isProtected AS current_isProtected,
+            note_revisions.title,
+            note_revisions.utcDateCreated AS utcDate,
+            note_revisions.dateCreated AS date
+        FROM 
+            note_revisions
+            JOIN notes USING(noteId)`);
 
-    for (const noteRow of noteRows) {
-        if (!noteCacheService.isInAncestor(noteRow.noteId, ancestorNoteId)) {
-            continue;
-        }
-
-        if (noteRow.noteRevisionId) {
-            recentChanges.push(await sql.getRow(`
-                SELECT 
-                    notes.noteId,
-                    notes.isDeleted AS current_isDeleted,
-                    notes.deleteId AS current_deleteId,
-                    notes.isErased AS current_isErased,
-                    notes.title AS current_title,
-                    notes.isProtected AS current_isProtected,
-                    note_revisions.title,
-                    note_revisions.dateCreated AS date
-                FROM 
-                    note_revisions
-                    JOIN notes USING(noteId)
-                WHERE noteRevisionId = ?`, [noteRow.noteRevisionId]));
-        }
-        else {
-            recentChanges.push(await sql.getRow(`
-                SELECT
-                    notes.noteId,
-                    notes.isDeleted AS current_isDeleted,
-                    notes.deleteId AS current_deleteId,
-                    notes.isErased AS current_isErased,
-                    notes.title AS current_title,
-                    notes.isProtected AS current_isProtected,
-                    notes.title,
-                    notes.dateModified AS date
-                FROM
-                    notes
-                WHERE noteId = ?`, [noteRow.noteId]));
-        }
-
-        if (recentChanges.length >= 200) {
-            break;
+    for (const noteRevision of noteRevisions) {
+        if (noteCacheService.isInAncestor(noteRevision.noteId, ancestorNoteId)) {
+            recentChanges.push(noteRevision);
         }
     }
 
+    const notes = await sql.getRows(`
+        SELECT
+            notes.noteId,
+            notes.isDeleted AS current_isDeleted,
+            notes.deleteId AS current_deleteId,
+            notes.isErased AS current_isErased,
+            notes.title AS current_title,
+            notes.isProtected AS current_isProtected,
+            notes.title,
+            notes.utcDateCreated AS utcDate,
+            notes.dateCreated AS date
+        FROM
+            notes`);
+
+    for (const note of notes) {
+        if (noteCacheService.isInAncestor(note.noteId, ancestorNoteId)) {
+            recentChanges.push(note);
+        }
+    }
+
+    recentChanges.sort((a, b) => a.utcDate > b.utcDate ? -1 : 1);
+
+    recentChanges = recentChanges.slice(0, Math.min(500, recentChanges.length));
+
+    console.log(recentChanges);
+
     for (const change of recentChanges) {
         if (change.current_isProtected) {
             if (protectedSessionService.isProtectedSessionAvailable()) {

src/routes/api/sync.js

@@ -55,6 +55,8 @@ async function checkSync() {
 }
 
 async function syncNow() {
+    log.info("Received request to trigger sync now.");
+
     return await syncService.sync();
 }
 
@@ -168,4 +170,4 @@ module.exports = {
     getStats,
     syncFinished,
     queueSector
-};
+};