[v0.4] Move lasso SQL cache in Steve (#473)

* Copy pkg/cache/sql from lasso to pkg/sqlcache

* Rename import from github.com/rancher/lasso/pkg/cache/sql to github.com/rancher/steve/pkg/sqlcache

* go mod tidy

* Fix lint errors

* Remove lasso SQL cache mentions

* Fix more CI lint errors

* fix goimports

Signed-off-by: Silvio Moioli <silvio@moioli.net>

* Fix imports

* Fix more linting errors

---------

Signed-off-by: Silvio Moioli <silvio@moioli.net>
Co-authored-by: Silvio Moioli <silvio@moioli.net>

pkg/sqlcache/db/transaction/transaction.go

@@ -0,0 +1,90 @@
+/*
+Package transaction provides a client for a live transaction, and interfaces for some relevant sql types. The transaction client automatically performs rollbacks  on failures.
+The use of this package simplifies testing for callers by making the underlying transaction mock-able.
+*/
+package transaction
+
+import (
+	"context"
+	"database/sql"
+
+	"github.com/pkg/errors"
+)
+
+// Client provides a way to interact with the underlying sql transaction.
+type Client struct {
+	sqlTx SQLTx
+}
+
+// SQLTx represents a sql transaction
+type SQLTx interface {
+	Exec(query string, args ...any) (sql.Result, error)
+	Stmt(stmt *sql.Stmt) *sql.Stmt
+	Commit() error
+	Rollback() error
+}
+
+// Stmt represents a sql stmt. It is used as a return type to offer some testability over returning sql's Stmt type
+// because we are able to mock its outputs and do not need an actual connection.
+type Stmt interface {
+	Exec(args ...any) (sql.Result, error)
+	Query(args ...any) (*sql.Rows, error)
+	QueryContext(ctx context.Context, args ...any) (*sql.Rows, error)
+}
+
+// NewClient returns a Client with the given transaction assigned.
+func NewClient(tx SQLTx) *Client {
+	return &Client{sqlTx: tx}
+}
+
+// Commit commits the transaction and then unlocks the database.
+func (c *Client) Commit() error {
+	return c.sqlTx.Commit()
+}
+
+// Exec uses the sqlTX Exec() with the given stmt and args. The transaction will be automatically rolled back if Exec()
+// returns an error.
+func (c *Client) Exec(stmt string, args ...any) error {
+	_, err := c.sqlTx.Exec(stmt, args...)
+	if err != nil {
+		return c.rollback(c.sqlTx, err)
+	}
+	return nil
+}
+
+// Stmt adds the given sql.Stmt to the client's transaction and then returns a Stmt. An interface is being returned
+// here to aid in testing callers by providing a way to configure the statement's behavior.
+func (c *Client) Stmt(stmt *sql.Stmt) Stmt {
+	s := c.sqlTx.Stmt(stmt)
+	return s
+}
+
+// StmtExec Execs the given statement with the given args. It assumes the stmt has been added to the transaction. The
+// transaction is rolled back if Stmt.Exec() returns an error.
+func (c *Client) StmtExec(stmt Stmt, args ...any) error {
+	_, err := stmt.Exec(args...)
+	if err != nil {
+		return c.rollback(c.sqlTx, err)
+	}
+	return nil
+}
+
+// rollback handles rollbacks and wraps errors if needed
+func (c *Client) rollback(tx SQLTx, err error) error {
+	rerr := tx.Rollback()
+	if rerr != nil {
+		return errors.Wrapf(err, "Encountered error, then encountered another error while rolling back: %v", rerr)
+	}
+	return errors.Wrapf(err, "Encountered error, successfully rolled back")
+}
+
+// Cancel rollbacks the transaction without wrapping an error. This only needs to be called if Client has not returned
+// an error yet or has not committed. Otherwise, transaction has already rolled back, or in the case of Commit() it is too
+// late.
+func (c *Client) Cancel() error {
+	rerr := c.sqlTx.Rollback()
+	if rerr != sql.ErrTxDone {
+		return rerr
+	}
+	return nil
+}