manager

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

type Client struct {
	ID       string `json:"id" validate:"required"`
	Username string `json:"username" validate:"required"`
	Passkey  string `json:"passkey,omitempty"`
}

type CustomExperimentManager interface {
	ExperimentManager
}

type CustomExperimentManagerConfig struct {
	// RemoteUI specifies the information for the custom experiment engine UI to be
	// consumed by the Turing app, using Module Federation
	RemoteUI RemoteUI `json:"remote_ui"`
	// ExperimentConfigSchema is the serialised schema as supported by https://github.com/WASD-Team/yup-ast.
	// If set, it will be used by the UI to validate experiment engine configuration in the Turing router.
	ExperimentConfigSchema string `json:"experiment_config_schema,omitempty"`
}

type Engine struct {
	// Name is the unique identifier for the experiment engine and will be used as
	// the display name in the UI if the optional `DisplayName` field is not set.
	Name string `json:"name"`
	// DisplayName is the name of the experiment engine that will be used in the UI,
	// solely for the purpose of display. The Turing API still relies on the `Name`.
	DisplayName string `json:"display_name"`
	// Type describes the class of the experiment engine manager
	Type ExperimentManagerType `json:"type"`
	// StandardExperimentManagerConfig is expected to be set by a "standard" experiment engine manager
	// and is used by the generic Turing experiment engine UI.
	StandardExperimentManagerConfig *StandardExperimentManagerConfig `json:"standard_experiment_manager_config,omitempty"`
	// CustomExperimentManagerConfig is expected to be set by a "custom" experiment engine manager
	// and is used to load the custom experiment engine UI.
	CustomExperimentManagerConfig *CustomExperimentManagerConfig `json:"custom_experiment_manager_config,omitempty"`
}

type Experiment struct {
	ID       string    `json:"id" validate:"required"`
	Name     string    `json:"name" validate:"required"`
	ClientID string    `json:"client_id"`
	Variants []Variant `json:"variants"`
}

type ExperimentManager interface {
	// GetEngineInfo returns the configuration of the experiment engine
	GetEngineInfo() (Engine, error)

	// ValidateExperimentConfig validates the given Turing experiment config for the expected data and format
	ValidateExperimentConfig(cfg json.RawMessage) error

	// GetExperimentRunnerConfig converts the given config (as retrieved from the DB) into a format suitable
	// for the Turing router (i.e., to be passed to the Experiment Runner). This interface method will be
	// called at the time of router deployment.
	//
	// cfg holds the experiment configuration in a format that is suitable for use with the Turing UI and
	// this is the data that is saved to the Turing DB.
	//
	// In case of StandardExperimentManager, cfg is expected to be unmarshalled into TuringExperimentConfig
	GetExperimentRunnerConfig(cfg json.RawMessage) (json.RawMessage, error)
}

type ExperimentManagerType string

type RemoteUI struct {
	// Name is the name of the remote app declared in the Module Federation plugin
	Name string `json:"name"`
	// URL is the Host + Remote Entry file at which the remote UI can be found
	URL string `json:"url"`
	// Config is an optional URL that will be loaded at run-time, to provide the experiment engine
	// configs dynamically
	Config string `json:"config,omitempty"`
}

type StandardExperimentManager interface {
	ExperimentManager
	// IsCacheEnabled returns whether the experiment engine wants to cache its responses in the Turing API cache
	IsCacheEnabled() (bool, error)
	// ListClients returns a list of the clients registered on the experiment engine
	ListClients() ([]Client, error)
	// ListExperiments returns a list of the experiments registered on the experiment engine
	ListExperiments() ([]Experiment, error)
	// ListExperimentsForClient returns a list of the experiments registered on the experiment engine,
	// for the given client
	ListExperimentsForClient(Client) ([]Experiment, error)
	// ListVariablesForClient returns a list of the variables registered on the given client
	ListVariablesForClient(Client) ([]Variable, error)
	// ListVariablesForExperiments returns a list of the variables registered on the given experiments
	ListVariablesForExperiments([]Experiment) (map[string][]Variable, error)
}

type StandardExperimentManagerConfig struct {
	// ClientSelectionEnabled is set to true if the experiment engine has the concept of
	// clients, that can be used to authenticate the experiment run requests.
	ClientSelectionEnabled bool `json:"client_selection_enabled"`
	// ExperimentSelectionEnabled is set to true if the experiment engine allows selecting
	// individual experiments configured elsewhere
	ExperimentSelectionEnabled bool `json:"experiment_selection_enabled"`
	// HomePageURL is an optional string which, if set, will be used by the UI to redirect
	// to the experiment engine's home page, to view more details on the experiment
	// configured in Turing.
	HomePageURL string `json:"home_page_url"`
}

type TuringExperimentConfig struct {
	Client      Client       `json:"client" validate:"dive"`
	Experiments []Experiment `json:"experiments" validate:"dive"`
	Variables   Variables    `json:"variables" validate:"dive"`
}

type Variable struct {
	Name     string       `json:"name" validate:"required"`
	Required bool         `json:"required"`
	Type     VariableType `json:"type" validate:"required"`
}

type VariableConfig struct {
	Name        string              `json:"name" validate:"required"`
	Required    bool                `json:"required"`
	Field       string              `json:"field" validate:"required_with=Required"`
	FieldSource request.FieldSource `json:"field_source" validate:"field-src"`
}

type VariableType string

type Variables struct {
	// ClientVariables represents the list of variables configured on the experiment engine's
	// client, if applicable
	ClientVariables []Variable `json:"client_variables" validate:"dive"`
	// ExperimentVariables is a map of experiment_id -> []Variable, representing the
	// variables configured on each experiment on the experiment engine
	ExperimentVariables map[string][]Variable `json:"experiment_variables" validate:"dive,dive"`
	// Config represents the request parsing configuration for all the Turing experiment variables
	Config []VariableConfig `json:"config" validate:"dive"`
}

type Variant struct {
	Name string `json:"name"`
}