api/error.defaults.go

@@ -76,7 +76,7 @@ var errorReasons = map[Error]string{
 	ErrorUnknown:             "unknown error",
 	ErrorSuccess:             "all right",
 	ErrorFailure:             "it failed",
-	ErrorNoMatchFound:        "resource not found",
+	ErrorNoMatchFound:        "resource found",
 	ErrorAlreadyExists:       "already exists",
 	ErrorConfig:              "configuration error",
 	ErrorUpload:              "upload failed",

api/handler.go

@@ -0,0 +1,34 @@
+package api
+
+import (
+	"strings"
+)
+
+// HandlerFn defines the handler signature
+type HandlerFn func(req Request, res *Response) Error
+
+// Handler is an API handler ready to be bound
+type Handler struct {
+	path   string
+	method string
+	Fn     HandlerFn
+}
+
+// NewHandler builds a handler from its http method and path
+func NewHandler(method, path string, fn HandlerFn) (*Handler, error) {
+	return &Handler{
+		path:   path,
+		method: strings.ToUpper(method),
+		Fn:     fn,
+	}, nil
+}
+
+// GetMethod returns the handler's HTTP method
+func (h *Handler) GetMethod() string {
+	return h.method
+}
+
+// GetPath returns the handler's path
+func (h *Handler) GetPath() string {
+	return h.path
+}

dynamic/errors.go

@@ -1,48 +0,0 @@
-package dynamic
-
-// cerr allows you to create constant "const" error with type boxing.
-type cerr string
-
-// Error implements the error builtin interface.
-func (err cerr) Error() string {
-	return string(err)
-}
-
-// ErrHandlerNotFunc - handler is not a func
-const ErrHandlerNotFunc = cerr("handler must be a func")
-
-// ErrNoServiceForHandler - no service matching this handler
-const ErrNoServiceForHandler = cerr("no service found for this handler")
-
-// ErrMissingHandlerArgumentParam - missing params arguments for handler
-const ErrMissingHandlerArgumentParam = cerr("missing handler argument : parameter struct")
-
-// ErrMissingHandlerOutput - missing output for handler
-const ErrMissingHandlerOutput = cerr("handler must have at least 1 output")
-
-// ErrMissingHandlerOutputError - missing error output for handler
-const ErrMissingHandlerOutputError = cerr("handler must have its last output of type api.Error")
-
-// ErrMissingRequestArgument - missing request argument for handler
-const ErrMissingRequestArgument = cerr("handler first argument must be of type api.Request")
-
-// ErrMissingParamArgument - missing parameters argument for handler
-const ErrMissingParamArgument = cerr("handler second argument must be a struct")
-
-// ErrMissingParamOutput - missing output argument for handler
-const ErrMissingParamOutput = cerr("handler first output must be a *struct")
-
-// ErrMissingParamFromConfig - missing a parameter in handler struct
-const ErrMissingParamFromConfig = cerr("missing a parameter from configuration")
-
-// ErrMissingOutputFromConfig - missing a parameter in handler struct
-const ErrMissingOutputFromConfig = cerr("missing a parameter from configuration")
-
-// ErrWrongParamTypeFromConfig - a configuration parameter type is invalid in the handler param struct
-const ErrWrongParamTypeFromConfig = cerr("invalid struct field type")
-
-// ErrWrongOutputTypeFromConfig - a configuration output type is invalid in the handler output struct
-const ErrWrongOutputTypeFromConfig = cerr("invalid struct field type")
-
-// ErrMissingHandlerErrorOutput - missing handler output error
-const ErrMissingHandlerErrorOutput = cerr("last output must be of type api.Error")

dynamic/handler.go

@@ -1,90 +0,0 @@
-package dynamic
-
-import (
-	"fmt"
-	"reflect"
-
-	"git.xdrm.io/go/aicra/api"
-	"git.xdrm.io/go/aicra/internal/config"
-)
-
-// Build a handler from a service configuration and a HandlerFn
-//
-// a HandlerFn must have as a signature : `func(api.Request, inputStruct) (outputStruct, api.Error)`
-//  - `inputStruct` is a struct{} containing a field for each service input (with valid reflect.Type)
-//  - `outputStruct` is a struct{} containing a field for each service output (with valid reflect.Type)
-//
-// Special cases:
-//  - it there is no input, `inputStruct` can be omitted
-//  - it there is no output, `outputStruct` can be omitted
-func Build(fn HandlerFn, service config.Service) (*Handler, error) {
-	h := &Handler{
-		spec: makeSpec(service),
-		fn:   fn,
-	}
-
-	fnv := reflect.ValueOf(fn)
-
-	if fnv.Type().Kind() != reflect.Func {
-		return nil, ErrHandlerNotFunc
-	}
-
-	if err := h.spec.checkInput(fnv); err != nil {
-		return nil, fmt.Errorf("input: %w", err)
-	}
-	if err := h.spec.checkOutput(fnv); err != nil {
-		return nil, fmt.Errorf("output: %w", err)
-	}
-
-	return h, nil
-}
-
-// Handle binds input @data into HandleFn and returns map output
-func (h *Handler) Handle(data map[string]interface{}) (map[string]interface{}, api.Error) {
-	fnv := reflect.ValueOf(h.fn)
-
-	callArgs := []reflect.Value{}
-
-	// bind input data
-	if fnv.Type().NumIn() > 0 {
-		// create zero value struct
-		callStructPtr := reflect.New(fnv.Type().In(0))
-		callStruct := callStructPtr.Elem()
-
-		// set each field
-		for name := range h.spec.Input {
-			field := callStruct.FieldByName(name)
-			if !field.CanSet() {
-				continue
-			}
-
-			// get value from @data
-			value, inData := data[name]
-			if !inData {
-				continue
-			}
-			field.Set(reflect.ValueOf(value).Convert(field.Type()))
-		}
-		callArgs = append(callArgs, callStruct)
-	}
-
-	// call the HandlerFn
-	output := fnv.Call(callArgs)
-
-	// no output OR pointer to output struct is nil
-	outdata := make(map[string]interface{})
-	if len(h.spec.Output) < 1 || output[0].IsNil() {
-		return outdata, api.Error(output[len(output)-1].Int())
-	}
-
-	// extract struct from pointer
-	returnStruct := output[0].Elem()
-
-	for name := range h.spec.Output {
-		field := returnStruct.FieldByName(name)
-		outdata[name] = field.Interface()
-	}
-
-	// extract api.Error
-	return outdata, api.Error(output[len(output)-1].Int())
-}

dynamic/spec.go

@@ -1,119 +0,0 @@
-package dynamic
-
-import (
-	"fmt"
-	"reflect"
-
-	"git.xdrm.io/go/aicra/api"
-	"git.xdrm.io/go/aicra/internal/config"
-)
-
-// builds a spec from the configuration service
-func makeSpec(service config.Service) spec {
-	spec := spec{
-		Input:  make(map[string]reflect.Type),
-		Output: make(map[string]reflect.Type),
-	}
-
-	for _, param := range service.Input {
-		// make a pointer if optional
-		if param.Optional {
-			spec.Input[param.Rename] = reflect.PtrTo(param.ExtractType)
-			continue
-		}
-		spec.Input[param.Rename] = param.ExtractType
-	}
-
-	for _, param := range service.Output {
-		spec.Output[param.Rename] = param.ExtractType
-	}
-
-	return spec
-}
-
-// checks for HandlerFn input arguments
-func (s spec) checkInput(fnv reflect.Value) error {
-	fnt := fnv.Type()
-
-	// no input -> ok
-	if len(s.Input) == 0 {
-		return nil
-	}
-
-	if fnt.NumIn() != 1 {
-		return ErrMissingHandlerArgumentParam
-	}
-
-	// arg must be a struct
-	structArg := fnt.In(0)
-	if structArg.Kind() != reflect.Struct {
-		return ErrMissingParamArgument
-	}
-
-	// check for invlaid param
-	for name, ptype := range s.Input {
-		field, exists := structArg.FieldByName(name)
-		if !exists {
-			return fmt.Errorf("%s: %w", name, ErrMissingParamFromConfig)
-		}
-
-		if !ptype.AssignableTo(field.Type) {
-			return fmt.Errorf("%s: %w (%s instead of %s)", name, ErrWrongParamTypeFromConfig, field.Type, ptype)
-		}
-	}
-
-	return nil
-}
-
-// checks for HandlerFn output arguments
-func (s spec) checkOutput(fnv reflect.Value) error {
-	fnt := fnv.Type()
-	if fnt.NumOut() < 1 {
-		return ErrMissingHandlerOutput
-	}
-
-	// last output must be api.Error
-	errOutput := fnt.Out(fnt.NumOut() - 1)
-	if !errOutput.AssignableTo(reflect.TypeOf(api.ErrorUnknown)) {
-		return ErrMissingHandlerErrorOutput
-	}
-
-	// no output -> ok
-	if len(s.Output) == 0 {
-		return nil
-	}
-
-	if fnt.NumOut() != 2 {
-		return ErrMissingParamOutput
-	}
-
-	// fail if first output is not a pointer to struct
-	structOutputPtr := fnt.Out(0)
-	if structOutputPtr.Kind() != reflect.Ptr {
-		return ErrMissingParamOutput
-	}
-
-	structOutput := structOutputPtr.Elem()
-	if structOutput.Kind() != reflect.Struct {
-		return ErrMissingParamOutput
-	}
-
-	// fail on invalid output
-	for name, ptype := range s.Output {
-		field, exists := structOutput.FieldByName(name)
-		if !exists {
-			return fmt.Errorf("%s: %w", name, ErrMissingOutputFromConfig)
-		}
-
-		// ignore types evalutating to nil
-		if ptype == nil {
-			continue
-		}
-
-		if !ptype.ConvertibleTo(field.Type) {
-			return fmt.Errorf("%s: %w (%s instead of %s)", name, ErrWrongOutputTypeFromConfig, field.Type, ptype)
-		}
-	}
-
-	return nil
-}

dynamic/types.go

@@ -1,17 +0,0 @@
-package dynamic
-
-import "reflect"
-
-// HandlerFn defines a dynamic handler function
-type HandlerFn interface{}
-
-// Handler represents a dynamic api handler
-type Handler struct {
-	spec spec
-	fn   HandlerFn
-}
-
-type spec struct {
-	Input  map[string]reflect.Type
-	Output map[string]reflect.Type
-}

errors.go

@@ -1,15 +0,0 @@
-package aicra
-
-// cerr allows you to create constant "const" error with type boxing.
-type cerr string
-
-// Error implements the error builtin interface.
-func (err cerr) Error() string {
-	return string(err)
-}
-
-// ErrNoServiceForHandler - no service matching this handler
-const ErrNoServiceForHandler = cerr("no service found for this handler")
-
-// ErrNoHandlerForService - no handler matching this service
-const ErrNoHandlerForService = cerr("no handler found for this service")

handler.go

@@ -1,32 +0,0 @@
-package aicra
-
-import (
-	"fmt"
-	"strings"
-
-	"git.xdrm.io/go/aicra/dynamic"
-	"git.xdrm.io/go/aicra/internal/config"
-)
-
-type handler struct {
-	Method     string
-	Path       string
-	dynHandler *dynamic.Handler
-}
-
-// createHandler builds a handler from its http method and path
-// also it checks whether the function signature is valid
-func createHandler(method, path string, service config.Service, fn dynamic.HandlerFn) (*handler, error) {
-	method = strings.ToUpper(method)
-
-	dynHandler, err := dynamic.Build(fn, service)
-	if err != nil {
-		return nil, fmt.Errorf("%s '%s' handler: %w", method, path, err)
-	}
-
-	return &handler{
-		Path:       path,
-		Method:     method,
-		dynHandler: dynHandler,
-	}, nil
-}

http.go

@@ -55,11 +55,11 @@ func (server httpServer) ServeHTTP(res http.ResponseWriter, req *http.Request) {
 	}
 
 	// 6. find a matching handler
-	var foundHandler *handler
+	var foundHandler *api.Handler
 	var found bool
 
 	for _, handler := range server.handlers {
-		if handler.Method == service.Method && handler.Path == service.Pattern {
+		if handler.GetMethod() == service.Method && handler.GetPath() == service.Pattern {
 			foundHandler = handler
 			found = true
 		}
@@ -91,17 +91,9 @@ func (server httpServer) ServeHTTP(res http.ResponseWriter, req *http.Request) {
 	apireq.Param = dataset.Data
 
 	// 10. execute
-	returned, apiErr := foundHandler.dynHandler.Handle(dataset.Data)
-	response := api.EmptyResponse().WithError(apiErr)
-	for key, value := range returned {
-
-		// find original name from rename
-		for name, param := range service.Output {
-			if param.Rename == key {
-				response.SetData(name, value)
-			}
-		}
-	}
+	response := api.EmptyResponse()
+	apiErr := foundHandler.Fn(*apireq, response)
+	response.WithError(apiErr)
 
 	// 11. apply headers
 	res.Header().Set("Content-Type", "application/json; charset=utf-8")

internal/config/errors.go

@@ -41,9 +41,6 @@ const ErrMissingDescription = cerr("missing description")
 // ErrIllegalOptionalURIParam - an URI parameter cannot be optional
 const ErrIllegalOptionalURIParam = cerr("URI parameter cannot be optional")
 
-// ErrOptionalOption - an output is optional
-const ErrOptionalOption = cerr("output cannot be optional")
-
 // ErrMissingParamDesc - a parameter is missing its description
 const ErrMissingParamDesc = cerr("missing parameter description")
 

internal/config/parameter.go

@@ -1,8 +1,6 @@
 package config
 
-import (
-	"git.xdrm.io/go/aicra/datatype"
-)
+import "git.xdrm.io/go/aicra/datatype"
 
 // Validate implements the validator interface
 func (param *Parameter) Validate(datatypes ...datatype.T) error {
@@ -23,14 +21,16 @@ func (param *Parameter) Validate(datatypes ...datatype.T) error {
 	}
 
 	// assign the datatype
+	datatypeFound := false
 	for _, dtype := range datatypes {
 		param.Validator = dtype.Build(param.Type, datatypes...)
-		param.ExtractType = dtype.Type()
 		if param.Validator != nil {
+			datatypeFound = true
+			param.ExtractType = dtype.Type()
 			break
 		}
 	}
-	if param.Validator == nil {
+	if !datatypeFound {
 		return ErrUnknownDataType
 	}
 

internal/config/service.go

@@ -108,12 +108,6 @@ func (svc *Service) Validate(datatypes ...datatype.T) error {
 		}
 	}
 
-	// check output
-	err = svc.validateOutput(datatypes)
-	if err != nil {
-		return fmt.Errorf("field 'out': %w", err)
-	}
-
 	return nil
 }
 
@@ -263,52 +257,3 @@ func (svc *Service) validateInput(types []datatype.T) error {
 
 	return nil
 }
-
-func (svc *Service) validateOutput(types []datatype.T) error {
-
-	// ignore no parameter
-	if svc.Output == nil || len(svc.Output) < 1 {
-		svc.Output = make(map[string]*Parameter, 0)
-		return nil
-	}
-
-	// for each parameter
-	for paramName, param := range svc.Output {
-		if len(paramName) < 1 {
-			return fmt.Errorf("%s: %w", paramName, ErrIllegalParamName)
-		}
-
-		// use param name if no rename
-		if len(param.Rename) < 1 {
-			param.Rename = paramName
-		}
-
-		err := param.Validate(types...)
-		if err != nil {
-			return fmt.Errorf("%s: %w", paramName, err)
-		}
-
-		if param.Optional {
-			return fmt.Errorf("%s: %w", paramName, ErrOptionalOption)
-		}
-
-		// fail on name/rename conflict
-		for paramName2, param2 := range svc.Output {
-			// ignore self
-			if paramName == paramName2 {
-				continue
-			}
-
-			// 3.2.1. Same rename field
-			// 3.2.2. Not-renamed field matches a renamed field
-			// 3.2.3. Renamed field matches name
-			if param.Rename == param2.Rename || paramName == param2.Rename || paramName2 == param.Rename {
-				return fmt.Errorf("%s: %w", paramName, ErrParamNameConflict)
-			}
-
-		}
-
-	}
-
-	return nil
-}

server.go

@@ -5,15 +5,15 @@ import (
 	"io"
 	"os"
 
+	"git.xdrm.io/go/aicra/api"
 	"git.xdrm.io/go/aicra/datatype"
-	"git.xdrm.io/go/aicra/dynamic"
 	"git.xdrm.io/go/aicra/internal/config"
 )
 
 // Server represents an AICRA instance featuring: type checkers, services
 type Server struct {
 	config   *config.Server
-	handlers []*handler
+	handlers []*api.Handler
 }
 
 // New creates a framework instance from a configuration file
@@ -26,7 +26,7 @@ func New(configPath string, dtypes ...datatype.T) (*Server, error) {
 	// 1. init instance
 	var i = &Server{
 		config:   nil,
-		handlers: make([]*handler, 0),
+		handlers: make([]*api.Handler, 0),
 	}
 
 	// 2. open config file
@@ -46,26 +46,13 @@ func New(configPath string, dtypes ...datatype.T) (*Server, error) {
 
 }
 
-// Handle sets a new handler for an HTTP method to a path
-func (s *Server) Handle(method, path string, fn dynamic.HandlerFn) error {
-	// find associated service
-	var found *config.Service = nil
-	for _, service := range s.config.Services {
-		if method == service.Method && path == service.Pattern {
-			found = service
-			break
-		}
-	}
-	if found == nil {
-		return fmt.Errorf("%s '%s': %w", method, path, ErrNoServiceForHandler)
-	}
-
-	handler, err := createHandler(method, path, *found, fn)
+// 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 {
-		return err
+		panic(err)
 	}
 	s.handlers = append(s.handlers, handler)
-	return nil
 }
 
 // ToHTTPServer converts the server to a http server
@@ -75,13 +62,13 @@ func (s Server) ToHTTPServer() (*httpServer, error) {
 	for _, service := range s.config.Services {
 		found := false
 		for _, handler := range s.handlers {
-			if handler.Method == service.Method && handler.Path == service.Pattern {
+			if handler.GetMethod() == service.Method && handler.GetPath() == service.Pattern {
 				found = true
 				break
 			}
 		}
 		if !found {
-			return nil, fmt.Errorf("%s '%s': %w", service.Method, service.Pattern, ErrNoHandlerForService)
+			return nil, fmt.Errorf("missing handler for %s '%s'", service.Method, service.Pattern)
 		}
 	}