recordstore

type AppendResult struct {
	Window  Window `json:"window"`
	Skipped int64  `json:"skipped"`
}

type Backend interface {
	// Append adds rows to stream, creating it under kind when it does not
	// exist, and returns the window the rows were numbered into. Appending to
	// an existing stream under a different kind is an error.
	//
	// A keyed kind (KindOptions.Key) skips every row whose key the stream
	// already holds, atomically with the append, and numbers only the rows it
	// keeps; a batch naming one key twice is refused whole. A kind retaining
	// rows (RetainRows) slides the stream's expiry to the backend ttl from now
	// and trims the rows appended longer than that ago, in the same write.
	Append(ctx context.Context, stream, kind string, rows []Row) (AppendResult, error)

	// Meta describes stream, or returns ErrNotFound.
	Meta(ctx context.Context, stream string) (Meta, error)

	// Scan calls fn with every row after afterSeq, in seq order, stopping at
	// the first error fn returns. A scan from below the stream's low seq starts
	// at the low seq. An unknown stream is ErrNotFound.
	Scan(ctx context.Context, stream string, afterSeq int64, fn func(seq int64, row Row) error) error

	// Trim removes the rows appended before before — every append up to the
	// last one made before it — and returns the stream's metadata after. The
	// rows kept keep their seqs, the low seq moves to the first of them, and
	// the keys of the rows removed may be appended again. An unknown stream is
	// ErrNotFound.
	Trim(ctx context.Context, stream string, before time.Time) (Meta, error)

	// Expire removes stream ttl from now, rows appended later included. The
	// ttl must be positive; an unknown stream is ErrNotFound.
	Expire(ctx context.Context, stream string, ttl time.Duration) error

	Close() error
}

type BackendKind string

type ImportRequest struct {
	Source Meta
	First  int64
	Rows   []Row
}

type Index interface {
	Backend

	// Prepare reconciles the storage for source's kind and returns the indexed
	// incarnation of its stream. A derived index removes an older generation
	// under the same stream id and reports it absent.
	Prepare(ctx context.Context, source Meta) (indexed Meta, found bool, err error)

	// Import stores request.Rows under their source seqs. First must be the seq
	// after the indexed stream's high seq, or for a stream the index does not
	// hold yet the source's low seq; a gap or different generation fails.
	Import(ctx context.Context, request ImportRequest) (Window, error)

	// TrimBelow mirrors a source trim: it drops the indexed rows below lowSeq,
	// and moves an indexed stream that had not reached lowSeq up to it empty.
	TrimBelow(ctx context.Context, stream string, lowSeq int64) (Meta, error)

	// Derived reports whether the index can discard rows and rebuild them from
	// a separate source.
	Derived() bool

	// SetExpiry mirrors the source's absolute expiry. Nil keeps the indexed
	// stream while its source exists.
	SetExpiry(ctx context.Context, stream string, expiresAt *time.Time) error
}

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

type KindOptions struct {
	// Key names a string column whose value identifies a row within a stream.
	// A keyed stream holds each key once: an append skips a row whose key is
	// already stored. Empty leaves the kind unkeyed, where every row appended
	// is stored.
	Key string

	// Retention says how long a stream keeps its rows.
	Retention Retention
}

type KindSchema struct {
	Kind    string
	Columns []query.ColumnDef
	Options KindOptions
}

type Meta struct {
	Stream     string `json:"stream"`
	Kind       string `json:"kind"`
	Generation string `json:"generation"`

	// Total is how many rows the stream holds, LowSeq the seq of the first one
	// and HighSeq the seq of the last. Rows only leave a stream from its low end
	// (Trim), so Total is HighSeq-LowSeq+1 in a durable backend; all three are
	// reported because an index mirroring it may lag. An empty stream has
	// LowSeq HighSeq+1.
	Total   int64 `json:"total"`
	LowSeq  int64 `json:"lowSeq"`
	HighSeq int64 `json:"highSeq"`

	UpdatedAt time.Time `json:"updatedAt"`

	// ExpiresAt is when the stream is removed, or nil when it is kept until
	// something expires it.
	ExpiresAt *time.Time `json:"expiresAt,omitempty"`

	// Capped reports that an append was refused for capacity: the stream is
	// complete up to HighSeq and missing whatever that append carried.
	Capped bool `json:"capped,omitempty"`
}

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

type NotifierOptions struct {
	// RecheckInterval is how often a waiter re-reads its stream's metadata
	// while no append wakes it. Appends made through the Notifier wake waiters
	// at once; the recheck is what notices what no append announces — a stream
	// expired, trimmed away or removed by the backend itself. Required.
	RecheckInterval time.Duration
}

type Retention int

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

type RouterOptions struct {
	// Route names the route a call's context belongs to — the tenant, the
	// environment — and fails for a context that carries none.
	Route func(ctx context.Context) (string, error)

	// Open opens one route's backend. It is called once per route, and again
	// only after Forget drops it. The backend it returns must belong to that
	// route alone: never shared with another route, and never the index a
	// registry reads, or one route's streams become readable through another.
	Open func(ctx context.Context, route string) (Backend, error)
}

type Row = query.Row

type SchemaResolver func(kind string) (KindSchema, error)

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

type Settings struct {
	// Prefix is the property prefix the settings were read under; errors about
	// a setting name the key under it.
	Prefix string

	// Backend is the backend asked for, or empty for the caller's default.
	Backend           BackendKind
	Dir               string
	TTL               time.Duration
	NDJSONMaxBytes    int64
	NDJSONKeepStreams int
}

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

type Window struct {
	From int64 `json:"from"`
	To   int64 `json:"to"`
}