Merge 280697f2f7ef363d6ca85a7bbbbfe2ff4cc83479 into a64c4ef66f1c7c8552304b6fe120278fff0c6931

This reverts commit 0650be664d99858a55f476d92bf08dc99e2bad35.

.github/workflows/checks.yml

@@ -12,7 +12,7 @@ jobs:
     steps:
       - name: Check if PRs have conflicts
         uses: eps1lon/actions-label-merge-conflict@v3
-        if: github.repository == ${{ vars.REPO_MAIN }}
+        if: ${{ github.repository == vars.REPO_MAIN }}
         with:
           dirtyLabel: "merge-conflicts"
           repoToken: "${{ secrets.MERGE_CONFLICT_LABEL_PAT }}"

.github/workflows/deploy-docs.yml

@@ -67,7 +67,7 @@ jobs:
 
       - name: Deploy
         uses: ./.github/actions/deploy-to-cloudflare-pages
-        if: github.repository == ${{ vars.REPO_MAIN }}
+        if: ${{ github.repository == vars.REPO_MAIN }}
         with:
           project_name: "trilium-docs"
           comment_body: "📚 Documentation preview is ready"

.github/workflows/nightly.yml

@@ -26,7 +26,7 @@ permissions:
 
 jobs:
   nightly-electron:
-    if: github.repository == ${{ vars.REPO_MAIN }}
+    if: ${{ github.repository == vars.REPO_MAIN }}
     name: Deploy nightly
     strategy:
       fail-fast: false
@@ -109,7 +109,7 @@ jobs:
           path: apps/desktop/upload
 
   nightly-server:
-    if: github.repository == ${{ vars.REPO_MAIN }}
+    if: ${{ github.repository == vars.REPO_MAIN }}
     name: Deploy server nightly
     strategy:
       fail-fast: false

apps/build-docs/package.json

@@ -11,7 +11,7 @@
   "license": "AGPL-3.0-only",
   "packageManager": "pnpm@10.28.2",
   "devDependencies": {
-    "@redocly/cli": "2.14.9",
+    "@redocly/cli": "2.15.0",
     "archiver": "7.0.1",
     "fs-extra": "11.3.3",
     "react": "19.2.4",

apps/client/package.json

@@ -43,7 +43,7 @@
     "debounce": "3.0.0",
     "draggabilly": "3.0.0",
     "force-graph": "1.51.0",
-    "globals": "17.0.0",
+    "globals": "17.2.0",
     "i18next": "25.8.0",
     "i18next-http-backend": "3.0.2",
     "jquery": "4.0.0",

apps/desktop/package.json

@@ -35,7 +35,7 @@
     "@triliumnext/commons": "workspace:*",
     "@triliumnext/server": "workspace:*",
     "copy-webpack-plugin": "13.0.1",
-    "electron": "40.0.0",
+    "electron": "40.1.0",
     "@electron-forge/cli": "7.11.1",
     "@electron-forge/maker-deb": "7.11.1",
     "@electron-forge/maker-dmg": "7.11.1",

apps/edit-docs/package.json

@@ -12,7 +12,7 @@
     "@triliumnext/desktop": "workspace:*",
     "@types/fs-extra": "11.0.4",
     "copy-webpack-plugin": "13.0.1",
-    "electron": "40.0.0",
+    "electron": "40.1.0",
     "fs-extra": "11.3.3"
   },
   "scripts": {

apps/server-e2e/src/support/app.ts

@@ -59,7 +59,7 @@ export default class App {
 
         // Wait for the page to load.
         if (url === "/") {
-            await expect(this.page.locator(".tree")).toContainText("Trilium Integration Test");
+            await expect(this.page.locator(".tree", { hasText: "Trilium Integration Test" })).toBeVisible();
             if (!preserveTabs) {
                 await this.closeAllTabs();
             }
@@ -76,7 +76,7 @@ export default class App {
         const suggestionSelector = resultsSelector.locator(".aa-suggestion")
             .nth(1); // Select the second one (best candidate), as the first one is "Create a new note"
         await expect(suggestionSelector).toContainText(noteTitle);
-        suggestionSelector.click();
+        await suggestionSelector.click();
     }
 
     async goToSettings() {

apps/server/etapi.openapi.yaml

@@ -337,6 +337,130 @@ paths:
                         application/json; charset=utf-8:
                             schema:
                                 $ref: "#/components/schemas/Error"
+    /notes/{noteId}/revisions:
+        parameters:
+            - name: noteId
+              in: path
+              required: true
+              schema:
+                  $ref: "#/components/schemas/EntityId"
+        get:
+            description: Returns all revisions for a note identified by its ID
+            operationId: getNoteRevisions
+            responses:
+                "200":
+                    description: list of revisions
+                    content:
+                        application/json; charset=utf-8:
+                            schema:
+                                type: array
+                                items:
+                                    $ref: "#/components/schemas/Revision"
+                default:
+                    description: unexpected error
+                    content:
+                        application/json; charset=utf-8:
+                            schema:
+                                $ref: "#/components/schemas/Error"
+    /notes/{noteId}/undelete:
+        parameters:
+            - name: noteId
+              in: path
+              required: true
+              schema:
+                  $ref: "#/components/schemas/EntityId"
+        post:
+            description: Restore a deleted note. The note must be deleted and must have at least one undeleted parent.
+            operationId: undeleteNote
+            responses:
+                "200":
+                    description: note restored successfully
+                    content:
+                        application/json; charset=utf-8:
+                            schema:
+                                type: object
+                                properties:
+                                    success:
+                                        type: boolean
+                                        example: true
+                default:
+                    description: unexpected error
+                    content:
+                        application/json; charset=utf-8:
+                            schema:
+                                $ref: "#/components/schemas/Error"
+    /notes/history:
+        get:
+            description: Returns recent changes including note creations, modifications, and deletions
+            operationId: getNoteHistory
+            parameters:
+                - name: ancestorNoteId
+                  in: query
+                  required: false
+                  description: Limit changes to a subtree identified by this note ID. Defaults to "root" (all notes).
+                  schema:
+                      $ref: "#/components/schemas/EntityId"
+            responses:
+                "200":
+                    description: list of recent changes
+                    content:
+                        application/json; charset=utf-8:
+                            schema:
+                                type: array
+                                items:
+                                    $ref: "#/components/schemas/RecentChange"
+                default:
+                    description: unexpected error
+                    content:
+                        application/json; charset=utf-8:
+                            schema:
+                                $ref: "#/components/schemas/Error"
+    /revisions/{revisionId}:
+        parameters:
+            - name: revisionId
+              in: path
+              required: true
+              schema:
+                  $ref: "#/components/schemas/EntityId"
+        get:
+            description: Returns a revision identified by its ID
+            operationId: getRevisionById
+            responses:
+                "200":
+                    description: revision response
+                    content:
+                        application/json; charset=utf-8:
+                            schema:
+                                $ref: "#/components/schemas/Revision"
+                default:
+                    description: unexpected error
+                    content:
+                        application/json; charset=utf-8:
+                            schema:
+                                $ref: "#/components/schemas/Error"
+    /revisions/{revisionId}/content:
+        parameters:
+            - name: revisionId
+              in: path
+              required: true
+              schema:
+                  $ref: "#/components/schemas/EntityId"
+        get:
+            description: Returns revision content identified by its ID
+            operationId: getRevisionContent
+            responses:
+                "200":
+                    description: revision content response
+                    content:
+                        text/html:
+                            schema:
+                                type: string
+                default:
+                    description: unexpected error
+                    content:
+                        application/json; charset=utf-8:
+                            schema:
+                                $ref: "#/components/schemas/Error"
     /branches:
         post:
             description: >
@@ -1186,3 +1310,93 @@ components:
                     type: string
                     description: Human readable error, potentially with more details,
                     example: Note 'evnnmvHTCgIn' is protected and cannot be modified through ETAPI
+        Revision:
+            type: object
+            description: Revision represents a snapshot of note's title and content at some point in the past.
+            properties:
+                revisionId:
+                    $ref: "#/components/schemas/EntityId"
+                    readOnly: true
+                noteId:
+                    $ref: "#/components/schemas/EntityId"
+                    readOnly: true
+                type:
+                    type: string
+                    enum:
+                        [
+                            text,
+                            code,
+                            render,
+                            file,
+                            image,
+                            search,
+                            relationMap,
+                            book,
+                            noteMap,
+                            mermaid,
+                            webView,
+                            shortcut,
+                            doc,
+                            contentWidget,
+                            launcher,
+                        ]
+                mime:
+                    type: string
+                isProtected:
+                    type: boolean
+                    readOnly: true
+                title:
+                    type: string
+                blobId:
+                    type: string
+                    description: ID of the blob object which effectively serves as a content hash
+                dateLastEdited:
+                    $ref: "#/components/schemas/LocalDateTime"
+                    readOnly: true
+                dateCreated:
+                    $ref: "#/components/schemas/LocalDateTime"
+                    readOnly: true
+                utcDateLastEdited:
+                    $ref: "#/components/schemas/UtcDateTime"
+                    readOnly: true
+                utcDateCreated:
+                    $ref: "#/components/schemas/UtcDateTime"
+                    readOnly: true
+                utcDateModified:
+                    $ref: "#/components/schemas/UtcDateTime"
+                    readOnly: true
+                contentLength:
+                    type: integer
+                    format: int32
+                    readOnly: true
+        RecentChange:
+            type: object
+            description: Represents a recent change event (creation, modification, or deletion).
+            properties:
+                noteId:
+                    $ref: "#/components/schemas/EntityId"
+                    readOnly: true
+                title:
+                    type: string
+                    description: Title at the time of the change (may be "[protected]" for protected notes)
+                current_title:
+                    type: string
+                    description: Current title of the note (may be "[protected]" for protected notes)
+                current_isDeleted:
+                    type: boolean
+                    description: Whether the note is currently deleted
+                current_deleteId:
+                    type: string
+                    description: Delete ID if the note is deleted
+                current_isProtected:
+                    type: boolean
+                    description: Whether the note is protected
+                utcDate:
+                    $ref: "#/components/schemas/UtcDateTime"
+                    description: UTC timestamp of the change
+                date:
+                    $ref: "#/components/schemas/LocalDateTime"
+                    description: Local timestamp of the change
+                canBeUndeleted:
+                    type: boolean
+                    description: Whether the note can be undeleted (only present for deleted notes)

apps/server/package.json

@@ -35,7 +35,7 @@
     "sucrase": "3.35.1"
   },
   "devDependencies": {
-    "@anthropic-ai/sdk": "0.71.2",
+    "@anthropic-ai/sdk": "0.72.1",
     "@braintree/sanitize-url": "7.1.1",
     "@electron/remote": "2.1.3",
     "@triliumnext/commons": "workspace:*",
@@ -83,7 +83,7 @@
     "debounce": "3.0.0",
     "debug": "4.4.3",
     "ejs": "4.0.1",
-    "electron": "40.0.0",
+    "electron": "40.1.0",
     "electron-debug": "4.1.0",
     "electron-window-state": "5.0.3",
     "escape-html": "1.0.3",

apps/server/spec/etapi/get-note-revisions.spec.ts

@@ -0,0 +1,77 @@
+import { Application } from "express";
+import { beforeAll, describe, expect, it } from "vitest";
+import supertest from "supertest";
+import { createNote, login } from "./utils.js";
+import config from "../../src/services/config.js";
+
+let app: Application;
+let token: string;
+
+const USER = "etapi";
+let createdNoteId: string;
+
+describe("etapi/get-note-revisions", () => {
+    beforeAll(async () => {
+        config.General.noAuthentication = false;
+        const buildApp = (await (import("../../src/app.js"))).default;
+        app = await buildApp();
+        token = await login(app);
+        createdNoteId = await createNote(app, token);
+
+        // Create a revision by updating the note content
+        await supertest(app)
+            .put(`/etapi/notes/${createdNoteId}/content`)
+            .auth(USER, token, { "type": "basic" })
+            .set("Content-Type", "text/plain")
+            .send("Updated content for revision")
+            .expect(204);
+
+        // Force create a revision
+        await supertest(app)
+            .post(`/etapi/notes/${createdNoteId}/revision`)
+            .auth(USER, token, { "type": "basic" })
+            .expect(204);
+    });
+
+    it("gets revisions for a note", async () => {
+        const response = await supertest(app)
+            .get(`/etapi/notes/${createdNoteId}/revisions`)
+            .auth(USER, token, { "type": "basic" })
+            .expect(200);
+
+        expect(Array.isArray(response.body)).toBe(true);
+        expect(response.body.length).toBeGreaterThan(0);
+
+        const revision = response.body[0];
+        expect(revision).toHaveProperty("revisionId");
+        expect(revision).toHaveProperty("noteId", createdNoteId);
+        expect(revision).toHaveProperty("type");
+        expect(revision).toHaveProperty("mime");
+        expect(revision).toHaveProperty("title");
+        expect(revision).toHaveProperty("isProtected");
+        expect(revision).toHaveProperty("blobId");
+        expect(revision).toHaveProperty("utcDateCreated");
+    });
+
+    it("returns empty array for note with no revisions", async () => {
+        // Create a new note without any revisions
+        const newNoteId = await createNote(app, token, "Brand new content");
+
+        const response = await supertest(app)
+            .get(`/etapi/notes/${newNoteId}/revisions`)
+            .auth(USER, token, { "type": "basic" })
+            .expect(200);
+
+        expect(Array.isArray(response.body)).toBe(true);
+        // New notes may or may not have revisions depending on settings
+    });
+
+    it("returns 404 for non-existent note", async () => {
+        const response = await supertest(app)
+            .get("/etapi/notes/nonexistentnote/revisions")
+            .auth(USER, token, { "type": "basic" })
+            .expect(404);
+
+        expect(response.body.code).toStrictEqual("NOTE_NOT_FOUND");
+    });
+});

apps/server/spec/etapi/get-revision.spec.ts

@@ -0,0 +1,71 @@
+import { Application } from "express";
+import { beforeAll, describe, expect, it } from "vitest";
+import supertest from "supertest";
+import { createNote, login } from "./utils.js";
+import config from "../../src/services/config.js";
+
+let app: Application;
+let token: string;
+
+const USER = "etapi";
+let createdNoteId: string;
+let revisionId: string;
+
+describe("etapi/get-revision", () => {
+    beforeAll(async () => {
+        config.General.noAuthentication = false;
+        const buildApp = (await (import("../../src/app.js"))).default;
+        app = await buildApp();
+        token = await login(app);
+        createdNoteId = await createNote(app, token, "Initial content");
+
+        // Update content to create a revision
+        await supertest(app)
+            .put(`/etapi/notes/${createdNoteId}/content`)
+            .auth(USER, token, { "type": "basic" })
+            .set("Content-Type", "text/plain")
+            .send("Updated content")
+            .expect(204);
+
+        // Force create a revision
+        await supertest(app)
+            .post(`/etapi/notes/${createdNoteId}/revision`)
+            .auth(USER, token, { "type": "basic" })
+            .expect(204);
+
+        // Get the revision ID
+        const revisionsResponse = await supertest(app)
+            .get(`/etapi/notes/${createdNoteId}/revisions`)
+            .auth(USER, token, { "type": "basic" })
+            .expect(200);
+
+        expect(revisionsResponse.body.length).toBeGreaterThan(0);
+        revisionId = revisionsResponse.body[0].revisionId;
+    });
+
+    it("gets revision metadata by ID", async () => {
+        const response = await supertest(app)
+            .get(`/etapi/revisions/${revisionId}`)
+            .auth(USER, token, { "type": "basic" })
+            .expect(200);
+
+        expect(response.body).toHaveProperty("revisionId", revisionId);
+        expect(response.body).toHaveProperty("noteId", createdNoteId);
+        expect(response.body).toHaveProperty("type", "text");
+        expect(response.body).toHaveProperty("mime", "text/html");
+        expect(response.body).toHaveProperty("title", "Hello");
+        expect(response.body).toHaveProperty("isProtected", false);
+        expect(response.body).toHaveProperty("blobId");
+        expect(response.body).toHaveProperty("utcDateCreated");
+        expect(response.body).toHaveProperty("utcDateModified");
+    });
+
+    it("returns 404 for non-existent revision", async () => {
+        const response = await supertest(app)
+            .get("/etapi/revisions/nonexistentrevision")
+            .auth(USER, token, { "type": "basic" })
+            .expect(404);
+
+        expect(response.body.code).toStrictEqual("REVISION_NOT_FOUND");
+    });
+});

apps/server/spec/etapi/note-history.spec.ts

@@ -0,0 +1,94 @@
+import { Application } from "express";
+import { beforeAll, describe, expect, it } from "vitest";
+import supertest from "supertest";
+import { createNote, login } from "./utils.js";
+import config from "../../src/services/config.js";
+
+let app: Application;
+let token: string;
+
+const USER = "etapi";
+let createdNoteId: string;
+
+describe("etapi/note-history", () => {
+    beforeAll(async () => {
+        config.General.noAuthentication = false;
+        const buildApp = (await (import("../../src/app.js"))).default;
+        app = await buildApp();
+        token = await login(app);
+
+        // Create a note to ensure there's some history
+        createdNoteId = await createNote(app, token, "History test content");
+
+        // Create a revision to ensure history has entries
+        await supertest(app)
+            .post(`/etapi/notes/${createdNoteId}/revision`)
+            .auth(USER, token, { "type": "basic" })
+            .expect(204);
+    });
+
+    it("gets recent changes history", async () => {
+        const response = await supertest(app)
+            .get("/etapi/notes/history")
+            .auth(USER, token, { "type": "basic" })
+            .expect(200);
+
+        expect(Array.isArray(response.body)).toBe(true);
+        expect(response.body.length).toBeGreaterThan(0);
+
+        // Check that history entries have expected properties
+        const entry = response.body[0];
+        expect(entry).toHaveProperty("noteId");
+        expect(entry).toHaveProperty("title");
+        expect(entry).toHaveProperty("utcDate");
+        expect(entry).toHaveProperty("date");
+        expect(entry).toHaveProperty("current_isDeleted");
+        expect(entry).toHaveProperty("current_isProtected");
+    });
+
+    it("filters history by ancestor note", async () => {
+        const response = await supertest(app)
+            .get("/etapi/notes/history?ancestorNoteId=root")
+            .auth(USER, token, { "type": "basic" })
+            .expect(200);
+
+        expect(Array.isArray(response.body)).toBe(true);
+        // All results should be descendants of root (which is everything)
+    });
+
+    it("returns empty array for non-existent ancestor", async () => {
+        const response = await supertest(app)
+            .get("/etapi/notes/history?ancestorNoteId=nonexistentancestor")
+            .auth(USER, token, { "type": "basic" })
+            .expect(200);
+
+        expect(Array.isArray(response.body)).toBe(true);
+        // Should be empty since no notes are descendants of a non-existent note
+        expect(response.body.length).toBe(0);
+    });
+
+    it("includes canBeUndeleted for deleted notes", async () => {
+        // Create and delete a note
+        const noteToDeleteId = await createNote(app, token, "Note to delete for history test");
+
+        await supertest(app)
+            .delete(`/etapi/notes/${noteToDeleteId}`)
+            .auth(USER, token, { "type": "basic" })
+            .expect(204);
+
+        // Check history - deleted note should appear with canBeUndeleted property
+        const response = await supertest(app)
+            .get("/etapi/notes/history")
+            .auth(USER, token, { "type": "basic" })
+            .expect(200);
+
+        const deletedEntry = response.body.find(
+            (entry: any) => entry.noteId === noteToDeleteId && entry.current_isDeleted === true
+        );
+
+        // Deleted entries should have canBeUndeleted property
+        if (deletedEntry) {
+            expect(deletedEntry).toHaveProperty("canBeUndeleted");
+        }
+    });
+});

apps/server/spec/etapi/revision-content.spec.ts

@@ -0,0 +1,64 @@
+import { Application } from "express";
+import { beforeAll, describe, expect, it } from "vitest";
+import supertest from "supertest";
+import { createNote, login } from "./utils.js";
+import config from "../../src/services/config.js";
+
+let app: Application;
+let token: string;
+
+const USER = "etapi";
+let createdNoteId: string;
+let revisionId: string;
+
+describe("etapi/revision-content", () => {
+    beforeAll(async () => {
+        config.General.noAuthentication = false;
+        const buildApp = (await (import("../../src/app.js"))).default;
+        app = await buildApp();
+        token = await login(app);
+        createdNoteId = await createNote(app, token, "Initial revision content");
+
+        // Update content to ensure we have content in the revision
+        await supertest(app)
+            .put(`/etapi/notes/${createdNoteId}/content`)
+            .auth(USER, token, { "type": "basic" })
+            .set("Content-Type", "text/plain")
+            .send("Content after first update")
+            .expect(204);
+
+        // Force create a revision
+        await supertest(app)
+            .post(`/etapi/notes/${createdNoteId}/revision`)
+            .auth(USER, token, { "type": "basic" })
+            .expect(204);
+
+        // Get the revision ID
+        const revisionsResponse = await supertest(app)
+            .get(`/etapi/notes/${createdNoteId}/revisions`)
+            .auth(USER, token, { "type": "basic" })
+            .expect(200);
+
+        expect(revisionsResponse.body.length).toBeGreaterThan(0);
+        revisionId = revisionsResponse.body[0].revisionId;
+    });
+
+    it("gets revision content", async () => {
+        const response = await supertest(app)
+            .get(`/etapi/revisions/${revisionId}/content`)
+            .auth(USER, token, { "type": "basic" })
+            .expect(200);
+
+        expect(response.headers["content-type"]).toMatch(/text\/html/);
+        expect(response.text).toBeTruthy();
+    });
+
+    it("returns 404 for non-existent revision content", async () => {
+        const response = await supertest(app)
+            .get("/etapi/revisions/nonexistentrevision/content")
+            .auth(USER, token, { "type": "basic" })
+            .expect(404);
+
+        expect(response.body.code).toStrictEqual("REVISION_NOT_FOUND");
+    });
+});

apps/server/spec/etapi/undelete-note.spec.ts

@@ -0,0 +1,103 @@
+import { Application } from "express";
+import { beforeAll, beforeEach, describe, expect, it } from "vitest";
+import supertest from "supertest";
+import { login } from "./utils.js";
+import config from "../../src/services/config.js";
+import { randomInt } from "crypto";
+
+let app: Application;
+let token: string;
+
+const USER = "etapi";
+
+describe("etapi/undelete-note", () => {
+    beforeAll(async () => {
+        config.General.noAuthentication = false;
+        const buildApp = (await (import("../../src/app.js"))).default;
+        app = await buildApp();
+        token = await login(app);
+    });
+
+    it("undeletes a deleted note", async () => {
+        // Create a note
+        const noteId = `testNote${randomInt(10000)}`;
+        await supertest(app)
+            .post("/etapi/create-note")
+            .auth(USER, token, { "type": "basic" })
+            .send({
+                "noteId": noteId,
+                "parentNoteId": "root",
+                "title": "Note to delete and restore",
+                "type": "text",
+                "content": "Content to restore"
+            })
+            .expect(201);
+
+        // Verify note exists
+        await supertest(app)
+            .get(`/etapi/notes/${noteId}`)
+            .auth(USER, token, { "type": "basic" })
+            .expect(200);
+
+        // Delete the note
+        await supertest(app)
+            .delete(`/etapi/notes/${noteId}`)
+            .auth(USER, token, { "type": "basic" })
+            .expect(204);
+
+        // Verify note is deleted (should return 404)
+        await supertest(app)
+            .get(`/etapi/notes/${noteId}`)
+            .auth(USER, token, { "type": "basic" })
+            .expect(404);
+
+        // Undelete the note
+        const response = await supertest(app)
+            .post(`/etapi/notes/${noteId}/undelete`)
+            .auth(USER, token, { "type": "basic" })
+            .expect(200);
+
+        expect(response.body).toHaveProperty("success", true);
+
+        // Verify note is restored
+        const restoredResponse = await supertest(app)
+            .get(`/etapi/notes/${noteId}`)
+            .auth(USER, token, { "type": "basic" })
+            .expect(200);
+
+        expect(restoredResponse.body.title).toStrictEqual("Note to delete and restore");
+    });
+
+    it("returns 404 for non-existent note", async () => {
+        const response = await supertest(app)
+            .post("/etapi/notes/nonexistentnote/undelete")
+            .auth(USER, token, { "type": "basic" })
+            .expect(404);
+
+        expect(response.body.code).toStrictEqual("NOTE_NOT_FOUND");
+    });
+
+    it("returns 400 when trying to undelete a non-deleted note", async () => {
+        // Create a note
+        const noteId = `testNote${randomInt(10000)}`;
+        await supertest(app)
+            .post("/etapi/create-note")
+            .auth(USER, token, { "type": "basic" })
+            .send({
+                "noteId": noteId,
+                "parentNoteId": "root",
+                "title": "Note not deleted",
+                "type": "text",
+                "content": "Content"
+            })
+            .expect(201);
+
+        // Try to undelete a note that isn't deleted
+        const response = await supertest(app)
+            .post(`/etapi/notes/${noteId}/undelete`)
+            .auth(USER, token, { "type": "basic" })
+            .expect(400);
+
+        expect(response.body.code).toStrictEqual("NOTE_NOT_DELETED");
+    });
+});

apps/server/src/etapi/etapi_utils.ts

@@ -121,6 +121,16 @@ function getAndCheckAttribute(attributeId: string) {
     }
 }
 
+function getAndCheckRevision(revisionId: string) {
+    const revision = becca.getRevision(revisionId);
+
+    if (revision) {
+        return revision;
+    } else {
+        throw new EtapiError(404, "REVISION_NOT_FOUND", `Revision '${revisionId}' not found.`);
+    }
+}
+
 function validateAndPatch(target: any, source: any, allowedProperties: ValidatorMap) {
     for (const key of Object.keys(source)) {
         if (!(key in allowedProperties)) {
@@ -152,5 +162,6 @@ export default {
     getAndCheckNote,
     getAndCheckBranch,
     getAndCheckAttribute,
-    getAndCheckAttachment
+    getAndCheckAttachment,
+    getAndCheckRevision
 };

apps/server/src/etapi/mappers.ts

@@ -2,6 +2,7 @@ import type BAttachment from "../becca/entities/battachment.js";
 import type BAttribute from "../becca/entities/battribute.js";
 import type BBranch from "../becca/entities/bbranch.js";
 import type BNote from "../becca/entities/bnote.js";
+import type BRevision from "../becca/entities/brevision.js";
 
 function mapNoteToPojo(note: BNote) {
     return {
@@ -64,9 +65,28 @@ function mapAttachmentToPojo(attachment: BAttachment) {
     };
 }
 
+function mapRevisionToPojo(revision: BRevision) {
+    return {
+        revisionId: revision.revisionId,
+        noteId: revision.noteId,
+        type: revision.type,
+        mime: revision.mime,
+        isProtected: revision.isProtected,
+        title: revision.title,
+        blobId: revision.blobId,
+        dateLastEdited: revision.dateLastEdited,
+        dateCreated: revision.dateCreated,
+        utcDateLastEdited: revision.utcDateLastEdited,
+        utcDateCreated: revision.utcDateCreated,
+        utcDateModified: revision.utcDateModified,
+        contentLength: revision.contentLength
+    };
+}
+
 export default {
     mapNoteToPojo,
     mapBranchToPojo,
     mapAttributeToPojo,
-    mapAttachmentToPojo
+    mapAttachmentToPojo,
+    mapRevisionToPojo
 };

apps/server/src/etapi/revisions.ts

@@ -0,0 +1,205 @@
+import becca from "../becca/becca.js";
+import sql from "../services/sql.js";
+import eu from "./etapi_utils.js";
+import mappers from "./mappers.js";
+import noteService from "../services/notes.js";
+import TaskContext from "../services/task_context.js";
+import protectedSessionService from "../services/protected_session.js";
+import utils from "../services/utils.js";
+import type { Router } from "express";
+import type { NoteRow, RecentChangeRow } from "@triliumnext/commons";
+
+function register(router: Router) {
+    // GET /etapi/notes/history - must be registered before /etapi/notes/:noteId routes
+    eu.route(router, "get", "/etapi/notes/history", (req, res, next) => {
+        const ancestorNoteId = (req.query.ancestorNoteId as string) || "root";
+
+        let recentChanges: RecentChangeRow[];
+
+        if (ancestorNoteId === "root") {
+            // Optimized path: no ancestor filtering needed, fetch directly from DB
+            recentChanges = sql.getRows<RecentChangeRow>(`
+                SELECT
+                    notes.noteId,
+                    notes.isDeleted AS current_isDeleted,
+                    notes.deleteId AS current_deleteId,
+                    notes.title AS current_title,
+                    notes.isProtected AS current_isProtected,
+                    revisions.title,
+                    revisions.utcDateCreated AS utcDate,
+                    revisions.dateCreated AS date
+                FROM revisions
+                JOIN notes USING(noteId)
+                UNION ALL
+                SELECT
+                    notes.noteId,
+                    notes.isDeleted AS current_isDeleted,
+                    notes.deleteId AS current_deleteId,
+                    notes.title AS current_title,
+                    notes.isProtected AS current_isProtected,
+                    notes.title,
+                    notes.utcDateCreated AS utcDate,
+                    notes.dateCreated AS date
+                FROM notes
+                UNION ALL
+                SELECT
+                    notes.noteId,
+                    notes.isDeleted AS current_isDeleted,
+                    notes.deleteId AS current_deleteId,
+                    notes.title AS current_title,
+                    notes.isProtected AS current_isProtected,
+                    notes.title,
+                    notes.utcDateModified AS utcDate,
+                    notes.dateModified AS date
+                FROM notes
+                WHERE notes.isDeleted = 1
+                ORDER BY utcDate DESC
+                LIMIT 500`);
+        } else {
+            // Use recursive CTE to find all descendants, then filter at DB level
+            // This pushes filtering to the database for much better performance
+            recentChanges = sql.getRows<RecentChangeRow>(`
+                WITH RECURSIVE descendants(noteId) AS (
+                    SELECT ?
+                    UNION
+                    SELECT branches.noteId
+                    FROM branches
+                    JOIN descendants ON branches.parentNoteId = descendants.noteId
+                )
+                SELECT
+                    notes.noteId,
+                    notes.isDeleted AS current_isDeleted,
+                    notes.deleteId AS current_deleteId,
+                    notes.title AS current_title,
+                    notes.isProtected AS current_isProtected,
+                    revisions.title,
+                    revisions.utcDateCreated AS utcDate,
+                    revisions.dateCreated AS date
+                FROM revisions
+                JOIN notes USING(noteId)
+                WHERE notes.noteId IN (SELECT noteId FROM descendants)
+                UNION ALL
+                SELECT
+                    notes.noteId,
+                    notes.isDeleted AS current_isDeleted,
+                    notes.deleteId AS current_deleteId,
+                    notes.title AS current_title,
+                    notes.isProtected AS current_isProtected,
+                    notes.title,
+                    notes.utcDateCreated AS utcDate,
+                    notes.dateCreated AS date
+                FROM notes
+                WHERE notes.noteId IN (SELECT noteId FROM descendants)
+                UNION ALL
+                SELECT
+                    notes.noteId,
+                    notes.isDeleted AS current_isDeleted,
+                    notes.deleteId AS current_deleteId,
+                    notes.title AS current_title,
+                    notes.isProtected AS current_isProtected,
+                    notes.title,
+                    notes.utcDateModified AS utcDate,
+                    notes.dateModified AS date
+                FROM notes
+                WHERE notes.isDeleted = 1 AND notes.noteId IN (SELECT noteId FROM descendants)
+                ORDER BY utcDate DESC
+                LIMIT 500`, [ancestorNoteId]);
+        }
+
+        for (const change of recentChanges) {
+            if (change.current_isProtected) {
+                if (protectedSessionService.isProtectedSessionAvailable()) {
+                    change.title = protectedSessionService.decryptString(change.title) || "[protected]";
+                    change.current_title = protectedSessionService.decryptString(change.current_title) || "[protected]";
+                } else {
+                    change.title = change.current_title = "[protected]";
+                }
+            }
+
+            if (change.current_isDeleted) {
+                const deleteId = change.current_deleteId;
+
+                const undeletedParentBranchIds = noteService.getUndeletedParentBranchIds(change.noteId, deleteId);
+
+                // note (and the subtree) can be undeleted if there's at least one undeleted parent (whose branch would be undeleted by this op)
+                change.canBeUndeleted = undeletedParentBranchIds.length > 0;
+            }
+        }
+
+        res.json(recentChanges);
+    });
+
+    // GET /etapi/notes/:noteId/revisions - List all revisions for a note
+    eu.route(router, "get", "/etapi/notes/:noteId/revisions", (req, res, next) => {
+        const note = eu.getAndCheckNote(req.params.noteId);
+
+        const revisions = becca.getRevisionsFromQuery(
+            `SELECT revisions.*, LENGTH(blobs.content) AS contentLength
+             FROM revisions
+             JOIN blobs USING (blobId)
+             WHERE noteId = ?
+             ORDER BY utcDateCreated DESC`,
+            [note.noteId]
+        );
+
+        res.json(revisions.map((revision) => mappers.mapRevisionToPojo(revision)));
+    });
+
+    // POST /etapi/notes/:noteId/undelete - Restore a deleted note
+    eu.route(router, "post", "/etapi/notes/:noteId/undelete", (req, res, next) => {
+        const { noteId } = req.params;
+
+        const noteRow = sql.getRow<NoteRow | null>("SELECT * FROM notes WHERE noteId = ?", [noteId]);
+
+        if (!noteRow) {
+            throw new eu.EtapiError(404, "NOTE_NOT_FOUND", `Note '${noteId}' not found.`);
+        }
+
+        if (!noteRow.isDeleted || !noteRow.deleteId) {
+            throw new eu.EtapiError(400, "NOTE_NOT_DELETED", `Note '${noteId}' is not deleted.`);
+        }
+
+        const undeletedParentBranchIds = noteService.getUndeletedParentBranchIds(noteId, noteRow.deleteId);
+
+        if (undeletedParentBranchIds.length === 0) {
+            throw new eu.EtapiError(400, "CANNOT_UNDELETE", `Cannot undelete note '${noteId}' - no undeleted parent found.`);
+        }
+
+        const taskContext = new TaskContext("no-progress-reporting", "undeleteNotes", null);
+        noteService.undeleteNote(noteId, taskContext);
+
+        res.json({ success: true });
+    });
+
+    // GET /etapi/revisions/:revisionId - Get revision metadata
+    eu.route(router, "get", "/etapi/revisions/:revisionId", (req, res, next) => {
+        const revision = eu.getAndCheckRevision(req.params.revisionId);
+
+        if (revision.isProtected) {
+            throw new eu.EtapiError(400, "REVISION_IS_PROTECTED", `Revision '${req.params.revisionId}' is protected and cannot be read through ETAPI.`);
+        }
+
+        res.json(mappers.mapRevisionToPojo(revision));
+    });
+
+    // GET /etapi/revisions/:revisionId/content - Get revision content
+    eu.route(router, "get", "/etapi/revisions/:revisionId/content", (req, res, next) => {
+        const revision = eu.getAndCheckRevision(req.params.revisionId);
+
+        if (revision.isProtected) {
+            throw new eu.EtapiError(400, "REVISION_IS_PROTECTED", `Revision '${req.params.revisionId}' is protected and content cannot be read through ETAPI.`);
+        }
+
+        const filename = utils.formatDownloadTitle(revision.title, revision.type, revision.mime);
+
+        res.setHeader("Content-Disposition", utils.getContentDisposition(filename));
+        res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
+        res.setHeader("Content-Type", revision.mime);
+
+        res.send(revision.getContent());
+    });
+}
+
+export default {
+    register
+};

apps/server/src/routes/routes.ts

@@ -12,6 +12,7 @@ import etapiMetricsRoute from "../etapi/metrics.js";
 import etapiNoteRoutes from "../etapi/notes.js";
 import etapiSpecRoute from "../etapi/spec.js";
 import etapiSpecialNoteRoutes from "../etapi/special_notes.js";
+import etapiRevisionsRoutes from "../etapi/revisions.js";
 import auth from "../services/auth.js";
 import openID from '../services/open_id.js';
 import { isElectron } from "../services/utils.js";
@@ -361,6 +362,8 @@ function register(app: express.Application) {
     etapiAttachmentRoutes.register(router);
     etapiAttributeRoutes.register(router);
     etapiBranchRoutes.register(router);
+    // Register revisions routes BEFORE notes routes so /etapi/notes/history is matched before /etapi/notes/:noteId
+    etapiRevisionsRoutes.register(router);
     etapiNoteRoutes.register(router);
     etapiSpecialNoteRoutes.register(router);
     etapiSpecRoute.register(router);

apps/website/package.json

@@ -17,7 +17,7 @@
 		"react-i18next": "16.5.4"
 	},
 	"devDependencies": {
-		"@preact/preset-vite": "2.10.2",
+		"@preact/preset-vite": "2.10.3",
 		"eslint": "9.39.2",
 		"eslint-config-preact": "2.0.0",
 		"typescript": "5.9.3",

package.json

@@ -46,7 +46,7 @@
   "devDependencies": {
     "@electron/rebuild": "4.0.3",
     "@fast-csv/parse": "5.0.5",
-    "@playwright/test": "1.57.0",
+    "@playwright/test": "1.58.0",
     "@triliumnext/server": "workspace:*",
     "@types/express": "5.0.6",
     "@types/js-yaml": "4.0.9",
@@ -73,7 +73,7 @@
     "tslib": "2.8.1",
     "tsx": "4.21.0",
     "typescript": "5.9.3",
-    "typescript-eslint": "8.53.0",
+    "typescript-eslint": "8.54.0",
     "upath": "2.0.1",
     "vite": "7.3.1",
     "vite-plugin-dts": "4.5.4",

packages/ckeditor5-admonition/package.json

@@ -24,8 +24,8 @@
     "@ckeditor/ckeditor5-dev-build-tools": "54.3.2",
     "@ckeditor/ckeditor5-inspector": ">=4.1.0",
     "@ckeditor/ckeditor5-package-tools": "5.0.1",
-    "@typescript-eslint/eslint-plugin": "8.53.0",
-    "@typescript-eslint/parser": "8.53.0",
+    "@typescript-eslint/eslint-plugin": "8.54.0",
+    "@typescript-eslint/parser": "8.54.0",
     "@vitest/browser": "4.0.18",
     "@vitest/coverage-istanbul": "4.0.18",
     "ckeditor5": "47.4.0",

packages/ckeditor5-footnotes/package.json

@@ -25,8 +25,8 @@
     "@ckeditor/ckeditor5-dev-build-tools": "54.3.2",
     "@ckeditor/ckeditor5-inspector": ">=4.1.0",
     "@ckeditor/ckeditor5-package-tools": "5.0.1",
-    "@typescript-eslint/eslint-plugin": "8.53.0",
-    "@typescript-eslint/parser": "8.53.0",
+    "@typescript-eslint/eslint-plugin": "8.54.0",
+    "@typescript-eslint/parser": "8.54.0",
     "@vitest/browser": "4.0.18",
     "@vitest/coverage-istanbul": "4.0.18",
     "ckeditor5": "47.4.0",

packages/ckeditor5-keyboard-marker/package.json

@@ -27,8 +27,8 @@
     "@ckeditor/ckeditor5-dev-build-tools": "54.3.2",
     "@ckeditor/ckeditor5-inspector": ">=4.1.0",
     "@ckeditor/ckeditor5-package-tools": "5.0.1",
-    "@typescript-eslint/eslint-plugin": "8.53.0",
-    "@typescript-eslint/parser": "8.53.0",
+    "@typescript-eslint/eslint-plugin": "8.54.0",
+    "@typescript-eslint/parser": "8.54.0",
     "@vitest/browser": "4.0.18",
     "@vitest/coverage-istanbul": "4.0.18",
     "ckeditor5": "47.4.0",

packages/ckeditor5-math/package.json

@@ -27,8 +27,8 @@
     "@ckeditor/ckeditor5-dev-build-tools": "54.3.2",
     "@ckeditor/ckeditor5-inspector": ">=4.1.0",
     "@ckeditor/ckeditor5-package-tools": "5.0.1",
-    "@typescript-eslint/eslint-plugin": "8.53.0",
-    "@typescript-eslint/parser": "8.53.0",
+    "@typescript-eslint/eslint-plugin": "8.54.0",
+    "@typescript-eslint/parser": "8.54.0",
     "@vitest/browser": "4.0.18",
     "@vitest/coverage-istanbul": "4.0.18",
     "ckeditor5": "47.4.0",

packages/ckeditor5-mermaid/package.json

@@ -27,8 +27,8 @@
     "@ckeditor/ckeditor5-dev-build-tools": "54.3.2",
     "@ckeditor/ckeditor5-inspector": ">=4.1.0",
     "@ckeditor/ckeditor5-package-tools": "5.0.1",
-    "@typescript-eslint/eslint-plugin": "8.53.0",
-    "@typescript-eslint/parser": "8.53.0",
+    "@typescript-eslint/eslint-plugin": "8.54.0",
+    "@typescript-eslint/parser": "8.54.0",
     "@vitest/browser": "4.0.18",
     "@vitest/coverage-istanbul": "4.0.18",
     "ckeditor5": "47.4.0",

packages/ckeditor5/package.json

@@ -16,7 +16,7 @@
     "ckeditor5-premium-features": "47.4.0"
   },
   "devDependencies": {
-    "@smithy/middleware-retry": "4.4.27",
+    "@smithy/middleware-retry": "4.4.29",
     "@types/jquery": "3.5.33"
   }
 }

packages/share-theme/package.json

@@ -31,8 +31,8 @@
   "devDependencies": {
     "@digitak/esrun": "3.2.26",
     "@triliumnext/ckeditor5": "workspace:*",
-    "@typescript-eslint/eslint-plugin": "8.53.0",
-    "@typescript-eslint/parser": "8.53.0",
+    "@typescript-eslint/eslint-plugin": "8.54.0",
+    "@typescript-eslint/parser": "8.54.0",
     "dotenv": "17.2.3",
     "esbuild": "0.27.2",
     "eslint": "9.39.2",