database

type BigCacheClient struct {
	Client *bigcache.BigCache
}

type ComparisonOperators string

type Config struct {
	LIKE        LIKE            `json:"like"`
	MongoDB     MongoDB         `json:"mongodb"`
	Redis       Redis           `json:"redis,omitempty"`
	CustomCache CustomCache     `json:"customCache,omitempty"`
	BigCache    bigcache.Config `json:"bigCache,omitempty"`
}

type CustomCache struct {
	CacheSize        int64         `json:"cacheSize,omitempty"` // byte
	CleaningEnable   bool          `json:"cleaningEnable,omitempty"`
	CleaningInterval time.Duration `json:"cleaningInterval,omitempty"` // nanosecond
}

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

type ICaching interface {
	Middleware(hash hash.IHash) echo.MiddlewareFunc
	Get(key string) (interface{}, error)
	Set(key string, value interface{}, expire time.Duration) error
	Update(key string, value interface{}, expire time.Duration) error
	Delete(key string) error
	GetNumberOfRecords() int
	GetCapacity() (interface{}, error)
	Close() error
}

type INoSQL interface {
	GetALL(
		databaseName,
		collectionName,
		lastID,
		pageSize string,
		dataModel reflect.Type) (results interface{}, err error)

	GetByField(
		databaseName,
		collectionName,
		field,
		value string,
		dataModel reflect.Type) (interface{}, error)

	Create(
		databaseName,
		collectionName string,
		dataModel interface{}) (result interface{}, err error)

	Update(
		databaseName,
		collectionName,
		ID string,
		dataModel interface{}) (result interface{}, err error)

	Delete(
		databaseName,
		collectionName,
		ID string) (result interface{}, err error)

	MatchAndLookup(
		databaseName,
		collectionName string,
		model MatchLookup,
		dataModel reflect.Type) (results interface{}, err error)
}

type ISQL interface {
	Execute(
		query string,
		dataModel interface{}) (interface{}, error)
}

type LIKE struct {
	DriverName            string        `json:"driverName"`
	DataSourceName        string        `json:"dataSourceName"`
	MaxConnectionLifetime time.Duration `json:"maxConnectionLifetime"`
	MaxConnectionIdle     int           `json:"maxConnectionIdle"`
	MaxConnectionOpen     int           `json:"maxConnectionOpen"`
}

type Lookup struct {
	From         string `json:"From"`
	LocalField   string `json:"localField"`
	ForeignField string `json:"foreignField"`
	As           string `json:"as"`
}

type Match struct {
	Field    string              `json:"field"`
	Operator ComparisonOperators `json:"operator"`
	Value    string              `json:"value"`
}

type MatchLookup struct {
	Match  []Match  `json:"match"`
	Lookup []Lookup `json:"lookup"`
}

type MongoClient struct {
	Client *mongo.Client
	Config *MongoDB
}

type MongoDB struct {
	User     string   `json:"user"`
	Password string   `json:"password"`
	Hosts    []string `json:"hosts"`
	DB       string   `json:"db"`
	Options  []string `json:"options"`
}

type Redis struct {
	Password   string `json:"password,omitempty"`
	Host       string `json:"host,omitempty"`
	DB         int    `json:"db,omitempty"`
	MaxRetries int    `json:"maxRetries,omitempty"`
}

type RedisClient struct {
	Client *redis.Client
}

type SQLLikeClient struct {
	Client *sql.DB
	Config *LIKE
}

type Set struct {
	Operator UpdateOperators `json:"operator"`
	Data     interface{}     `json:"data"`
}

type UpdateOperators string