wrouter

type ParamPerms interface {
	// Safe returns true if the parameter with the provided name is safe to log. Case-insensitive.
	Safe(paramName string) bool
	// Forbidden returns true if the provided parameter is forbidden from being logged (that is, it should not be logged
	// at all, even as an unsafe parameter). Case-insensitive.
	Forbidden(paramName string) bool
}

type PathSegment struct {
	Type  SegmentType
	Value string
}

type PathTemplate interface {
	Template() string
	Segments() []PathSegment
}

type RequestHandlerMiddleware func(rw http.ResponseWriter, r *http.Request, next http.Handler)

type RequestVals struct {
	Spec          RouteSpec
	PathParamVals map[string]string
	ParamPerms    RouteParamPerms
	MetricTags    metrics.Tags
}

type ResponseVals struct {
	RespStatus  int
	RespSize    int64
	ReqDuration time.Duration
}

type RootRouter interface {
	http.Handler
	Router

	AddRequestHandlerMiddleware(handlers ...RequestHandlerMiddleware)
	AddRouteHandlerMiddleware(handlers ...RouteHandlerMiddleware)

	// RegisterNotFoundHandler registers a handler to produce 404 responses.
	// It should be called after all middlewares are added to the router.
	RegisterNotFoundHandler(handler http.Handler)
}

type RootRouterParam interface {
	// contains filtered or unexported methods
}

type RouteHandlerMiddleware func(rw http.ResponseWriter, r *http.Request, reqVals RequestVals, next RouteRequestHandler)

type RouteParam interface {
	// contains filtered or unexported methods
}

type RouteParamPerms interface {
	PathParamPerms() ParamPerms
	QueryParamPerms() ParamPerms
	HeaderParamPerms() ParamPerms
}

type RouteRequestHandler func(rw http.ResponseWriter, r *http.Request, reqVals RequestVals)

type RouteSpec struct {
	Method       string
	PathTemplate string
}

type Router interface {
	// Register registers the provided handler for this router for the provided method (GET, POST, etc.) and path.
	// The RouteParam parameters specifies any path, query or header parameters that should be considered safe or
	// forbidden for the purposes of logging.
	Register(method, path string, handler http.Handler, params ...RouteParam) error

	// RegisteredRoutes returns a slice of all of the routes registered with this router in sorted order.
	RegisteredRoutes() []RouteSpec

	// Get is a shorthand for Register(http.MethodGet, path, handler, params...)
	Get(path string, handler http.Handler, params ...RouteParam) error

	// Head is a shorthand for Register(http.MethodHead, path, handler, params...)
	Head(path string, handler http.Handler, params ...RouteParam) error

	// Post is a shorthand for Register(http.MethodPost, path, handler, params...)
	Post(path string, handler http.Handler, params ...RouteParam) error

	// Put is a shorthand for Register(http.MethodPut, path, handler, params...)
	Put(path string, handler http.Handler, params ...RouteParam) error

	// Patch is a shorthand for Register(http.MethodPatch, path, handler, params...)
	Patch(path string, handler http.Handler, params ...RouteParam) error

	// Delete is a shorthand for Register(http.MethodDelete, path, handler, params...)
	Delete(path string, handler http.Handler, params ...RouteParam) error

	// Subrouter returns a new Router that is a child of this Router. A child router is effectively an alias to the root
	// router -- any routes registered on the child router are registered on the root router with all of the prefixes up
	// to the child router.
	Subrouter(path string, params ...RouteParam) Router

	// Path returns the path stored by this router. The path is empty for the root router, while subrouters will return
	// only the portion of the path managed by the subrouter.
	Path() string

	// Parent returns the parent router of this Router, or nil if this router is the root router.
	Parent() Router

	// RootRouter returns the RootRouter for this router (which may be itself).
	RootRouter() RootRouter
}

type RouterImpl interface {
	// RouterImpl must implement http.Handler
	http.Handler

	// Register registers the provided handler for this router for the provided method (GET, POST, etc.) and
	// pathSegments.
	Register(method string, pathSegments []PathSegment, handler http.Handler)

	// PathParams returns the path parameters for the provided request. The size of the returned slice must match
	// the number of parameters in the path. The variable names of the parameters in the path are provided in order
	// in the "pathVarNames" slice.
	PathParams(req *http.Request, pathVarNames []string) map[string]string

	// RegisterNotFoundHandler registers a handler that is used to handle any requests that do not match any registered routes on the router.
	// If not provided, the implementation's default behavior is used (typically returns an http.Error with a 404 response code).
	RegisterNotFoundHandler(handler http.Handler)
}

type SegmentType int