api/error.defaults.go

@@ -1,94 +1,70 @@
 package api
 
 var (
+	// ErrorSuccess represents a generic successful service execution
+	ErrorSuccess = func() Error { return Error{0, "all right", nil} }
+
+	// ErrorFailure is the most generic error
+	ErrorFailure = func() Error { return Error{1, "it failed", nil} }
+
 	// ErrorUnknown represents any error which cause is unknown.
 	// It might also be used for debug purposes as this error
 	// has to be used the less possible
-	ErrorUnknown Error = -1
-
-	// ErrorSuccess represents a generic successful service execution
-	ErrorSuccess Error = 0
-
-	// ErrorFailure is the most generic error
-	ErrorFailure Error = 1
+	ErrorUnknown = func() Error { return Error{-1, "", nil} }
 
 	// ErrorNoMatchFound has to be set when trying to fetch data and there is no result
-	ErrorNoMatchFound Error = 2
+	ErrorNoMatchFound = func() Error { return Error{2, "no resource found", nil} }
 
 	// ErrorAlreadyExists has to be set when trying to insert data, but identifiers or
 	// unique fields already exists
-	ErrorAlreadyExists Error = 3
+	ErrorAlreadyExists = func() Error { return Error{3, "resource already exists", nil} }
 
 	// ErrorConfig has to be set when there is a configuration error
-	ErrorConfig Error = 4
+	ErrorConfig = func() Error { return Error{4, "configuration error", nil} }
 
 	// ErrorUpload has to be set when a file upload failed
-	ErrorUpload Error = 100
+	ErrorUpload = func() Error { return Error{100, "upload failed", nil} }
 
 	// ErrorDownload has to be set when a file download failed
-	ErrorDownload Error = 101
+	ErrorDownload = func() Error { return Error{101, "download failed", nil} }
 
 	// MissingDownloadHeaders has to be set when the implementation
 	// of a service of type 'download' (which returns a file instead of
 	// a set or output fields) is missing its HEADER field
-	MissingDownloadHeaders Error = 102
+	MissingDownloadHeaders = func() Error { return Error{102, "download headers are missing", nil} }
 
 	// ErrorMissingDownloadBody has to be set when the implementation
 	// of a service of type 'download' (which returns a file instead of
 	// a set or output fields) is missing its BODY field
-	ErrorMissingDownloadBody Error = 103
+	ErrorMissingDownloadBody = func() Error { return Error{103, "download body is missing", nil} }
 
 	// ErrorUnknownService is set when there is no service matching
 	// the http request URI.
-	ErrorUnknownService Error = 200
+	ErrorUnknownService = func() Error { return Error{200, "unknown service", nil} }
 
 	// ErrorUncallableService is set when there the requested service's
 	// implementation (plugin file) is not found/callable
-	ErrorUncallableService Error = 202
-
-	// ErrorNotImplemented is set when a handler is not implemented yet
-	ErrorNotImplemented Error = 203
+	ErrorUncallableService = func() Error { return Error{202, "uncallable service", nil} }
 
 	// ErrorPermission is set when there is a permission error by default
 	// the api returns a permission error when the current scope (built
 	// by middlewares) does not match the scope required in the config.
 	// You can add your own permission policy and use this error
-	ErrorPermission Error = 300
+	ErrorPermission = func() Error { return Error{300, "permission error", nil} }
 
 	// ErrorToken has to be set (usually in authentication middleware) to tell
 	// the user that this authentication token is expired or invalid
-	ErrorToken Error = 301
+	ErrorToken = func() Error { return Error{301, "token error", nil} }
 
 	// ErrorMissingParam is set when a *required* parameter is missing from the
 	// http request
-	ErrorMissingParam Error = 400
+	ErrorMissingParam = func() Error { return Error{400, "missing parameter", nil} }
 
 	// ErrorInvalidParam is set when a given parameter fails its type check as
 	// defined in the config file.
-	ErrorInvalidParam Error = 401
+	ErrorInvalidParam = func() Error { return Error{401, "invalid parameter", nil} }
 
 	// ErrorInvalidDefaultParam is set when an optional parameter's default value
 	// does not match its type.
-	ErrorInvalidDefaultParam Error = 402
+	ErrorInvalidDefaultParam = func() Error { return Error{402, "invalid default param", nil} }
 )
-
-var errorReasons = map[Error]string{
-	ErrorUnknown:             "unknown error",
-	ErrorSuccess:             "all right",
-	ErrorFailure:             "it failed",
-	ErrorNoMatchFound:        "resource found",
-	ErrorAlreadyExists:       "already exists",
-	ErrorConfig:              "configuration error",
-	ErrorUpload:              "upload failed",
-	ErrorDownload:            "download failed",
-	MissingDownloadHeaders:   "download headers are missing",
-	ErrorMissingDownloadBody: "download body is missing",
-	ErrorUnknownService:      "unknown service",
-	ErrorUncallableService:   "uncallable service",
-	ErrorNotImplemented:      "not implemented",
-	ErrorPermission:          "permission error",
-	ErrorToken:               "token error",
-	ErrorMissingParam:        "missing parameter",
-	ErrorInvalidParam:        "invalid parameter",
-	ErrorInvalidDefaultParam: "invalid default param",
-}

api/error.go

@@ -1,42 +1,40 @@
 package api
 
 import (
-	"encoding/json"
 	"fmt"
 )
 
 // Error represents an http response error following the api format.
 // These are used by the services to set the *execution status*
 // directly into the response as JSON alongside response output fields.
-type Error int
-
-// Error implements the error interface
-func (e Error) Error() string {
-	// use unknown error if no reason
-	reason, ok := errorReasons[e]
-	if !ok {
-		return ErrorUnknown.Error()
-	}
-
-	return fmt.Sprintf("[%d] %s", e, reason)
-}
-
-// MarshalJSON implements encoding/json.Marshaler interface
-func (e Error) MarshalJSON() ([]byte, error) {
-	// use unknown error if no reason
-	reason, ok := errorReasons[e]
-	if !ok {
-		return ErrorUnknown.MarshalJSON()
-	}
-
-	// format to proper struct
-	formatted := struct {
+type Error struct {
 	Code      int           `json:"code"`
 	Reason    string        `json:"reason"`
-	}{
-		Code:   int(e),
-		Reason: reason,
+	Arguments []interface{} `json:"arguments"`
 }
 
-	return json.Marshal(formatted)
+// SetArguments set one or multiple arguments to the error
+// to be displayed back to API caller
+func (e *Error) SetArguments(arg0 interface{}, args ...interface{}) {
+
+	// 1. clear arguments */
+	e.Arguments = make([]interface{}, 0)
+
+	// 2. add arg[0]
+	e.Arguments = append(e.Arguments, arg0)
+
+	// 3. add optional other arguments
+	for _, arg := range args {
+		e.Arguments = append(e.Arguments, arg)
+	}
+
+}
+
+// Implements 'error'
+func (e Error) Error() string {
+	if e.Arguments == nil || len(e.Arguments) < 1 {
+		return fmt.Sprintf("[%d] %s", e.Code, e.Reason)
+	}
+
+	return fmt.Sprintf("[%d] %s (%v)", e.Code, e.Reason, e.Arguments)
 }

api/handler.go

@@ -4,23 +4,28 @@ import (
 	"strings"
 )
 
-// HandlerFn defines the handler signature
-type HandlerFn func(req Request, res *Response) Error
+// HandlerFunc manages an API request
+type HandlerFunc func(Request, *Response)
 
 // Handler is an API handler ready to be bound
 type Handler struct {
 	path   string
 	method string
-	Fn     HandlerFn
+	handle HandlerFunc
 }
 
 // NewHandler builds a handler from its http method and path
-func NewHandler(method, path string, fn HandlerFn) (*Handler, error) {
+func NewHandler(method, path string, handlerFunc HandlerFunc) *Handler {
 	return &Handler{
 		path:   path,
 		method: strings.ToUpper(method),
-		Fn:     fn,
-	}, nil
+		handle: handlerFunc,
+	}
+}
+
+// Handle fires a handler
+func (h *Handler) Handle(req Request, res *Response) {
+	h.handle(req, res)
 }
 
 // GetMethod returns the handler's HTTP method

api/response.go

@@ -16,22 +16,31 @@ type Response struct {
 	err     Error
 }
 
-// EmptyResponse creates an empty response.
-func EmptyResponse() *Response {
-	return &Response{
+// NewResponse creates an empty response. An optional error can be passed as its first argument.
+func NewResponse(errors ...Error) *Response {
+	res := &Response{
 		Status:  http.StatusOK,
 		Data:    make(ResponseData),
-		err:     ErrorFailure,
+		err:     ErrorFailure(),
 		Headers: make(http.Header),
 	}
+
+	// optional error
+	if len(errors) == 1 {
+		res.err = errors[0]
 	}
 
-// WithError sets the error from a base error with error arguments.
-func (res *Response) WithError(err Error) *Response {
-	res.err = err
 	return res
 }
 
+// SetError sets the error from a base error with error arguments.
+func (res *Response) SetError(baseError Error, arguments ...interface{}) {
+	if len(arguments) > 0 {
+		baseError.SetArguments(arguments[0], arguments[1:]...)
+	}
+	res.err = baseError
+}
+
 // Error implements the error interface and dispatches to internal error.
 func (res *Response) Error() string {
 	return res.err.Error()

http.go

@@ -18,7 +18,7 @@ func (server httpServer) ServeHTTP(res http.ResponseWriter, req *http.Request) {
 	// 1. find a matching service in the config
 	service := server.config.Find(req)
 	if service == nil {
-		response := api.EmptyResponse().WithError(api.ErrorUnknownService)
+		response := api.NewResponse(api.ErrorUnknownService())
 		response.ServeHTTP(res, req)
 		logError(response)
 		return
@@ -30,7 +30,7 @@ func (server httpServer) ServeHTTP(res http.ResponseWriter, req *http.Request) {
 	// 3. extract URI data
 	err := dataset.ExtractURI(req)
 	if err != nil {
-		response := api.EmptyResponse().WithError(api.ErrorMissingParam)
+		response := api.NewResponse(api.ErrorMissingParam())
 		response.ServeHTTP(res, req)
 		logError(response)
 		return
@@ -39,7 +39,7 @@ func (server httpServer) ServeHTTP(res http.ResponseWriter, req *http.Request) {
 	// 4. extract query data
 	err = dataset.ExtractQuery(req)
 	if err != nil {
-		response := api.EmptyResponse().WithError(api.ErrorMissingParam)
+		response := api.NewResponse(api.ErrorMissingParam())
 		response.ServeHTTP(res, req)
 		logError(response)
 		return
@@ -48,7 +48,7 @@ func (server httpServer) ServeHTTP(res http.ResponseWriter, req *http.Request) {
 	// 5. extract form/json data
 	err = dataset.ExtractForm(req)
 	if err != nil {
-		response := api.EmptyResponse().WithError(api.ErrorMissingParam)
+		response := api.NewResponse(api.ErrorMissingParam())
 		response.ServeHTTP(res, req)
 		logError(response)
 		return
@@ -68,13 +68,15 @@ func (server httpServer) ServeHTTP(res http.ResponseWriter, req *http.Request) {
 	// 7. fail if found no handler
 	if foundHandler == nil {
 		if found {
-			r := api.EmptyResponse().WithError(api.ErrorUncallableService)
+			r := api.NewResponse()
+			r.SetError(api.ErrorUncallableService(), service.Method, service.Pattern)
 			r.ServeHTTP(res, req)
 			logError(r)
 			return
 		}
 
-		r := api.EmptyResponse().WithError(api.ErrorUnknownService)
+		r := api.NewResponse()
+		r.SetError(api.ErrorUnknownService(), service.Method, service.Pattern)
 		r.ServeHTTP(res, req)
 		logError(r)
 		return
@@ -91,9 +93,8 @@ func (server httpServer) ServeHTTP(res http.ResponseWriter, req *http.Request) {
 	apireq.Param = dataset.Data
 
 	// 10. execute
-	response := api.EmptyResponse()
-	apiErr := foundHandler.Fn(*apireq, response)
-	response.WithError(apiErr)
+	response := api.NewResponse()
+	foundHandler.Handle(*apireq, response)
 
 	// 11. apply headers
 	res.Header().Set("Content-Type", "application/json; charset=utf-8")

server.go

@@ -47,11 +47,13 @@ func New(configPath string, dtypes ...datatype.T) (*Server, error) {
 }
 
 // HandleFunc sets a new handler for an HTTP method to a path
-func (s *Server) Handle(httpMethod, path string, fn api.HandlerFn) {
-	handler, err := api.NewHandler(httpMethod, path, fn)
-	if err != nil {
-		panic(err)
+func (s *Server) HandleFunc(httpMethod, path string, handlerFunc api.HandlerFunc) {
+	handler := api.NewHandler(httpMethod, path, handlerFunc)
+	s.handlers = append(s.handlers, handler)
 }
+
+// Handle sets a new handler
+func (s *Server) Handle(handler *api.Handler) {
 	s.handlers = append(s.handlers, handler)
 }