event

type AckFunc func() error

type Client interface {
	types.Component

	// Request runs a REST like call on the given topic.
	// This is an internal function, clients MUST use event.Request().
	Request(ctx context.Context, req *Req[[]byte, any], opts ...RequestOption) ([]byte, error)

	// HandleRequest subscribes to the given topic and handles the requests.
	// This is a blocking operation.
	// This is an internal function, clients MUST use event.HandleRequest().
	HandleRequest(ctx context.Context, topic string, cb func(context.Context, *Req[[]byte, []byte]))

	// Clone creates a clone of the handler, this is useful for parallel requests.
	Clone() Type

	// GetCodec returns the codec used by the handler for publish and subscribe.
	GetPublishCodec() codecs.Marshaler

	// Publish publishes a Event to the given topic.
	Publish(ctx context.Context, topic string, event any, opts ...PublishOption) error

	// Consume lets you consume events from a given topic.
	Consume(topic string, opts ...ConsumeOption) (<-chan Event, error)
}

type Config struct {
	// Plugin selects the client implementation.
	Plugin string `json:"plugin" yaml:"plugin"`
}

type ConfigType interface {
	// contains filtered or unexported methods
}

type ConsumeOption func(o *ConsumeOptions)

type ConsumeOptions struct {
	// Offset is the time from which the messages should be consumed from. If not provided then
	// the messages will be consumed starting from the moment the Subscription starts.
	Offset time.Time
	// Group is the name of the consumer group, if two consumers have the same group the events
	// are distributed between them
	Group   string
	AckWait time.Duration
	// RetryLimit indicates number of times a message is retried
	RetryLimit int
	// AutoAck if true (default true), automatically acknowledges every message so it will not be redelivered.
	// If false specifies that each message need ts to be manually acknowledged by the subscriber.
	// If processing is successful the message should be ack'ed to remove the message from the stream.
	// If processing is unsuccessful the message should be nack'ed (negative acknowledgement) which will mean it will
	// remain on the stream to be processed again.
	AutoAck bool
	// CustomRetries indicates whether to use RetryLimit
	CustomRetries bool
}

type Event struct {
	// Handler is a reference to the client.
	Handler Client

	// Timestamp of the event
	Timestamp time.Time
	// Metadata contains the values the event was indexed by
	Metadata map[string]string

	// ID to uniquely identify the event
	ID string
	// Topic of event, e.g. "registry.service.created"
	Topic string
	// Payload contains the encoded message
	Payload []byte
	// contains filtered or unexported fields
}

type NackFunc func() error

type Option func(ConfigType)

type ProviderFunc func(
	configData map[string]any,
	logger log.Logger,
	opts ...Option,
) (Type, error)

type PublishOption func(o *PublishOptions)

type PublishOptions struct {
	// Metadata contains any keys which can be used to query the data, for example a customer id
	Metadata map[string]string
	// Timestamp to set for the event, if the timestamp is a zero value, the current time will be used
	Timestamp time.Time
}

type Req[TReq any, TResp any] struct {
	Topic       string `json:"topic"`
	ContentType string `json:"contentType"`

	// The Data of type TReq
	Data TReq `json:"data" yaml:"data"`
	// Err is an error that might happened during encoding.
	Err error
	// contains filtered or unexported fields
}

type RequestOption func(o *RequestOptions)

type RequestOptions struct {
	// ContentType for transporting the message.
	ContentType string
	// Metadata contains keys which can be used to query the data, for example a customer id
	Metadata map[string]string

	// RequestTimeout defines how long to wait for the server to reply on a request.
	RequestTimeout time.Duration
}

type Type struct {
	Client
}