fluxaorm

type Alter struct {
	SQL  string
	Safe bool
	Pool string
}

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

type Bind map[string]any

type BindError struct {
	Field   string
	Message string
}

type ColumnSchemaDefinition struct {
	ColumnName string
	Definition string
}

type Config struct {
	MySQlPools         []ConfigMysql         `yaml:"mysqlPools"`
	RedisPools         []ConfigRedis         `yaml:"redisPools"`
	RedisSentinelPools []ConfigRedisSentinel `yaml:"redisSentinelPools"`
	LocalCachePools    []ConfigLocalCache    `yaml:"localCachePools"`
}

type ConfigLocalCache struct {
	Code  string `yaml:"code" validate:"required"`
	Limit int    `yaml:"limit" validate:"required"`
}

type ConfigMysql struct {
	Code               string   `yaml:"code" validate:"required"`
	URI                string   `yaml:"uri" validate:"required"`
	ConnMaxLifetime    int      `yaml:"connMaxLifetime"`
	MaxOpenConnections int      `yaml:"maxOpenConnections"`
	MaxIdleConnections int      `yaml:"maxIdleConnections"`
	DefaultEncoding    string   `yaml:"defaultEncoding"`
	DefaultCollate     string   `yaml:"defaultCollate"`
	IgnoredTables      []string `yaml:"ignoredTables"`
}

type ConfigRedis struct {
	Code     string   `yaml:"code" validate:"required"`
	URI      string   `yaml:"uri" validate:"required"`
	Database int      `yaml:"database"`
	User     string   `yaml:"user"`
	Password string   `yaml:"password"`
	Streams  []string `yaml:"streams"`
}

type ConfigRedisSentinel struct {
	Code       string   `yaml:"code" validate:"required"`
	MasterName string   `yaml:"masterName" validate:"required"`
	Database   int      `yaml:"database"`
	Sentinels  []string `yaml:"sentinels"`
	User       string   `yaml:"user"`
	Password   string   `yaml:"password"`
	Streams    []string `yaml:"streams"`
}

type Context interface {
	Context() context.Context
	Clone() Context
	CloneWithContext(context context.Context) Context
	Engine() Engine
	NewEntity(entity any)
	EditEntity(entity any) any
	DeleteEntity(entity any)
	ForceDeleteEntity(entity any)
	PushDirty(entities ...any) error
	ClearCache()
	EnableContextCache()
	Flush() error
	FlushAsync() error
	ClearFlush()
	RedisPipeLine(pool string) *RedisPipeLine
	DatabasePipeLine(pool string) *DatabasePipeline
	RegisterQueryLogger(handler LogHandler, mysql, redis, local bool)
	EnableQueryDebug()
	EnableQueryDebugCustom(mysql, redis, local bool)
	SetMetaData(key, value string)
	GetMetaData() Meta

	Track(f Flushable, cacheIndex uint64)
	GetEventBroker() EventBroker
	// contains filtered or unexported methods
}

type DB interface {
	DBBase
	Begin(ctx Context) (DBTransaction, error)
}

type DBBase interface {
	GetConfig() MySQLConfig
	GetDBClient() DBClient
	SetMockDBClient(mock DBClient)
	Exec(ctx Context, query string, args ...any) (ExecResult, error)
	QueryRow(ctx Context, query Where, toFill ...any) (found bool, err error)
	Query(ctx Context, query string, args ...any) (rows Rows, close func(), err error)
}

type DBClient interface {
	DBClientQuery
}

type DBClientNoTX interface {
	DBClientQuery
	Begin() (*sql.Tx, error)
}

type DBClientQuery interface {
	Exec(query string, args ...any) (sql.Result, error)
	ExecContext(context context.Context, query string, args ...any) (sql.Result, error)
	QueryRow(query string, args ...any) *sql.Row
	QueryRowContext(context context.Context, query string, args ...any) *sql.Row
	Query(query string, args ...any) (*sql.Rows, error)
	QueryContext(context context.Context, query string, args ...any) (*sql.Rows, error)
}

type DBTransaction interface {
	DBBase
	Commit(ctx Context) error
	Rollback(ctx Context) error
}

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

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

type DirtyStreamEvent struct {
	EntityName string
	ID         uint64
	Operation  FlushType
	Bind       Bind
	// contains filtered or unexported fields
}

type DirtyStreamEventHandler func(events []*DirtyStreamEvent)

type DuplicateKeyError struct {
	Message string
	Index   string
}

type Engine interface {
	NewContext(parent context.Context) Context
	DB(code string) DB
	LocalCache(code string) LocalCache
	Redis(code string) RedisCache
	Registry() EngineRegistry
	Option(key string) any
	GetRedisStreams() map[string]map[string]string
}

type EngineRegistry interface {
	EntitySchema(entity any) EntitySchema
	DBPools() map[string]DB
	LocalCachePools() map[string]LocalCache
	RedisPools() map[string]RedisCache
	Entities() []EntitySchema
	Option(key string) any
	Enums() map[string][]string
	DisableLogTables()
	// contains filtered or unexported methods
}

type EngineSetter interface {
	SetOption(key string, value any)
}

type EntityAnonymousIterator interface {
	Next() bool
	ID() uint64
	Index() int

	Len() int
	All() ([]any, error)
	AllIDs() ([]uint64, error)
	Entity() (any, error)
	Reset()
	LoadReference(columns ...string) error
	// contains filtered or unexported methods
}

type EntityFlush interface {
	ID() uint64
	Schema() *entitySchema
	// contains filtered or unexported methods
}

type EntityFlushedEvent interface {
	FlushType() FlushType
}

type EntityIterator[E any] interface {
	Next() bool
	ID() uint64
	Index() int
	Len() int
	Entity() (*E, error)
	All() ([]*E, error)
	AllIDs() ([]uint64, error)
	Reset()
	LoadReference(columns ...string) error
	// contains filtered or unexported methods
}

type EntitySchema interface {
	EntitySchemaShared
	DropTable(ctx Context) error
	TruncateTable(ctx Context) error
	UpdateSchema(ctx Context) error
	UpdateSchemaAndTruncateTable(ctx Context) error
	GetSchemaChanges(ctx Context) (alters []Alter, has bool, err error)
	DisableCache(local, redis bool)
	NewEntity(ctx Context) any
	GetByID(ctx Context, id uint64) (entity any, found bool, err error)
	GetByIDs(ctx Context, ids ...uint64) (EntityAnonymousIterator, error)
	Search(ctx Context, where Where, pager *Pager) (EntityAnonymousIterator, error)
	SearchWithCount(ctx Context, where Where, pager *Pager) (results EntityAnonymousIterator, totalRows int, err error)
	SearchIDs(ctx Context, where Where, pager *Pager) ([]uint64, error)
	SearchIDsWithCount(ctx Context, where Where, pager *Pager) (results []uint64, totalRows int, err error)
	IsDirty(ctx Context, id uint64) (oldValues, newValues Bind, hasChanges bool)
	Copy(ctx Context, source any) any
	EditEntityField(ctx Context, entity any, field string, value any) error
	EditEntity(ctx Context, entity any) any
	DeleteEntity(ctx Context, entity any)

	ReindexRedisIndex(ctx Context) error
	ClearCache(ctx Context) (int, error)
	// contains filtered or unexported methods
}

type EntitySchemaSetter interface {
	SetOption(key string, value any)
	EntitySchemaShared
}

type EntitySchemaShared interface {
	GetTableName() string
	IsVirtual() bool
	GetType() reflect.Type
	GetColumns() []string
	GetTag(field, key, trueValue, defaultValue string) string
	Option(key string) any
	GetUniqueIndexes() map[string][]string
	GetDB() DB
	GetLocalCache() (cache LocalCache, has bool)
	GetRedisCache() (cache RedisCache, has bool)
	GetRedisSearchPoolCode() string
	GetRedisSearchIndexName() string
}

type EnumValues interface {
	EnumValues() any
}

type Event interface {
	Ack() error
	ID() string
	Tag(key string) (value string)
	Unserialize(val interface{}) error
}

type EventBroker interface {
	Publish(stream string, body interface{}, meta ...string) (id string, err error)
	ConsumerSingle(ctx Context, stream string) (EventsConsumer, error)
	ConsumerMany(ctx Context, stream string) (EventsConsumer, error)
	NewFlusher() EventFlusher
	GetStreamsStatistics(stream ...string) ([]*RedisStreamStatistics, error)
	GetStreamStatistics(stream string) (*RedisStreamStatistics, error)
}

type EventConsumerHandler func([]Event) error

type EventFlusher interface {
	Publish(stream string, body interface{}, meta ...string) error
	Flush() error
}

type EventsConsumer interface {
	Consume(count int, blockTime time.Duration, handler EventConsumerHandler) error
	AutoClaim(count int, minIdle time.Duration, handler EventConsumerHandler) error
	Cleanup() error
	Name() string
}

type ExecResult interface {
	LastInsertId() (uint64, error)
	RowsAffected() (uint64, error)
}

type FlushType int

type Flushable interface {
	PrivateFlush() error
	PrivateFlushed()
	GetID() uint64
}

type ID interface {
	int | uint | uint8 | uint16 | uint32 | uint64 | int8 | int16 | int32 | int64
}

type IDGetter interface {
	GetID() uint64
}

type IndexDefinition struct {
	Columns string
	Cached  bool
}

type IndexInterface interface {
	Indexes() any
}

type IndexSchemaDefinition struct {
	Name       string
	Unique     bool
	Duplicated bool
	// contains filtered or unexported fields
}

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

type LocalCache interface {
	Set(ctx Context, key string, value any)
	Remove(ctx Context, key string)
	GetConfig() LocalCacheConfig
	Get(ctx Context, key string) (value any, ok bool)
	Clear(ctx Context)
	GetUsage() []LocalCacheUsage
	// contains filtered or unexported methods
}

type LocalCacheConfig interface {
	GetCode() string
	GetLimit() int
	GetSchema() EntitySchema
}

type LocalCacheUsage struct {
	Type      string
	Limit     uint64
	Used      uint64
	Evictions uint64
}

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

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

type LogEntity[Entity any] struct {
	ID       uint64
	EntityID uint64
	Date     time.Time `orm:"time"`
	Meta     []byte
	Before   []byte
	After    []byte
}

type LogHandler interface {
	Handle(ctx Context, log map[string]any)
}

type LogQueueValue struct {
	PoolName  string
	TableName string
	ID        uint64
	LogID     uint64
	Meta      map[string]interface{}
	Before    map[string]interface{}
	Changes   map[string]interface{}
	Updated   time.Time
}

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

type Meta map[string]string

type MockDBClient struct {
	OriginDB            DBClient
	PrepareMock         func(query string) (*sql.Stmt, error)
	ExecMock            func(query string, args ...any) (sql.Result, error)
	ExecContextMock     func(context context.Context, query string, args ...any) (sql.Result, error)
	QueryRowMock        func(query string, args ...any) *sql.Row
	QueryRowContextMock func(context context.Context, query string, args ...any) *sql.Row
	QueryMock           func(query string, args ...any) (*sql.Rows, error)
	QueryContextMock    func(context context.Context, query string, args ...any) (*sql.Rows, error)
	BeginMock           func() (*sql.Tx, error)
	CommitMock          func() error
	RollbackMock        func() error
}

type MockLogHandler struct {
	Logs []map[string]any
}

type MySQLConfig interface {
	GetCode() string
	GetDatabaseName() string
	GetDataSourceURI() string
	GetOptions() *MySQLOptions
	// contains filtered or unexported methods
}

type MySQLOptions struct {
	ConnMaxLifetime    time.Duration
	MaxOpenConnections int
	MaxIdleConnections int
	DefaultEncoding    string
	DefaultCollate     string
	IgnoredTables      []string
	Beta               bool
}

type Pager struct {
	CurrentPage int
	PageSize    int
}

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

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

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

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

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

type PluginInitNewEntity interface {
	InitNewEntity(schema EntitySchema, entity reflect.Value)
}

type PluginInterfaceEntityFlush interface {
	EntityFlush(schema EntitySchema, entity reflect.Value, id uint64, before, after Bind, engine Engine) (PostFlushAction, error)
}

type PluginInterfaceInitRegistryFromYaml interface {
	InitRegistryFromYaml(registry Registry, yaml map[string]any) error
}

type PluginInterfaceValidateEntitySchema interface {
	ValidateEntitySchema(schema EntitySchemaSetter) error
}

type PluginInterfaceValidateRegistry interface {
	ValidateRegistry(engine EngineSetter, registry Registry) error
}

type PostFlushAction func(ctx Context)

type QueryLoggerSource int

type RedisCache interface {
	Set(ctx Context, key string, value any, expiration time.Duration) error
	MSet(ctx Context, pairs ...any) error
	Del(ctx Context, keys ...string) error
	HSet(ctx Context, key string, values ...any) error
	HDel(ctx Context, key string, keys ...string) error
	GetSet(ctx Context, key string, expiration time.Duration, provider func() any) (any, error)
	Info(ctx Context, section ...string) (string, error)
	GetConfig() RedisPoolConfig
	Get(ctx Context, key string) (value string, has bool, err error)
	Eval(ctx Context, script string, keys []string, args ...any) (any, error)
	EvalSha(ctx Context, sha1 string, keys []string, args ...any) (res any, exists bool, err error)
	SetNX(ctx Context, key string, value any, expiration time.Duration) (bool, error)
	ScriptExists(ctx Context, sha1 string) (bool, error)
	ScriptLoad(ctx Context, script string) (string, error)
	LPush(ctx Context, key string, values ...any) (int64, error)
	LPop(ctx Context, key string) (string, error)
	RPush(ctx Context, key string, values ...any) (int64, error)
	LLen(ctx Context, key string) (int64, error)
	Exists(ctx Context, keys ...string) (int64, error)
	Type(ctx Context, key string) (string, error)
	LRange(ctx Context, key string, start, stop int64) ([]string, error)
	LIndex(ctx Context, key string, index int64) (string, bool, error)
	LSet(ctx Context, key string, index int64, value any) error
	RPop(ctx Context, key string) (value string, found bool, err error)
	BLMove(ctx Context, source, destination, srcPos, destPos string, timeout time.Duration) (string, error)
	LMove(ctx Context, source, destination, srcPos, destPos string) (string, error)
	LRem(ctx Context, key string, count int64, value any) error
	Ltrim(ctx Context, key string, start, stop int64) error
	HSetNx(ctx Context, key, field string, value any) (bool, error)
	HMGet(ctx Context, key string, fields ...string) (map[string]any, error)
	HGetAll(ctx Context, key string) (map[string]string, error)
	HGet(ctx Context, key, field string) (value string, has bool, err error)
	HLen(ctx Context, key string) (int64, error)
	HIncrBy(ctx Context, key, field string, incr int64) (int64, error)
	IncrBy(ctx Context, key string, incr int64) (int64, error)
	Incr(ctx Context, key string) (int64, error)
	IncrWithExpire(ctx Context, key string, expire time.Duration) (int64, error)
	Expire(ctx Context, key string, expiration time.Duration) (bool, error)
	ZAdd(ctx Context, key string, members ...redis.Z) (int64, error)
	ZRevRange(ctx Context, key string, start, stop int64) ([]string, error)
	ZRevRangeWithScores(ctx Context, key string, start, stop int64) ([]redis.Z, error)
	ZRangeWithScores(ctx Context, key string, start, stop int64) ([]redis.Z, error)
	ZRangeArgsWithScores(ctx Context, z redis.ZRangeArgs) ([]redis.Z, error)
	ZCard(ctx Context, key string) (int64, error)
	ZCount(ctx Context, key string, min, max string) (int64, error)
	ZScore(ctx Context, key, member string) (float64, error)
	MGet(ctx Context, keys ...string) ([]any, error)
	SAdd(ctx Context, key string, members ...any) (int64, error)
	SMembers(ctx Context, key string) ([]string, error)
	SIsMember(ctx Context, key string, member any) (bool, error)
	SCard(ctx Context, key string) (int64, error)
	SPop(ctx Context, key string) (string, bool, error)
	SPopN(ctx Context, key string, max int64) ([]string, error)
	XTrim(ctx Context, stream string, maxLen int64) (deleted int64, err error)
	XRange(ctx Context, stream, start, stop string, count int64) ([]redis.XMessage, error)
	XRevRange(ctx Context, stream, start, stop string, count int64) ([]redis.XMessage, error)
	XInfoStream(ctx Context, stream string) (*redis.XInfoStream, error)
	XInfoGroups(ctx Context, stream string) ([]redis.XInfoGroup, error)
	XGroupCreate(ctx Context, stream, group, start string) (key string, exists bool, err error)
	XGroupCreateMkStream(ctx Context, stream, group, start string) (key string, exists bool, err error)
	XGroupDestroy(ctx Context, stream, group string) (int64, error)
	XRead(ctx Context, a *redis.XReadArgs) ([]redis.XStream, error)
	XDel(ctx Context, stream string, ids ...string) (int64, error)
	XAutoClaim(ctx Context, a *redis.XAutoClaimArgs) (messages []redis.XMessage, start string, err error)
	XGroupDelConsumer(ctx Context, stream, group, consumer string) (int64, error)
	XReadGroup(ctx Context, a *redis.XReadGroupArgs) (streams []redis.XStream, err error)
	XPending(ctx Context, stream, group string) (*redis.XPending, error)
	XPendingExt(ctx Context, a *redis.XPendingExtArgs) ([]redis.XPendingExt, error)
	XLen(ctx Context, stream string) (int64, error)
	XClaim(ctx Context, a *redis.XClaimArgs) ([]redis.XMessage, error)
	XClaimJustID(ctx Context, a *redis.XClaimArgs) ([]string, error)
	XAck(ctx Context, stream, group string, ids ...string) (int64, error)

	FlushAll(ctx Context) error
	FlushDB(ctx Context) error
	Scan(ctx Context, cursor uint64, match string, count int64) (keys []string, cursorNext uint64, err error)
	GetLocker() *Locker
	GetCode() string
	FTList(ctx Context) ([]string, error)
	FTDrop(ctx Context, index string, dropDocuments bool) error
	FTSearch(ctx Context, index string, query string, options *redis.FTSearchOptions) (redis.FTSearchResult, error)
	FTCreate(ctx Context, index string, options *redis.FTCreateOptions, schema ...*redis.FieldSchema) error
	FTInfo(ctx Context, index string) (info *redis.FTInfoResult, found bool, err error)
	Client() *redis.Client
	// contains filtered or unexported methods
}

type RedisOptions struct {
	User            string
	Password        string
	Master          string
	Sentinels       []string
	SentinelOptions *redis.FailoverOptions
}

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

type RedisPoolConfig interface {
	GetCode() string
	GetDatabaseNumber() int
	GetAddress() string
	// contains filtered or unexported methods
}

type RedisSearchAlter struct {
	IndexName       string
	DocumentsInDB   uint64
	Pool            string
	Drop            bool
	IndexDefinition string
	// contains filtered or unexported fields
}

type RedisSearchFilter struct {
	FieldName string
	Min       any
	Max       any
}

type RedisSearchQuery struct {
	Query   string
	SortBy  []RedisSearchSortBy
	Filters []RedisSearchFilter
	Tags    string
}

type RedisSearchSortBy struct {
	FieldName string
	Desc      bool
}

type RedisStreamConsumerStatistics struct {
	Name    string
	Pending uint64
}

type RedisStreamGroupStatistics struct {
	Group                 string
	Lag                   int64
	Pending               uint64
	LastDeliveredID       string
	LastDeliveredDuration time.Duration
	LowerID               string
	LowerDuration         time.Duration
	Consumers             []*RedisStreamConsumerStatistics
}

type RedisStreamStatistics struct {
	Stream             string
	RedisPool          string
	Len                uint64
	OldestEventSeconds int
	Group              *RedisStreamGroupStatistics
}

type Reference[E any] uint64

type ReferenceInterface interface {
	IDGetter
	Schema(ctx Context) EntitySchema
	// contains filtered or unexported methods
}

type References[E any] struct {
	// contains filtered or unexported fields
}

type Registry interface {
	Validate() (Engine, error)
	RegisterEntity(entity ...any)
	RegisterPlugin(plugin ...any)
	RegisterMySQL(dataSourceName string, poolCode string, poolOptions *MySQLOptions)
	RegisterLocalCache(code string, limit int)
	RegisterRedis(address string, db int, poolCode string, options *RedisOptions)
	InitByYaml(yaml any) error
	InitByConfig(config *Config) error
	SetOption(key string, value any)
	RegisterRedisStream(name string, redisPool string)
	EnableMetrics(factory promauto.Factory)
}

type Rows interface {
	Next() bool
	Scan(dest ...any) error
	Columns() ([]string, error)
}

type SQLRow interface {
	Scan(dest ...any) error
	Err() error
}

type SQLRows interface {
	Next() bool
	Err() error
	Close() error
	Scan(dest ...any) error
	Columns() ([]string, error)
}

type Struct[E any] struct {
	// contains filtered or unexported fields
}

type TXClient interface {
	DBClientQuery
}

type TableSQLSchemaDefinition struct {
	EntitySchema   EntitySchema
	EntityColumns  []*ColumnSchemaDefinition
	EntityIndexes  []*IndexSchemaDefinition
	DBTableColumns []*ColumnSchemaDefinition
	DBIndexes      []*IndexSchemaDefinition
	DBCreateSchema string
	DBEncoding     string
	Engine         string
	PreAlters      []Alter
	PostAlters     []Alter
	// contains filtered or unexported fields
}

type UniqueIndexDefinition struct {
	Columns string
	Cached  bool
}

type Where interface {
	String() string
	GetParameters() []any
}