beautify result struct (#16)

Author: Benjamin Hotop

pkg/must/return.go

@@ -1,8 +1,8 @@
 package must
 
-func Return[T any](val T, err error) TypedResult[T] {
+func Return[T any](data T, err error) TypedResult[T] {
 	return NewTypedResult(
 		Succeed(err),
-		val,
+		data,
 	)
 }

pkg/must/return_test.go

@@ -12,27 +12,27 @@ import (
 func TestReturn(t *testing.T) {
 	type testCase struct {
 		name       string
-		val        any
+		data       any
 		err        error
 		statusCode int
 	}
 
 	testCases := []testCase{
 		{
 			name:       "error is not nil",
-			val:        nil,
+			data:       nil,
 			err:        errors.New("something went wrong"),
 			statusCode: http.StatusBadRequest,
 		},
 		{
 			name:       "value is string",
-			val:        "test",
+			data:       "test",
 			err:        nil,
 			statusCode: http.StatusOK,
 		},
 		{
 			name:       "value is float",
-			val:        1.1,
+			data:       1.1,
 			err:        nil,
 			statusCode: http.StatusOK,
 		},
@@ -44,19 +44,19 @@ func TestReturn(t *testing.T) {
 			tester := &must.ExecuteTester{}
 
 			if tc.err != nil {
-				assert.Panics(t, func() { must.Return(tc.val, tc.err).ElseRespond(&writer, tc.statusCode) })
-				assert.Panics(t, func() { must.Return(tc.val, tc.err).ElseExecute(tester.TestTyped) })
-				assert.Panics(t, func() { must.Return(tc.val, tc.err).ElsePanic() })
+				assert.Panics(t, func() { must.Return(tc.data, tc.err).ElseRespond(&writer, tc.statusCode) })
+				assert.Panics(t, func() { must.Return(tc.data, tc.err).ElseExecute(tester.TestTyped) })
+				assert.Panics(t, func() { must.Return(tc.data, tc.err).ElsePanic() })
 				assert.True(t, tester.Called)
 				assert.Contains(t, *writer.Error, tc.err.Error())
 				assert.Equal(t, tc.statusCode, writer.StatusCode)
 			} else {
 				var result any
-				assert.NotPanics(t, func() { result = must.Return(tc.val, tc.err).ElseRespond(&writer, tc.statusCode) })
-				assert.NotPanics(t, func() { must.Return(tc.val, tc.err).ElseExecute(tester.TestTyped) })
-				assert.NotPanics(t, func() { must.Return(tc.val, tc.err).ElsePanic() })
+				assert.NotPanics(t, func() { result = must.Return(tc.data, tc.err).ElseRespond(&writer, tc.statusCode) })
+				assert.NotPanics(t, func() { must.Return(tc.data, tc.err).ElseExecute(tester.TestTyped) })
+				assert.NotPanics(t, func() { must.Return(tc.data, tc.err).ElsePanic() })
 				assert.False(t, tester.Called)
-				assert.Equal(t, tc.val, result)
+				assert.Equal(t, tc.data, result)
 				assert.Nil(t, writer.Error)
 				assert.Zero(t, writer.StatusCode)
 			}

pkg/must/typed_result.go

@@ -6,13 +6,13 @@ import (
 
 type TypedResult[T any] struct {
 	UntypedResult
-	Val T `json:"val"`
+	Data T `json:"data"`
 }
 
 type TypedResultAction[T any] func(T)
 
-func NewTypedResult[T any](res UntypedResult, val T) TypedResult[T] {
-	return TypedResult[T]{res, val}
+func NewTypedResult[T any](res UntypedResult, data T) TypedResult[T] {
+	return TypedResult[T]{res, data}
 }
 
 func (res TypedResult[T]) ElseRespond(w ResponseWriter, statusCode int) T {
@@ -29,23 +29,23 @@ func (res TypedResult[T]) ElseRespond(w ResponseWriter, statusCode int) T {
 		panic(res.err)
 	}
 
-	return res.Val
+	return res.Data
 }
 
 func (res TypedResult[T]) ElseExecute(fn TypedResultAction[T]) T {
 	if res.err != nil {
-		fn(res.Val)
+		fn(res.Data)
 
 		panic(res.err)
 	}
 
-	return res.Val
+	return res.Data
 }
 
 func (res TypedResult[T]) ElsePanic() T {
 	if res.err != nil {
 		panic(res.err)
 	}
 
-	return res.Val
+	return res.Data
 }

pkg/must/untyped_result.go

@@ -3,20 +3,22 @@ package must
 import "encoding/json"
 
 type UntypedResult struct {
-	err          error  `json:"-"`
-	HasError     bool   `json:"hasError"`
-	ErrorMessage string `json:"errorMessage,omitempty"`
+	err     error  `json:"-"`
+	Success bool   `json:"success"`
+	Error   bool   `json:"error"`
+	Message string `json:"message,omitempty"`
 }
 
 type ResultAction func()
 
 func NewResult(err error) UntypedResult {
 	var errorMessage string
-	if err != nil {
+	hasError := err != nil
+	if hasError {
 		errorMessage = err.Error()
 	}
 
-	return UntypedResult{err, err != nil, errorMessage}
+	return UntypedResult{err, !hasError, hasError, errorMessage}
 }
 
 func (res UntypedResult) ElseRespond(w ResponseWriter, statusCode int) {