dal

type Adapter interface {

	// Name of the dalgo adapter
	Name() string

	// Version of the name if applicable
	Version() string
}

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

type CollectionRef struct {
	Name   string
	Alias  string
	Parent *Key
}

type Column struct {
	Alias      string     `json:"Alias"`
	Expression Expression `json:"expression"`
}

type Comparison struct {
	Operator Operator
	Left     Expression
	Right    Expression
}

type Condition interface {
	fmt.Stringer
}

type Constant struct {
	Value any `json:"value"`
}

type Cursor string

type DB interface {

	// ID is an identifier provided at time of DB creation
	ID() string

	// Adapter provides information about underlying name to access data
	Adapter() Adapter

	// TransactionCoordinator provides shortcut methods to work with transactions
	// without opening connection explicitly.
	TransactionCoordinator

	// ReadSession implements a virtual read session that opens connection/session for each read call on DB level
	// TODO: consider to sacrifice some simplicity for the sake of interoperability?
	ReadSession
}

type DataWrapper interface {
	Data() any
}

type Deleter interface {

	// Delete deletes a single record from database by key
	Delete(ctx context.Context, key *Key) error
}

type EmptyReader struct{}

type ErrDuplicateUser struct {
	// TODO: Should it be moved out of this package to strongo/app/user?
	SearchCriteria   string
	DuplicateUserIDs []string
}

type ErrNotFoundByKey interface {
	Key() *Key
	Cause() error
	error
}

type Expression interface {
	fmt.Stringer
}

type FieldPath []string

type FieldRef struct {
	Name string
	IsID bool
}

type FieldVal struct {
	Name  string `json:"Name"`
	Value any    `json:"value"`
}

type Getter interface {

	// Get gets a single record from database by key
	Get(ctx context.Context, record Record) error
}

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

type IDGenerator = func(ctx context.Context, record Record) error

type InsertOption func(options *insertOptions)

type InsertOptions interface {
	IDGenerator() IDGenerator
}

type Inserter interface {

	// Insert inserts a single record in database
	Insert(ctx context.Context, record Record, opts ...InsertOption) error
}

type Key struct {
	ID     any
	IDKind reflect.Kind
	// contains filtered or unexported fields
}

type KeyOption = func(*Key) error

type MultiDeleter interface {

	// DeleteMulti deletes multiple records from database by keys
	DeleteMulti(ctx context.Context, keys []*Key) error
}

type MultiGetter interface {

	// GetMulti gets multiples records from database by keys
	GetMulti(ctx context.Context, records []Record) error
}

type MultiSetter interface {

	// SetMulti stores multiples records into database by keys
	SetMulti(ctx context.Context, records []Record) error
}

type MultiUpdater interface {

	// UpdateMulti updates multiples records in database by keys
	UpdateMulti(ctx context.Context, keys []*Key, updates []Update, preconditions ...Precondition) error
}

type Operator string

type OrderExpression interface {
	fmt.Stringer
	Expression() Expression
	Descending() bool
}

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

type Preconditions interface {
	Exists() bool
	LastUpdateTime() time.Time
}

type Query interface {
	fmt.Stringer

	// From defines target table/collection
	From() *CollectionRef

	// Where defines filter condition
	Where() Condition

	// GroupBy defines expressions to group by
	GroupBy() []Expression

	// OrderBy defines expressions to order by
	OrderBy() []OrderExpression

	// Columns defines what columns to return
	Columns() []Column

	// Into defines the type of the result
	Into() func() Record

	// IDKind defines the type of the ID
	IDKind() reflect.Kind // TODO: what about composite keys?

	// Offset specifies number of records to skip
	Offset() int

	// Limit specifies maximum number of records to be returned
	Limit() int

	// StartFrom specifies the startCursor/point to start from
	StartFrom() Cursor
}

type QueryBuilder interface {
	Offset(int) QueryBuilder
	Limit(int) QueryBuilder
	Where(conditions ...Condition) QueryBuilder
	WhereField(name string, operator Operator, v any) QueryBuilder
	OrderBy(expressions ...OrderExpression) QueryBuilder
	SelectInto(func() Record) Query
	SelectKeysOnly(idKind reflect.Kind) Query
	StartFrom(cursor Cursor) QueryBuilder
}

type QueryExecutor interface {

	// QueryReader returns a reader for the given query to read records 1 by 1 sequentially.
	// The Reader.Next() method returns ErrNoMoreRecords when there are no more records.
	QueryReader(ctx context.Context, query Query) (Reader, error)

	// QueryAllRecords is a helper method that returns all records for the given query.
	// It reads reader created by QueryReader until it returns ErrNoMoreRecords.
	// If you are interested only in IDs, use like:
	//
	//		reader, err := queryExecutor.SelectReader(ctx)
	//      // handle err
	//		var ids []int
	//		ids, err = dal.SelectAllIDs[int](reader)
	QueryAllRecords(ctx context.Context, query Query) (records []Record, err error)
}

type ROTxWorker = func(ctx context.Context, tx ReadTransaction) error

type RWTxWorker = func(ctx context.Context, tx ReadwriteTransaction) error

type RandomStringOptions interface {
	Prefix() string
	Length() int
}

type ReadSession interface {
	Getter
	MultiGetter
	QueryExecutor
}

type ReadTransaction interface {
	Transaction
	ReadSession
}

type ReadTransactionCoordinator interface {

	// RunReadonlyTransaction starts readonly transaction
	RunReadonlyTransaction(ctx context.Context, f ROTxWorker, options ...TransactionOption) error
}

type Reader interface {

	// Next returns the next record for a query.
	// If no more records a nil record and ErrNoMoreRecords are returned.
	Next() (Record, error)

	// Cursor points to a position in the result set. This can be used for pagination.
	Cursor() (string, error)

	// Close closes the reader
	Close() error
}

type ReaderOption = func(ro *readerOptions)

type ReaderOptions interface {
	Limit() int
	Offset() int
}

type ReaderProvider = func(ctx context.Context, query Query) (reader Reader, err error)

type ReadwriteSession interface {
	ReadSession
	WriteSession
}

type ReadwriteTransaction interface {

	// ID returns a unique ID of a transaction if it is supported by the underlying DB client
	ID() string

	Transaction
	ReadwriteSession
}

type ReadwriteTransactionCoordinator interface {

	// RunReadwriteTransaction starts read-write transaction
	RunReadwriteTransaction(ctx context.Context, f RWTxWorker, options ...TransactionOption) error
}

type Record interface {
	// Key keeps a `table` Name of an entity and an ID within that table or a chain of nested keys
	Key() *Key

	// Error keeps an error for the last operation on the record. Not found is not treated as an error
	Error() error

	// Exists indicates if record was found in database. Throws panic if called before a `Get` or `Set`.
	Exists() bool

	// SetError sets error relevant to specific record. Intended to be used only by DALgo DB drivers.
	// Returns the record itself for convenience.
	SetError(err error) Record

	// Data returns record data (without ID/key).
	// Requires either record to be created by NewRecordWithData()
	// or DataTo() to be called first, otherwise panics.
	Data() any

	// HasChanged & MarkAsChanged are methods of convenience
	HasChanged() bool

	// MarkAsChanged & HasChanged are methods of convenience
	MarkAsChanged()
}

type RecordAfterLoadHook interface {
	AfterLoad(ctx context.Context, key *Key) (err error)
}

type RecordBeforeSaveHook interface {
	BeforeSave(ctx context.Context, key *Key) (err error)
}

type RecordDataHook = func(ctx context.Context, db DB, key *Key, data any) (err error)

type RecordDataOption = func(rd *recordData)

type RecordHook = func(ctx context.Context, record Record) error

type Setter interface {

	// Set stores a single record into database by key
	Set(ctx context.Context, record Record) error
}

type SingleSource interface {
	Where(conditions ...Condition) QueryBuilder
}

type Transaction interface {

	// Options indicates parameters that were requested at time of transaction creation.
	Options() TransactionOptions
}

type TransactionCoordinator interface {

	// ReadTransactionCoordinator can start a readonly transaction
	ReadTransactionCoordinator

	// ReadwriteTransactionCoordinator can start a readwrite transaction
	ReadwriteTransactionCoordinator
}

type TransactionOption func(options *txOptions)

type TransactionOptions interface {

	// IsolationLevel indicates requested isolation level
	IsolationLevel() TxIsolationLevel

	// IsReadonly indicates a readonly transaction
	IsReadonly() bool

	// IsCrossGroup indicates a cross-group transaction. Makes sense for Google App Engine.
	IsCrossGroup() bool

	// Attempts returns number of attempts to execute a transaction. This is used in Google Datastore for example.
	Attempts() int
}

type Transform interface {

	// Name returns Name of a transform
	Name() string

	// Value returns arguments of transform
	Value() any
}

type TxIsolationLevel int

type Update struct {
	Field     string
	FieldPath FieldPath
	Value     any
}

type Updater interface {

	// Update updates a single record in database by key
	Update(ctx context.Context, key *Key, updates []Update, preconditions ...Precondition) error
}

type ValidatableRecord interface {
	Validate() error
}

type WriteSession interface {
	//Connection // TODO
	Setter
	MultiSetter
	Deleter
	MultiDeleter
	Updater
	MultiUpdater
	Inserter
}