wmsqlitemodernc

type ConsumerGroupMatcher interface {
	// MatchTopic returns a consumer group name
	// for a given topic. This name must follow the same
	// naming conventions as the topic name.
	MatchTopic(topic string) (consumerGroupName string, err error)
}

type ConsumerGroupMatcherFunc func(topic string) (consumerGroupName string, err error)

type Error uint8

type ExpiringKeyRepositoryConfiguration struct {
	// Database is SQLite3 database handle.
	Database *sql.DB

	// TableName is the name of the table used to store expiring keys.
	// The
	// Defaults to "watermill_expiring_keys".
	TableName string

	// Expiration is the duration after which a key is considered expired.
	// If lower than five milliseconds, it is set to five milliseconds.
	// Defaults to one minute.
	Expiration time.Duration

	// CleanUpInterval is the interval at which expired keys are cleaned up.
	// Defaults to 15 seconds.
	CleanUpInterval time.Duration

	// CleanUpLogger tracks any problems that might emerge when cleaning up expired keys.
	// Defaults to [watermill.NewStdLogger].
	CleanUpLogger watermill.LoggerAdapter
}

type PublisherOptions struct {
	// TableNameGenerators is a set of functions that generate table names for topics and offsets.
	// Defaults to [TableNameGenerators.WithDefaultGeneratorsInsteadOfNils].
	TableNameGenerators TableNameGenerators

	// InitializeSchema enables initialization of schema database during publish.
	// Schema is initialized once per topic per publisher instance.
	// InitializeSchema is forbidden if using an ongoing transaction as database handle.
	// It could result in an implicit commit of the transaction by a CREATE TABLE statement.
	InitializeSchema bool

	// Logger reports message publishing errors and traces. Defaults value is [watermill.NopLogger].
	Logger watermill.LoggerAdapter
}

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

type SQLiteDatabase interface {
	SQLiteConnection
	BeginTx(context.Context, *sql.TxOptions) (*sql.Tx, error)
}

type SubscriberOptions struct {
	// ConsumerGroupMatcher differentiates message consumers within the same topic.
	// Messages are processed in batches.
	// Therefore, another subscriber with the same consumer group name may only obtain
	// messages whenever it is able to acquire the row lock.
	// Default value is a static consumer group matcher that
	// always returns [DefaultConsumerGroupName].
	ConsumerGroupMatcher ConsumerGroupMatcher

	// BatchSize is the number of messages to read in a single batch.
	// Default value is [DefaultMessageBatchSize].
	BatchSize int

	// TableNameGenerators is a set of functions that generate table names for topics and offsets.
	// Default value is [TableNameGenerators.WithDefaultGeneratorsInsteadOfNils].
	TableNameGenerators TableNameGenerators

	// PollInterval is the interval to wait between subsequent SELECT queries, if
	// no more messages were found in the database (Prefer using the BackoffManager instead).
	// Must be non-negative. Defaults to one second.
	PollInterval time.Duration

	// LockTimeout is the maximum duration of the row lock. If the subscription
	// is unable to extend the lock before this time out ends, the lock will expire.
	// Then, another subscriber in the same consumer group name may
	// acquire the lock and continue processing messages.
	//
	// Duration must not be less than one second, because seconds are added
	// to the SQLite `unixepoch` function, rounded to the nearest second.
	// A zero duration would create a lock that expires immediately.
	// There is no reason to set higher precision fractional duration,
	// because the lock timeout will rarely ever trigger in a healthy system.
	//
	// Normally, the row lock is set to zero after each batch of messages is processed.
	// LockTimeout might occur if a consuming node shuts down unexpectedly,
	// before it is able to complete processing a batch of messages. Only
	// in such rare cases the time out matters. And, it is better to set it
	// to a higher value in order to avoid unnecessary batch re-processing.
	// Therefore, a value lower than one second is impractical.
	//
	// Default value is [DefaultLockTimeout].
	LockTimeout time.Duration

	// AckDeadline is the time to wait for acking a message.
	// If message is not acked within this time, it will be nacked and re-delivered.
	//
	// When messages are read in bulk, this time is calculated for each message separately.
	//
	// If you want to disable the acknowledgement deadline, set it to 0.
	// Warning: when acknowledgement deadline is disabled, messages may block and
	// prevent the subscriber from accepting new messages.
	//
	// Must be non-negative. Default value is [DefaultAckDeadline].
	AckDeadline *time.Duration

	// InitializeSchema option enables initializing schema on making a subscription.
	InitializeSchema bool

	// Logger reports message consumption errors and traces.
	//
	// Defaults to [watermill.NopLogger].
	Logger watermill.LoggerAdapter
}

type TableNameGenerator func(topic string) string

type TableNameGenerators struct {
	Topic   TableNameGenerator
	Offsets TableNameGenerator
}