configs

type APIMapping ¶

type APIMapping struct {
	Path    string
	Package string
	Methods []string
	Queries []string
}

APIMapping within a configs.DatastoreAPIMapping which holds all information that is needed to map an incoming request to a rego package. The Path can be a regular expression.

type AppConfig ¶

type AppConfig struct {
	ExternalConfig
	CallOperands    map[string]map[string]func(args ...string) (string, error)
	MetricsProvider telemetry.MetricsProvider
	TraceProvider   telemetry.TraceProvider
}

AppConfig represents the configuration for the entire app.

type ByteConfigLoader ¶

type ByteConfigLoader struct {
	FileBytes []byte
}

ByteConfigLoader implements Loader by loading config from provided bytes slices.

func (l *ByteConfigLoader) Load() (*ExternalConfig, error)

type ConfigLoader ¶

type ConfigLoader interface {
	// Load loads all external configuration files from a predefined source.
	// It returns the loaded configuration and any error encountered that caused the Loader to stop early.
	Load() (*ExternalConfig, error)
}

ConfigLoader is the interface that the functionality of loading kelon's external configuration.

type Datastore ¶

type Datastore struct {
	Type       string
	Connection map[string]string
	Metadata   map[string]string
}

Datastore has a fixed Type (enum type) and variable connection-/metadata-properties Which should be validated and parsed by each data.Datastore separately.

type DatastoreAPIMapping ¶

type DatastoreAPIMapping struct {
	Prefix         string   `yaml:"path-prefix"`
	Datastores     []string `yaml:"datastores,omitempty"`
	Authentication *bool    `yaml:",omitempty"`
	Authorization  *bool    `yaml:",omitempty"`
	Mappings       []*APIMapping
}

DatastoreAPIMapping holds the API-mappings for one of the datastores defined in configs.DatastoreConfig.

Each mapping has a type of 'mapping global' Prefix which should be appended to each Path of its Mappings. The prefix can be a regular expression.

func (m *DatastoreAPIMapping) Defaults()

func (m *DatastoreAPIMapping) Validate(schema DatastoreSchemas) error

type DatastoreSchemas ¶ added in v0.2.0

type DatastoreSchemas = map[string]map[string]*EntitySchema

DatastoreSchemas maps the datastore alias to a datastore schema to a slice of Entities which are contained in this schema.

type Entity ¶

type Entity struct {
	Name     string
	Alias    string
	Entities []*Entity
}

Entity inside a schema

type EntitySchema ¶

type EntitySchema struct {
	Entities []*Entity
}

EntitySchema contains a List of entities of a schema

func (schema EntitySchema) ContainsEntity(search string) (bool, *Entity)

func (schema EntitySchema) GenerateEntityPaths() map[string]map[string][]string

func (schema EntitySchema) HasNestedEntities() bool

type ExternalConfig ¶

type ExternalConfig struct {
	Global           Global                              `yaml:"global"`
	APIMappings      []*DatastoreAPIMapping              `yaml:"apis"`
	Datastores       map[string]*Datastore               `yaml:"datastores"`
	DatastoreSchemas map[string]map[string]*EntitySchema `yaml:"entity_schemas"`
	OPA              any                                 `yaml:"opa"`
}

ExternalConfig holds all externally configurable properties

func (ec *ExternalConfig) Defaults()

func (ec *ExternalConfig) Validate() error

type FileConfigLoader ¶

type FileConfigLoader struct {
	FilePath string
}

FileConfigLoader implements Loader by loading config from two files located at given paths.

func (l FileConfigLoader) Load() (*ExternalConfig, error)

type Global ¶ added in v0.2.0

type Global struct {
	Input Input `yaml:"input"`
}

Global holds the global configuration for the application.

func (g *Global) Validate() error

type HeaderMapping ¶ added in v0.2.0

type HeaderMapping struct {
	Name  string `yaml:"name"`
	Alias string `yaml:"alias"`
}

HeaderMapping is a simple struct to hold a key-value pair for headers that should be included in the request. If Name is not set, the header will be included as is, otherwise the header will be included as the specified name.

type Input ¶ added in v0.2.0

type Input struct {
	HeaderMapping []*HeaderMapping `yaml:"header-mapping"`
}

Input holds input related configuration, such as global header to input mappings.

func (i *Input) Validate() error