feat: enhance error handling with repository error mapping and detailed responses

Author: UltimateForm

internal/core/errors.go

@@ -5,6 +5,8 @@ import (
 	"log"
 	"net/http"
 	"runtime"
+
+	"github.com/UltimateForm/gopen-api/internal/repository"
 )
 
 type ErrorResponse struct {
@@ -42,12 +44,27 @@ func RespondKnownError(res http.ResponseWriter, err ErrorResponse) {
 	json.NewEncoder(res).Encode(err)
 }
 
+func mapRepoError(err repository.RepoError) ErrorResponse {
+	switch err.Code {
+	case repository.EmptyCollectionRepoError:
+		return NotFound()
+	case repository.ValidationError:
+		return BadRequest("Db validation error occured, if you were trying to create something it's likely it already exists")
+	case repository.UnknownRepoError:
+		fallthrough
+	default:
+		return InternalServerError()
+	}
+}
+
 func RespondError(res http.ResponseWriter, req *http.Request, err error) {
 	switch bindErr := err.(type) {
 	case ErrorResponse:
 		RespondKnownError(res, bindErr)
+	case repository.RepoError:
+		RespondKnownError(res, mapRepoError(bindErr))
 	default:
-		log.Printf("Non HTTP error occured: %v", err)
+		log.Printf("Non HTTP error of type %T occured: %v", err, err)
 		RespondKnownError(res, InternalServerError())
 
 	}

internal/repository/charrep/main.go

@@ -62,16 +62,17 @@ func txReadOneCharacter(ctx context.Context, id string) neo4j.ManagedTransaction
 		`
 MATCH (character:Character {id: $id})
 RETURN character
+LIMIT 1
 	`)
 	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
+		var record *neo4j.Record
+		hasNext := res.NextRecord(ctx, &record)
+		if !hasNext {
+			return Character{}, repository.RepoError{Code: repository.EmptyCollectionRepoError}
 		}
 
 		return extractCharacterFromRecord(record)

internal/repository/main.go

@@ -8,20 +8,79 @@ import (
 	"github.com/neo4j/neo4j-go-driver/v5/neo4j"
 )
 
+func mapNeo4JToRepo(err *neo4j.Neo4jError) RepoError {
+	switch err.Code {
+	case "Neo.ClientError.Statement.EntityNotFound":
+		return RepoError{Code: UnknownRepoError}
+	case "Neo.ClientError.Schema.ConstraintValidationFailed":
+		return RepoError{Code: ValidationError}
+	case "Neo.ClientError.Statement.ArgumentError":
+		return RepoError{Code: ValidationError}
+	case "Neo.ClientError.Statement.InvalidArgument":
+		return RepoError{Code: ValidationError}
+	case "Neo.ClientError.General.InvalidConfiguration":
+		return RepoError{Code: UnknownRepoError}
+	case "Neo.ClientError.Statement.SyntaxError":
+		return RepoError{Code: ValidationError}
+	case "Neo.ClientError.Transaction.InvalidOperation":
+		return RepoError{Code: UnknownRepoError}
+	case "Neo.ClientError.Statement.ParameterError":
+		return RepoError{Code: ValidationError}
+	case "Neo.ClientError.Security.Unauthorized":
+		return RepoError{Code: UnknownRepoError}
+	case "Neo.ClientError.Statement.TypeError":
+		return RepoError{Code: ValidationError}
+	case "Neo.ClientError.Statement.ValueError":
+		return RepoError{Code: ValidationError}
+	case "Neo.ClientError.General.NotSupported":
+		return RepoError{Code: UnknownRepoError}
+	case "Neo.ClientError.Statement.ArithmeticError":
+		return RepoError{Code: ValidationError}
+	case "Neo.ClientError.Security.AuthenticationFailed":
+		return RepoError{Code: UnknownRepoError}
+	case "Neo.ClientError.Security.AuthorizationExpired":
+		return RepoError{Code: UnknownRepoError}
+	case "Neo.ClientError.Security.Forbidden":
+		return RepoError{Code: UnknownRepoError}
+	case "Neo.ClientError.Transaction.LockClientStopped":
+		return RepoError{Code: UnknownRepoError}
+	case "Neo.TransientError.General.DatabaseUnavailable":
+		return RepoError{Code: UnknownRepoError}
+	case "Neo.ClientError.Transaction.InvalidState":
+		return RepoError{Code: UnknownRepoError}
+	case "Neo.TransientError.Transaction.Terminated":
+		return RepoError{Code: UnknownRepoError}
+	case "Neo.ClientError.Statement.NoSuchEntity":
+		return RepoError{Code: EmptyCollectionRepoError}
+	default:
+		return RepoError{Code: UnknownRepoError}
+	}
+}
+
 func ExecuteReadWithDriver[T any](ctx context.Context, tx neo4j.ManagedTransactionWorkT[T]) (T, error) {
 	session := db.Driver.NewSession(ctx, neo4j.SessionConfig{})
 	defer session.Close(ctx)
-	return neo4j.ExecuteRead(ctx, session, tx, func(config *neo4j.TransactionConfig) {
+	result, err := neo4j.ExecuteRead(ctx, session, tx, func(config *neo4j.TransactionConfig) {
 		config.Timeout = time.Second * 10
 	})
+	neo4jError, isNeo4jError := err.(*neo4j.Neo4jError)
+	if isNeo4jError {
+		return result, mapNeo4JToRepo(neo4jError)
+	}
+	return result, err
 }
 
 func ExecuteWriteWithDriver[T any](ctx context.Context, tx neo4j.ManagedTransactionWorkT[T]) (T, error) {
 	session := db.Driver.NewSession(ctx, neo4j.SessionConfig{})
 	defer session.Close(ctx)
-	return neo4j.ExecuteWrite(ctx, session, tx, func(config *neo4j.TransactionConfig) {
+	result, err := neo4j.ExecuteWrite(ctx, session, tx, func(config *neo4j.TransactionConfig) {
 		config.Timeout = time.Second * 10
 	})
+	neo4jError, isNeo4jError := err.(*neo4j.Neo4jError)
+	if isNeo4jError {
+		return result, mapNeo4JToRepo(neo4jError)
+	}
+	return result, err
 }
 
 func NewQuery(data map[string]any, query string) QueryRunner {

internal/repository/types.go

@@ -15,3 +15,27 @@ func (src QueryRunner) Execute(tx neo4j.ManagedTransaction, ctx context.Context)
 type IQueryParams interface {
 	ToParams() map[string]any
 }
+type RepoErrorCode int
+
+const (
+	UnknownRepoError RepoErrorCode = iota
+	EmptyCollectionRepoError
+	ValidationError
+)
+
+type RepoError struct {
+	Code RepoErrorCode
+}
+
+func (src RepoError) Error() string {
+	switch src.Code {
+	case EmptyCollectionRepoError:
+		return "Empty collection"
+	case ValidationError:
+		return "Conflicting records"
+	case UnknownRepoError:
+		fallthrough
+	default:
+		return "Unknown repo error"
+	}
+}