hydro

type AdapterCategory string

type BatchOptions struct {
	BatchDuration time.Duration
	MaxAmount     int
}

type BatchOutput[I comparable, O any] struct {
	Err     error
	Outputs map[I]O
}

type BatchRequest[I comparable, O any] struct {
	Inputs    []I
	Collector chan BatchOutput[I, O]
}

type Batcher[I comparable, O any] struct {
	Options   BatchOptions
	Collector chan BatchRequest[I, O]
	BatchFunc func([]I) (map[I]O, error)
}

type Change[T any] interface {
	Stack(c Change[T]) Change[T]
}

type Config[T any, PS IPubSubBackend] struct {
	// The neogate instance. All events will be sent through here.
	Gate *neogate.Instance[T]

	// Path for the external Hydro gateway (just leave empty if you don't plan on mounting it anyway)
	GatewayPath string

	// The backend for Hydro's pub/sub model (if not set we'll use a local backend that acts as a replacement for a dedicated pub/sub service)
	PubSubBackend PS
}

type DatabaseListenerCreate[DB any, C Change[C]] struct {
	Identifier string                                           // Identifier for the listener (REQUIRED)
	Get        func(DB, []string) (map[string]C, error)         // Get the base data from results of listeners or just with key (required)
	ToEvent    func(key string, change Change[C]) neogate.Event // Should convert string and change info into an event that can be sent with Neo (required)

	PoolConfig PoolConfig // Config for the pooling of subscription workers
}

type DatabaseListenerDictionary[T any, PS IPubSubBackend, DB any, C Change[C]] struct {
	Instance   *Instance[T, PS] // Hydro instance related
	Identifier string           // Unique identifier for this listener dictionary
	// contains filtered or unexported fields
}

type HydroAdapter struct {
	Category AdapterCategory // The category the adapter is in
	Adapter  string          // The id of the adapter
}

type HydroAddress struct {
	Server  string       // Server where the thing exists
	Adapter HydroAdapter // Adapter to call on the target server
}

type IPubSubBackend interface {
	CreateWorker() ISubWorker
	Publish(ctx context.Context, channel string, message string) error
}

type ISubWorker interface {
	Subscribe(ctx context.Context, channels ...string) error
	Unsubscribe(ctx context.Context, channels ...string) error
	OnMessage(func(channel string, message string))
	OnError(func(channel string, err error))
	Close()
}

type Identifiable interface {
	GetIdentifier() string
}

type Instance[T any, PS IPubSubBackend] struct {
	// contains filtered or unexported fields
}

type ListenerSubscriptions[T any, PS IPubSubBackend, C Change[C]] struct {
	// contains filtered or unexported fields
}

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

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

type OutboxCreate[DB any] struct {

	// How long the outbox waits before pulling from the database again (default: 100 milliseconds).
	WaitDuration time.Duration

	// This function should save an event with an identifier to the database.
	Save func(database DB, messages []OutboxMessage) error

	// This is the main function handling the pulling of messages for the outbox.
	//
	// handler takes in a list of messages that you pulled from your database of choice in a transaction. It then returns which message identifiers were completed and an error for the first one that failed. Make sure your transaction skips any currently locked items in the table for the pull (the best pattern here is to just use one row / identifier to make sure no out-of-order stuff happens, if an insertion fails you can always just return a "already processing" error in most cases). Make sure to delete all the ones that have been completed.
	Tx func(database DB, handler func([]OutboxMessage) ([]string, error))
}

type OutboxMessage struct {
	Identifier string
	Data       []byte
}

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

type PoolConfig struct {
	// How many subscriptions should, at maximum, be done by one worker (default: 100)
	MaxAmountByWorker int
}

type PubSubOutbox[DB any, PS IPubSubBackend] struct {
	// contains filtered or unexported fields
}

type SubPool[PS IPubSubBackend] struct {
	// contains filtered or unexported fields
}

type Subscription[C Change[C]] interface {
	func(neogate.Event, Change[C]) | HydroAddress
}