store

type Adapter interface {
	SegmentReader
	LinkWriter
	EvidenceStore

	// Returns arbitrary information about the adapter.
	GetInfo(ctx context.Context) (interface{}, error)

	// Adds a channel that receives events from the store.
	AddStoreEventChannel(chan *Event)

	// Creates a new Batch
	NewBatch(ctx context.Context) (Batch, error)
}

type AdapterConfig interface {
	// EnforceUniqueMapEntry prevents multiple "first" links from being added
	// to the same map.
	// By default maps can have any number of "first" links (links without a
	// parent).
	// In some cases that doesn't reflect the reality of your process: each map
	// should be started with a single link and other links should be children
	// of the first link. If that's the case, you need to call this method when
	// creating your store adapter.
	EnforceUniqueMapEntry() error
}

type Batch interface {
	SegmentReader
	LinkWriter

	// Write definitely writes the content of the Batch
	Write(ctx context.Context) error
}

type Event struct {
	EventType EventType
	Data      interface{}
}

type EventType string

type EvidenceReader interface {
	// Get the evidences for a segment.
	// Can return a nil error with an empty evidence slice if
	// the segment currently doesn't have evidence.
	GetEvidences(ctx context.Context, linkHash chainscript.LinkHash) (types.EvidenceSlice, error)
}

type EvidenceStore interface {
	EvidenceReader
	EvidenceWriter
}

type EvidenceWriter interface {
	// Add an evidence to a segment.
	AddEvidence(ctx context.Context, linkHash chainscript.LinkHash, evidence *chainscript.Evidence) error
}

type KeyValueReader interface {
	GetValue(ctx context.Context, key []byte) ([]byte, error)
}

type KeyValueStore interface {
	KeyValueReader
	KeyValueWriter
}

type KeyValueWriter interface {
	SetValue(ctx context.Context, key []byte, value []byte) error
	DeleteValue(ctx context.Context, key []byte) ([]byte, error)
}

type LinkWriter interface {
	// Create the immutable part of a segment.
	// The input link is expected to be valid.
	// Returns the link hash or an error.
	CreateLink(ctx context.Context, link *chainscript.Link) (chainscript.LinkHash, error)
}

type MapFilter struct {
	Pagination `json:"pagination"`

	// Filter to get maps with IDs starting with a given prefix.
	Prefix string `json:"prefix" url:"prefix"`

	// Filter to get maps with IDs ending with a given suffix.
	Suffix string `json:"suffix" url:"suffix"`

	// Process name is optional.
	Process string `json:"process" url:"process"`
}

type Pagination struct {
	// Index of the first entry.
	Offset int `json:"offset" url:"offset"`

	// Maximum number of entries.
	Limit int `json:"limit" url:"limit"`
}

type SegmentFilter struct {
	Pagination `json:"pagination"`

	// Map IDs the segments must have.
	MapIDs []string `json:"mapIds" url:"mapIds,brackets"`

	// Process name the segments must have.
	Process string `json:"process" url:"process"`

	// Step the segments must have.
	Step string `json:"step" url:"step"`

	// If true, selects only segments that don't have a parent.
	WithoutParent bool `json:"withoutParent" url:"withoutParent"`

	// A previous link hash the segments must have.
	PrevLinkHash chainscript.LinkHash `json:"prevLinkHash" url:"-"`

	// A slice of linkHashes to search Segments.
	LinkHashes []chainscript.LinkHash `json:"linkHashes" url:"-"`

	// A link that should be referenced by the matching segments.
	Referencing chainscript.LinkHash `json:"referencing" url:"-"`

	// A slice of tags the segments must all contain.
	Tags []string `json:"tags" url:"tags,brackets"`

	// Flag to reverse segment ordering.
	Reverse bool `json:"reverse" url:"reverse"`
}

type SegmentReader interface {
	// Get a segment by link hash. Returns nil if no match is found.
	// Will return link and evidences (if there are some in that store).
	GetSegment(ctx context.Context, linkHash chainscript.LinkHash) (*chainscript.Segment, error)

	// Find segments. Returns an empty slice if there are no results.
	// Will return links and evidences (if there are some).
	FindSegments(ctx context.Context, filter *SegmentFilter) (*types.PaginatedSegments, error)

	// Get all the existing map IDs.
	GetMapIDs(ctx context.Context, filter *MapFilter) ([]string, error)
}