storageapi

type BatchOp struct {
	Type          BatchOpType
	ID            string
	Doc           any
	Updates       []Update
	Preconditions []Precondition
}

type BatchOpResult struct {
	// Err is one of ErrAlreadyExists, ErrNotFound or
	// ErrPreconditionFailed when the operation was rejected by the
	// store, and nil when it was applied.
	Err error
}

type BatchOpType int

type BatchWriter interface {
	// ApplyBatch applies every op to the same collection. Operations
	// rejected for document-level reasons (a Create over an existing
	// document, an Update whose preconditions fail) do not abort the
	// batch: their error is reported in the result at the same index
	// and the remaining ops are still applied. Any other failure aborts
	// the batch, leaves the store untouched, and is returned as the
	// call error.
	ApplyBatch(ctx context.Context, ops []BatchOp) ([]BatchOpResult, error)
}

type DroppableService interface {
	Service

	// Drop deletes all records in a document.Service. Implementors must guarantee
	// that (1) this is done efficiently and (2) the service remains functional
	// after this operation succeeds.
	Drop(context.Context) error
}

type Field struct {
	FieldPath []string
	Value     any
}

type Filter struct {
	Field
	Op
}

type Iterator interface {
	HasNext() bool
	NextTo(doc any) error
	io.Closer
}

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

type Op string

type Precondition Field

type Service interface {
	// Create creates the document with the given data.
	// It returns an ErrAlreadyExists if a document with the same ID already exists.
	// The data argument can be a map with string keys, a struct, or a pointer
	// to a struct. The map keys or exported struct fields become the
	// fields of the document.
	//
	// Pointers and the empty any are permitted as
	// struct attributes or map values, and their elements processed recursively.
	//
	// DefaultCreatedAtField is automatically added and clients can consume it
	// by adding the corresponding property in the document structure.
	// Note that certain implementations might require special field tags.
	Create(ctx context.Context, ID string, doc any) error

	// Set creates a document with the given data or updates it if it already exists.
	//
	// DefaultUpdatedAtField is automatically updated and clients can consume it
	// by adding the corresponding property in the document structure.
	//
	// See Create for more details.
	Set(ctx context.Context, ID string, doc any) error

	// Update updates the document. The values at the given
	// field paths are replaced, but other fields of the stored document
	// are untouched. If one of the preconditions fails, it returns
	// ErrPreconditionFailed. If the document with the given ID doesn't exist
	// it returns ErrNotFound.
	//
	// DefaultUpdatedAtField is automatically updated and clients can consume it
	// by adding the corresponding property in the document structure.
	Update(ctx context.Context, ID string,
		updates []Update, precond ...Precondition) error

	// Get retrieves the document. If the document does not exist,
	// it returns a ErrNotFound error.
	// Parameter doc is used to populate the document's fields.
	// It can be a pointer to a map[string]any or a pointer to a struct.
	// If the document with the given ID doesn't exist
	// it returns ErrNotFound.
	Get(ctx context.Context, ID string, doc any) error

	// Delete deletes the document. If the document doesn't exist,
	// it does nothing and returns no error.
	Delete(ctx context.Context, ID string) error

	// The List operation returns a page of all documents in the collection.
	// To return a subset of the collection, you can provide a set of filters.
	List(ctx context.Context, filters []Filter) (Iterator, error)

	// Partition returns a child Service whose records are isolated from sibling
	// partitions created from the same underlying Service.
	Partition(name string) (Service, error)

	io.Closer
}

type Update Field