server

type ApiAppHandler interface {
	// Handle(ctx context.Context)
	ServeHTTP(w http.ResponseWriter, r *http.Request, app *models.App)
}

type ApiAppHandlerFunc func(w http.ResponseWriter, r *http.Request, app *models.App)

type ApiHandler interface {
	// Handle(ctx context.Context)
	ServeHTTP(w http.ResponseWriter, r *http.Request)
}

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

type AppListener interface {
	// BeforeAppCreate called right before creating App in the database
	BeforeAppCreate(ctx context.Context, app *models.App) error
	// AfterAppCreate called after creating App in the database
	AfterAppCreate(ctx context.Context, app *models.App) error
	// BeforeAppUpdate called right before updating App in the database
	BeforeAppUpdate(ctx context.Context, app *models.App) error
	// AfterAppUpdate called after updating App in the database
	AfterAppUpdate(ctx context.Context, app *models.App) error
	// BeforeAppDelete called right before deleting App in the database
	BeforeAppDelete(ctx context.Context, app *models.App) error
	// AfterAppDelete called after deleting App in the database
	AfterAppDelete(ctx context.Context, app *models.App) error
}

type Handle func(http.ResponseWriter, *http.Request, Params)

type HandlerContext interface {
	// Context return the context object
	Context() context.Context

	// Request returns the underlying http.Request object
	Request() *http.Request

	// Response returns the http.ResponseWriter
	Response() http.ResponseWriter

	// Overwrite value in the context
	Set(key string, value interface{})
}

type Middleware interface {
	// Serve is what the Middleware must implement. Can modify the request, write output, etc.
	// todo: should we abstract the HTTP out of this?  In case we want to support other protocols.
	Serve(ctx MiddlewareContext, w http.ResponseWriter, r *http.Request, app *models.App) error
}

type MiddlewareContext interface {
	context.Context
	// Middleware can call Next() explicitly to call the next middleware in the chain. If Next() is not called and an error is not returned, Next() will automatically be called.
	Next()
	// Index returns the index of where we're at in the chain
	Index() int
}

type MiddlewareFunc func(ctx MiddlewareContext, w http.ResponseWriter, r *http.Request, app *models.App) error

type Param struct {
	Key   string
	Value string
}

type Params []Param

type RunnerListener interface {
	// BeforeDispatch called before a function run
	BeforeDispatch(ctx context.Context, route *models.Route) error
	// AfterDispatch called after a function run
	AfterDispatch(ctx context.Context, route *models.Route) error
}

type Server struct {
	Datastore models.Datastore
	Runner    *runner.Runner
	Router    *gin.Engine
	MQ        models.MessageQueue
	Enqueue   models.Enqueue
	// contains filtered or unexported fields
}

type ServerOption func(*Server)

type SpecialHandler interface {
	Handle(c HandlerContext) error
}

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