capabilities

type AuthCapability interface {
	HeaderForDomain(string) *AuthHeader
}

type AuthConfig struct {
	Enabled bool `json:"enabled" yaml:"enabled"`

	// Headers is a map between domains and auth header that should be added to requests to those domains
	Headers map[string]AuthHeader `json:"headers" yaml:"headers"`
}

type AuthHeader struct {
	HeaderType string `json:"headerType" yaml:"headerType"`
	Value      string `json:"value" yaml:"value"`
}

type CacheCapability interface {
	Set(key string, val []byte, ttl int) error
	Get(key string) ([]byte, error)
	Delete(key string) error
}

type CacheConfig struct {
	Enabled     bool         `json:"enabled" yaml:"enabled"`
	Rules       CacheRules   `json:"rules" yaml:"rules"`
	RedisConfig *RedisConfig `json:"redis,omitempty" yaml:"redis,omitempty"`
}

type CacheRules struct {
	AllowSet    bool `json:"allowSet" yaml:"allowSet"`
	AllowGet    bool `json:"allowGet" yaml:"allowGet"`
	AllowDelete bool `json:"allowDelete" yaml:"allowDelete"`
}

type Capabilities struct {
	Auth          AuthCapability
	LoggerSource  LoggerCapability
	HTTPClient    HTTPCapability
	GraphQLClient GraphQLCapability
	Cache         CacheCapability
	FileSource    FileCapability
	Database      DatabaseCapability

	// RequestHandler and doFunc are special because they are more
	// sensitive; they could cause memory leaks or expose internal state,
	// so they cannot be swapped out for a different implementation.
	RequestConfig *RequestHandlerConfig
	// contains filtered or unexported fields
}

type CapabilityConfig struct {
	Logger  *LoggerConfig         `json:"logger,omitempty" yaml:"logger,omitempty"`
	HTTP    *HTTPConfig           `json:"http,omitempty" yaml:"http,omitempty"`
	GraphQL *GraphQLConfig        `json:"graphql,omitempty" yaml:"graphql,omitempty"`
	Auth    *AuthConfig           `json:"auth,omitempty" yaml:"auth,omitempty"`
	Cache   *CacheConfig          `json:"cache,omitempty" yaml:"cache,omitempty"`
	File    *FileConfig           `json:"file,omitempty" yaml:"file,omitempty"`
	DB      *DatabaseConfig       `json:"db" yaml:"db"`
	Request *RequestHandlerConfig `json:"requestHandler,omitempty" yaml:"requestHandler,omitempty"`
}

type DatabaseCapability interface {
	ExecQuery(queryType int32, name string, vars []interface{}) ([]byte, error)
	Prepare(q *Query) error
}

type DatabaseConfig struct {
	Enabled          bool    `json:"enabled" yaml:"enabled"`
	DBType           string  `json:"dbType" yaml:"dbType"`
	ConnectionString string  `json:"connectionString" yaml:"connectionString"`
	Queries          []Query `json:"queries" yaml:"queries"`
}

type FileCapability interface {
	GetStatic(filename string) ([]byte, error)
}

type FileConfig struct {
	Enabled bool `json:"enabled" yaml:"enabled"`

	FileFunc StaticFileFunc `json:"-" yaml:"-"`
}

type GraphQLCapability interface {
	Do(auth AuthCapability, endpoint, query string) (*GraphQLResponse, error)
}

type GraphQLConfig struct {
	Enabled bool      `json:"enabled" yaml:"enabled"`
	Rules   HTTPRules `json:"rules" yaml:"rules"`
}

type GraphQLError struct {
	Message string `json:"message"`
	Path    string `json:"path"`
}

type GraphQLRequest struct {
	Query         string            `json:"query"`
	Variables     map[string]string `json:"variables,omitempty"`
	OperationName string            `json:"operationName,omitempty"`
}

type GraphQLResponse struct {
	Data   map[string]interface{} `json:"data"`
	Errors []GraphQLError         `json:"errors,omitempty"`
}

type HTTPCapability interface {
	Do(auth AuthCapability, method, urlString string, body []byte, headers http.Header) (*http.Response, error)
}

type HTTPConfig struct {
	Enabled bool      `json:"enabled" yaml:"enabled"`
	Rules   HTTPRules `json:"rules" yaml:"rules"`
}

type HTTPRules struct {
	AllowedDomains []string `json:"allowedDomains" yaml:"allowedDomains"`
	BlockedDomains []string `json:"blockedDomains" yaml:"blockedDomains"`
	AllowedPorts   []int    `json:"allowedPorts" yaml:"allowedPorts"`
	BlockedPorts   []int    `json:"blockedPorts" yaml:"blockedPorts"`
	AllowIPs       bool     `json:"allowIPs" yaml:"allowIPs"`
	AllowPrivate   bool     `json:"allowPrivate" yaml:"allowPrivate"`
	AllowHTTP      bool     `json:"allowHTTP" yaml:"allowHTTP"`
}

type LoggerCapability interface {
	Log(level int32, msg string, scope interface{})
}

type LoggerConfig struct {
	Enabled bool         `json:"enabled" yaml:"enabled"`
	Logger  *vlog.Logger `json:"-" yaml:"-"`
}

type Query struct {
	Type     QueryType `json:"type" yaml:"type"`
	Name     string    `json:"name" yaml:"name"`
	VarCount int       `json:"varCount" yaml:"varCount"`
	Query    string    `json:"query" yaml:"query"`
	// contains filtered or unexported fields
}

type QueryType int32

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

type RedisConfig struct {
	ServerAddress string `json:"serverAddress" yaml:"serverAddress"`
	Username      string `json:"username" yaml:"username"`
	Password      string `json:"password" yaml:"password"`
}

type RequestHandlerCapability interface {
	GetField(fieldType int32, key string) ([]byte, error)
	SetField(fieldType int32, key string, val string) error
	SetResponseHeader(key, val string) error
}

type RequestHandlerConfig struct {
	Enabled       bool `json:"enabled" yaml:"enabled"`
	AllowGetField bool `json:"allowGetField" yaml:"allowGetField"`
	AllowSetField bool `json:"allowSetField" yaml:"allowSetField"`
}

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

type StaticFileFunc func(string) ([]byte, error)