database

type AccessMode uint8

type Beginner interface {
	Begin(ctx context.Context, opts *TransactionOptions) (Transaction, error)
}

type Boolean interface {
	~bool
}

type Bytes interface {
	~[]byte
}

type BytesOperation uint8

type CTEChange interface {
	Change
	// WriteCTE writes the CTE part of the change to the given statement builder.
	// It writes the part inside the brackets meaning without the "WITH cte_name AS (" and the ending ")".
	WriteCTE(builder *StatementBuilder)
	// SetName sets the name of the CTE.
	// This is defined by the caller to ensure uniqueness.
	// The name is used to reference the CTE in the main change.
	SetName(name string)
}

type Change interface {
	gomock.Matcher

	// Write writes the change to the given statement builder.
	Write(builder *StatementBuilder) error
	// IsOnColumn checks if the change is on the given column.
	IsOnColumn(col Column) bool
	// contains filtered or unexported methods
}

type Changes []Change

type CheckError struct {
	IntegrityViolationError
}

type CollectableRows interface {
	// Collect collects all rows and scans them into dest.
	// dest must be a pointer to a slice of pointer to structs
	// e.g. *[]*MyStruct
	// Rows are closed after this call.
	Collect(dest any) error
	// CollectFirst collects the first row and scans it into dest.
	// dest must be a pointer to a struct
	// e.g. *MyStruct{}
	// Rows are closed after this call.
	CollectFirst(dest any) error
	// CollectExactlyOneRow collects exactly one row and scans it into dest.
	// e.g. *MyStruct{}
	// Rows are closed after this call.
	CollectExactlyOneRow(dest any) error
}

type Column interface {
	gomock.Matcher

	// WriteQualified writes the column with the table name as prefix.
	WriteQualified(builder *StatementBuilder)
	// WriteUnqualified writes the column without the table name as prefix.
	WriteUnqualified(builder *StatementBuilder)
	// Equals checks if two columns are equal.
	Equals(col Column) bool
	// contains filtered or unexported methods
}

type Columns []Column

type Condition interface {
	gomock.Matcher
	Write(builder *StatementBuilder)
	// IsRestrictingColumn is used to check if the condition filters for a specific column.
	// It acts as a safeguard database operations that should be specific on the given column.
	IsRestrictingColumn(col Column) bool
}

type Config struct {
	Raw map[string]any `mapstructure:",remain" yaml:",inline"`
}

type Connection interface {
	Beginner
	QueryExecutor
	Migrator

	Release(ctx context.Context) error

	Ping(ctx context.Context) error
}

type Connector interface {
	Connect(ctx context.Context) (Pool, error)
}

type DialectDecoder func(value any) (Connector, error)

type Executor interface {
	Exec(ctx context.Context, stmt string, args ...any) (int64, error)
}

type ForeignKeyError struct {
	IntegrityViolationError
}

type Identity string

type Instruction string

type IntegrityType string

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

type IsolationLevel uint8

type Migrator interface {
	// Migrate executes migrations to set up the database.
	// The method can be called once per running Zitadel.
	Migrate(ctx context.Context) error
}

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

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

type NoChange interface {
	NoChange() bool
}

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

type NotNullError struct {
	IntegrityViolationError
}

type Null[T any] = sql.Null[T]

type Number interface {
	constraints.Integer | constraints.Float | constraints.Complex | time.Time | time.Duration
}

type NumberOperation uint8

type Operation interface {
	NumberOperation | TextOperation | BytesOperation
}

type Order interface {
	Write(builder *StatementBuilder)
}

type OrderDirection uint8

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

type Pool interface {
	Beginner
	QueryExecutor
	Migrator

	Acquire(ctx context.Context) (Connection, error)
	Close(ctx context.Context) error

	Ping(ctx context.Context) error
}

type PoolTest interface {
	Pool
	// MigrateTest is the same as [Migrator] but executes the migrations multiple times instead of only once.
	MigrateTest(ctx context.Context) error
	// RawDB returns an *[sql.DB] handle backed by the same database as the [PoolTest].
	// The returned handle is intended for use in tests, and the caller is responsible for closing it when done.
	RawDB() *sql.DB
}

type Querier interface {
	Query(ctx context.Context, stmt string, args ...any) (Rows, error)
	QueryRow(ctx context.Context, stmt string, args ...any) Row
}

type QueryExecutor interface {
	Querier
	Executor
}

type QueryOption func(opts *QueryOpts)

type QueryOpts struct {
	// Condition is the condition to filter the results.
	// It is used to build the WHERE clause of the SQL statement.
	Condition Condition
	// Extra holds optional structured data decoded by repositories (e.g. user list filters).
	Extra any
	// OrderBy is the columns to order the results by.
	// It is used to build the ORDER BY clause of the SQL statement.
	OrderBy Columns
	// Ordering defines if the columns should be ordered ascending or descending.
	// Default is ascending.
	Ordering OrderDirection
	// Limit is the maximum number of results to return.
	// It is used to build the LIMIT clause of the SQL statement.
	Limit uint32
	// Offset is the number of results to skip before returning the results.
	// It is used to build the OFFSET clause of the SQL statement.
	Offset uint32
	// GroupBy is the columns to group the results by.
	// It is used to build the GROUP BY clause of the SQL statement.
	GroupBy Columns
	// Joins is a list of joins to be applied to the query.
	// It is used to build the JOIN clauses of the SQL statement.
	Joins []join
	// Permission required to read or write the resource.
	// When unset, no permission check is made.
	Permission string
	// ShouldLock the results during the transaction.
	ShouldLock bool
}

type Row interface {
	Scanner
}

type Rows interface {
	Scanner
	Next() bool
	Close() error
	Err() error
}

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

type Scanner interface {
	Scan(dest ...any) error
}

type StatementBuilder struct {
	strings.Builder
	// contains filtered or unexported fields
}

type Text interface {
	~string | Bytes
}

type TextOperation uint8

type Transaction interface {
	Beginner

	// Commit marks a transaction as successful and commits it to the database.
	Commit(ctx context.Context) error
	// Rollback undoes all changes made in the transaction.
	Rollback(ctx context.Context) error
	// End commits the transaction if err is nil, otherwise rollbacks.
	//
	// If err is nil the returned error is from Commit.
	// If err is not nil, and rollback is successful, the original err is returned.
	// If err is not nil, and rollback fails, the two errors are joined using [errors.Join].
	End(ctx context.Context, err error) error

	QueryExecutor
}

type TransactionOptions struct {
	IsolationLevel IsolationLevel
	AccessMode     AccessMode
}

type UniqueError struct {
	IntegrityViolationError
}

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

type Value interface {
	Boolean | Number | Text | Instruction | Bytes | any
}