joplin-mcp-server 1.0.0

package/dist/tests/unit/create-tools.test.js

@@ -0,0 +1,223 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import JoplinAPIClient from "../../lib/joplin-api-client.js";
+import CreateNote from "../../lib/tools/create-note.js";
+import CreateFolder from "../../lib/tools/create-folder.js";
+// Mock JoplinAPIClient
+vi.mock("../../lib/joplin-api-client.js", () => {
+    const mockClient = {
+        post: vi.fn(),
+        get: vi.fn(),
+    };
+    return { default: vi.fn(() => mockClient) };
+});
+describe("Create Tools", () => {
+    let mockApiClient;
+    let createNote;
+    let createFolder;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockApiClient = new JoplinAPIClient({ token: "test-token" });
+        createNote = new CreateNote(mockApiClient);
+        createFolder = new CreateFolder(mockApiClient);
+    });
+    describe("CreateNote", () => {
+        it("should create a note with title and body", async () => {
+            const mockCreatedNote = {
+                id: "note-123",
+                title: "Test Note",
+                body: "Test content",
+                created_time: 1234567890000,
+                updated_time: 1234567890000,
+                parent_id: null,
+                is_todo: false,
+            };
+            mockApiClient.post.mockResolvedValue(mockCreatedNote);
+            const result = await createNote.call({
+                title: "Test Note",
+                body: "Test content",
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/notes", {
+                title: "Test Note",
+                body: "Test content",
+            });
+            expect(result).toContain("✅ Successfully created note!");
+            expect(result).toContain("Test Note");
+            expect(result).toContain("note-123");
+        });
+        it("should create a note in a specific notebook", async () => {
+            const mockCreatedNote = {
+                id: "note-123",
+                title: "Test Note",
+                body: "Test content",
+                created_time: 1234567890000,
+                updated_time: 1234567890000,
+                parent_id: "notebook-456",
+                is_todo: false,
+            };
+            const mockNotebook = {
+                id: "notebook-456",
+                title: "Test Notebook",
+            };
+            mockApiClient.post.mockResolvedValue(mockCreatedNote);
+            mockApiClient.get.mockResolvedValue(mockNotebook);
+            const result = await createNote.call({
+                title: "Test Note",
+                body: "Test content",
+                parent_id: "notebook-456",
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/notes", {
+                title: "Test Note",
+                body: "Test content",
+                parent_id: "notebook-456",
+            });
+            expect(result).toContain("Test Notebook");
+        });
+        it("should create a todo note", async () => {
+            const mockCreatedNote = {
+                id: "note-123",
+                title: "Test Todo",
+                body: "Todo content",
+                created_time: 1234567890000,
+                updated_time: 1234567890000,
+                parent_id: null,
+                is_todo: true,
+                todo_completed: false,
+            };
+            mockApiClient.post.mockResolvedValue(mockCreatedNote);
+            const result = await createNote.call({
+                title: "Test Todo",
+                body: "Todo content",
+                is_todo: true,
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/notes", {
+                title: "Test Todo",
+                body: "Todo content",
+                is_todo: true,
+            });
+            expect(result).toContain("Type: Todo item");
+        });
+        it("should validate required fields", async () => {
+            const result = await createNote.call({});
+            expect(result).toContain("Please provide at least a title, body, or body_html");
+            expect(mockApiClient.post).not.toHaveBeenCalled();
+        });
+        it("should validate parent_id format", async () => {
+            const result = await createNote.call({
+                title: "Test Note",
+                parent_id: "short",
+            });
+            expect(result).toContain("does not appear to be a valid notebook ID");
+            expect(mockApiClient.post).not.toHaveBeenCalled();
+        });
+        it("should handle API errors", async () => {
+            mockApiClient.post.mockRejectedValue(new Error("API Error"));
+            const result = await createNote.call({
+                title: "Test Note",
+            });
+            expect(result).toContain("Error creating note");
+        });
+        it("should handle 404 errors for parent notebook", async () => {
+            const error = new Error("Not found");
+            error.response = { status: 404 };
+            mockApiClient.post.mockRejectedValue(error);
+            const result = await createNote.call({
+                title: "Test Note",
+                parent_id: "a1b2c3d4e5f6789012345678901234567890abcd",
+            });
+            expect(result).toContain("Notebook with ID");
+            expect(result).toContain("not found");
+        });
+    });
+    describe("CreateFolder", () => {
+        it("should create a folder with title", async () => {
+            const mockCreatedFolder = {
+                id: "folder-123",
+                title: "Test Folder",
+                parent_id: null,
+                created_time: 1234567890000,
+                updated_time: 1234567890000,
+            };
+            mockApiClient.post.mockResolvedValue(mockCreatedFolder);
+            const result = await createFolder.call({
+                title: "Test Folder",
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/folders", {
+                title: "Test Folder",
+            });
+            expect(result).toContain("✅ Successfully created notebook!");
+            expect(result).toContain("Test Folder");
+            expect(result).toContain("folder-123");
+        });
+        it("should create a subfolder", async () => {
+            const mockCreatedFolder = {
+                id: "folder-123",
+                title: "Test Subfolder",
+                parent_id: "parent-456",
+                created_time: 1234567890000,
+                updated_time: 1234567890000,
+            };
+            const mockParentFolder = {
+                id: "parent-456",
+                title: "Parent Folder",
+            };
+            mockApiClient.post.mockResolvedValue(mockCreatedFolder);
+            mockApiClient.get.mockResolvedValue(mockParentFolder);
+            const result = await createFolder.call({
+                title: "Test Subfolder",
+                parent_id: "parent-456",
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/folders", {
+                title: "Test Subfolder",
+                parent_id: "parent-456",
+            });
+            expect(result).toContain("Parent Folder");
+        });
+        it("should validate required title", async () => {
+            const result = await createFolder.call({});
+            expect(result).toContain("Please provide a title");
+            expect(mockApiClient.post).not.toHaveBeenCalled();
+        });
+        it("should validate empty title", async () => {
+            const result = await createFolder.call({
+                title: "   ",
+            });
+            expect(result).toContain("Please provide a title");
+            expect(mockApiClient.post).not.toHaveBeenCalled();
+        });
+        it("should validate parent_id format", async () => {
+            const result = await createFolder.call({
+                title: "Test Folder",
+                parent_id: "short",
+            });
+            expect(result).toContain("does not appear to be a valid parent notebook ID");
+            expect(mockApiClient.post).not.toHaveBeenCalled();
+        });
+        it("should handle API errors", async () => {
+            mockApiClient.post.mockRejectedValue(new Error("API Error"));
+            const result = await createFolder.call({
+                title: "Test Folder",
+            });
+            expect(result).toContain("Error creating notebook");
+        });
+        it("should handle 404 errors for parent folder", async () => {
+            const error = new Error("Not found");
+            error.response = { status: 404 };
+            mockApiClient.post.mockRejectedValue(error);
+            const result = await createFolder.call({
+                title: "Test Folder",
+                parent_id: "a1b2c3d4e5f6789012345678901234567890abcd",
+            });
+            expect(result).toContain("Parent notebook with ID");
+            expect(result).toContain("not found");
+        });
+        it("should handle 409 conflict errors", async () => {
+            const error = new Error("Conflict");
+            error.response = { status: 409 };
+            mockApiClient.post.mockRejectedValue(error);
+            const result = await createFolder.call({
+                title: "Existing Folder",
+            });
+            expect(result).toContain('notebook with the title "Existing Folder" might already exist');
+        });
+    });
+});

package/dist/tests/unit/delete-tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/unit/delete-tools.test.js

@@ -0,0 +1,225 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import JoplinAPIClient from "../../lib/joplin-api-client.js";
+import DeleteNote from "../../lib/tools/delete-note.js";
+import DeleteFolder from "../../lib/tools/delete-folder.js";
+// Mock JoplinAPIClient
+vi.mock("../../lib/joplin-api-client.js", () => {
+    const mockClient = {
+        get: vi.fn(),
+        delete: vi.fn(),
+    };
+    return { default: vi.fn(() => mockClient) };
+});
+describe("Delete Tools", () => {
+    let mockApiClient;
+    let deleteNote;
+    let deleteFolder;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockApiClient = new JoplinAPIClient({ token: "test-token" });
+        deleteNote = new DeleteNote(mockApiClient);
+        deleteFolder = new DeleteFolder(mockApiClient);
+    });
+    describe("DeleteNote", () => {
+        const mockNote = {
+            id: "note-123",
+            title: "Test Note",
+            body: "This is a test note content",
+            parent_id: "notebook-456",
+            is_todo: false,
+            todo_completed: false,
+            created_time: 1234567890000,
+            updated_time: 1234567891000,
+        };
+        it("should require confirmation before deleting", async () => {
+            const result = await deleteNote.call({
+                note_id: "a1b2c3d4e5f6789012345678901234567890abcd",
+            });
+            expect(result).toContain("This will permanently delete the note!");
+            expect(result).toContain('"confirm": true');
+            expect(mockApiClient.get).not.toHaveBeenCalled();
+            expect(mockApiClient.delete).not.toHaveBeenCalled();
+        });
+        it("should delete note with confirmation", async () => {
+            const mockNotebook = { title: "Test Notebook" };
+            mockApiClient.get.mockResolvedValueOnce(mockNote).mockResolvedValueOnce(mockNotebook);
+            mockApiClient.delete.mockResolvedValue({});
+            const result = await deleteNote.call({
+                note_id: "a1b2c3d4e5f6789012345678901234567890abcd",
+                confirm: true,
+            });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/notes/a1b2c3d4e5f6789012345678901234567890abcd", {
+                query: { fields: "id,title,body,parent_id,is_todo,todo_completed,created_time,updated_time" },
+            });
+            expect(mockApiClient.delete).toHaveBeenCalledWith("/notes/a1b2c3d4e5f6789012345678901234567890abcd");
+            expect(result).toContain("🗑️  Successfully deleted note!");
+            expect(result).toContain("Test Note");
+            expect(result).toContain("Test Notebook");
+        });
+        it("should delete todo note with status", async () => {
+            const mockTodo = { ...mockNote, is_todo: true, todo_completed: true };
+            mockApiClient.get.mockResolvedValue(mockTodo);
+            mockApiClient.delete.mockResolvedValue({});
+            const result = await deleteNote.call({
+                note_id: "a1b2c3d4e5f6789012345678901234567890abcd",
+                confirm: true,
+            });
+            expect(result).toContain("Type: Todo (Completed)");
+        });
+        it("should handle note not found", async () => {
+            mockApiClient.get.mockResolvedValue(null);
+            const result = await deleteNote.call({
+                note_id: "a1b2c3d4e5f6789012345678901234567890abcd",
+                confirm: true,
+            });
+            expect(result).toContain("Note with ID");
+            expect(result).toContain("not found");
+            expect(mockApiClient.delete).not.toHaveBeenCalled();
+        });
+        it("should validate note_id format", async () => {
+            const result = await deleteNote.call({
+                note_id: "short",
+                confirm: true,
+            });
+            expect(result).toContain("does not appear to be a valid note ID");
+            expect(mockApiClient.get).not.toHaveBeenCalled();
+        });
+        it("should handle API errors", async () => {
+            mockApiClient.get.mockResolvedValue(mockNote);
+            mockApiClient.delete.mockRejectedValue(new Error("API Error"));
+            const result = await deleteNote.call({
+                note_id: "a1b2c3d4e5f6789012345678901234567890abcd",
+                confirm: true,
+            });
+            expect(result).toContain("Error deleting note");
+        });
+        it("should handle 404 errors on delete", async () => {
+            mockApiClient.get.mockResolvedValue(mockNote);
+            const error = new Error("Not found");
+            error.response = { status: 404 };
+            mockApiClient.delete.mockRejectedValue(error);
+            const result = await deleteNote.call({
+                note_id: "a1b2c3d4e5f6789012345678901234567890abcd",
+                confirm: true,
+            });
+            expect(result).toContain("Note with ID");
+            expect(result).toContain("not found");
+        });
+    });
+    describe("DeleteFolder", () => {
+        const mockFolder = {
+            id: "folder-123",
+            title: "Test Folder",
+            parent_id: "parent-456",
+        };
+        it("should require confirmation before deleting", async () => {
+            const result = await deleteFolder.call({
+                folder_id: "a1b2c3d4e5f6789012345678901234567890abcd",
+            });
+            expect(result).toContain("This will permanently delete the notebook/folder!");
+            expect(result).toContain('"confirm": true');
+            expect(mockApiClient.get).not.toHaveBeenCalled();
+            expect(mockApiClient.delete).not.toHaveBeenCalled();
+        });
+        it("should delete empty folder with confirmation", async () => {
+            const mockParent = { title: "Parent Folder" };
+            mockApiClient.get
+                .mockResolvedValueOnce(mockFolder)
+                .mockResolvedValueOnce({ items: [] }) // notes
+                .mockResolvedValueOnce({ items: [] }) // subfolders
+                .mockResolvedValueOnce(mockParent);
+            mockApiClient.delete.mockResolvedValue({});
+            const result = await deleteFolder.call({
+                folder_id: "a1b2c3d4e5f6789012345678901234567890abcd",
+                confirm: true,
+            });
+            expect(mockApiClient.delete).toHaveBeenCalledWith("/folders/a1b2c3d4e5f6789012345678901234567890abcd");
+            expect(result).toContain("🗑️  Successfully deleted notebook!");
+            expect(result).toContain("Test Folder");
+            expect(result).toContain("Parent Folder");
+        });
+        it("should warn about non-empty folder without force", async () => {
+            const mockNotes = { items: [{ id: "note1", title: "Note 1" }] };
+            const mockSubfolders = { items: [{ id: "sub1", title: "Subfolder 1" }] };
+            mockApiClient.get
+                .mockResolvedValueOnce(mockFolder)
+                .mockResolvedValueOnce(mockNotes)
+                .mockResolvedValueOnce({ items: mockSubfolders.items });
+            const result = await deleteFolder.call({
+                folder_id: "a1b2c3d4e5f6789012345678901234567890abcd",
+                confirm: true,
+            });
+            expect(result).toContain("Cannot delete non-empty notebook!");
+            expect(result).toContain("Contains: 1 notes and 0 subfolders");
+            expect(result).toContain("Force delete");
+            expect(mockApiClient.delete).not.toHaveBeenCalled();
+        });
+        it("should force delete non-empty folder when requested", async () => {
+            const mockNotes = { items: [{ id: "note1", title: "Note 1" }] };
+            const mockSubfolders = { items: [] };
+            mockApiClient.get
+                .mockResolvedValueOnce(mockFolder)
+                .mockResolvedValueOnce(mockNotes)
+                .mockResolvedValueOnce({ items: mockSubfolders.items });
+            mockApiClient.delete.mockResolvedValue({});
+            const result = await deleteFolder.call({
+                folder_id: "a1b2c3d4e5f6789012345678901234567890abcd",
+                confirm: true,
+                force: true,
+            });
+            expect(mockApiClient.delete).toHaveBeenCalledWith("/folders/a1b2c3d4e5f6789012345678901234567890abcd");
+            expect(result).toContain("🗑️  Successfully deleted notebook!");
+            expect(result).toContain("Deleted Content: 1 notes and 0 subfolders");
+        });
+        it("should handle folder not found", async () => {
+            mockApiClient.get.mockResolvedValue(null);
+            const result = await deleteFolder.call({
+                folder_id: "a1b2c3d4e5f6789012345678901234567890abcd",
+                confirm: true,
+            });
+            expect(result).toContain("Folder with ID");
+            expect(result).toContain("not found");
+            expect(mockApiClient.delete).not.toHaveBeenCalled();
+        });
+        it("should validate folder_id format", async () => {
+            const result = await deleteFolder.call({
+                folder_id: "short",
+                confirm: true,
+            });
+            expect(result).toContain("does not appear to be a valid folder ID");
+            expect(mockApiClient.get).not.toHaveBeenCalled();
+        });
+        it("should handle API errors", async () => {
+            mockApiClient.get
+                .mockResolvedValueOnce(mockFolder)
+                .mockResolvedValueOnce({ items: [] })
+                .mockResolvedValueOnce({ items: [] });
+            mockApiClient.delete.mockRejectedValue(new Error("API Error"));
+            const result = await deleteFolder.call({
+                folder_id: "a1b2c3d4e5f6789012345678901234567890abcd",
+                confirm: true,
+            });
+            expect(result).toContain("Error deleting folder");
+        });
+        it("should handle 409 conflict errors", async () => {
+            mockApiClient.get
+                .mockResolvedValueOnce(mockFolder)
+                .mockResolvedValueOnce({ items: [] })
+                .mockResolvedValueOnce({ items: [] });
+            const error = new Error("Conflict");
+            error.response = { status: 409 };
+            mockApiClient.delete.mockRejectedValue(error);
+            const result = await deleteFolder.call({
+                folder_id: "a1b2c3d4e5f6789012345678901234567890abcd",
+                confirm: true,
+            });
+            expect(result).toContain("Cannot delete folder");
+            expect(result).toContain("may contain items that prevent deletion");
+        });
+        it("should validate required parameters", async () => {
+            const result = await deleteFolder.call({});
+            expect(result).toContain("Please provide folder deletion options");
+            expect(mockApiClient.get).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/tests/unit/edit-tools.test.d.ts

@@ -0,0 +1 @@
+export {};