types

type Client interface {
	// Enqueue adds an item to the queue
	Enqueue(context.Context, []Item) ([]ItemToPersist, error)

	// Ack marks the item as processed.
	// Out of order acks are supported.
	// Acking an item that has not been dequeued will have no effect.
	// Queue's committed offset is updated to the last ack'ed item's offset periodically until there's a gap (un-acked item).
	// In other words, all items up to the committed offset are ack'ed.
	// Ack'ed item might still be returned from Dequeue if its offset is higher than last committed offset before process restarts.
	Ack(context.Context, Item) error

	// Nack negatively acknowledges an item in the queue
	// Nack'ing an already ack'ed item will have no effect.
	Nack(context.Context, Item) error

	// Start the client. It will
	// - fetch the last committed offsets from the persister,
	// - start corresponding consumers
	// - dispatch items starting from those offsets.
	Start(context.Context) error

	// Stop the client. It will
	// - stop all consumers
	// - persist the last committed offsets
	Stop(context.Context) error
}

type Consumer interface {
	Start(context.Context) error
	Stop(context.Context) error
	Process(context.Context, Item) error
}

type ConsumerFactory interface {
	// New creates a new consumer with the given partitions or returns an existing consumer
	// to process the given partitions
	// Consumer lifecycle is managed by the factory so the returned consumer must be started.
	New(ItemPartitions) (Consumer, error)

	// Stop stops all consumers created by this factory
	Stop(context.Context) error
}

type DispatchPolicy struct {
	// DispatchRPS is the rate limit for items dequeued from the node to be pushed to processors.
	// All nodes inherit the DispatchRPS from the parent node as is (not distributed to children).
	// If parent has 100 rps limit, then all curent and to-be-created children will have 100 rps limit.
	DispatchRPS int64 `json:"dispatchRPS,omitempty"`

	// Concurrency is the maximum number of items to be processed concurrently.
	Concurrency int `json:"concurrency,omitempty"`
}

type Item interface {
	// GetAttribute returns the value of the attribute key.
	// Value can be any type. It's up to the client to interpret the value.
	// Attribute keys used as partition keys will be converted to string because they are used as node
	// identifiers in the queue tree.
	GetAttribute(key string) any

	// Offset returns the offset of the item in the queue. e.g. monotonically increasing sequence number or a timestamp
	Offset() int64

	// String returns a human friendly representation of the item for logging purposes
	String() string
}

type ItemPartitions interface {
	// GetPartitionKeys returns the partition keys ordered by their level in the tree
	GetPartitionKeys() []string

	// GetPartitionValue returns the partition value to determine the target queue
	// e.g.
	//  Below example demonstrates that item is in a catch-all queue for sub-type
	//  	Item.GetAttribute("sub-type") returns "timer"
	//  	ItemPartitions.GetPartitionValue("sub-type") returns "*"
	//
	GetPartitionValue(key string) any

	// String returns a human friendly representation of the item for logging purposes
	String() string
}

type ItemToPersist interface {
	Item
	ItemPartitions
}

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

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

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

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

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

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

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

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

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

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

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

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

type NodePolicy struct {
	// The path to the node
	// Root node has empty path "".
	// "/" is used as path separator.
	// "*" means the policy applies to the special catch-all node
	// "." means the policy applies to all nodes in the specified level except the catch-all node
	Path string `json:"path,omitempty"`

	SplitPolicy *SplitPolicy `json:"splitPolicy,omitempty"`

	// DispatchPolicy is enforced at the leaf node level.
	DispatchPolicy *DispatchPolicy `json:"dispatchPolicy,omitempty"`
}

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

type Offsets struct {
}

type PageInfo struct {
}

type Persister interface {
	Persist(ctx context.Context, items []ItemToPersist) error
	GetOffsets(ctx context.Context) (*Offsets, error)
	CommitOffsets(ctx context.Context, offsets *Offsets) error
	Fetch(ctx context.Context, partitions ItemPartitions, pageInfo PageInfo) ([]Item, error)
}

type SplitPolicy struct {
	// Disabled is used to disable the split policy for the node.
	Disabled bool `json:"disabled,omitempty"`

	// PredefinedSplits is a list of predefined splits for the attribute key
	// Child nodes for these attributes will be created during initialization
	PredefinedSplits []any `json:"predefinedSplits,omitempty"`
}