storage

Documentation

Index

• Constants
• func ListAll[P, V any](ctx context.Context, fn ListFunc[P, V], params ListAllParams) (res []V, err error)
• type EvaluationConstraint
• type EvaluationDistribution
• type EvaluationRule
• type EvaluationStore
• type FlagStore
• type ListAllParams
• type ListFunc
• type ListOption
  • func ListWithQueryParamOptions[T any](opts ...QueryOption) ListOption[T]
• type ListRequest
  • func NewListRequest[T any](opts ...ListOption[T]) *ListRequest[T]
• type NamespaceStore
• type Order
  • func (o Order) String() string
• type QueryOption
  • func WithLimit(limit uint64) QueryOption
  • func WithOffset(offset uint64) QueryOption
  • func WithOrder(order Order) QueryOption
  • func WithPageToken(pageToken string) QueryOption
• type QueryParams
  • func NewQueryParams(opts ...QueryOption) (params QueryParams)
  • func (q *QueryParams) Normalize()
• type ResultSet
• type RuleStore
• type SegmentStore
• type Store

Constants

const (
	// DefaultListLimit is the default limit applied to any list operation page size when one is not provided.
	DefaultListLimit uint64 = 25

	// MaxListLimit is the upper limit applied to any list operation page size.
	MaxListLimit uint64 = 100
)

const DefaultNamespace = "default"

Functions

func ListAll

func ListAll[P, V any](ctx context.Context, fn ListFunc[P, V], params ListAllParams) (res []V, err error)

ListAll can return the entire contents of some generic storage layer if given a ListFunc implementation for that store. It performs an entire paginated walk until an empty next page token is returned.

Types

type EvaluationConstraint

type EvaluationConstraint struct {
	ID       string
	Type     flipt.ComparisonType
	Property string
	Operator string
	Value    string
}

EvaluationConstraint represents a segment constraint that is used for evaluation

type EvaluationDistribution

type EvaluationDistribution struct {
	ID                string
	RuleID            string
	VariantID         string
	Rollout           float32
	VariantKey        string
	VariantAttachment string
}

EvaluationDistribution represents a rule distribution along with its variant for evaluation

type EvaluationRule

type EvaluationRule struct {
	ID               string
	NamespaceKey     string
	FlagKey          string
	SegmentKey       string
	SegmentMatchType flipt.MatchType
	Rank             int32
	Constraints      []EvaluationConstraint
}

EvaluationRule represents a rule and constraints required for evaluating if a given flagKey matches a segment

type EvaluationStore

type EvaluationStore interface {
	// GetEvaluationRules returns rules applicable to flagKey provided
	// Note: Rules MUST be returned in order by Rank
	GetEvaluationRules(ctx context.Context, namespaceKey, flagKey string) ([]*EvaluationRule, error)
	GetEvaluationDistributions(ctx context.Context, ruleID string) ([]*EvaluationDistribution, error)
}

EvaluationStore returns data necessary for evaluation

type FlagStore

type FlagStore interface {
	GetFlag(ctx context.Context, namespaceKey, key string) (*flipt.Flag, error)
	ListFlags(ctx context.Context, namespaceKey string, opts ...QueryOption) (ResultSet[*flipt.Flag], error)
	CountFlags(ctx context.Context, namespaceKey string) (uint64, error)
	CreateFlag(ctx context.Context, r *flipt.CreateFlagRequest) (*flipt.Flag, error)
	UpdateFlag(ctx context.Context, r *flipt.UpdateFlagRequest) (*flipt.Flag, error)
	DeleteFlag(ctx context.Context, r *flipt.DeleteFlagRequest) error
	CreateVariant(ctx context.Context, r *flipt.CreateVariantRequest) (*flipt.Variant, error)
	UpdateVariant(ctx context.Context, r *flipt.UpdateVariantRequest) (*flipt.Variant, error)
	DeleteVariant(ctx context.Context, r *flipt.DeleteVariantRequest) error
}

FlagStore stores and retrieves flags and variants

type ListAllParams

type ListAllParams struct {
	PerPage int
	Order   Order
}

type ListFunc

type ListFunc[P, V any] func(context.Context, *ListRequest[P]) (ResultSet[V], error)

ListFunc is a function which can return a set of results for a list request.

type ListOption

type ListOption[T any] func(*ListRequest[T])

ListOption is a function which can configure a ListRequest.

func ListWithQueryParamOptions

func ListWithQueryParamOptions[T any](opts ...QueryOption) ListOption[T]

ListWithQueryParamOptions takes a set of functional options for QueryParam and returns a ListOption which applies them in order on the provided ListRequest.

type ListRequest

type ListRequest[P any] struct {
	Predicate   P
	QueryParams QueryParams
}

ListRequest is a generic container for the parameters required to perform a list operation. It contains a generic type T intended for a list predicate. It also contains a QueryParams object containing pagination constraints.

func NewListRequest

func NewListRequest[T any](opts ...ListOption[T]) *ListRequest[T]

NewListRequest constructs a new ListRequest using the provided ListOption.

type NamespaceStore

type NamespaceStore interface {
	GetNamespace(ctx context.Context, key string) (*flipt.Namespace, error)
	ListNamespaces(ctx context.Context, opts ...QueryOption) (ResultSet[*flipt.Namespace], error)
	CountNamespaces(ctx context.Context) (uint64, error)
	CreateNamespace(ctx context.Context, r *flipt.CreateNamespaceRequest) (*flipt.Namespace, error)
	UpdateNamespace(ctx context.Context, r *flipt.UpdateNamespaceRequest) (*flipt.Namespace, error)
	DeleteNamespace(ctx context.Context, r *flipt.DeleteNamespaceRequest) error
}

NamespaceStore stores and retrieves namespaces

type Order

type Order uint8

const (
	OrderAsc Order = iota
	OrderDesc
)

func (Order) String

func (o Order) String() string

type QueryOption

type QueryOption func(p *QueryParams)

func WithLimit

func WithLimit(limit uint64) QueryOption

func WithOffset

func WithOffset(offset uint64) QueryOption

func WithOrder

func WithOrder(order Order) QueryOption

func WithPageToken

func WithPageToken(pageToken string) QueryOption

type QueryParams

type QueryParams struct {
	Limit     uint64
	Offset    uint64 // deprecated
	PageToken string
	Order     Order // not exposed to the user yet
}

func NewQueryParams

func NewQueryParams(opts ...QueryOption) (params QueryParams)

func (*QueryParams) Normalize

func (q *QueryParams) Normalize()

Normalize adjusts query parameters within the enforced boundaries. For example, limit is adjusted to be in the range (0, max]. Given the limit is not supplied (0) it is set to the default limit.

type ResultSet

type ResultSet[T any] struct {
	Results       []T
	NextPageToken string
}

type RuleStore

type RuleStore interface {
	GetRule(ctx context.Context, namespaceKey, id string) (*flipt.Rule, error)
	ListRules(ctx context.Context, namespaceKey, flagKey string, opts ...QueryOption) (ResultSet[*flipt.Rule], error)
	CountRules(ctx context.Context, namespaceKey, flagKey string) (uint64, error)
	CreateRule(ctx context.Context, r *flipt.CreateRuleRequest) (*flipt.Rule, error)
	UpdateRule(ctx context.Context, r *flipt.UpdateRuleRequest) (*flipt.Rule, error)
	DeleteRule(ctx context.Context, r *flipt.DeleteRuleRequest) error
	OrderRules(ctx context.Context, r *flipt.OrderRulesRequest) error
	CreateDistribution(ctx context.Context, r *flipt.CreateDistributionRequest) (*flipt.Distribution, error)
	UpdateDistribution(ctx context.Context, r *flipt.UpdateDistributionRequest) (*flipt.Distribution, error)
	DeleteDistribution(ctx context.Context, r *flipt.DeleteDistributionRequest) error
}

RuleStore stores and retrieves rules and distributions

type SegmentStore

type SegmentStore interface {
	GetSegment(ctx context.Context, namespaceKey, key string) (*flipt.Segment, error)
	ListSegments(ctx context.Context, namespaceKey string, opts ...QueryOption) (ResultSet[*flipt.Segment], error)
	CountSegments(ctx context.Context, namespaceKey string) (uint64, error)
	CreateSegment(ctx context.Context, r *flipt.CreateSegmentRequest) (*flipt.Segment, error)
	UpdateSegment(ctx context.Context, r *flipt.UpdateSegmentRequest) (*flipt.Segment, error)
	DeleteSegment(ctx context.Context, r *flipt.DeleteSegmentRequest) error
	CreateConstraint(ctx context.Context, r *flipt.CreateConstraintRequest) (*flipt.Constraint, error)
	UpdateConstraint(ctx context.Context, r *flipt.UpdateConstraintRequest) (*flipt.Constraint, error)
	DeleteConstraint(ctx context.Context, r *flipt.DeleteConstraintRequest) error
}

SegmentStore stores and retrieves segments and constraints

type Store

type Store interface {
	FlagStore
	RuleStore
	SegmentStore
	EvaluationStore
	NamespaceStore
	fmt.Stringer
}