kv

type Driver interface {
	// Open opens access to the database store. Implementations give access to the same storage based on the dsn.
	// Implementation can return the same Storage instance based on dsn or new one as long as it provides access to
	// the same storage.
	Open(ctx context.Context, dsn string) (Store, error)
}

type EntriesIterator interface {
	// Next should be called first before access Entry.
	// it will process the next entry and return true if it was successful, and false when none or error.
	Next() bool

	// Entry current entry read after calling Next, set to nil in case of an error or no more entries.
	Entry() *Entry

	// Err set to last error by reading or parse the next entry.
	Err() error

	// Close should be called at the end of processing entries, required to release resources used to scan entries.
	// After calling 'Close' the instance should not be used as the behaviour will not be defined.
	Close()
}

type Entry struct {
	Key   []byte
	Value []byte
}

type Header struct {
	LakeFSVersion   string
	PackageName     string
	DBSchemaVersion int
	CreatedAt       time.Time
}

type MessageEntry struct {
	Key   string
	Value protoreflect.ProtoMessage
}

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

type Predicate interface{}

type PrefixIterator struct {
	Iterator EntriesIterator
	Prefix   []byte
	// contains filtered or unexported fields
}

type Store interface {
	// Get returns a result containing the Value and Predicate for the given key, or ErrNotFound if key doesn't exist
	//   Predicate can be used for SetIf operation
	Get(ctx context.Context, key []byte) (*ValueWithPredicate, error)

	// Set stores the given value, overwriting an existing value if one exists
	Set(ctx context.Context, key, value []byte) error

	// SetIf returns an ErrPredicateFailed error if the key with valuePredicate passed
	//  doesn't match the currently stored value. SetIf is a simple compare-and-swap operator:
	//  valuePredicate is either the existing value, or nil for no previous key exists.
	//  this is intentionally simplistic: we can model a better abstraction on top, keeping this interface simple for implementors
	SetIf(ctx context.Context, key, value []byte, valuePredicate Predicate) error

	// Delete will delete the key, no error in if key doesn't exist
	Delete(ctx context.Context, key []byte) error

	// Scan returns entries that can be read by key order, starting at or after the `start` position
	Scan(ctx context.Context, start []byte) (EntriesIterator, error)

	// Close access to the database store. After calling Close the instance is unusable.
	Close()
}

type StoreMessage struct {
	Store
}

type ValueWithPredicate struct {
	Value     []byte
	Predicate Predicate
}