Merge branch 'error-handling' into rt-domains

backend/v3/storage/database/dialect/postgres/config.go

@@ -41,10 +41,10 @@ type Config struct {
 func (c *Config) Connect(ctx context.Context) (database.Pool, error) {
 	pool, err := c.getPool(ctx)
 	if err != nil {
-		return nil, err
+		return nil, wrapError(err)
 	}
 	if err = pool.Ping(ctx); err != nil {
-		return nil, err
+		return nil, wrapError(err)
 	}
 	return &pgxPool{Pool: pool}, nil
 }

backend/v3/storage/database/dialect/postgres/conn.go

@@ -25,7 +25,7 @@ func (c *pgxConn) Release(_ context.Context) error {
 func (c *pgxConn) Begin(ctx context.Context, opts *database.TransactionOptions) (database.Transaction, error) {
 	tx, err := c.Conn.BeginTx(ctx, transactionOptionsToPgx(opts))
 	if err != nil {
-		return nil, err
+		return nil, wrapError(err)
 	}
 	return &pgxTx{tx}, nil
 }
@@ -34,20 +34,26 @@ func (c *pgxConn) Begin(ctx context.Context, opts *database.TransactionOptions)
 // Subtle: this method shadows the method (*Conn).Query of pgxConn.Conn.
 func (c *pgxConn) Query(ctx context.Context, sql string, args ...any) (database.Rows, error) {
 	rows, err := c.Conn.Query(ctx, sql, args...)
-	return &Rows{rows}, err
+	if err != nil {
+		return nil, wrapError(err)
+	}
+	return &Rows{rows}, nil
 }
 
 // QueryRow implements sql.Client.
 // Subtle: this method shadows the method (*Conn).QueryRow of pgxConn.Conn.
 func (c *pgxConn) QueryRow(ctx context.Context, sql string, args ...any) database.Row {
-	return c.Conn.QueryRow(ctx, sql, args...)
+	return &Row{c.Conn.QueryRow(ctx, sql, args...)}
 }
 
 // Exec implements [database.Pool].
 // Subtle: this method shadows the method (Pool).Exec of pgxPool.Pool.
 func (c *pgxConn) Exec(ctx context.Context, sql string, args ...any) (int64, error) {
 	res, err := c.Conn.Exec(ctx, sql, args...)
-	return res.RowsAffected(), err
+	if err != nil {
+		return 0, wrapError(err)
+	}
+	return res.RowsAffected(), nil
 }
 
 // Migrate implements [database.Migrator].
@@ -57,5 +63,5 @@ func (c *pgxConn) Migrate(ctx context.Context) error {
 	}
 	err := migration.Migrate(ctx, c.Conn.Conn())
 	isMigrated = err == nil
-	return err
+	return wrapError(err)
 }

backend/v3/storage/database/dialect/postgres/error.go

@@ -0,0 +1,38 @@
+package postgres
+
+import (
+	"errors"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+
+	"github.com/zitadel/zitadel/backend/v3/storage/database"
+)
+
+func wrapError(err error) error {
+	if err == nil {
+		return nil
+	}
+	if errors.Is(err, pgx.ErrNoRows) {
+		return database.NewNoRowFoundError(err)
+	}
+	var pgxErr *pgconn.PgError
+	if !errors.As(err, &pgxErr) {
+		return database.NewUnknownError(err)
+	}
+	switch pgxErr.Code {
+	// 23514: check_violation - A value violates a CHECK constraint.
+	case "23514":
+		return database.NewCheckError(pgxErr.TableName, pgxErr.ConstraintName, pgxErr)
+	// 23505: unique_violation - A value violates a UNIQUE constraint.
+	case "23505":
+		return database.NewUniqueError(pgxErr.TableName, pgxErr.ConstraintName, pgxErr)
+	// 23503: foreign_key_violation - A value violates a foreign key constraint.
+	case "23503":
+		return database.NewForeignKeyError(pgxErr.TableName, pgxErr.ConstraintName, pgxErr)
+	// 23502: not_null_violation - A value violates a NOT NULL constraint.
+	case "23502":
+		return database.NewNotNullError(pgxErr.TableName, pgxErr.ConstraintName, pgxErr)
+	}
+	return database.NewUnknownError(err)
+}

backend/v3/storage/database/dialect/postgres/pool.go

@@ -25,7 +25,7 @@ func PGxPool(pool *pgxpool.Pool) *pgxPool {
 func (c *pgxPool) Acquire(ctx context.Context) (database.Client, error) {
 	conn, err := c.Pool.Acquire(ctx)
 	if err != nil {
-		return nil, err
+		return nil, wrapError(err)
 	}
 	return &pgxConn{Conn: conn}, nil
 }
@@ -34,27 +34,33 @@ func (c *pgxPool) Acquire(ctx context.Context) (database.Client, error) {
 // Subtle: this method shadows the method (Pool).Query of pgxPool.Pool.
 func (c *pgxPool) Query(ctx context.Context, sql string, args ...any) (database.Rows, error) {
 	rows, err := c.Pool.Query(ctx, sql, args...)
-	return &Rows{rows}, err
+	if err != nil {
+		return nil, wrapError(err)
+	}
+	return &Rows{rows}, nil
 }
 
 // QueryRow implements [database.Pool].
 // Subtle: this method shadows the method (Pool).QueryRow of pgxPool.Pool.
 func (c *pgxPool) QueryRow(ctx context.Context, sql string, args ...any) database.Row {
-	return c.Pool.QueryRow(ctx, sql, args...)
+	return &Row{c.Pool.QueryRow(ctx, sql, args...)}
 }
 
 // Exec implements [database.Pool].
 // Subtle: this method shadows the method (Pool).Exec of pgxPool.Pool.
 func (c *pgxPool) Exec(ctx context.Context, sql string, args ...any) (int64, error) {
 	res, err := c.Pool.Exec(ctx, sql, args...)
-	return res.RowsAffected(), err
+	if err != nil {
+		return 0, wrapError(err)
+	}
+	return res.RowsAffected(), nil
 }
 
 // Begin implements [database.Pool].
 func (c *pgxPool) Begin(ctx context.Context, opts *database.TransactionOptions) (database.Transaction, error) {
 	tx, err := c.Pool.BeginTx(ctx, transactionOptionsToPgx(opts))
 	if err != nil {
-		return nil, err
+		return nil, wrapError(err)
 	}
 	return &pgxTx{tx}, nil
 }
@@ -78,7 +84,7 @@ func (c *pgxPool) Migrate(ctx context.Context) error {
 
 	err = migration.Migrate(ctx, client.Conn())
 	isMigrated = err == nil
-	return err
+	return wrapError(err)
 }
 
 // Migrate implements [database.PoolTest].

backend/v3/storage/database/dialect/postgres/rows.go

@@ -10,10 +10,29 @@ import (
 var (
 	_ database.Rows            = (*Rows)(nil)
 	_ database.CollectableRows = (*Rows)(nil)
+	_ database.Row             = (*Row)(nil)
 )
 
+type Row struct{ pgx.Row }
+
+// Scan implements [database.Row].
+// Subtle: this method shadows the method ([pgx.Row]).Scan of Row.Row.
+func (r *Row) Scan(dest ...any) error {
+	return wrapError(r.Row.Scan(dest...))
+}
+
 type Rows struct{ pgx.Rows }
 
+// Err implements [database.Rows].
+// Subtle: this method shadows the method ([pgx.Rows]).Err of Rows.Rows.
+func (r *Rows) Err() error {
+	return wrapError(r.Rows.Err())
+}
+
+func (r *Rows) Scan(dest ...any) error {
+	return wrapError(r.Rows.Scan(dest...))
+}
+
 // Collect implements [database.CollectableRows].
 // See [this page](https://github.com/georgysavva/scany/blob/master/dbscan/doc.go#L8) for additional details.
 func (r *Rows) Collect(dest any) (err error) {
@@ -23,7 +42,7 @@ func (r *Rows) Collect(dest any) (err error) {
 			err = closeErr
 		}
 	}()
-	return pgxscan.ScanAll(dest, r.Rows)
+	return wrapError(pgxscan.ScanAll(dest, r.Rows))
 }
 
 // CollectFirst implements [database.CollectableRows].
@@ -35,7 +54,7 @@ func (r *Rows) CollectFirst(dest any) (err error) {
 			err = closeErr
 		}
 	}()
-	return pgxscan.ScanRow(dest, r.Rows)
+	return wrapError(pgxscan.ScanRow(dest, r.Rows))
 }
 
 // CollectExactlyOneRow implements [database.CollectableRows].
@@ -47,7 +66,7 @@ func (r *Rows) CollectExactlyOneRow(dest any) (err error) {
 			err = closeErr
 		}
 	}()
-	return pgxscan.ScanOne(dest, r.Rows)
+	return wrapError(pgxscan.ScanOne(dest, r.Rows))
 }
 
 // Close implements [database.Rows].

backend/v3/storage/database/dialect/postgres/tx.go

@@ -15,12 +15,14 @@ var _ database.Transaction = (*pgxTx)(nil)
 
 // Commit implements [database.Transaction].
 func (tx *pgxTx) Commit(ctx context.Context) error {
-	return tx.Tx.Commit(ctx)
+	err := tx.Tx.Commit(ctx)
+	return wrapError(err)
 }
 
 // Rollback implements [database.Transaction].
 func (tx *pgxTx) Rollback(ctx context.Context) error {
-	return tx.Tx.Rollback(ctx)
+	err := tx.Tx.Rollback(ctx)
+	return wrapError(err)
 }
 
 // End implements [database.Transaction].
@@ -39,20 +41,26 @@ func (tx *pgxTx) End(ctx context.Context, err error) error {
 // Subtle: this method shadows the method (Tx).Query of pgxTx.Tx.
 func (tx *pgxTx) Query(ctx context.Context, sql string, args ...any) (database.Rows, error) {
 	rows, err := tx.Tx.Query(ctx, sql, args...)
-	return &Rows{rows}, err
+	if err != nil {
+		return nil, wrapError(err)
+	}
+	return &Rows{rows}, nil
 }
 
 // QueryRow implements [database.Transaction].
 // Subtle: this method shadows the method (Tx).QueryRow of pgxTx.Tx.
 func (tx *pgxTx) QueryRow(ctx context.Context, sql string, args ...any) database.Row {
-	return tx.Tx.QueryRow(ctx, sql, args...)
+	return &Row{tx.Tx.QueryRow(ctx, sql, args...)}
 }
 
 // Exec implements [database.Transaction].
 // Subtle: this method shadows the method (Pool).Exec of pgxPool.Pool.
 func (tx *pgxTx) Exec(ctx context.Context, sql string, args ...any) (int64, error) {
 	res, err := tx.Tx.Exec(ctx, sql, args...)
-	return res.RowsAffected(), err
+	if err != nil {
+		return 0, wrapError(err)
+	}
+	return res.RowsAffected(), nil
 }
 
 // Begin implements [database.Transaction].
@@ -60,7 +68,7 @@ func (tx *pgxTx) Exec(ctx context.Context, sql string, args ...any) (int64, erro
 func (tx *pgxTx) Begin(ctx context.Context) (database.Transaction, error) {
 	savepoint, err := tx.Tx.Begin(ctx)
 	if err != nil {
-		return nil, err
+		return nil, wrapError(err)
 	}
 	return &pgxTx{savepoint}, nil
 }