datasources

type Datasource interface {
	// Allowed actions
	Actions() *DatasourceActionResult

	// Get total count of items based on the provided request.
	// Note: The count should reflect the given 'Size' and number of 'IDs'
	Count(ctx *context.Context, request *DatasourceFetchRequest) uint64
	// Fetch data
	Fetch(ctx *context.Context, request *DatasourceFetchRequest) DatasourceFetchResult
	// Insert, Update, Delete data (in that order)
	Push(ctx *context.Context, request *DatasourcePushRequest) (DatasourcePushCount, error)
	// Listen to Change Data Streams or periodically watch for changes
	Watch(ctx *context.Context, request *DatasourceStreamRequest) <-chan DatasourceStreamResult
	// Clear data source
	Clear(ctx *context.Context) error
	// Close data source
	Close(ctx *context.Context) error

	// Import data
	Import(ctx *context.Context, request DatasourceImportRequest) error
	// Export data
	Export(ctx *context.Context, request DatasourceExportRequest) error
}

type DatasourceActionResult struct {
	Read   bool
	Write  bool
	Stream bool
}

type DatasourceExportDestination string

type DatasourceExportRequest struct {
	Type        DatasourceExportType
	Destination DatasourceExportDestination
	Location    string
	BatchSize   uint64
}

type DatasourceExportType string

type DatasourceFetchRequest struct {
	// List of IDs to fetch (optional)
	IDs []string
	// Number of items to fetch. 0 to fetch all (optional)
	Size uint64
	// Offset to start fetching from. 0 to start from beginning (optional)
	Offset uint64
}

type DatasourceFetchResult struct {
	Err  error
	Docs []map[string]any
	// Start offset: where first offset = 0
	Start uint64
	// End offset: where first offset = 0
	End uint64
}

type DatasourceImportRequest struct {
	Type      DatasourceImportType
	Source    DatasourceImportSource
	Location  string
	BatchSize uint64
}

type DatasourceImportSource string

type DatasourceImportType string

type DatasourcePushCount struct {
	Inserts uint64
	Updates uint64
	Deletes uint64
}

type DatasourcePushRequest struct {
	Inserts []map[string]any
	Updates []map[string]any
	Deletes []string
}

type DatasourceStreamRequest struct {
	// Number of items to batch. 0 to disable batching (optional)
	BatchSize uint64
	// How long to wait to accumulate batch (optional)
	BatchWindowSeconds uint64
}

type DatasourceStreamResult struct {
	Err  error
	Docs DatasourcePushRequest
}

type DatasourceTransformer func(data map[string]any) (map[string]any, error)

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

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

type MongoDatasourceConfigs struct {
	URI            string
	DatabaseName   string
	CollectionName string

	// MongoDB Filter Query
	Filter map[string]any
	// MongoDB Sort Query
	Sort map[string]any
	// Use accurate counting instead of estimated count (slower)
	AccurateCount bool

	// Provide custom mongo client
	WithClient func(ctx *context.Context, uri string) (*mongo.Client, error)
	// Provide custom transformer. E.g To convert item's ID to mongo ID
	WithTransformer DatasourceTransformer
	// Perform actions on init
	OnInit func(client *mongo.Client) error
}

type MySQLConnectionInfo struct {
	Addr     string
	User     string
	Password string
	Database string
}

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

type MySQLDatasourceConfigs[T any] struct {
	// Database connection string
	DSN string
	// Table name to work with
	TableName string
	// GORM model struct for the table.
	// @see: https://gorm.io/docs/models.html
	Model *T
	// ID Field for the table. Default is "id".
	// This would very likely correspond to the primary key field in the table
	IDField string
	// Database flavor: "mysql" (default) or "mariadb"
	DBFlavor MySQLFlavor

	// Filter conditions (WHERE clause)
	Filter MySQLDatasourceFilter
	// Sort order (ORDER BY clause)
	Sort map[string]any

	// Provide custom GORM DB instance
	WithDB func(ctx *context.Context, dsn string) (*gorm.DB, error)
	// Provide custom transformer
	WithTransformer MySQLDatasourceTransformer[T]
	// Perform actions on init
	OnInit func(db *gorm.DB) error

	// Binlog replication settings
	DisableReplication  bool
	BinlogStartPosition mysql.Position

	// Connection pool settings
	DBMaxIdleConns    int
	DBMaxOpenConns    int
	DBMaxConnLifetime time.Duration

	// Whether to disable auto-migration of the table schema
	// Use this if you want to manage the table schema manually
	//   or if the table already exists with a different schema
	DisableAutoMigrate bool
}

type MySQLDatasourceFilter struct {
	// SQL WHERE clause (without the "WHERE" keyword)
	// Use "?" for parameters, e.g. "status = ? AND age > ?"
	Query string
	// Query parameters
	Params []any
}

type MySQLDatasourceTransformer[T any] func(data map[string]any) (T, error)

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

type MySQLFlavor string

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

type PostgresDatasourceConfigs[T any] struct {
	// Database connection string
	DSN string
	// Table name to work with
	TableName string
	// GORM model struct for the table.
	// @see: https://gorm.io/docs/models.html
	Model *T
	// ID Field for the table. Default is "id".
	// This would very likely correspond to the primary key field in the table
	IDField string

	// Filter conditions (WHERE clause)
	Filter PostgresDatasourceFilter
	// Sort order (ORDER BY clause)
	Sort map[string]any

	// Provide custom GORM DB instance
	WithDB func(ctx *context.Context, dsn string) (*gorm.DB, error)
	// Provide custom transformer
	WithTransformer PostgresDatasourceTransformer[T]
	// Perform actions on init
	OnInit func(db *gorm.DB) error

	// Logical replication settings
	PublicationName     string
	ReplicationSlotName string
	DisableReplication  bool

	// Connection pool settings
	DBMaxIdleConns    int
	DBMaxOpenConns    int
	DBMaxConnLifetime time.Duration

	// Whether to disable auto-migration of the table schema
	// Use this if you want to manage the table schema manually
	//   or if the table already exists with a different schema
	DisableAutoMigrate bool
}

type PostgresDatasourceFilter struct {
	// SQL WHERE clause (without the "WHERE" keyword)
	// Use "?" for parameters, e.g. "status = ? AND age > ?"
	Query string
	// Query parameters
	Params []any
}

type PostgresDatasourceTransformer[T any] func(data map[string]any) (T, error)

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

type RedisDatasourceConfigs struct {
	// Redis connection URI
	URI string
	// Key prefix to use for saving and fetching items. E.g. `user:profile:`
	KeyPrefix string
	// ID Field for input JSON
	IDField string
	// Size of scan operations. E.g. '1000' to scan a thousand at a time. Min = 1.
	ScanSize uint64

	// Custom redis client provider
	WithClient func(ctx *context.Context, uri string) (*redis.Client, error)
	// Transform data before saving to redis
	WithTransformer RedisDatasourceTransformer
	// Perform actions on init
	OnInit func(client *redis.Client) error
}

type RedisDatasourceTransformer func(data map[string]any) (RedisInputSchema, error)

type RedisDsType string

type RedisInputSchema struct {
	String    string
	List      []any
	Set       []string
	Hash      map[string]string
	JSON      map[string]any
	SortedSet []map[string]float64
}

type RedisOutputHashSchema map[string]string

type RedisOutputJSONSchema map[string]any

type RedisOutputListSchema struct {
	Key     string   `json:"key"`
	Members []string `json:"array"`
}

type RedisOutputSetSchema struct {
	Key     string   `json:"key"`
	Members []string `json:"members"`
}

type RedisOutputSortedSetSchema struct {
	Key     string                 `json:"key"`
	Members []RedisSortedSetSchema `json:"members"`
}

type RedisOutputStringSchema struct {
	Key   string `json:"key"`
	Value string `json:"value"`
}

type RedisSortedSetSchema struct {
	Value string      `json:"value"`
	Score json.Number `json:"score"`
}

type ReplicationEvent struct {
	Action ReplicationEventAction `json:"action"`
	Data   map[string]any         `json:"data"`
}

type ReplicationEventAction string