feat: add character retrieval endpoint and associated query logic

Author: UltimateForm

api/bruno/character.bru

@@ -0,0 +1,23 @@
+meta {
+  name: character
+  type: http
+  seq: 4
+}
+
+get {
+  url: {{BASE_URL}}/character/qyeufszVydeucS2CRGfKjC
+  body: none
+  auth: inherit
+}
+
+params:query {
+  ~limit: 10
+  ~skip: 0
+}
+
+body:json {
+  {
+    "limit": 10,
+    "skip": 0
+  }
+}

cmd/api/charactersapi/character.go

@@ -0,0 +1,29 @@
+package charactersapi
+
+import (
+	"net/http"
+
+	"github.com/UltimateForm/gopen-api/internal/core"
+	"github.com/UltimateForm/gopen-api/internal/repository/charrep"
+	"github.com/go-chi/chi/v5"
+)
+
+func HandleGetCharacter(res http.ResponseWriter, req *http.Request) {
+	id := chi.URLParam(req, "id")
+	if id == "" {
+		core.RespondError(res, req, core.BadRequest("id in path is required"))
+		return
+	}
+	character, err := charrep.ReadOneCharacter(req.Context(), id)
+	if err != nil {
+		core.RespondError(res, req, err)
+		return
+	}
+	var char Character = Character{
+		Id:          character.Id,
+		Name:        character.Name,
+		Description: character.Description,
+		Debut:       character.Debut,
+	}
+	core.RespondOk(res, char)
+}

cmd/api/main.go

@@ -19,6 +19,7 @@ func Start() http.Handler {
 	router.Route("/characters", func(r chi.Router) {
 		r.Use(core.AuthMiddleware)
 		r.Get("/", charactersapi.HandleGetCharacters)
+		r.Get("/{id}", charactersapi.HandleGetCharacter)
 	})
 	log.Println("ROUTER CREATED")
 	return router

internal/repository/authrep/main.go

@@ -9,7 +9,7 @@ import (
 )
 
 func txUsrExistsAtomically(ctx context.Context, user User) neo4j.ManagedTransactionWorkT[bool] {
-	query := repository.NewQuery(
+	query := repository.NewQueryWithParams(
 		user,
 		`
 MATCH (u:User {email:$email, password:$password})

internal/repository/charrep/main.go

@@ -2,14 +2,57 @@ package charrep
 
 import (
 	"context"
+	"errors"
 	"log"
 
 	"github.com/UltimateForm/gopen-api/internal/repository"
 	"github.com/neo4j/neo4j-go-driver/v5/neo4j"
 )
 
+func txReadOneCharacter(ctx context.Context, id string) neo4j.ManagedTransactionWorkT[Character] {
+	query := repository.NewQuery(map[string]any{"id": id},
+		`
+MATCH (character:Character {id: $id})
+RETURN character
+	`)
+	return func(tx neo4j.ManagedTransaction) (Character, error) {
+		res, err := query.Execute(tx, ctx)
+		if err != nil {
+			return Character{}, err
+		}
+
+		record, singleErr := res.Single(ctx)
+		if singleErr != nil {
+			return Character{}, singleErr
+		}
+
+		rowMap, rowMapOk := record.AsMap()["character"]
+		rowCharacter, rowCharacterOk := rowMap.(neo4j.Node)
+		if !rowMapOk || !rowCharacterOk {
+			return Character{}, errors.New("bad row from db")
+		}
+
+		propsMap := rowCharacter.GetProperties()
+		name := propsMap["name"]
+		id := propsMap["id"]
+		description := propsMap["description"]
+		debut := propsMap["debut"]
+		nameStr := name.(string)
+		idStr := id.(string)
+		debutNum := int(debut.(float64))
+		descrStr := description.(string)
+
+		return Character{
+			Name:        nameStr,
+			Id:          idStr,
+			Debut:       debutNum,
+			Description: descrStr,
+		}, nil
+	}
+}
+
 func txReadCharacters(ctx context.Context, offset Offset) neo4j.ManagedTransactionWorkT[[]Character] {
-	query := repository.NewQuery(offset,
+	query := repository.NewQueryWithParams(offset,
 		`
 MATCH (character:Character)
 RETURN character
@@ -61,3 +104,7 @@ LIMIT $limit
 func ReadCharacters(ctx context.Context, offset Offset) ([]Character, error) {
 	return repository.ExecuteReadWithDriver(ctx, txReadCharacters(ctx, offset))
 }
+
+func ReadOneCharacter(ctx context.Context, id string) (Character, error) {
+	return repository.ExecuteReadWithDriver(ctx, txReadOneCharacter(ctx, id))
+}

internal/repository/main.go

@@ -16,11 +16,15 @@ func ExecuteReadWithDriver[T any](ctx context.Context, tx neo4j.ManagedTransacti
 	})
 }
 
-func NewQuery(data IQueryParams, query string) QueryRunner {
+func NewQuery(data map[string]any, query string) QueryRunner {
 	return func(tx neo4j.ManagedTransaction, ctx context.Context) (neo4j.ResultWithContext, error) {
 		return tx.Run(
 			ctx,
 			query,
-			data.ToParams())
+			data)
 	}
 }
+
+func NewQueryWithParams(data IQueryParams, query string) QueryRunner {
+	return NewQuery(data.ToParams(), query)
+}