From 18c2af792826ea4ad7522f44408eddb8a7022fa8 Mon Sep 17 00:00:00 2001
From: Kristian Borgwarth <10348902@pm.me>
Date: Thu, 2 Apr 2026 11:29:10 +0200
Subject: [PATCH] ref(server): simplified server

---
 cmd/main.go                                   |  1 +
 core/rpc/models.go                            |  2 +-
 core/server/server.go                         | 31 +++++++++----------
 .../create_note_handler_test.go               | 25 +++++++++------
 test/test_integration/main_test.go            | 30 +++++++++++++++---
 5 files changed, 57 insertions(+), 32 deletions(-)

diff --git a/cmd/main.go b/cmd/main.go
index d2efd75..9848439 100644
--- a/cmd/main.go
+++ b/cmd/main.go
@@ -1,6 +1,7 @@
 package main
 
 import (
+	"database/sql"
 	"log/slog"
 	"os"
 
diff --git a/core/rpc/models.go b/core/rpc/models.go
index 3dcb7f1..e8ddfb3 100644
--- a/core/rpc/models.go
+++ b/core/rpc/models.go
@@ -15,7 +15,7 @@ type Request struct {
 type Response struct {
 	Jsonrpc string `json:"jsonrpc"`
 	ID      *int   `json:"id"`
-	Result  any    `json:"result,omitempty"`
+	Result  json.RawMessage `json:"result,omitempty"`
 	Error   *Error `json:"error,omitempty"`
 }
 
diff --git a/core/server/server.go b/core/server/server.go
index a9bf558..6aed220 100644
--- a/core/server/server.go
+++ b/core/server/server.go
@@ -1,17 +1,20 @@
-// Package server contains the server running the JSON-RPC 2.0 Protocol. 
+// Package server contains the server running the JSON-RPC 2.0 Protocol.
 package server
 
 import (
 	"bufio"
 	"context"
+	"database/sql"
 	"encoding/json"
 	"fmt"
 	"io"
+
 	"github.com/KristianJBorgwarth/dendrite.daemon/core/handlers"
 	"github.com/KristianJBorgwarth/dendrite.daemon/core/rpc"
 )
 
 type Server struct {
+	Db *sql.DB
 	handlers map[string]handlers.Handler
 }
 
@@ -21,6 +24,10 @@ func NewServer() *Server {
 	}
 }
 
+func (s *Server) InitDatabase(db *sql.DB) {
+	s.Db = db
+}
+
 func (s *Server) Register(method string, handler handlers.Handler) {
 	s.handlers[method] = handler
 }
@@ -51,31 +58,21 @@ func (s *Server) handle(w io.Writer, req rpc.Request) {
 	handler, ok := s.handlers[req.Method]
 
 	if !ok {
-		s.respond(w, req.ID, nil, &rpc.Error{
-			Code:    -32601,
-			Message: "method not found",
+		s.write(w, rpc.Response{
+			Jsonrpc: "2.0",
+			ID:      req.ID,
+			Error:   &rpc.Error{Code: -32601, Message: "method not found"},
 		})
 	return
 }
 
-	result, err := handler.Handle(ctx, req.Params)
+	result := handler.Handle(ctx, req.Params)
 
 	if req.ID == nil {
 		return
 	}
 
-	s.respond(w, req.ID, result, err)
-}
-
-func (s *Server) respond(w io.Writer, id *int, result any, err *rpc.Error) {
-	resp := rpc.Response{
-		Jsonrpc: "2.0",
-		ID:      id,
-		Result:  result,
-		Error:   err,
-	}
-
-	s.write(w, resp)
+	s.write(w, *result)
 }
 
 func (s *Server) write(w io.Writer, resp rpc.Response) {
diff --git a/test/test_integration/create_note_handler_test.go b/test/test_integration/create_note_handler_test.go
index dd4ae2f..97f3348 100644
--- a/test/test_integration/create_note_handler_test.go
+++ b/test/test_integration/create_note_handler_test.go
@@ -1,7 +1,6 @@
 package integration_test
 
 import (
-	"database/sql"
 	"encoding/json"
 	"testing"
 
@@ -11,14 +10,7 @@ import (
 
 func TestCreateNoteHandlerOnSucess(t *testing.T) {
 	// Arrange
-	// TODO: move to test vars and main_test.go
-	db, err := sql.Open("sqlite", DbPath)
-	if err != nil {
-		t.Fatalf("failed to open database: %v", err)
-	}
-	defer db.Close()
-
-	uow := repositories.NewUnitOfWork(db)
+	uow := repositories.NewUnitOfWork(Fixture.Db)
 
 	handler := handlers.NewCreateNoteHandler(uow)
 
@@ -38,5 +30,18 @@ func TestCreateNoteHandlerOnSucess(t *testing.T) {
 	request := CreateTestRequest("createNote", 1, requestParamsBytes)
 
 	// Act
-	response, rpcError = handler.Handle(TestContext, request.Params)
+	response := handler.Handle(Fixture.TestContext, request.Params)
+
+	// Assert
+	if response.Error != nil {
+		t.Fatalf("expected no error, got: %v", response.Error)
+	}
+
+	if response.Result == nil {
+		t.Fatal("expected result, got nil")
+	}
+
+	if  *response.ID != 1 {
+		t.Fatal("expected non-empty ID in response result")
+	}
 }
diff --git a/test/test_integration/main_test.go b/test/test_integration/main_test.go
index 9b8515e..14668b8 100644
--- a/test/test_integration/main_test.go
+++ b/test/test_integration/main_test.go
@@ -2,6 +2,7 @@ package integration_test
 
 import (
 	"context"
+	"database/sql"
 	"encoding/json"
 	"os"
 	"testing"
@@ -10,19 +11,38 @@ import (
 	"github.com/KristianJBorgwarth/dendrite.daemon/persistence"
 )
 
-var DbPath string = os.TempDir() + "/dendrite_test_vault"
-var TestContext = context.Background()
+type TestFixture struct {
+	Db *sql.DB
+	DbPath string
+	TestContext context.Context
+}
+
+func NewTestFixture() (*TestFixture, error) {
+	dbPath := os.TempDir() + "/dendrite_test_vault"
+	db, err := sql.Open("sqlite", dbPath)
+	if err != nil {
+		return nil, err
+	}
+
+	return &TestFixture{
+		Db: db,
+		DbPath: dbPath,
+		TestContext: context.Background(),
+	}, nil
+}
+
+var Fixture, err = NewTestFixture()
 
 func TestMain(m *testing.M) {
 
-	err := persistence.InitializeIndex(DbPath)
+	err := persistence.InitializeIndex(Fixture.DbPath)
 	if err != nil {
 		panic(err)
 	}
 
 	code := m.Run()
 
-	os.RemoveAll(DbPath)
+	os.RemoveAll(Fixture.DbPath)
 
 	os.Exit(code)
 }
@@ -35,3 +55,5 @@ func CreateTestRequest(method string, ID int, params json.RawMessage) *rpc.Reque
 		Params:  params,
 	}
 }
+
+