datastore

Documentation

Index

• Constants
• Variables
• func ParseAferoBackend(backend string) (afero.Fs, error)
• type Backend
  • func (b Backend) String() string
• type Config
• type ConsistencyLevel
  • func ParseConsistentLevel(consistencyLevel string) ConsistencyLevel
  • func (c ConsistencyLevel) String() string
• type Factory
• type GenericDAO
• type OrganizationDAO
• type PageQuery
  • func NewPageQuery() PageQuery
• type PageResult
  • func NewPageResult[E any]() PageResult[E]
  • func NewPageResultFromQuery[E any](q PageQuery) PageResult[E]
• type Pager
• type PagerProcFunc
• type Params
  • func ParamsFromConfig[E any](config *Config, partition string) (*Params[E], error)
• type RegistrationDAO
• type RoleDAO
• type StoreType
  • func ParseStoreType(storeType string) (StoreType, error)
  • func (s StoreType) String() string
• type UserDAO
• type WebAuthnDAO

Constants

const (
	SORT_ASCENDING = iota
	SORT_DESCENDING
)

const (
	QUERY_TYPE_COUNT = iota
)

Variables

var (
	DefaultConfig = Config{
		ConsistencyLevel: "local",
		Backend:          "fs",
		Serializer:       "json",
		ReadBufferSize:   50,
		RootDir:          "datastore",
	}

	ErrRecordNotFound     = errors.New("datastore: record not found")
	ErrInvalidIndexEntity = errors.New("datastore: invalid index entity")
	ErrInvalidStoreType   = errors.New("datastore: invalid store type")
)

Functions

func ParseAferoBackend

func ParseAferoBackend(backend string) (afero.Fs, error)

Types

type Backend

type Backend string

func (Backend) String

func (b Backend) String() string

type Config

type Config struct {
	Backend          string `yaml:"backend" json:"backend" mapstructure:"backend"`
	ConsistencyLevel string `yaml:"consistency-level" json:"consistency_level" mapstructure:"consistency-level"`
	ReadBufferSize   int    `yaml:"read-buffer-size" json:"read_buffer_size" mapstructure:"read-buffer-size"`
	RootDir          string `yaml:"home" json:"home" mapstructure:"home"`
	Serializer       string `yaml:"serializer" json:"serializer" mapstructure:"serializer"`
}

type ConsistencyLevel

type ConsistencyLevel int

const (
	ConsistencyLevelLocal ConsistencyLevel = iota
	ConsistencyLevelQuorum
)

func ParseConsistentLevel

func ParseConsistentLevel(consistencyLevel string) ConsistencyLevel

func (ConsistencyLevel) String

func (c ConsistencyLevel) String() string

type Factory

type Factory interface {
	OrganizationDAO() (OrganizationDAO, error)
	UserDAO() (UserDAO, error)
	RegistrationDAO() (RegistrationDAO, error)
	RoleDAO() (RoleDAO, error)
	SerializerType() serializer.SerializerType
	WebAuthnDAO() (WebAuthnDAO, error)
}

DAO Factory interface

type GenericDAO

type GenericDAO[E any] interface {
	Save(entity E) error
	Get(id uint64, CONSISTENCY_LEVEL ConsistencyLevel) (E, error)
	Delete(entity E) error
	Count(CONSISTENCY_LEVEL ConsistencyLevel) (int, error)
	Pager[E]
}

type OrganizationDAO

type OrganizationDAO interface {
	GetUsers(id uint64, CONSISTENCY_LEVEL ConsistencyLevel) ([]*entities.User, error)
	GenericDAO[*entities.Organization]
}

type PageQuery

type PageQuery struct {
	Page      int
	PageSize  int
	SortOrder int
}

PageQuery represents a datastore query for a single page of records

func NewPageQuery

func NewPageQuery() PageQuery

type PageResult

type PageResult[E any] struct {
	Entities []E  `yaml:"entities" json:"entities"`
	Page     int  `yaml:"page" json:"page"`
	PageSize int  `yaml:"size" json:"size"`
	HasMore  bool `yaml:"has_more" json:"has_more"`
}

PageResult represents a datastore page query resultset

func NewPageResult

func NewPageResult[E any]() PageResult[E]

func NewPageResultFromQuery

func NewPageResultFromQuery[E any](q PageQuery) PageResult[E]

type Pager

type Pager[E any] interface {
	Page(pageQuery PageQuery, CONSISTENCY_LEVEL ConsistencyLevel) (PageResult[E], error)
	ForEachPage(pageQuery PageQuery, pagerProcFunc PagerProcFunc[E], CONSISTENCY_LEVEL ConsistencyLevel) error
}

DAO interfaces

type PagerProcFunc

type PagerProcFunc[E any] func(entities []E) error

type Params

type Params[E any] struct {
	ConsistencyLevel ConsistencyLevel
	Fs               afero.Fs
	Logger           *logging.Logger
	Partition        string
	ReadBufferSize   int
	RootDir          string
	Serializer       serializer.Serializer[E]
}

func ParamsFromConfig

func ParamsFromConfig[E any](config *Config, partition string) (*Params[E], error)

type RegistrationDAO

type RegistrationDAO interface {
	GenericDAO[*entities.Registration]
}

type RoleDAO

type RoleDAO interface {
	GetByName(name string, CONSISTENCY_LEVEL ConsistencyLevel) (*entities.Role, error)
	GenericDAO[*entities.Role]
}

type StoreType

type StoreType string

var (
	BackendAferoFS     StoreType = "AFERO_FS"
	BackendAferoMemory StoreType = "AFERO_MEMORY"
	BackendRaft        StoreType = "RAFT"

	ErrInvalidBackend          = errors.New("datastore: invalid backend")
	ErrInvalidConsistencyLevel = errors.New("datastore: invalid consistency level")
)

func ParseStoreType

func ParseStoreType(storeType string) (StoreType, error)

func (StoreType) String

func (s StoreType) String() string

type UserDAO

type UserDAO interface {
	GenericDAO[*entities.User]
}

type WebAuthnDAO

type WebAuthnDAO interface {
	GenericDAO[*entities.Blob]
}