domain

type CRUD[T any, I comparable] interface {
	// GetAll retrieves all entities of type T from the database.
	GetAll(ctx context.Context, dest *[]T) error

	// GetByID retrieves a single entity by its ID.
	// Returns an error if the entity is not found.
	GetByID(ctx context.Context, dest *T, id I) error

	// GetByIDs retrieves multiple entities by their IDs.
	// The returned slice maintains the same order as the input IDs.
	GetByIDs(ctx context.Context, dest *[]T, ids []I) error

	// Create inserts a new entity into the database.
	// The entity pointer must not be nil.
	Create(ctx context.Context, e *T) (sql.Result, error)

	// DeleteAll removes all entities of type T from the database.
	DeleteAll(ctx context.Context) (sql.Result, error)

	// Delete removes a single entity by its ID.
	Delete(ctx context.Context, id I) (sql.Result, error)

	// Update modifies an existing entity identified by its ID.
	// The entity pointer must not be nil.
	Update(ctx context.Context, id I, e *T) (sql.Result, error)
}

type DebugFunc func(sql string, args ...any)

type NewPageOpt[T any] func(*NewPageOptsObj[T])

type NewPageOptsObj[T any] struct {
	Content         *[]T
	ContentInitSize *int
}

type Page[T any] struct {
	Number     uint   // Current page number (0-based)
	Size       uint   // Number of items in the current page
	Total      uint64 // Total number of items across all pages
	TotalPages uint   // Total number of pages
	Content    []T    // Slice containing the page's items
}

type PageOpt func(*PageOpts)

type PageOpts struct {
	PageNumber uint     // The current page number (0-based)
	PageSize   uint     // Number of items per page
	SortBy     []string // List of columns to sort by
	SortDesc   bool     // If true, sort in descending order
}

type PageResolver[T any] interface {
	// GetPage retrieves a single page of results based on the provided pagination options.
	GetPage(ctx context.Context, dest *Page[T], opts ...PageOpt) error

	// Count returns the total number of items available across all pages.
	// This is useful for calculating total pages and displaying pagination metadata.
	Count(ctx context.Context) (uint64, error)
}

type SQLExecutor interface {
	// SelectOne executes a query that is expected to return at most one row.
	// It scans the resulting row into the dest parameter, which must be a pointer.
	// Returns an error if the query fails or if scanning into dest fails.
	SelectOne(ctx context.Context, dest any, query string, args ...any) error

	// SelectMany executes a query that can return multiple rows.
	// It scans all resulting rows into the dest parameter, which must be a pointer to a slice.
	// Returns an error if the query fails or if scanning into dest fails.
	SelectMany(ctx context.Context, dest any, query string, args ...any) error

	// Exec executes a query that doesn't return rows (like INSERT, UPDATE, DELETE).
	// Returns a Result object summarizing the effect of the query and any error encountered.
	Exec(ctx context.Context, query string, args ...any) (sql.Result, error)
}

type Transaction[T any, I comparable] interface {
	SQLExecutor
	CRUD[T, I]
	PageResolver[T]

	// Commit commits the transaction
	Commit() error

	// Rollback aborts the transaction
	Rollback() error
}

type TransactionExecutor[T any, I comparable] interface {
	// BeginTx creates and starts new transaction.
	// Returns the transaction object and any error encountered during transaction creation.
	BeginTx(ctx context.Context, opts *sql.TxOptions) (Transaction[T, I], error)
}