dao

type AttemptDAO interface {
	BaseDAO[entities.Attempt]
	UpdateStatusToQueued(ctx context.Context, ids []string) error
	UpdateErrorCode(ctx context.Context, id string, status entities.AttemptStatus, code entities.AttemptErrorCode) error
	UpdateDelivery(ctx context.Context, result *AttemptResult) error
	ListUnqueuedForUpdate(ctx context.Context, maxScheduledAt time.Time, limit int) (list []*entities.Attempt, err error)
}

type AttemptDetailDAO interface {
	BaseDAO[entities.AttemptDetail]
	Insert(ctx context.Context, attemptDetail *entities.AttemptDetail) error
}

type AttemptQuery struct {
	Query

	IDs        []string
	EventId    *string
	EndpointId *string
	Status     *string
}

type AttemptResult struct {
	ID          string
	Request     *entities.AttemptRequest
	Response    *entities.AttemptResponse
	AttemptedAt types.Time
	Status      entities.AttemptStatus
	ErrorCode   *entities.AttemptErrorCode
	Exhausted   bool
}

type BaseDAO[T any] interface {
	Get(ctx context.Context, id string) (*T, error)
	Select(ctx context.Context, field string, id string) (*T, error)
	Insert(ctx context.Context, entity *T) error
	Update(ctx context.Context, entity *T) error
	Upsert(ctx context.Context, fields []string, entity *T) error
	Delete(ctx context.Context, id string) (bool, error)
	Count(ctx context.Context, query *Query) (int64, error)
	List(ctx context.Context, query *Query) ([]*T, error)
	Cursor(ctx context.Context, query *Query) (Cursor[*T], error)
	BatchInsert(ctx context.Context, entities []*T) error
	Iterate(ctx context.Context, query *Query) *Iterator[T]
}

type Condition struct {
	Column string
	Op     Operator
	Value  interface{}
}

type Cursor[T any] struct {
	Cursor   bool
	Reversed bool
	Data     []T
	// Deprecated
	Total   int64
	HasMore bool
	FirstId *string
	LastId  *string
}

type DAO[T Schema] struct {
	// contains filtered or unexported fields
}

type EndpointDAO interface {
	BaseDAO[entities.Endpoint]
	Disable(ctx context.Context, id string) (bool, error)
}

type EndpointQuery struct {
	Query
	Enabled     *bool
	WorkspaceId *string
}

type EventDAO interface {
	BaseDAO[entities.Event]
	BatchInsertIgnoreConflict(ctx context.Context, events []*entities.Event) ([]string, error)
	ListExistingUniqueIDs(ctx context.Context, uniques []string) ([]string, error)
}

type EventQuery struct {
	Query
}

type Iterator[T any] struct {
	// contains filtered or unexported fields
}

type Operator int

type OptionFunc func(*Options)

type Options struct {
	Table            string
	EntityName       string
	Workspace        bool
	CachePropagate   bool
	CacheName        string
	PropagateHandler func(ctx context.Context, opts *Options, id string, entity interface{})
	Instrumented     bool
}

type Order struct {
	Column string
	Sort   Sort
}

type PluginDAO interface {
	BaseDAO[entities.Plugin]
}

type PluginQuery struct {
	Query

	WorkspaceId *string
	EndpointId  *string
	SourceId    *string
	Enabled     *bool
}

type Query struct {
	Offset      int
	Limit       int
	Wheres      []Condition
	Orders      []Order
	CursorModel bool
	Reverse     bool
}

type Queryable interface {
	sqlx.ExtContext
	GetContext(context.Context, interface{}, string, ...interface{}) error
	SelectContext(context.Context, interface{}, string, ...interface{}) error
}

type Schema interface {
	PrimaryKey() string
}

type SchemaMeta struct {
	Name string
	// contains filtered or unexported fields
}

type Sort = string

type SourceDAO interface {
	BaseDAO[entities.Source]
}

type SourceQuery struct {
	Query

	WorkspaceId *string
}

type WorkspaceDAO interface {
	BaseDAO[entities.Workspace]
	GetDefault(ctx context.Context) (*entities.Workspace, error)
	GetWorkspace(ctx context.Context, name string) (*entities.Workspace, error)
}

type WorkspaceQuery struct {
	Query
}