storage

type Cache[V Value] interface {
	// Start starts the cache. This must be called before the cache can be used.
	Start(ctx context.Context) error
	// Put returns an operation that puts a key-value pair into storage.
	Put(item V, options ...clientv3.OpOption) PutOp[V]
	// Create returns an operation that creates a key value pair with an
	// optional time-to-live. This operation will fail with ErrAlreadyExists if
	// the given key already exists.
	Create(item V, options ...clientv3.OpOption) PutOp[V]
	// Update returns an operation updates an existing key value pair with a new
	// value and an optional time-to-live. This operation will fail with
	// ErrValueVersionMismatch if the stored value's version does not match the
	// given value's version. Note that this operation is equivalent to a create
	// when the item version is 0.
	Update(item V, options ...clientv3.OpOption) PutOp[V]
	// DeleteByKey returns an operation that deletes a single value by key.
	DeleteByKey(key string, options ...clientv3.OpOption) DeleteOp
	// DeleteValue returns an operation that deletes a single value if its
	// version matches the given value's version. Its Exec method will return an
	// ErrValueVersionMismatch if the stored value version did not match the
	// given value version.
	DeleteValue(item V, options ...clientv3.OpOption) DeleteValueOp[V]
	// DeletePrefix returns an operation that deletes a multiple values by
	// prefix.
	DeletePrefix(prefix string, options ...clientv3.OpOption) DeleteOp
	// Get returns an operation that returns a single value by key.
	Get(key string) GetOp[V]
	// GetPrefix returns an operation that returns multiple values by prefix.
	GetPrefix(prefix string) GetMultipleOp[V]
	// Stop stops the cache.
	Stop()
	// Error reports errors that originate from the cache's watch.
	Error() <-chan error
	// PropagateErrors will propagate errors from the cache's Error() channel to
	// the given error channel in a goroutine until the given context is
	// complete.
	PropagateErrors(ctx context.Context, ch chan error)
}

type CachedTxnOp interface {
	UpdateCache()
}

type DeleteOp interface {
	TxnOperation
	Exec(ctx context.Context) (int64, error)
	// The revision returned by the server. Only populated after Exec() is
	// called.
	Revision() int64
}

type DeleteValueOp[V Value] interface {
	TxnOperation
	Exec(ctx context.Context) error
	// The revision returned by the server. Only populated after Exec is called.
	Revision() int64
}

type Event[V Value] struct {
	// Err will be non-nil when Type is "error".
	Err      error
	Type     EventType
	Key      string
	Value    V
	IsCreate bool
	IsModify bool
	Revision int64
}

type EventType string

type ExistsOp interface {
	Exec(ctx context.Context) (bool, error)
}

type GetMultipleOp[V Value] interface {
	Exec(ctx context.Context) ([]V, error)
}

type GetOp[V Value] interface {
	Exec(ctx context.Context) (V, error)
}

type PutOp[V Value] interface {
	TxnOperation
	// WithTTL sets a time-to-live for this value. The value will automatically
	// be removed after the TTL has expired.
	WithTTL(ttl time.Duration) PutOp[V]
	// WithUpdatedVersion will update the version on the value after the put
	// operation completes.
	WithUpdatedVersion() PutOp[V]
	Exec(ctx context.Context) error
	// The revision returned by the server. Only populated after Exec is called.
	Revision() int64

	VersionUpdater
}

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

type Txn interface {
	AddOps(ops ...TxnOperation)
	Commit(ctx context.Context) error
}

type TxnOperation interface {
	ClientOp(ctx context.Context) (clientv3.Op, error)
	Cmps() []clientv3.Cmp
	UpdateRevision(revision int64)
	Revision() int64
}

type Value interface {
	Version() int64
	SetVersion(version int64)
}

type VersionUpdater interface {
	// UpdateVersionEnabled should return true if this operation should update
	// the item's version.
	UpdateVersionEnabled() bool
	// UpdateVersion should read the previous KVs that it manages from prevKV
	// and update its item's versions.
	UpdateVersion(prevKVs map[string]*mvccpb.KeyValue)
}

type WatchOp[V Value] interface {
	// Watch performs an initial Get of current items, calls handle for each,
	// then persistently watches for modifications, calling handle for each
	// event. The initial Get is blocking, and then it starts the watch in a
	// goroutine. Errors originating from the watch or handler are reported via
	// the Error() channel.
	Watch(ctx context.Context, handle func(e *Event[V]) error) error
	// Close cancels the active watch and enables callers to use Watch again.
	Close()
	// Error reports errors that originate from the watch or from the handler.
	Error() <-chan error
	// PropagateErrors will propagate errors from the watch's Error() channel to
	// the given error channel in a goroutine until the given context is
	// complete.
	PropagateErrors(ctx context.Context, ch chan error)
}