From 21b892ec448e3e9f46623d8c233def42201cd9ca Mon Sep 17 00:00:00 2001
From: oshankkkk <oshankodagoda200667@gmail.com>
Date: Sat, 11 Apr 2026 07:58:11 +0530
Subject: [PATCH 1/7] feat: add note options frontend

---
 frontend/src/Puffnote.tsx           | 10 ++--------
 frontend/src/components/Options.tsx | 20 ++++++++++++++++++++
 2 files changed, 22 insertions(+), 8 deletions(-)
 create mode 100644 frontend/src/components/Options.tsx

diff --git a/frontend/src/Puffnote.tsx b/frontend/src/Puffnote.tsx
index e092e90..1730b68 100644
--- a/frontend/src/Puffnote.tsx
+++ b/frontend/src/Puffnote.tsx
@@ -6,6 +6,7 @@ import {
   SignUpButton,
 } from "@clerk/clerk-react";
 import { Editor } from "./components/Editor";
+import { Options } from "./components/Options";
 import { Sidebar } from "./components/Sidebar";
 import { useNotes } from "./hooks/useNotes";
 
@@ -35,14 +36,7 @@ function NotesApp() {
         onToggle={() => setSidebarOpen(!sidebarOpen)}
       />
       <main className={`flex-1 transition-[margin] duration-300 ease min-h-screen w-full relative ${sidebarOpen ? "ml-[250px]" : "ml-0"}`}>
-        <div className="absolute top-4 right-5 z-50 md:right-15">
-          <button
-            type="button"
-            className="inline-flex items-center rounded-xl border border-border bg-card/95 px-4 py-2 text-sm font-medium text-foreground shadow-lg backdrop-blur transition hover:bg-accent"
-          >
-            Share note
-          </button>
-        </div>
+        <Options />
 
         <div className="h-full pt-16 md:pt-4">
           <Editor activeNote={activeNote} updateNoteContent={updateNoteContent} />
diff --git a/frontend/src/components/Options.tsx b/frontend/src/components/Options.tsx
new file mode 100644
index 0000000..323dc1a
--- /dev/null
+++ b/frontend/src/components/Options.tsx
@@ -0,0 +1,20 @@
+export function Options() {
+  return (
+    <div className="absolute top-4 right-5 z-50 md:right-15">
+      <div className="flex items-center gap-3">
+        <button
+          type="button"
+          className="inline-flex items-center rounded-xl border border-border bg-card/95 px-4 py-2 text-sm font-medium text-foreground shadow-lg backdrop-blur transition hover:bg-accent"
+        >
+          Share note
+        </button>
+        <button
+          type="button"
+          className="inline-flex items-center rounded-xl border border-border bg-card/95 px-4 py-2 text-sm font-medium text-foreground shadow-lg backdrop-blur transition hover:bg-accent"
+        >
+          Import notes
+        </button>
+      </div>
+    </div>
+  );
+}

From 2659072c2e0ff7ad02b0bb152a4990734584040f Mon Sep 17 00:00:00 2001
From: oshankkkk <oshankodagoda200667@gmail.com>
Date: Sat, 11 Apr 2026 09:01:28 +0530
Subject: [PATCH 2/7] feat: add import files frontend routing and file input

---
 frontend/src/Puffnote.tsx           |  3 ++-
 frontend/src/components/Options.tsx | 31 +++++++++++++++++++++-
 frontend/src/hooks/useNotes.ts      | 40 +++++++++++++++++++++++++++++
 3 files changed, 72 insertions(+), 2 deletions(-)

diff --git a/frontend/src/Puffnote.tsx b/frontend/src/Puffnote.tsx
index 1730b68..8da1d87 100644
--- a/frontend/src/Puffnote.tsx
+++ b/frontend/src/Puffnote.tsx
@@ -17,6 +17,7 @@ function NotesApp() {
     activeNote,
     setActiveIndex,
     createNote,
+    handleImportNotes,
     updateNoteContent,
     renameNote,
     deleteNote,
@@ -36,7 +37,7 @@ function NotesApp() {
         onToggle={() => setSidebarOpen(!sidebarOpen)}
       />
       <main className={`flex-1 transition-[margin] duration-300 ease min-h-screen w-full relative ${sidebarOpen ? "ml-[250px]" : "ml-0"}`}>
-        <Options />
+        <Options onImportNotes={handleImportNotes} />
 
         <div className="h-full pt-16 md:pt-4">
           <Editor activeNote={activeNote} updateNoteContent={updateNoteContent} />
diff --git a/frontend/src/components/Options.tsx b/frontend/src/components/Options.tsx
index 323dc1a..df1946f 100644
--- a/frontend/src/components/Options.tsx
+++ b/frontend/src/components/Options.tsx
@@ -1,6 +1,34 @@
-export function Options() {
+import { useRef, type ChangeEvent } from "react";
+
+type Props = {
+  onImportNotes: (file: File) => Promise<void> | void;
+};
+
+export function Options({ onImportNotes }: Props) {
+  const fileInputRef = useRef<HTMLInputElement | null>(null);
+
+  function handleImportButtonClick() {
+    if (!fileInputRef.current) return;
+    fileInputRef.current.value = "";
+    fileInputRef.current.click();
+  }
+
+  function handleFileChange(event: ChangeEvent<HTMLInputElement>) {
+    const file = event.target.files?.[0];
+    if (!file) return;
+
+    void onImportNotes(file);
+    event.target.value = "";
+  }
+
   return (
     <div className="absolute top-4 right-5 z-50 md:right-15">
+      <input
+        ref={fileInputRef}
+        type="file"
+        className="hidden"
+        onChange={handleFileChange}
+      />
       <div className="flex items-center gap-3">
         <button
           type="button"
@@ -10,6 +38,7 @@ export function Options() {
         </button>
         <button
           type="button"
+          onClick={handleImportButtonClick}
           className="inline-flex items-center rounded-xl border border-border bg-card/95 px-4 py-2 text-sm font-medium text-foreground shadow-lg backdrop-blur transition hover:bg-accent"
         >
           Import notes
diff --git a/frontend/src/hooks/useNotes.ts b/frontend/src/hooks/useNotes.ts
index ad7c0f6..07b181d 100644
--- a/frontend/src/hooks/useNotes.ts
+++ b/frontend/src/hooks/useNotes.ts
@@ -104,6 +104,30 @@ async function deleteNoteRequest(id: string, getToken: GetToken): Promise<void>
   }
 }
 
+async function importNotes(file: File, getToken: GetToken): Promise<void> {
+  const url = BASEURL + "/notes/imports";
+  const formData = new FormData();
+  formData.append("file", file);
+
+  const headers = await authHeaders(getToken);
+
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      credentials: "include",
+      body: formData,
+    });
+
+    if (!response.ok) {
+      throw new Error("request failed");
+    }
+  } catch (err) {
+    console.error(err);
+    throw err;
+  }
+}
+
 export function useNotes() {
   const { isLoaded, isSignedIn, getToken } = useAuth();
   const [notes, setNotes] = useState<Note[]>([]);
@@ -211,6 +235,21 @@ export function useNotes() {
     [getToken, notes]
   );
 
+  const handleImportNotes = useCallback(
+    async (file: File) => {
+      try {
+        await importNotes(file, getToken);
+
+        const loadedNotes = await loadNotes(getToken);
+        setNotes(loadedNotes);
+        setActiveIndex(Math.max(loadedNotes.length - 1, 0));
+      } catch (err) {
+        console.error(err);
+      }
+    },
+    [getToken]
+  );
+
   const activeNote = notes[activeIndex] ?? null;
 
   return {
@@ -219,6 +258,7 @@ export function useNotes() {
     activeNote,
     setActiveIndex,
     createNote,
+    handleImportNotes,
     updateNoteContent,
     renameNote,
     deleteNote,

From 2dbd6d174b6271741b904651fec09eae9f49c657 Mon Sep 17 00:00:00 2001
From: oshankkkk <oshankodagoda200667@gmail.com>
Date: Sat, 11 Apr 2026 09:17:14 +0530
Subject: [PATCH 3/7] feat: commit add import files route validations and
 handler scafolding and mux

---
 backend/cmd/server/main.go                  |  9 +++++++++
 backend/internal/api/handler/handler.go     | 18 ++++++++++++++++++
 backend/internal/api/validator/validator.go | 20 ++++++++++++++++++++
 3 files changed, 47 insertions(+)

diff --git a/backend/cmd/server/main.go b/backend/cmd/server/main.go
index a889445..c161eaf 100644
--- a/backend/cmd/server/main.go
+++ b/backend/cmd/server/main.go
@@ -81,6 +81,15 @@ func main() {
 		}
 	})))
 
+	mux.Handle("/notes/imports", authMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.Method {
+		case http.MethodPost:
+			handler.ImportNotesHandler(w, r)
+		default:
+			http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+		}
+	})))
+
 	mux.Handle("/notes/", authMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch r.Method {
 		case http.MethodGet:
diff --git a/backend/internal/api/handler/handler.go b/backend/internal/api/handler/handler.go
index b1722c2..b789e38 100644
--- a/backend/internal/api/handler/handler.go
+++ b/backend/internal/api/handler/handler.go
@@ -83,6 +83,24 @@ func (h *Handler) CreateNodeHandler(w http.ResponseWriter, r *http.Request) {
 	response.WriteResponse(w, http.StatusAccepted, fmt.Sprintf("%d", noteID))
 }
 
+func (h *Handler) ImportNotesHandler(w http.ResponseWriter, r *http.Request) {
+	h.Logger.Debug("ImportNotesHandler called")
+
+	httperr := validator.ImportNotesValidator(r)
+	if httperr != nil {
+		validator.WriteError(w, httperr)
+		return
+	}
+
+	clerkID, ok := auth.UserIDFromContext(r.Context())
+	if !ok {
+		http.Error(w, "unauthorized", http.StatusUnauthorized)
+		return
+	}
+	fmt.Println(clerkID)
+	//response.WriteResponse(w, http.StatusAccepted, fmt.Sprintf("%d", noteID))
+}
+
 func (db *Handler) UpdateNoteHandler(w http.ResponseWriter, r *http.Request) {
 	db.Logger.Debug("UpdateNoteHandler called")
 
diff --git a/backend/internal/api/validator/validator.go b/backend/internal/api/validator/validator.go
index e978a43..eb0d11f 100644
--- a/backend/internal/api/validator/validator.go
+++ b/backend/internal/api/validator/validator.go
@@ -135,3 +135,23 @@ func UpdateNoteValidator(r *http.Request) (int, *httpError) {
 
 	return id, nil
 }
+
+func ImportNotesValidator(r *http.Request) *httpError {
+	if err := validatehttpmethod(r, http.MethodPost); err != nil {
+		return &httpError{Status: http.StatusMethodNotAllowed, Msg: "method not supported"}
+	}
+
+	contentType := r.Header.Get("Content-Type")
+	if !strings.HasPrefix(contentType, "multipart/form-data") {
+		log.Printf("invalid content-type: %s", contentType)
+		return &httpError{Status: http.StatusUnsupportedMediaType, Msg: "media not supported"}
+	}
+
+	parts := formatpath(r.URL.Path)
+	if len(parts) != 2 || parts[0] != "notes" || parts[1] != "imports" {
+		log.Printf("invalid path: %s", r.URL.Path)
+		return &httpError{Status: http.StatusBadRequest, Msg: "path wrong"}
+	}
+
+	return nil
+}

From 628bff3bcdd4a07919e6ccb1225b2e82dc890d5f Mon Sep 17 00:00:00 2001
From: oshankkkk <oshankodagoda200667@gmail.com>
Date: Sun, 12 Apr 2026 21:47:26 +0530
Subject: [PATCH 4/7] feat: tiptap markdown to json conversion

---
 backend/internal/api/handler/handler.go     |  2 +-
 backend/internal/api/validator/validator.go |  2 +-
 frontend/src/components/Editor.tsx          | 40 ++++++++++-----------
 frontend/src/editor.ts                      | 31 ++++++++++++++++
 frontend/src/hooks/useNotes.ts              | 38 ++++++++++----------
 5 files changed, 71 insertions(+), 42 deletions(-)
 create mode 100644 frontend/src/editor.ts

diff --git a/backend/internal/api/handler/handler.go b/backend/internal/api/handler/handler.go
index b789e38..0a85160 100644
--- a/backend/internal/api/handler/handler.go
+++ b/backend/internal/api/handler/handler.go
@@ -97,7 +97,7 @@ func (h *Handler) ImportNotesHandler(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "unauthorized", http.StatusUnauthorized)
 		return
 	}
-	fmt.Println(clerkID)
+	fmt.Println(clerkID,"yay")
 	//response.WriteResponse(w, http.StatusAccepted, fmt.Sprintf("%d", noteID))
 }
 
diff --git a/backend/internal/api/validator/validator.go b/backend/internal/api/validator/validator.go
index eb0d11f..0f2ad0a 100644
--- a/backend/internal/api/validator/validator.go
+++ b/backend/internal/api/validator/validator.go
@@ -142,7 +142,7 @@ func ImportNotesValidator(r *http.Request) *httpError {
 	}
 
 	contentType := r.Header.Get("Content-Type")
-	if !strings.HasPrefix(contentType, "multipart/form-data") {
+	if contentType != "application/json"  {
 		log.Printf("invalid content-type: %s", contentType)
 		return &httpError{Status: http.StatusUnsupportedMediaType, Msg: "media not supported"}
 	}
diff --git a/frontend/src/components/Editor.tsx b/frontend/src/components/Editor.tsx
index 71b8454..81fcab3 100644
--- a/frontend/src/components/Editor.tsx
+++ b/frontend/src/components/Editor.tsx
@@ -1,12 +1,7 @@
-import { useEditor, EditorContent } from "@tiptap/react";
-import StarterKit from "@tiptap/starter-kit";
-import { Markdown } from "@tiptap/markdown";
-import CodeBlockLowlight from "@tiptap/extension-code-block-lowlight";
-import { createLowlight, common } from "lowlight";
-import { useEffect } from "react";
+import { EditorContent, useEditor } from "@tiptap/react";
+import { useEffect, useRef } from "react";
 import type { Note } from "../hooks/useNotes";
-
-const lowlight = createLowlight(common);
+import { editorExtensions, normalizeEditorContent } from "../editor";
 
 type Props = {
   activeNote: Note | null;
@@ -14,16 +9,17 @@ type Props = {
 };
 
 export function Editor({ activeNote, updateNoteContent }: Props) {
+  const updateNoteContentRef = useRef(updateNoteContent);
+
+  useEffect(() => {
+    updateNoteContentRef.current = updateNoteContent;
+  }, [updateNoteContent]);
+
   const editor = useEditor({
-    extensions: [
-      StarterKit.configure({ codeBlock: false }),
-      CodeBlockLowlight.configure({ lowlight }),
-      Markdown,
-    ],
-    content: activeNote?.content ?? "",
-    contentType: "markdown",
+    extensions: editorExtensions,
+    content: normalizeEditorContent(activeNote?.content),
     onUpdate({ editor }) {
-      updateNoteContent(editor.getJSON());
+      updateNoteContentRef.current(editor.getJSON());
     },
     onBlur({ editor }) {
       setTimeout(() => {
@@ -32,7 +28,6 @@ export function Editor({ activeNote, updateNoteContent }: Props) {
     },
   });
 
-  // Auto-focus on mount and when the window regains focus
   useEffect(() => {
     const timer = setTimeout(() => editor?.commands.focus(), 100);
     return () => clearTimeout(timer);
@@ -44,16 +39,17 @@ export function Editor({ activeNote, updateNoteContent }: Props) {
     return () => window.removeEventListener("focus", onFocus);
   }, [editor]);
 
-  // When switching notes, update editor content
   useEffect(() => {
-    if (!editor || !activeNote) return;
+    if (!editor) return;
+
     const currentJson = JSON.stringify(editor.getJSON());
-    const targetContent = activeNote.content;
+    const targetContent = normalizeEditorContent(activeNote?.content);
     const targetJson = JSON.stringify(targetContent);
+
     if (currentJson !== targetJson) {
-      editor.commands.setContent(targetContent as string | object, { emitUpdate: false });
+      editor.commands.setContent(targetContent, { emitUpdate: false });
     }
-  }, [editor, activeNote?.id]); // eslint-disable-line react-hooks/exhaustive-deps
+  }, [editor, activeNote]);
 
   return (
     <EditorContent
diff --git a/frontend/src/editor.ts b/frontend/src/editor.ts
new file mode 100644
index 0000000..08e6a5d
--- /dev/null
+++ b/frontend/src/editor.ts
@@ -0,0 +1,31 @@
+import type { Content, JSONContent } from "@tiptap/core";
+import CodeBlockLowlight from "@tiptap/extension-code-block-lowlight";
+import { Markdown, MarkdownManager } from "@tiptap/markdown";
+import StarterKit from "@tiptap/starter-kit";
+import { createLowlight, common } from "lowlight";
+
+const lowlight = createLowlight(common);
+
+export const editorExtensions = [
+  StarterKit.configure({ codeBlock: false }),
+  CodeBlockLowlight.configure({ lowlight }),
+  Markdown,
+];
+
+const markdownManager = new MarkdownManager({
+  extensions: editorExtensions,
+});
+
+export function parseMarkdownContent(markdown: string): JSONContent {
+  return markdownManager.parse(markdown);
+}
+
+export function normalizeEditorContent(
+  content: object | string | null | undefined
+): Content {
+  if (typeof content === "string") {
+    return parseMarkdownContent(content);
+  }
+
+  return (content ?? parseMarkdownContent("")) as Content;
+}
diff --git a/frontend/src/hooks/useNotes.ts b/frontend/src/hooks/useNotes.ts
index 07b181d..3b19097 100644
--- a/frontend/src/hooks/useNotes.ts
+++ b/frontend/src/hooks/useNotes.ts
@@ -1,5 +1,6 @@
 import { useState, useCallback, useEffect } from "react";
 import { useAuth } from "@clerk/clerk-react";
+import { parseMarkdownContent } from "../editor";
 
 const BASEURL = import.meta.env.VITE_API_BASE_URL;
 
@@ -106,25 +107,26 @@ async function deleteNoteRequest(id: string, getToken: GetToken): Promise<void>
 
 async function importNotes(file: File, getToken: GetToken): Promise<void> {
   const url = BASEURL + "/notes/imports";
-  const formData = new FormData();
-  formData.append("file", file);
-
   const headers = await authHeaders(getToken);
-
-  try {
-    const response = await fetch(url, {
-      method: "POST",
-      headers,
-      credentials: "include",
-      body: formData,
-    });
-
-    if (!response.ok) {
-      throw new Error("request failed");
-    }
-  } catch (err) {
-    console.error(err);
-    throw err;
+  const markdown = await file.text();
+  const content = parseMarkdownContent(markdown);
+  const title = file.name.replace(/\.md$/i, "");
+
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      ...headers,
+      "Content-Type": "application/json",
+    },
+    credentials: "include",
+    body: JSON.stringify({
+      title,
+      content,
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error("request failed");
   }
 }
 

From 3724babc95817ebf699b447a0be0006f7b67f180 Mon Sep 17 00:00:00 2001
From: oshankkkk <oshankodagoda200667@gmail.com>
Date: Sun, 12 Apr 2026 21:57:40 +0530
Subject: [PATCH 5/7] feat: call api handler functions for import notes

---
 backend/internal/api/handler/handler.go | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/backend/internal/api/handler/handler.go b/backend/internal/api/handler/handler.go
index 0a85160..70c77c2 100644
--- a/backend/internal/api/handler/handler.go
+++ b/backend/internal/api/handler/handler.go
@@ -83,8 +83,8 @@ func (h *Handler) CreateNodeHandler(w http.ResponseWriter, r *http.Request) {
 	response.WriteResponse(w, http.StatusAccepted, fmt.Sprintf("%d", noteID))
 }
 
-func (h *Handler) ImportNotesHandler(w http.ResponseWriter, r *http.Request) {
-	h.Logger.Debug("ImportNotesHandler called")
+func (db *Handler) ImportNotesHandler(w http.ResponseWriter, r *http.Request) {
+	db.Logger.Debug("ImportNotesHandler called")
 
 	httperr := validator.ImportNotesValidator(r)
 	if httperr != nil {
@@ -97,8 +97,18 @@ func (h *Handler) ImportNotesHandler(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "unauthorized", http.StatusUnauthorized)
 		return
 	}
-	fmt.Println(clerkID,"yay")
-	//response.WriteResponse(w, http.StatusAccepted, fmt.Sprintf("%d", noteID))
+	noteID, err := db.Service.CreateNote(r.Context(), clerkID)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	note, err := request.UpdateNoteparser(r)
+	check(err)
+
+	db.Service.UpdateNodeById(r.Context(), note, noteID)
+
+	response.WriteResponse(w, http.StatusAccepted, fmt.Sprintf("%d", noteID))
 }
 
 func (db *Handler) UpdateNoteHandler(w http.ResponseWriter, r *http.Request) {
@@ -114,6 +124,7 @@ func (db *Handler) UpdateNoteHandler(w http.ResponseWriter, r *http.Request) {
 	check(err)
 
 	db.Service.UpdateNodeById(r.Context(), note, id)
+
 }
 
 func (db *Handler) DelNoteHandler(w http.ResponseWriter, r *http.Request) {

From 79dd48b8f90e3fb686c832825f31d4b0055674ce Mon Sep 17 00:00:00 2001
From: oshankkkk <oshankodagoda200667@gmail.com>
Date: Sun, 12 Apr 2026 22:35:56 +0530
Subject: [PATCH 6/7] fix: update note error handling and note passing

---
 backend/internal/api/handler/handler.go      |  28 ++++-
 backend/internal/api/handler/handler_test.go | 117 ++++++++++++++++---
 2 files changed, 124 insertions(+), 21 deletions(-)

diff --git a/backend/internal/api/handler/handler.go b/backend/internal/api/handler/handler.go
index 70c77c2..1243936 100644
--- a/backend/internal/api/handler/handler.go
+++ b/backend/internal/api/handler/handler.go
@@ -97,16 +97,27 @@ func (db *Handler) ImportNotesHandler(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "unauthorized", http.StatusUnauthorized)
 		return
 	}
+
+	note, err := request.UpdateNoteparser(r)
+	if err != nil {
+		http.Error(w, "invalid request body", http.StatusBadRequest)
+		return
+	}
+
 	noteID, err := db.Service.CreateNote(r.Context(), clerkID)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 
-	note, err := request.UpdateNoteparser(r)
-	check(err)
+	if err := db.Service.UpdateNodeById(r.Context(), note, noteID); err != nil {
+		if deleteErr := db.Service.DelNoteById(r.Context(), noteID); deleteErr != nil {
+			db.Logger.Error("failed to delete imported note after update failure", "note_id", noteID, "error", deleteErr)
+		}
 
-	db.Service.UpdateNodeById(r.Context(), note, noteID)
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
 
 	response.WriteResponse(w, http.StatusAccepted, fmt.Sprintf("%d", noteID))
 }
@@ -121,10 +132,15 @@ func (db *Handler) UpdateNoteHandler(w http.ResponseWriter, r *http.Request) {
 	}
 
 	note, err := request.UpdateNoteparser(r)
-	check(err)
-
-	db.Service.UpdateNodeById(r.Context(), note, id)
+	if err != nil {
+		http.Error(w, "invalid request body", http.StatusBadRequest)
+		return
+	}
 
+	if err := db.Service.UpdateNodeById(r.Context(), note, id); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
 }
 
 func (db *Handler) DelNoteHandler(w http.ResponseWriter, r *http.Request) {
diff --git a/backend/internal/api/handler/handler_test.go b/backend/internal/api/handler/handler_test.go
index ce793c8..53443f5 100644
--- a/backend/internal/api/handler/handler_test.go
+++ b/backend/internal/api/handler/handler_test.go
@@ -4,19 +4,21 @@ import (
 	"backend/internal/api/request"
 	"backend/internal/db"
 	"context"
+	"errors"
 	"io"
 	"log/slog"
 	"net/http"
 	"net/http/httptest"
 	"strings"
 	"testing"
+
+	clerk "github.com/clerk/clerk-sdk-go/v2"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 )
 
 type MockService struct {
 	mock.Mock
-
 }
 
 func (m *MockService) GetNoteById(ctx context.Context, noteID int) (db.Note, error) {
@@ -44,6 +46,13 @@ func (m *MockService) CreateNote(ctx context.Context, clerkid string) (int, erro
 	return args.Int(0), args.Error(1)
 }
 
+func authenticatedRequest(req *http.Request, userID string) *http.Request {
+	claims := &clerk.SessionClaims{}
+	claims.Subject = userID
+	ctx := clerk.ContextWithSessionClaims(req.Context(), claims)
+	return req.WithContext(ctx)
+}
+
 func TestNoteHandler(t *testing.T) {
 	mockService := new(MockService)
 
@@ -52,8 +61,8 @@ func TestNoteHandler(t *testing.T) {
 		Return(db.Note{ID: 1}, nil)
 
 	handler := Handler{Service: mockService,
-	Logger: slog.New(slog.NewTextHandler(io.Discard,nil)),
-}
+		Logger: slog.New(slog.NewTextHandler(io.Discard, nil)),
+	}
 
 	req := httptest.NewRequest(http.MethodGet, "/notes/1", nil)
 	w := httptest.NewRecorder()
@@ -72,8 +81,8 @@ func TestNoteListHandler(t *testing.T) {
 		Return([]db.Note{}, nil)
 
 	handler := Handler{Service: mockService,
-	Logger: slog.New(slog.NewTextHandler(io.Discard,nil)),
-}
+		Logger: slog.New(slog.NewTextHandler(io.Discard, nil)),
+	}
 
 	req := httptest.NewRequest(http.MethodGet, "/notes", nil)
 	w := httptest.NewRecorder()
@@ -92,34 +101,114 @@ func TestUpdateNoteHandler(t *testing.T) {
 		Return(nil)
 
 	handler := Handler{Service: mockService,
+		Logger: slog.New(slog.NewTextHandler(io.Discard, nil)),
+	}
+
+	body := `{"title":"test","content":{}}`
+	req := httptest.NewRequest(http.MethodPatch, "/notes/1", strings.NewReader(body))
+	w := httptest.NewRecorder()
+	req.Header.Set("Content-Type", "application/json")
+
+	handler.UpdateNoteHandler(w, req)
 
-	Logger: slog.New(slog.NewTextHandler(io.Discard,nil)),
+	assert.Equal(t, http.StatusOK, w.Code)
+	mockService.AssertExpectations(t)
 }
 
-	body := `{"title":"test","content":{}}`
-	req := httptest.NewRequest(http.MethodPatch, "/notes/1", 
-		strings.NewReader(body))
+func TestUpdateNoteHandlerRejectsInvalidJSON(t *testing.T) {
+	mockService := new(MockService)
+	handler := Handler{Service: mockService,
+		Logger: slog.New(slog.NewTextHandler(io.Discard, nil)),
+	}
 
+	req := httptest.NewRequest(http.MethodPatch, "/notes/1", strings.NewReader(`{"title":`))
+	w := httptest.NewRecorder()
 	req.Header.Set("Content-Type", "application/json")
+
+	handler.UpdateNoteHandler(w, req)
+
+	assert.Equal(t, http.StatusBadRequest, w.Code)
+	mockService.AssertNotCalled(t, "UpdateNodeById", mock.Anything, mock.Anything, mock.Anything)
+}
+
+func TestUpdateNoteHandlerReturnsInternalServerErrorOnUpdateFailure(t *testing.T) {
+	mockService := new(MockService)
+	mockService.
+		On("UpdateNodeById", mock.Anything, mock.Anything, 1).
+		Return(errors.New("update failed"))
+
+	handler := Handler{Service: mockService,
+		Logger: slog.New(slog.NewTextHandler(io.Discard, nil)),
+	}
+
+	body := `{"title":"test","content":{}}`
+	req := httptest.NewRequest(http.MethodPatch, "/notes/1", strings.NewReader(body))
 	w := httptest.NewRecorder()
+	req.Header.Set("Content-Type", "application/json")
 
 	handler.UpdateNoteHandler(w, req)
 
+	assert.Equal(t, http.StatusInternalServerError, w.Code)
 	mockService.AssertExpectations(t)
 }
 
-func TestDelNoteHandler(t *testing.T) {
+func TestImportNotesHandlerRejectsInvalidJSONBeforeCreate(t *testing.T) {
 	mockService := new(MockService)
+	handler := Handler{Service: mockService,
+		Logger: slog.New(slog.NewTextHandler(io.Discard, nil)),
+	}
+
+	req := httptest.NewRequest(http.MethodPost, "/notes/imports", strings.NewReader(`{"title":`))
+	req = authenticatedRequest(req, "user_123")
+	req.Header.Set("Content-Type", "application/json")
+	w := httptest.NewRecorder()
+
+	handler.ImportNotesHandler(w, req)
+
+	assert.Equal(t, http.StatusBadRequest, w.Code)
+	mockService.AssertNotCalled(t, "CreateNote", mock.Anything, mock.Anything)
+	mockService.AssertNotCalled(t, "UpdateNodeById", mock.Anything, mock.Anything, mock.Anything)
+	mockService.AssertNotCalled(t, "DelNoteById", mock.Anything, mock.Anything)
+}
 
+func TestImportNotesHandlerDeletesCreatedNoteOnUpdateFailure(t *testing.T) {
+	mockService := new(MockService)
 	mockService.
-		On("DelNoteById", mock.Anything, 1).
+		On("CreateNote", mock.Anything, "user_123").
+		Return(42, nil)
+	mockService.
+		On("UpdateNodeById", mock.Anything, mock.Anything, 42).
+		Return(errors.New("update failed"))
+	mockService.
+		On("DelNoteById", mock.Anything, 42).
 		Return(nil)
 
-
 	handler := Handler{Service: mockService,
-	Logger: slog.New(slog.NewTextHandler(io.Discard,nil)),
+		Logger: slog.New(slog.NewTextHandler(io.Discard, nil)),
+	}
+
+	body := `{"title":"test","content":{}}`
+	req := httptest.NewRequest(http.MethodPost, "/notes/imports", strings.NewReader(body))
+	req = authenticatedRequest(req, "user_123")
+	req.Header.Set("Content-Type", "application/json")
+	w := httptest.NewRecorder()
+
+	handler.ImportNotesHandler(w, req)
+
+	assert.Equal(t, http.StatusInternalServerError, w.Code)
+	mockService.AssertExpectations(t)
 }
 
+func TestDelNoteHandler(t *testing.T) {
+	mockService := new(MockService)
+
+	mockService.
+		On("DelNoteById", mock.Anything, 1).
+		Return(nil)
+
+	handler := Handler{Service: mockService,
+		Logger: slog.New(slog.NewTextHandler(io.Discard, nil)),
+	}
 
 	req := httptest.NewRequest(http.MethodDelete, "/notes/1", nil)
 	w := httptest.NewRecorder()
@@ -128,5 +217,3 @@ func TestDelNoteHandler(t *testing.T) {
 
 	mockService.AssertExpectations(t)
 }
-
-

From e8e44f8e672c5766d836baade3a1c33c847b2b16 Mon Sep 17 00:00:00 2001
From: oshankkkk <oshankodagoda200667@gmail.com>
Date: Sun, 12 Apr 2026 22:51:24 +0530
Subject: [PATCH 7/7] fix: add mime parser for validations

---
 backend/internal/api/validator/validator.go   | 24 ++++++---
 .../internal/api/validator/validator_test.go  | 51 +++++++++++++++++--
 2 files changed, 62 insertions(+), 13 deletions(-)

diff --git a/backend/internal/api/validator/validator.go b/backend/internal/api/validator/validator.go
index 0f2ad0a..a96e518 100644
--- a/backend/internal/api/validator/validator.go
+++ b/backend/internal/api/validator/validator.go
@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"log"
+	"mime"
 	"net/http"
 	"strconv"
 	"strings"
@@ -36,6 +37,17 @@ func formatpath(path string) []string {
 	return strings.Split(path, "/")
 }
 
+func validateJSONContentType(r *http.Request) *httpError {
+	contentType := r.Header.Get("Content-Type")
+	mediaType, _, err := mime.ParseMediaType(contentType)
+	if err != nil || mediaType != "application/json" {
+		log.Printf("invalid content-type: %s", contentType)
+		return &httpError{Status: http.StatusUnsupportedMediaType, Msg: "media not supported"}
+	}
+
+	return nil
+}
+
 func GetNoteValidator(r *http.Request) (int, *httpError) {
 	if err := validatehttpmethod(r, http.MethodGet); err != nil {
 		return 0, &httpError{Status: http.StatusBadRequest, Msg: "method is not supported"}
@@ -110,10 +122,8 @@ func UpdateNoteValidator(r *http.Request) (int, *httpError) {
 		return 0, &httpError{Status: http.StatusMethodNotAllowed, Msg: "method not supported"}
 	}
 
-	contentType := r.Header.Get("Content-Type")
-	if contentType != "application/json" {
-		log.Printf("invalid content-type: %s", contentType)
-		return 0, &httpError{Status: http.StatusUnsupportedMediaType, Msg: "media not supported"}
+	if err := validateJSONContentType(r); err != nil {
+		return 0, err
 	}
 
 	if r.ContentLength == 0 {
@@ -141,10 +151,8 @@ func ImportNotesValidator(r *http.Request) *httpError {
 		return &httpError{Status: http.StatusMethodNotAllowed, Msg: "method not supported"}
 	}
 
-	contentType := r.Header.Get("Content-Type")
-	if contentType != "application/json"  {
-		log.Printf("invalid content-type: %s", contentType)
-		return &httpError{Status: http.StatusUnsupportedMediaType, Msg: "media not supported"}
+	if err := validateJSONContentType(r); err != nil {
+		return err
 	}
 
 	parts := formatpath(r.URL.Path)
diff --git a/backend/internal/api/validator/validator_test.go b/backend/internal/api/validator/validator_test.go
index 0e9889c..ae4e45b 100644
--- a/backend/internal/api/validator/validator_test.go
+++ b/backend/internal/api/validator/validator_test.go
@@ -10,7 +10,7 @@ import (
 )
 
 /*
-   GetNoteValidator
+GetNoteValidator
 */
 func TestGetNoteValidator_Success(t *testing.T) {
 	req := httptest.NewRequest(http.MethodGet, "/notes/1", nil)
@@ -30,7 +30,7 @@ func TestGetNoteValidator_InvalidMethod(t *testing.T) {
 }
 
 /*
-   GetNotelistValidator
+GetNotelistValidator
 */
 func TestGetNotelistValidator_Success(t *testing.T) {
 	req := httptest.NewRequest(http.MethodGet, "/notes", nil)
@@ -49,7 +49,7 @@ func TestGetNotelistValidator_InvalidPath(t *testing.T) {
 }
 
 /*
-   CreateNoteValidator
+CreateNoteValidator
 */
 func TestCreateNoteValidator_Success(t *testing.T) {
 	req := httptest.NewRequest(http.MethodPost, "/notes", nil)
@@ -68,7 +68,7 @@ func TestCreateNoteValidator_InvalidMethod(t *testing.T) {
 }
 
 /*
-   DeleteNoteValidator
+DeleteNoteValidator
 */
 func TestDeleteNoteValidator_Success(t *testing.T) {
 	req := httptest.NewRequest(http.MethodDelete, "/notes/2", nil)
@@ -88,7 +88,7 @@ func TestDeleteNoteValidator_InvalidID(t *testing.T) {
 }
 
 /*
-   UpdateNoteValidator
+UpdateNoteValidator
 */
 func TestUpdateNoteValidator_Success(t *testing.T) {
 	body := strings.NewReader(`{"title":"test"}`)
@@ -101,6 +101,17 @@ func TestUpdateNoteValidator_Success(t *testing.T) {
 	assert.Equal(t, 3, id)
 }
 
+func TestUpdateNoteValidator_AcceptsContentTypeParameters(t *testing.T) {
+	body := strings.NewReader(`{"title":"test"}`)
+	req := httptest.NewRequest(http.MethodPatch, "/notes/3", body)
+	req.Header.Set("Content-Type", "application/json; charset=utf-8")
+
+	id, err := UpdateNoteValidator(req)
+
+	assert.Nil(t, err)
+	assert.Equal(t, 3, id)
+}
+
 func TestUpdateNoteValidator_InvalidContentType(t *testing.T) {
 	body := strings.NewReader(`{"title":"test"}`)
 	req := httptest.NewRequest(http.MethodPatch, "/notes/3", body)
@@ -110,3 +121,33 @@ func TestUpdateNoteValidator_InvalidContentType(t *testing.T) {
 
 	assert.NotNil(t, err)
 }
+
+func TestImportNotesValidator_Success(t *testing.T) {
+	body := strings.NewReader(`{"title":"test","content":{}}`)
+	req := httptest.NewRequest(http.MethodPost, "/notes/imports", body)
+	req.Header.Set("Content-Type", "application/json")
+
+	err := ImportNotesValidator(req)
+
+	assert.Nil(t, err)
+}
+
+func TestImportNotesValidator_AcceptsContentTypeParameters(t *testing.T) {
+	body := strings.NewReader(`{"title":"test","content":{}}`)
+	req := httptest.NewRequest(http.MethodPost, "/notes/imports", body)
+	req.Header.Set("Content-Type", "application/json; charset=utf-8")
+
+	err := ImportNotesValidator(req)
+
+	assert.Nil(t, err)
+}
+
+func TestImportNotesValidator_InvalidContentType(t *testing.T) {
+	body := strings.NewReader(`{"title":"test","content":{}}`)
+	req := httptest.NewRequest(http.MethodPost, "/notes/imports", body)
+	req.Header.Set("Content-Type", "text/plain")
+
+	err := ImportNotesValidator(req)
+
+	assert.NotNil(t, err)
+}