storage

type BBoltBackupConfig struct {
	// Directory specifies the directory in which the BBolt backup should be written.
	Directory string `koanf:"directory"`
	// Interval specifies the time between backups.
	Interval time.Duration `koanf:"interval"`
}

type BBoltConfig struct {
	// Backup specifies backup config for the database.
	Backup BBoltBackupConfig `koanf:"backup"`
	// LockTimeout specifies the maximum time to wait for acquiring a lock on the database before giving up and returning an error.
	LockTimeout time.Duration `koanf:"locktimeout"`
}

type Class int

type Config struct {
	BBolt   BBoltConfig   `koanf:"bbolt"`
	Redis   RedisConfig   `koanf:"redis"`
	SQL     SQLConfig     `koanf:"sql"`
	Session SessionConfig `koanf:"session"`
}

type Engine interface {
	core.Engine
	core.Configurable
	core.Runnable

	// GetProvider returns the Provider for the given module.
	GetProvider(moduleName string) Provider
	// GetSessionDatabase returns the SessionDatabase
	GetSessionDatabase() SessionDatabase

	// GetSQLDatabase returns the SQL database.
	GetSQLDatabase() *gorm.DB
}

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

type KVBackedLeiaStore interface {
	leia.Store
	// AddConfiguration adds a configuration for a collection to the store.
	// This is needed to know the kind of collection, the backup shelf name and the iterate query to fetch the documents.
	AddConfiguration(config LeiaBackupConfiguration)
	// HandleRestore migrates the data from the backup store to the leia.Store if needed.
	// It's up to the caller to create the indices on the leia.Collections first before calling this method.
	HandleRestore() error
}

type LeiaBackupConfiguration struct {
	// CollectionName is the name of the collection in the leia.Store.
	CollectionName string
	CollectionType leia.CollectionType
	// BackupShelf is the name of the shelf in the backup store.
	BackupShelf string
	// SearchQuery is used to fill the backup shelf if not present.
	SearchQuery leia.QueryPath
}

type MemcachedConfig struct {
	Address []string `koanf:"address"`
}

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

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

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

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

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

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

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

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

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

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

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

type Provider interface {
	// GetKVStore returns a key-value store. Stores are identified by a name.
	// When identical name is passed the same store is returned.
	// Names must be alphanumeric, non-zero strings.
	GetKVStore(name string, class Class) (stoabs.KVStore, error)
}

type RDSIAMConfig struct {
	// Enabled determines whether to use AWS IAM authentication for RDS.
	Enabled bool `koanf:"enabled"`
	// Region is the AWS region where the RDS instance is located.
	// If not specified, it will be loaded from the AWS SDK default configuration.
	Region string `koanf:"region"`
	// DBUser is the database user for IAM authentication.
	// If not specified, the user from the connection string will be used.
	DBUser string `koanf:"dbuser"`
	// TokenRefreshInterval is how often to refresh the IAM token (default: 14 minutes).
	// RDS tokens are valid for 15 minutes, so we refresh before expiry.
	TokenRefreshInterval time.Duration `koanf:"tokenrefreshinterval"`
}

type RedisConfig struct {
	Address  string              `koanf:"address"`
	Username string              `koanf:"username"`
	Password string              `koanf:"password"`
	Database string              `koanf:"database"`
	TLS      RedisTLSConfig      `koanf:"tls"`
	Sentinel RedisSentinelConfig `koanf:"sentinel"`
}

type RedisSentinelConfig struct {
	Master   string   `koanf:"master"`
	Nodes    []string `koanf:"nodes"`
	Username string   `koanf:"username"`
	Password string   `koanf:"password"`
}

type RedisTLSConfig struct {
	TrustStoreFile string `koanf:"truststorefile"`
}

type SQLConfig struct {
	// ConnectionString is the connection string for the SQL database.
	// This string may contain secrets (user:password), so should never be logged.
	ConnectionString string `koanf:"connection"`
	// RDSIAM specifies AWS RDS IAM authentication configuration.
	RDSIAM RDSIAMConfig `koanf:"rdsiam"`
}

type SessionConfig struct {
	// Memcached specifies config for the Memcached session storage engine.
	Memcached MemcachedConfig `koanf:"memcached"`
	// Redis specifies config for the Redis session storage engine.
	Redis RedisConfig `koanf:"redis"`
}

type SessionDatabase interface {
	// GetStore returns a SessionStore with the given keys as key prefixes.
	// The keys are used to logically partition the store, eg: tenants and/or flows that are not allowed to overlap like credential issuance and verification.
	// The TTL is the time-to-live for the entries in the store.
	GetStore(ttl time.Duration, keys ...string) SessionStore

	// Close stops any background processes and closes the database.
	Close()
	// contains filtered or unexported methods
}

type SessionOption func(target *sessionOptions)

type SessionStore interface {
	// Delete deletes the entry for the given key.
	// It does not return an error if the key does not exist.
	Delete(key string) error
	// Exists returns true if the key exists.
	Exists(key string) bool
	// Get returns the value for the given key.
	// Returns ErrNotFound if the key does not exist.
	Get(key string, target interface{}) error
	// Put stores the given value for the given key.
	// options can be used to fine-tune the storage of the item.
	Put(key string, value interface{}, options ...SessionOption) error
	// GetAndDelete combines Get and Delete as a convenience for burning nonce entries.
	GetAndDelete(key string, target interface{}) error
}

type SessionStoreImpl[T StringOrBytes] struct {
	// contains filtered or unexported fields
}

type StaticKVStoreProvider struct {
	Store stoabs.KVStore
}

type StringOrBytes interface {
	~string | ~[]byte
}

type TransactionKey struct{}