tx

type ErrTagTransactionTimeout struct{ errtag.Internal }

type PGXRepositoryTxer[R any] struct {
	Config PGXRepositoryTxerConfig[R]
	// contains filtered or unexported fields
}

type PGXRepositoryTxerConfig[R any] struct {
	// Timeout is the maximum duration allowed for the entire transaction. Must
	// be a positive duration up to 10 seconds otherwise DefaultTimeout
	// is used.
	Timeout time.Duration

	// WithTxFunc returns a tx-bound copy of the repo using the provided
	// transaction. If the PGXRepositoryTxer already represents an in-flight
	// transaction, the original repo is returned unchanged (ambient tx reuse).
	//
	// The function must:
	//   - Clone the repo value passed in.
	//   - Bind the clone to the provided transaction (e.g. sqlc.Queries.WithTx).
	//   - Set the provided *PGXRepositoryTxer on the clone so nested calls reuse
	//     the ambient transaction.
	//   - Return the clone.
	//
	// NOTE: WithTxFunc receives a copied PGXRepositoryTxer whose transaction is
	// set for the lifetime of the new repository instance.
	WithTxFunc func(repo R, txer *PGXRepositoryTxer[R], tx pgx.Tx) R
}

type PGXTxer interface {
	BeginTx(ctx context.Context, txOptions pgx.TxOptions) (pgx.Tx, error)
}

type Repository[R any] interface {
	// WithTx returns a copy of the repository bound to the provided transaction.
	// The returned repository executes all database operations using the given
	// transaction context.
	//
	// This is typically called by BeginTxFunc to build a new repository instance
	// scoped to the lifetime of the transaction. Nested transactional calls
	// reuse the existing transaction, returning the original repository unchanged.
	WithTx(tx Tx) R

	// BeginTxFunc begins a new transaction (unless one is already in progress)
	// and executes fn with a tx-bound repository. The transaction is
	// automatically committed if fn returns nil, or rolled back if fn returns
	// an error or panics.
	//
	// Nested Behavior:
	//
	//   - If a transaction is already active (i.e. called within another
	//     BeginTxFunc or WithTx context), the existing transaction is reused
	//     and fn is invoked directly without starting a new transaction.
	//
	// Panic Semantics:
	//
	//   - If fn panics, the transaction helper will attempt to roll back and
	//     re-panic. If rollback itself fails, the panic message is annotated
	//     accordingly.
	//
	// Timeouts:
	//
	//   - Transactions should be configured with a timeout to avoid deadlocks.
	//     When timeout occurs, the returned error must be tagged with
	//     ErrTagTransactionTimeout.
	BeginTxFunc(ctx context.Context, fn func(ctx context.Context, tx Tx, repo R) error) error
}

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

type SQLiteRepositoryTxer[R any] struct {
	Config SQLiteRepositoryTxerConfig[R]
	// contains filtered or unexported fields
}

type SQLiteRepositoryTxerConfig[R any] struct {
	// Timeout is the maximum duration allowed for the entire transaction. Must
	// be a positive duration up to 10 seconds otherwise DefaultTimeout
	// is used.
	//
	// Timeout is applied by:
	//   - Running the transaction under a context deadline.
	//   - Setting PRAGMA busy_timeout to the same duration (unless NoPragma
	//     is true).
	Timeout time.Duration

	// NoPragma disables PRAGMA statements (e.g. busy_timeout) inside
	// transactions. Set this to true when using a SQLite driver or backend
	// that does not support PRAGMAs.
	NoPragma bool

	// WithTxFunc returns a tx-bound copy of the repo using the provided
	// transaction. If the SQLiteRepositoryTxer already represents an in-flight
	// transaction, the original repo is returned unchanged (ambient tx reuse).
	//
	// The function must:
	//   - Clone the repo value passed in.
	//   - Bind the clone to the provided transaction (e.g. sqlc.Queries.WithTx).
	//   - Set the provided *SQLiteRepositoryTxer on the clone so nested calls
	//     reuse the ambient transaction.
	//   - Return the clone.
	//
	// NOTE: WithTxFunc receives a copied SQLiteRepositoryTxer whose transaction
	// is set for the lifetime of the new repository instance.
	WithTxFunc func(repo R, txer *SQLiteRepositoryTxer[R], tx *sql.Tx) R
}

type SQLiteTxer interface {
	BeginTx(ctx context.Context, opts *sql.TxOptions) (*sql.Tx, error)
	Conn(ctx context.Context) (*sql.Conn, error)
}

type Tx interface {
	Commit(ctx context.Context) error
	Rollback(ctx context.Context) error
}