eventmodels

type AbstractDB[ID AbstractID[ID], TX AbstractTX] interface {
	CanTransact[TX]
	// ProduceSpecificTxEvents should not be called by transaction wrappers because
	// sending a batch to Kafka usually has a one second latecny.
	ProduceSpecificTxEvents(context.Context, []ID) (int, error)
	ProduceDroppedTxEvents(ctx context.Context, batchSize int) (int, error)
	LockOrError(ctx context.Context, key uint32, timeout time.Duration) (unlock func() error, err error)

	// MarkEventProcessed is always called inside a transaction. It must return
	// ErrAlreadyProcessed if the event has already been processed. The DB should not
	// be used by MarkEventProcessed, it is a DB method for simplicity of wrapping.
	MarkEventProcessed(ctx context.Context, tx TX, topic string, source string, id string, handlerName string) error
}

type AbstractID[ID AbstractIDMethods] interface {
	AbstractIDMethods
	New() ID
}

type AbstractIDMethods interface {
	Value() (driver.Value, error)
	String() string
}

type AbstractTX interface {
	ExecContext(context.Context, string, ...any) (sql.Result, error)
	QueryContext(context.Context, string, ...any) (*sql.Rows, error)
	QueryRowContext(context.Context, string, ...any) *sql.Row
}

type BatchHandlerInterface interface {
	HandlerInterface
	// contains filtered or unexported methods
}

type BatchHandlerTxInterface[ID AbstractID[ID], TX AbstractTX] interface {
	HandlerTxInterface[ID, TX]
	// contains filtered or unexported methods
}

type BinaryEventID struct {
	googleuuid.UUID
}

type BoundTopic[E any] string

type BoundTopicTx[E any, ID AbstractID[ID], TX AbstractTX, DB AbstractDB[ID, TX]] struct {
	BoundTopic[E]
}

type CanAugment[ID AbstractID[ID], TX AbstractTX] interface {
	AugmentWithProducer(Producer[ID, TX])
}

type CanTransact[TX AbstractTX] interface {
	AbstractTX
	Transact(context.Context, func(TX) error) error
}

type EnhancedTX interface {
	AbstractTX
	Produce(events ...ProducingEvent)
}

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

type ErrorHandling int

type Event[E any] struct {
	Topic         string // may be a dead-letter topic. Un-prefixed.
	Key           string
	Data          []byte
	Payload       E
	Headers       map[string][]string
	Timestamp     time.Time
	ID            string // CloudEvents field, defaults to a checksum if not present
	ContentType   string // Optional field, required for CloudEvents messages
	Subject       string // CloudEvents field, defaults to Kafka Key
	Type          string // CloudEvents field, defaults to Kafka Topic
	Source        string // CloudEvents field, empty for non-CloudEvents messages
	SpecVersion   string // CloudEvents field, empty for non-CloudEvents messages
	DataSchema    string // optional CloudEvents field, empty if not set
	ConsumerGroup string
	HandlerName   string
	BaseTopic     string // always the non-dead-letter topic, different from Topic when processing dead letters. Un-prefixed.
	// contains filtered or unexported fields
}

type HandlerInfo interface {
	Name() string
	BaseTopic() string
	ConsumerGroup() string
	IsDeadLetter() bool
}

type HandlerInterface interface {
	SharedHandlerInterface
	SetLibrary(LibraryInterface)
	// contains filtered or unexported methods
}

type HandlerTxInterface[ID AbstractID[ID], TX AbstractTX] interface {
	SharedHandlerInterface
	SetLibrary(LibraryInterfaceTx[ID, TX])
	// contains filtered or unexported methods
}

type LibraryInterface interface {
	RemovePrefix(string) string
	TracerProvider(context.Context) Tracer
	TracerConfig() TracerConfig
}

type LibraryInterfaceTx[ID AbstractID[ID], TX AbstractTX] interface {
	LibraryInterface
	DB() AbstractDB[ID, TX]
}

type OnFailure int

type ProduceMethod string

type Producer[ID AbstractID[ID], TX AbstractTX] interface {
	DB() AbstractDB[ID, TX]
	Produce(context.Context, ProduceMethod, ...ProducingEvent) error
	// ProduceFromTable should be called by transaction wappers. It will
	// send ids to a central thread that will in turn call ProduceSpecificTxEvents.
	ProduceFromTable(ctx context.Context, eventIDs map[string][]ID) error
	RecordError(context.Context, string, error) error       // pauses to avoid spamming
	RecordErrorNoWait(context.Context, string, error) error // does not pause
	IsConfigured() bool
	ValidateTopics(context.Context, []string) error
	TracerProvider(context.Context) Tracer
}

type ProducingEvent interface {
	GetKey() string
	GetTimestamp() time.Time // used for the cloudevents time header
	GetTopic() string        // Topic is also used to generate the cloudevents type header. The topic is un-prefixed. Suggested format: noun.verb
	GetHeaders() map[string][]string
}

type SelfMarshalingEvent interface {
	Marshal() (encoded []byte, contentType string, err error)
}

type SharedHandlerInterface interface {
	GetTopic() string
	// Handle synchronously invokes the handler function for a message.
	Handle(ctx context.Context, handlerInfo HandlerInfo, messages []*kafka.Message) []error
	Batch() bool
}

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

type StringEventID struct {
	baseuuid.UUID
}

type Tracer func(string, ...any)

type TracerConfig struct {
	BeginSpan func(context.Context, map[string]string) (context.Context, func())            // start of a span. All logs are inside spans.
	Handle    func(context.Context, bool, string, *kafka.Message) (context.Context, func()) // string is the handler name, bool is true for deadletter delivery
}

type TracerProvider func(context.Context) Tracer