ffapi

type APIRequest struct {
	Req             *http.Request
	QP              map[string]string
	PP              map[string]string
	FP              map[string]string
	Filter          AndFilter
	Input           interface{}
	Part            *Multipart
	SuccessStatus   int
	ResponseHeaders http.Header
}

type APIServer interface {
	Serve(ctx context.Context) error
	Started() <-chan struct{}
	APIPublicURL() string // valid to call after server is successfully started
}

type APIServerOptions[T any] struct {
	MetricsRegistry metric.MetricsRegistry
	Routes          []*Route
	EnrichRequest   func(r *APIRequest) (T, error)
	Description     string
	APIConfig       config.Section
	MetricsConfig   config.Section
	CORSConfig      config.Section
	FavIcon16       []byte
	FavIcon32       []byte
}

type APIServerRouteExt[T any] struct {
	JSONHandler   func(*APIRequest, T) (output interface{}, err error)
	UploadHandler func(*APIRequest, T) (output interface{}, err error)
}

type AndFilter interface{ MultiConditionFilter }

type BigIntField struct{}

type BoolField struct{}

type Bytes32Field struct{}

type CtxFFRequestIDKey struct{}

type CtxHeadersKey struct{}

type FFStringArrayField struct{}

type Field interface {
	GetSerialization() FieldSerialization
	Description() string
	FilterAsString() bool
}

type FieldSerialization interface {
	driver.Valuer
	sql.Scanner // Implementations can assume the value is ALWAYS a string
}

type Filter interface {
	// Sort adds a set of sort conditions (all in a single sort order)
	Sort(...string) Filter

	// Ascending sort order
	Ascending() Filter

	// Descending sort order
	Descending() Filter

	// Skip for pagination
	Skip(uint64) Filter

	// Limit for pagination
	Limit(uint64) Filter

	// Request a count to be returned on the total number that match the query
	Count(c bool) Filter

	// Finalize completes the filter, and for the plugin to validated output structure to convert
	Finalize() (*FilterInfo, error)

	// Builder returns the builder that made it
	Builder() FilterBuilder
}

type FilterBuilder interface {
	// Fields is the list of available fields
	Fields() []string
	// And requires all sub-filters to match
	And(and ...Filter) AndFilter
	// Or requires any of the sub-filters to match
	Or(and ...Filter) OrFilter
	// Eq equal - case sensitive
	Eq(name string, value driver.Value) Filter
	// Neq not equal - case sensitive
	Neq(name string, value driver.Value) Filter
	// IEq equal - case insensitive
	IEq(name string, value driver.Value) Filter
	// INeq not equal - case insensitive
	NIeq(name string, value driver.Value) Filter
	// In one of an array of values
	In(name string, value []driver.Value) Filter
	// NotIn not one of an array of values
	NotIn(name string, value []driver.Value) Filter
	// Lt less than
	Lt(name string, value driver.Value) Filter
	// Gt greater than
	Gt(name string, value driver.Value) Filter
	// Gte greater than or equal
	Gte(name string, value driver.Value) Filter
	// Lte less than or equal
	Lte(name string, value driver.Value) Filter
	// Contains allows the string anywhere - case sensitive
	Contains(name string, value driver.Value) Filter
	// NotContains disallows the string anywhere - case sensitive
	NotContains(name string, value driver.Value) Filter
	// IContains allows the string anywhere - case insensitive
	IContains(name string, value driver.Value) Filter
	// INotContains disallows the string anywhere - case insensitive
	NotIContains(name string, value driver.Value) Filter
	// StartsWith allows the string at the start - case sensitive
	StartsWith(name string, value driver.Value) Filter
	// NotStartsWith disallows the string at the start - case sensitive
	NotStartsWith(name string, value driver.Value) Filter
	// IStartsWith allows the string at the start - case insensitive
	IStartsWith(name string, value driver.Value) Filter
	// NotIStartsWith disallows the string att the start - case insensitive
	NotIStartsWith(name string, value driver.Value) Filter
	// EndsWith allows the string at the end - case sensitive
	EndsWith(name string, value driver.Value) Filter
	// NotEndsWith disallows the string at the end - case sensitive
	NotEndsWith(name string, value driver.Value) Filter
	// IEndsWith allows the string at the end - case insensitive
	IEndsWith(name string, value driver.Value) Filter
	// NotIEndsWith disallows the string att the end - case insensitive
	NotIEndsWith(name string, value driver.Value) Filter
}

type FilterInfo struct {
	Sort      []*SortField
	Skip      uint64
	Limit     uint64
	Count     bool
	CountExpr string
	Field     string
	Op        FilterOp
	Values    []FieldSerialization
	Value     FieldSerialization
	Children  []*FilterInfo
}

type FilterOp string

type FilterResult struct {
	TotalCount *int64
}

type FilterResultsWithCount struct {
	Count int64       `json:"count"`
	Total int64       `json:"total"`
	Items interface{} `json:"items"`
}

type FormParam struct {
	// Name is the name of the parameter, from the Gorilla path mux
	Name string
	// Description is a message key to a translatable description of the parameter
	Description i18n.MessageKey
}

type HandlerFactory struct {
	DefaultRequestTimeout time.Duration
	MaxTimeout            time.Duration
	DefaultFilterLimit    uint64
	MaxFilterSkip         uint64
	MaxFilterLimit        uint64
	PassthroughHeaders    []string
}

type Int64Field struct{}

type JSONField struct{}

type MultiConditionFilter interface {
	Filter
	// Add adds filters to the condition
	Condition(...Filter) MultiConditionFilter
}

type Multipart struct {
	Filename string
	Mimetype string
	Data     io.Reader
}

type NullBehavior int

type Options struct {
	BaseURL                   string
	Title                     string
	Version                   string
	Description               string
	PanicOnMissingDescription bool
	DefaultRequestTimeout     time.Duration
	APIMaxFilterSkip          uint
	APIDefaultFilterLimit     string
	APIMaxFilterLimit         uint

	RouteCustomizations func(ctx context.Context, sg *SwaggerGen, route *Route, op *openapi3.Operation)
}

type OrFilter interface{ MultiConditionFilter }

type PathParam struct {
	// Name is the name of the parameter, from the Gorilla path mux
	Name string
	// Default is the value that will be used in the case no value is supplied
	Default string
	// Example is a field to fill in, in the helper UI
	Example string
	// ExampleFromConf is a field to fill in, in the helper UI, from the runtime configuration
	ExampleFromConf config.RootKey
	// Description is a message key to a translatable description of the parameter
	Description i18n.MessageKey
}

type QueryFactory interface {
	NewFilter(ctx context.Context) FilterBuilder
	NewFilterLimit(ctx context.Context, defLimit uint64) FilterBuilder
	NewUpdate(ctx context.Context) UpdateBuilder
}

type QueryFields map[string]Field

type QueryParam struct {
	// Name is the name of the parameter, from the Gorilla path mux
	Name string
	// IsBool if this is a boolean query
	IsBool bool
	// Default is the value that will be used in the case no value is supplied
	Default string
	// Example is a field to fill in, in the helper UI
	Example string
	// ExampleFromConf is a field to fill in, in the helper UI, from the runtime configuration
	ExampleFromConf config.RootKey
	// Description is a message key to a translatable description of the parameter
	Description i18n.MessageKey
	// Deprecated whether this param is deprecated
	Deprecated bool
}

type Route struct {
	// Name is the operation name that will go into the Swagger definition, and prefix input/output schema
	Name string
	// Path is a Gorilla mux path spec
	Path string
	// PathParams is a list of documented path parameters
	PathParams []*PathParam
	// QueryParams is a list of documented query parameters
	QueryParams []*QueryParam
	// FormParams is a list of documented multi-part form parameters - combine with FormUploadHandler
	FormParams []*FormParam
	// Method is the HTTP method
	Method string
	// Description is a message key to a translatable description of the operation
	Description i18n.MessageKey
	// PreTranslatedDescription is a string describing the operation - used for programmatically generated routes where a built-in string translation is not available
	PreTranslatedDescription string
	// FilterFactory models the filter fields that can be specified on the API, and will automatically be parsed
	FilterFactory QueryFactory
	// JSONInputValue is a function that returns a pointer to a structure to take JSON input
	JSONInputValue func() interface{}
	// JSONInputMask are fields that aren't available for users to supply on input
	JSONInputMask []string
	// JSONInputSchema is a custom schema definition, for the case where the auto-gen + mask isn't good enough
	JSONInputSchema func(ctx context.Context, schemaGen SchemaGenerator) (*openapi3.SchemaRef, error)
	// JSONOutputSchema is a custom schema definition, for the case where the auto-gen + mask isn't good enough
	JSONOutputSchema func(ctx context.Context, schemaGen SchemaGenerator) (*openapi3.SchemaRef, error)
	// JSONOutputValue is a function that returns a pointer to a structure to take JSON output
	JSONOutputValue func() interface{}
	// JSONOutputCodes is the success response code
	JSONOutputCodes []int
	// JSONHandler is a function for handling JSON content type input. Input/Ouptut objects are returned by JSONInputValue/JSONOutputValue funcs
	JSONHandler func(r *APIRequest) (output interface{}, err error)
	// FormUploadHandler takes a single file upload, and returns a JSON object
	FormUploadHandler func(r *APIRequest) (output interface{}, err error)
	// Deprecated whether this route is deprecated
	Deprecated bool
	// Tag a category identifier for this route in the generated OpenAPI spec
	Tag string
	// Extensions allows extension of the route struct by individual microservices
	Extensions interface{}
}

type SchemaGenerator func(o interface{}) (*openapi3.SchemaRef, error)

type SetOperation struct {
	Field string
	Value FieldSerialization
}

type SortField struct {
	Field      string
	Descending bool
	Nulls      NullBehavior
}

type StringField struct{}

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

type TimeField struct{}

type UUIDField struct{}

type Update interface {
	// Set adds a set condition to the update
	Set(field string, value interface{}) Update

	// IsEmpty
	IsEmpty() bool

	// Finalize completes the update, and for the plugin to validated output structure to convert
	Finalize() (*UpdateInfo, error)
}

type UpdateBuilder interface {
	// Set starts creation of a set operation
	Set(field string, value interface{}) Update

	// S starts an update that doesn't have any fields
	S() Update

	// Fields returns the available fields on the update
	Fields() []string
}

type UpdateFactory interface {
	New(ctx context.Context) UpdateBuilder
}

type UpdateInfo struct {
	SetOperations []*SetOperation
}