events

type Event interface {
	// Schema returns the avro schema of this event
	Schema() string

	// Serialize writes the event (in avro format) to the given writer.
	Serialize(io.Writer) error
}

type EventHeader struct {
	Key   string `json:"key"`
	Value string `json:"value"`
}

type EventHeaders []EventHeader

type EventMetadata struct {
	Type    reflect.Type
	Topic   string
	Key     *string
	Headers EventHeaders
}

type EventSender interface {
	// SendAsync sends the given event. This method should be non blocking and
	// must never fail. If sending would block, you are allowed to discard the event.
	// Errors will be logged to the terminal but otherwise ignored.
	SendAsync(ctx context.Context, event Event)

	// SendAsyncCh returns a channel you can use to enqueue events to the sender. Sending events on this
	// channel will give you no delivery guarantees for those events.
	SendAsyncCh() chan<- Event

	// SendInTx sends the message in the transaction.
	// Returns an error, if sending fails.
	SendInTx(ctx context.Context, tx sqlx.ExecerContext, event Event) error

	// Close the event sender and flush all pending events.
	// Waits for all events to be send out.
	Close() error
}

type EventSenderInitializer interface {
	Close() error
	Initialize() (EventSender, error)
}

type EventTopics struct {
	EventTypes map[reflect.Type]kafka.Topic
}

type KafkaEvent struct {
	Event
	Key     string
	Headers []EventHeader
}

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

type NormalizedEventTypes struct {
	EventTopics
}

type TopicsFunc func(replicationFactor int16) EventTopics