dal

type Adapter interface {

	// Name of the dalgo adapter
	Name() string

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

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

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

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

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

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

	// Schema provides schema for the DB - for example, how keys are mapped to columns
	Schema() Schema

	// TransactionCoordinator provides shortcut methods to work with transactions
	// without opening a 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 DataToKeyFunc func(incompleteKey *Key, data any) (key *Key, err error)

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 ExtraField interface {
	Name() string
	Value() any
}

type FieldName string

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

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

type FromSource interface {
	Base() RecordsetSource
	Join(joint JoinedSource) FromSource
	Joins() []JoinedSource
	NewQuery() *QueryBuilder
}

type Getter interface {

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

	// Exists returns true if a record with the given key exists
	Exists(ctx context.Context, key *Key) (bool, error)
}

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

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

type IQueryBuilder interface {
	Clone() IQueryBuilder
	Offset(int) IQueryBuilder
	Limit(int) IQueryBuilder
	Where(conditions ...Condition) IQueryBuilder
	WhereField(name string, operator Operator, v any) IQueryBuilder
	WhereInArrayField(name string, v any) IQueryBuilder
	OrderBy(expressions ...OrderExpression) IQueryBuilder
	SelectIntoRecord(func() Record) StructuredQuery
	SelectIntoRecordset(options ...recordset.Option) StructuredQuery
	SelectKeysOnly(idKind reflect.Kind) StructuredQuery
	StartFrom(cursor Cursor) IQueryBuilder
}

type InsertOption func(options *insertOptions)

type InsertOptions interface {
	IDGenerator() IDGenerator
}

type Inserter interface {

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

type JoinedSource struct {
	RecordsetSource
	// contains filtered or unexported fields
}

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

type KeyOption = func(*Key) error

type KeyToFieldsFunc func(key *Key, data any) (fields []ExtraField, err error)

type MultiDeleter interface {

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

type MultiGetter interface {

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

type MultiInserter interface {
	// InsertMulti inserts multiple record intoRecord a database at once if possible, or fallback to batch of single inserts
	InsertMulti(ctx context.Context, records []Record, opts ...InsertOption) error
}

type MultiSetter interface {

	// SetMulti stores multiples records intoRecord 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.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 {
	String() string

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

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

	GetRecordsReader(ctx context.Context, qe QueryExecutor) (reader RecordsReader, err error)
	GetRecordsetReader(ctx context.Context, qe QueryExecutor) (reader RecordsetReader, err error)
}

type QueryArg struct {
	Name  string
	Value any
}

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

type QueryExecutor interface {

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

	// ExecuteQueryToRecordsetReader returns a RecordsetReader for the given query, allowing sequential read of records into the provided recordset.
	ExecuteQueryToRecordsetReader(ctx context.Context, query Query, options ...recordset.Option) (RecordsetReader, 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 {
	// 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 struct {
	// contains filtered or unexported fields
}

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 fields  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 RecordsReader interface {
	Reader
	// Next returns the next record for a query.
	// If no more records, a nil record and ErrNoMoreRecords are returned.
	Next() (Record, error)
}

type RecordsetReader interface {
	Reader
	Recordset() recordset.Recordset
	Next() (row recordset.Row, rs recordset.Recordset, err error)
}

type RecordsetSource interface {
	Name() string
	Alias() string
	// contains filtered or unexported methods
}

type Schema interface {
	DataToKey(incompleteKey *Key, data any) (key *Key, err error)
	KeyToFields(key *Key, data any) (fields []ExtraField, err error)
}

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

type Setter interface {

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

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

type StructuredQuery interface {
	Query

	// From - defines target table/recordsetSource
	From() FromSource

	// Where defines filter condition
	Where() Condition

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

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

	// Columns specifies columns to return
	Columns() []Column

	// IntoRecord provides a function that creates a record for a new row
	IntoRecord() Record // TODO: Should this be moved into Query.GetRecordsReader ?

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

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

type TextQuery interface {
	Query
	Text() string
	Args() []QueryArg
}

type TimeStampAccuracy int

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 {

	// Name describes what will be done in transaction.
	// This is useful for mocking transaction in tests
	Name() string

	// 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 Updater interface {

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

	// UpdateRecord updates a single record in a database.
	// For example, this is useful in case if we want to put the record.Data to memcache.
	// See https://github.com/dal-go/dalgo-memcache-appengine
	// A regular DB adapter should call update(record.Key()) inside this method.
	UpdateRecord(ctx context.Context, record Record, updates []update.Update, preconditions ...Precondition) error
}

type ValidatableRecord interface {
	Validate() error
}

type WriteSession interface {
	Setter
	MultiSetter
	Deleter
	MultiDeleter
	Updater
	MultiUpdater
	Inserter
	MultiInserter
}