forge

type App interface {
	// The Logger to be used
	Logger() *Logger
}

type AssertFailure struct {
	Expected interface{}
	Actual   interface{}
}

type CSP struct {
	Default []string
	Script  []string
	Connect []string
	Frame   []string
}

type Environment map[string]string

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

type HTTPClientInterceptor interface {
	ModRequest(request *http.Request) error
	ErrorCheck(response *http.Response) error
}

type HTTPLogger struct {
	Logger  *Logger
	Handler http.Handler
}

type HTTPRouter struct {
	Routes          map[string]http.Handler
	NotFoundHandler http.Handler
}

type HTTPStatic struct {
	FileSystem      http.FileSystem
	NotFoundHandler http.Handler
	CacheControl    string
}

type LogEntry struct {
	Timestamp time.Time      `json:"@timestamp"`
	Channel   string         `json:"channel"`
	Level     string         `json:"level"`
	Message   string         `json:"message"`
	Extras    map[string]any `json:"extras"`
	ContextID string         `json:"context_id"`
}

type LogSupplementer func(
	logEntry *LogEntry,
	ctx context.Context,
	r *http.Request,
)

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

type MockRoundTripFunc func(t *testing.T, request *http.Request) (*http.Response, error)

type MockableRoundTripper struct {
	RoundTripFunc func(*http.Request) (*http.Response, error)
}

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

type Resources struct {
	FileSystems []fs.FS
}

type Runtime struct {
	Environment Environment
	Stdout      io.Writer
	Stderr      io.Writer
	Stdin       io.Reader
	FS          fs.FS
}

type Validator interface {
	Validate() error
}

type ValidatorError struct {
	Message string
}

type WebApp interface {
	App
	// How it responds to web requests
	Handler() http.Handler
	// What address the webserver should listen on
	ListenAddress() string
	// Tasks to run in the background (a Go routine)
	Background(ctx context.Context)
}