flow

type ActionHandler interface {
	Method() string
	Path() string
	Middlewares() []MiddlewareHandlerFunc
	Handle(r *http.Request) Response
}

type HandlerFunc func(r *http.Request) Response

type Injector interface {
	Provide(constructor interface{}) (interface{}, error)
}

type Map map[string]interface{}

type MiddlewareFunc func(w http.ResponseWriter, r *http.Request) Response

type MiddlewareHandlerFunc func(MiddlewareFunc) MiddlewareFunc

type MiddlewareStack struct {
	// contains filtered or unexported fields
}

type Module struct {
	// contains filtered or unexported fields
}

type ModuleFactory interface {

	// ProvideImports returns list of instance providers for module dependecies
	// This method is used to register all module dependecies
	// eg. logging, db connection,....
	// all dependecies that are provided in this method
	// will be available to all modules imported by the factory
	ProvideImports() []Provider

	// ProvideExports returns list of instance providers for
	// functionalities that module will export.
	// Exported functionalities will be available to other modules that
	// import module created by the Factory
	ProvideExports() []Provider

	// ProvideModules returns list of instance providers
	// for modules that current module depends on
	ProvideModules() []Provider

	// ProvideRouters returns list of instance providers for module routers.
	// Module routers are used for http routing
	ProvideRouters() []Provider
}

type ModuleOptioner interface {
	Options() Options
}

type ModuleStarter interface {
	Start() error
}

type ModuleStopper interface {
	Stop()
}

type Options struct {
	RouterOptions

	Env              string
	Name             string
	Addr             string
	Version          string
	ModuleSuffix     string
	ControllerSuffix string
	ControllerIndex  string
	// contains filtered or unexported fields
}

type Param struct {
	Key   string
	Value string
}

type Params []Param

type Provider interface {
	Provide(injector Injector) (interface{}, error)
}

type Response interface {
	Status() int
	Handle(w http.ResponseWriter, r *http.Request) error
}

type Route struct {
	Method  string
	Path    string
	Mws     *MiddlewareStack
	Handler HandlerFunc
	// contains filtered or unexported fields
}

type Router struct {

	// Enables automatic redirection if the current route can't be matched but a
	// handler for the path with (without) the trailing slash exists.
	// For example if /foo/ is requested but a route only exists for /foo, the
	// client is redirected to /foo with http status code 301 for GET requests
	// and 308 for all other request methods.
	RedirectTrailingSlash bool

	// If enabled, the router tries to fix the current request path, if no
	// handle is registered for it.
	// First superfluous path elements like ../ or // are removed.
	// Afterwards the router does a case-insensitive lookup of the cleaned path.
	// If a handle can be found for this route, the router makes a redirection
	// to the corrected path with status code 301 for GET requests and 308 for
	// all other request methods.
	// For example /FOO and /..//Foo could be redirected to /foo.
	// RedirectTrailingSlash is independent of this option.
	RedirectFixedPath bool

	// If enabled, the router checks if another method is allowed for the
	// current route, if the current request can not be routed.
	// If this is the case, the request is answered with 'Method Not Allowed'
	// and HTTP status code 405.
	// If no other Method is allowed, the request is delegated to the NotFound
	// handler.
	HandleMethodNotAllowed bool

	// If enabled, the router automatically replies to OPTIONS requests.
	// Custom OPTIONS handlers take priority over automatic replies.
	HandleOptions bool

	// Body404 string to be displayed when route is not found
	Body404 string

	// Body405 string to be displayed when route is not allowed
	Body405 string
	// contains filtered or unexported fields
}

type RouterFactory interface {
	Path() string
	Middlewares() []MiddlewareHandlerFunc
	ProvideHandlers() []Provider
	RegisterSubRouters() bool
}

type RouterOptions struct {
	RedirectTrailingSlash  bool
	RedirectFixedPath      bool
	HandleMethodNotAllowed bool
	SaveMatchedRoutePath   bool
	HandleOptions          bool
	Body404                string
	Body405                string
}

type Routes []Route