Add error package to handle generally.

internal/interactor/license.go

@@ -3,6 +3,7 @@ package interactor
 import (
 	"context"
 
+	"github.com/gitploy-io/gitploy/pkg/e"
 	"github.com/gitploy-io/gitploy/pkg/license"
 	"github.com/gitploy-io/gitploy/vo"
 )
@@ -15,7 +16,10 @@ func (i *Interactor) GetLicense(ctx context.Context) (*vo.License, error) {
 	)
 
 	if cnt, err = i.Store.CountUsers(ctx); err != nil {
-		return nil, err
+		return nil, e.NewError(
+			e.ErrorCodeInternalError,
+			err,
+		)
 	}
 
 	if i.licenseKey == "" {
@@ -24,7 +28,10 @@ func (i *Interactor) GetLicense(ctx context.Context) (*vo.License, error) {
 	}
 
 	if d, err = license.Decode(i.licenseKey); err != nil {
-		return nil, err
+		return nil, e.NewError(
+			e.ErrorCodeLicenseDecode,
+			err,
+		)
 	}
 
 	lic := vo.NewStandardLicense(cnt, d)

internal/server/api/v1/license/license.go

@@ -24,7 +24,7 @@ func (l *Licenser) GetLicense(c *gin.Context) {
 
 	lic, err := l.i.GetLicense(ctx)
 	if err != nil {
-		gb.ErrorResponse(c, http.StatusInternalServerError, "It has failed to get the license.")
+		gb.ResponseWithError(c, err)
 		return
 	}
 

internal/server/global/http.go

@@ -1,6 +1,11 @@
 package global
 
-import "github.com/gin-gonic/gin"
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"github.com/gitploy-io/gitploy/pkg/e"
+)
 
 func Response(c *gin.Context, httpCode int, data interface{}) {
 	c.JSON(httpCode, data)
@@ -12,6 +17,21 @@ func ErrorResponse(c *gin.Context, httpCode int, message string) {
 	})
 }
 
+func ResponseWithError(c *gin.Context, err error) {
+	if ge, ok := err.(*e.Error); ok {
+		c.JSON(e.GetHttpCode(ge.Code), map[string]string{
+			"code":    string(ge.Code),
+			"message": e.GetMessage(ge.Code),
+		})
+		return
+	}
+
+	c.JSON(http.StatusInternalServerError, map[string]string{
+		"code":    string(e.ErrorCodeInternalError),
+		"message": err.Error(),
+	})
+}
+
 func AbortWithErrorResponse(c *gin.Context, httpCode int, message string) {
 	c.AbortWithStatusJSON(httpCode, map[string]string{
 		"message": message,

pkg/e/code.go

@@ -0,0 +1,40 @@
+package e
+
+import (
+	"fmt"
+)
+
+const (
+	// ErrorCodeMergeConflict is that the ref can't be merged into the main branch.
+	ErrorCodeMergeConflict ErrorCode = "merge_conflict"
+
+	// ErrorCodeLicenseDecode is that the license.
+	ErrorCodeLicenseDecode ErrorCode = "license_decode"
+
+	ErrorCodeInternalError ErrorCode = "internal_error"
+)
+
+type (
+	ErrorStatus int
+	ErrorCode   string
+
+	Error struct {
+		Code ErrorCode
+		Wrap error
+	}
+)
+
+func NewError(code ErrorCode, wrap error) *Error {
+	return &Error{
+		Code: code,
+		Wrap: wrap,
+	}
+}
+
+func (e *Error) Error() string {
+	return fmt.Sprintf("code: %s, message: %s : %s", e.Code, GetMessage(e.Code), e.Wrap)
+}
+
+func (e *Error) Unwrap() error {
+	return e.Wrap
+}

pkg/e/trans.go

@@ -0,0 +1,33 @@
+package e
+
+import "net/http"
+
+var messages = map[ErrorCode]string{
+	ErrorCodeMergeConflict: "There is merge conflict.",
+	ErrorCodeLicenseDecode: "Decoding the license is failed.",
+	ErrorCodeInternalError: "Server internal error.",
+}
+
+func GetMessage(code ErrorCode) string {
+	message, ok := messages[code]
+	if !ok {
+		return string(code)
+	}
+
+	return message
+}
+
+var httpCodes = map[ErrorCode]int{
+	ErrorCodeMergeConflict: http.StatusUnprocessableEntity,
+	ErrorCodeLicenseDecode: http.StatusUnprocessableEntity,
+	ErrorCodeInternalError: http.StatusInternalServerError,
+}
+
+func GetHttpCode(code ErrorCode) int {
+	httpCode, ok := httpCodes[code]
+	if !ok {
+		return http.StatusInternalServerError
+	}
+
+	return httpCode
+}

pkg/e/trans_test.go

@@ -0,0 +1,14 @@
+package e
+
+import "testing"
+
+func Test_GetMessage(t *testing.T) {
+	t.Run("Return code when the message is emtpy.", func(t *testing.T) {
+		const ErrorCodeEmpty ErrorCode = "emtpy"
+
+		message := GetMessage(ErrorCodeEmpty)
+		if message != string(ErrorCodeEmpty) {
+			t.Fatalf("GetMessage = %s, wanted %s", message, string(ErrorCodeEmpty))
+		}
+	})
+}