mirror of
https://github.com/zitadel/zitadel.git
synced 2025-08-12 10:37:32 +00:00
7708fdbbf4
This PR enhances error handling in the database package by introducing custom error types that wrap dialect-specific errors, providing better abstraction and context for error handling across the application. * Introduces standardized custom error types for common database errors (no rows found, integrity violations, etc.) * Wraps all PostgreSQL-specific errors at the dialect layer to provide consistent error handling # Which Problems Are Solved The database package didn't wrap the errors from dialect specifc packages. # How the Problems Are Solved Custom errors were added which wrap the dialect specifc errors. --------- Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
101 lines
2.4 KiB
Go
101 lines
2.4 KiB
Go
package postgres
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
|
|
"github.com/zitadel/zitadel/backend/v3/storage/database"
|
|
"github.com/zitadel/zitadel/backend/v3/storage/database/dialect/postgres/migration"
|
|
)
|
|
|
|
type pgxPool struct {
|
|
*pgxpool.Pool
|
|
}
|
|
|
|
var _ database.Pool = (*pgxPool)(nil)
|
|
|
|
func PGxPool(pool *pgxpool.Pool) *pgxPool {
|
|
return &pgxPool{
|
|
Pool: pool,
|
|
}
|
|
}
|
|
|
|
// Acquire implements [database.Pool].
|
|
func (c *pgxPool) Acquire(ctx context.Context) (database.Client, error) {
|
|
conn, err := c.Pool.Acquire(ctx)
|
|
if err != nil {
|
|
return nil, wrapError(err)
|
|
}
|
|
return &pgxConn{Conn: conn}, nil
|
|
}
|
|
|
|
// Query implements [database.Pool].
|
|
// 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...)
|
|
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 &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...)
|
|
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, wrapError(err)
|
|
}
|
|
return &pgxTx{tx}, nil
|
|
}
|
|
|
|
// Close implements [database.Pool].
|
|
func (c *pgxPool) Close(_ context.Context) error {
|
|
c.Pool.Close()
|
|
return nil
|
|
}
|
|
|
|
// Migrate implements [database.Migrator].
|
|
func (c *pgxPool) Migrate(ctx context.Context) error {
|
|
if isMigrated {
|
|
return nil
|
|
}
|
|
|
|
client, err := c.Pool.Acquire(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
err = migration.Migrate(ctx, client.Conn())
|
|
isMigrated = err == nil
|
|
return wrapError(err)
|
|
}
|
|
|
|
// Migrate implements [database.PoolTest].
|
|
func (c *pgxPool) MigrateTest(ctx context.Context) error {
|
|
client, err := c.Pool.Acquire(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
err = migration.Migrate(ctx, client.Conn())
|
|
isMigrated = err == nil
|
|
return err
|
|
}
|