characters list endpoint

Author: UltimateForm

api/bruno/character.bru api/bruno/characters.bruapi/bruno/character.bru renamed to api/bruno/characters.bru

@@ -1,11 +1,18 @@
 meta {
-  name: character
+  name: characters
   type: http
   seq: 2
 }
 
 get {
   url: {{BASE_URL}}/characters
-  body: none
+  body: json
   auth: inherit
 }
+
+body:json {
+  {
+    "limit": 10,
+    "skip": 0
+  }
+}

cmd/api/charactersapi/characters.go

@@ -0,0 +1,52 @@
+package charactersapi
+
+import (
+	"net/http"
+
+	"github.com/UltimateForm/gopen-api/internal/core"
+	"github.com/UltimateForm/gopen-api/internal/repository/charrep"
+)
+
+type Offset struct {
+	Limit int `json:"limit"`
+	Skip  int `json:"skip"`
+}
+
+func (src Offset) Validate() error {
+	if src.Limit <= 0 {
+		return core.BadRequest("limit must be a positive higher than 0 integer")
+	}
+	if src.Skip < 0 {
+		return core.BadRequest("skip be a positive integer")
+	}
+	return nil
+}
+
+func HandleGetCharacters(res http.ResponseWriter, req *http.Request) {
+	var offset Offset
+	// TODO: use query parameters silly
+	err := core.ParseBody(req, &offset)
+	if err != nil {
+		core.RespondError(res, req, err)
+		return
+	}
+	characters, err := charrep.ReadCharacters(req.Context(), charrep.Offset{
+		Limit: offset.Limit,
+		Skip:  offset.Skip,
+	})
+	if err != nil {
+		core.RespondError(res, req, err)
+		return
+	}
+	charactersMapped := make([]Character, len(characters))
+	// NOTE: eh should i be mapping at all, golang type integrity does mean i dont need to worry so much about leakage
+	for i, char := range characters {
+		charactersMapped[i] = Character{
+			Id:          char.Id,
+			Name:        char.Name,
+			Description: char.Description,
+			Debut:       char.Debut,
+		}
+	}
+	core.RespondOk(res, CharacterList{Offset: offset, Characters: charactersMapped})
+}

cmd/api/charactersapi/types.go

@@ -0,0 +1,13 @@
+package charactersapi
+
+type Character struct {
+	Id          string `json:"id"`
+	Name        string `json:"name"`
+	Description string `json:"description"`
+	Debut       int    `json:"debut"`
+}
+
+type CharacterList struct {
+	Offset
+	Characters []Character `json:"characters"`
+}

cmd/api/get_one_character.go

@@ -1,4 +1,4 @@
-package api
+package loginapi
 
 import (
 	"net/http"
@@ -16,14 +16,14 @@ type LoginResponse struct {
 	Token string `json:"token"`
 }
 
-func (src *LoginRequest) Validate() error {
+func (src LoginRequest) Validate() error {
 	if src.Email == "" || src.Password == "" {
 		return core.BadRequest("missing either email or password field")
 	}
 	return nil
 }
 
-func authHandler(res http.ResponseWriter, req *http.Request) {
+func HandlePostLogin(res http.ResponseWriter, req *http.Request) {
 	var reqData LoginRequest
 	bodyErr := core.ParseBody(req, &reqData)
 	if bodyErr != nil {

cmd/api/auth.go cmd/api/loginapi/main.gocmd/api/auth.go renamed to cmd/api/loginapi/main.go

@@ -4,6 +4,8 @@ import (
 	"log"
 	"net/http"
 
+	"github.com/UltimateForm/gopen-api/cmd/api/charactersapi"
+	"github.com/UltimateForm/gopen-api/cmd/api/loginapi"
 	"github.com/UltimateForm/gopen-api/internal/core"
 	"github.com/go-chi/chi/v5"
 	"github.com/go-chi/chi/v5/middleware"
@@ -13,10 +15,10 @@ func Start() http.Handler {
 	router := chi.NewRouter()
 	router.Use(middleware.Logger)
 	router.Use(core.ErrorHandlingMiddleware)
-	router.Post("/login", authHandler)
+	router.Post("/login", loginapi.HandlePostLogin)
 	router.Route("/characters", func(r chi.Router) {
 		r.Use(core.AuthMiddleware)
-		r.Get("/", characterHandler)
+		r.Get("/", charactersapi.HandleGetCharacters)
 	})
 	log.Println("ROUTER CREATED")
 	return router

cmd/api/main.go

@@ -0,0 +1,63 @@
+package charrep
+
+import (
+	"context"
+	"log"
+
+	"github.com/UltimateForm/gopen-api/internal/repository"
+	"github.com/neo4j/neo4j-go-driver/v5/neo4j"
+)
+
+func txReadCharacters(ctx context.Context, offset Offset) neo4j.ManagedTransactionWorkT[[]Character] {
+	query := repository.NewQuery(offset,
+		`
+MATCH (character:Character)
+RETURN character
+ORDER BY character.debut
+SKIP $skip
+LIMIT $limit
+	`)
+	return func(tx neo4j.ManagedTransaction) ([]Character, error) {
+		res, err := query.Execute(tx, ctx)
+		if err != nil {
+			return nil, err
+		}
+		characters := make([]Character, offset.Limit)
+		i := 0
+		for rec, yieldErr := range res.Records(ctx) {
+			if yieldErr != nil {
+				log.Printf("Error while iterating DB records, %v", yieldErr)
+				i++
+				continue
+			}
+			rowMap, rowMapOk := rec.AsMap()["character"]
+			rowCharacter, rowCharacterOk := rowMap.(neo4j.Node)
+			if !rowMapOk || !rowCharacterOk {
+				log.Printf("Bad row from db %+v\n", rec)
+				i++
+				continue
+			}
+			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)
+			characters[i] = Character{
+				Name:        nameStr,
+				Id:          idStr,
+				Debut:       debutNum,
+				Description: descrStr,
+			}
+			i++
+		}
+		return characters, nil
+	}
+}
+
+func ReadCharacters(ctx context.Context, offset Offset) ([]Character, error) {
+	return repository.ExecuteReadWithDriver(ctx, txReadCharacters(ctx, offset))
+}

internal/repository/charrep/main.go

@@ -0,0 +1,20 @@
+package charrep
+
+type Offset struct {
+	Limit int
+	Skip  int
+}
+
+func (src Offset) ToParams() map[string]any {
+	return map[string]any{
+		"limit": src.Limit,
+		"skip":  src.Skip,
+	}
+}
+
+type Character struct {
+	Id          string
+	Name        string
+	Description string
+	Debut       int
+}

internal/repository/charrep/types.go

@@ -9,11 +9,11 @@ import (
 )
 
 func ExecuteReadWithDriver[T any](ctx context.Context, tx neo4j.ManagedTransactionWorkT[T]) (T, error) {
-	readCtx, cancel := context.WithDeadline(ctx, time.Now().Add(time.Second*10))
-	defer cancel()
-	session := db.Driver.NewSession(readCtx, neo4j.SessionConfig{})
-	defer session.Close(readCtx)
-	return neo4j.ExecuteRead(readCtx, session, tx)
+	session := db.Driver.NewSession(ctx, neo4j.SessionConfig{})
+	defer session.Close(ctx)
+	return neo4j.ExecuteRead(ctx, session, tx, func(config *neo4j.TransactionConfig) {
+		config.Timeout = time.Second * 10
+	})
 }
 
 func NewQuery(data IQueryParams, query string) QueryRunner {