mq

type Conf struct {
	Topic               string        `yaml:"topic" json:"topic" toml:"topic"`
	Type                mqType        `yaml:"type" json:"type" toml:"type"`
	Producer            bool          `yaml:"producer" json:"producer" toml:"producer" default:"true"`
	Consumer            bool          `yaml:"consumer" json:"consumer" toml:"consumer"`
	ConsumerGroup       string        `yaml:"consumer_group" json:"consumer_group" toml:"consumer_group"`
	ConsumerConcurrency int           `yaml:"consumer_concurrency" json:"consumer_concurrency" toml:"consumer_concurrency"`
	Endpoint            *endpointConf `yaml:"endpoint" json:"endpoint" toml:"endpoint"`
	Persistent          bool          `yaml:"persistent" json:"persistent" toml:"persistent"`
	SerializeType       string        `yaml:"serialize_type" json:"serialize_type" toml:"serialize_type"`
	CompressType        string        `yaml:"compress_type" json:"compress_type" toml:"compress_type"`

	EnableLogger bool   `yaml:"enable_logger" json:"enable_logger" toml:"enable_logger" default:"false"`
	Logger       string `yaml:"logger" json:"logger" toml:"logger" default:"github.com/wfusion/gofusion/log/customlogger.mqLogger"`
	LogInstance  string `yaml:"log_instance" json:"log_instance" toml:"log_instance" default:"default"`

	// mongo, mysql, mariadb option
	MessageScheme  string `yaml:"message_scheme" json:"message_scheme" toml:"message_scheme" default:"watermill_message"`
	SeriesScheme   string `yaml:"series_scheme" json:"series_scheme" toml:"series_scheme" default:"watermill_series"`
	ConsumerScheme string `yaml:"consumer_scheme" json:"consumer_scheme" toml:"consumer_scheme" default:"watermill_subscriber"`

	ConsumeMiddlewares []*middlewareConf `yaml:"consume_middlewares" json:"consume_middlewares" toml:"consume_middlewares"`
}

type Event[T eventual] interface {
	ID() string
	Type() string
	CreatedAt() time.Time
	UpdatedAt() time.Time
	DeletedAt() time.Time
	Payload() T
	Context() context.Context
	Ack() bool
	Nack() bool
}

type EventPublisher[T eventual] interface {
	// PublishEvent publishes provided messages to given topic.
	//
	// PublishEvent can be synchronous or asynchronous - it depends on the implementation.
	//
	// Most publishers implementations don't support atomic publishing of messages.
	// This means that if publishing one of the messages fails, the next messages will not be published.
	//
	// PublishEvent must be thread safe.
	PublishEvent(ctx context.Context, opts ...utils.OptionExtender) error
}

type EventSubscriber[T eventual] interface {
	// SubscribeEvent returns output channel with events from provided topic.
	// Channel is closed, when Close() was called on the subscriber.
	//
	// When provided ctx is cancelled, subscriber will close subscribe and close output channel.
	// Provided ctx is set to all produced messages.
	SubscribeEvent(ctx context.Context, opts ...utils.OptionExtender) (<-chan Event[T], error)
}

type HandlerFunc func(msg Message) error

type IRouter interface {
	Handle(handlerName string, hdr any, opts ...utils.OptionExtender)
	Serve() error
	Start()
	Running() <-chan struct{}
	// contains filtered or unexported methods
}

type Message interface {
	ID() string
	Payload() []byte
	RawMessage() any
	Context() context.Context
	Object() any
	Ack() bool
	Nack() bool
}

type Publisher interface {
	// Publish publishes provided messages to given topic.
	//
	// Publish can be synchronous or asynchronous - it depends on the implementation.
	//
	// Most publishers implementations don't support atomic publishing of messages.
	// This means that if publishing one of the messages fails, the next messages will not be published.
	//
	// Publish must be thread safe.
	Publish(ctx context.Context, opts ...utils.OptionExtender) error

	// PublishRaw publishes provided raw messages to given topic.
	//
	// PublishRaw can be synchronous or asynchronous - it depends on the implementation.
	//
	// Most publishers implementations don't support atomic publishing of messages.
	// This means that if publishing one of the messages fails, the next messages will not be published.
	//
	// PublishRaw must be thread safe.
	PublishRaw(ctx context.Context, opts ...utils.OptionExtender) error
	// contains filtered or unexported methods
}

type Subscriber interface {
	// Subscribe returns output channel with messages from provided topic.
	// Channel is closed, when Close() was called on the subscriber.
	//
	// When provided ctx is cancelled, subscriber will close subscribe and close output channel.
	// Provided ctx is set to all produced messages.
	Subscribe(ctx context.Context, opts ...utils.OptionExtender) (<-chan Message, error)

	// SubscribeRaw returns output channel with original messages from provided topic.
	// Channel is closed, when Close() was called on the subscriber.
	//
	// When provided ctx is cancelled, subscriber will close subscribe and close output channel.
	// Provided ctx is set to all produced messages.
	SubscribeRaw(ctx context.Context, opts ...utils.OptionExtender) (<-chan Message, error)
	// contains filtered or unexported methods
}