upgrade from go-pg to bun

Author: dhax

README.md

@@ -14,7 +14,7 @@ The following feature set is a minimal selection of typical Web API requirements
 
 - Configuration using [viper](https://github.com/spf13/viper)
 - CLI features using [cobra](https://github.com/spf13/cobra)
-- PostgreSQL support including migrations using [go-pg](https://github.com/go-pg/pg)
+- PostgreSQL support including migrations using [bun](https://github.com/uptrace/bun)
 - Structured logging with [Logrus](https://github.com/sirupsen/logrus)
 - Routing with [chi router](https://github.com/go-chi/chi) and middleware
 - JWT Authentication using [lestrrat-go/jwx](https://github.com/lestrrat-go/jwx) with example passwordless email authentication
@@ -35,8 +35,8 @@ The following feature set is a minimal selection of typical Web API requirements
 ### Using Docker Compose
 
 - First start the database only: `docker compose up -d postgres`
-- Once initialize the database by running all migrations in database/migrate folder: `docker compose exec server ./main migrate`
-- Start the api server: `docker compose up server`
+- Once initialize the database by running all migrations in database/migrate folder: `docker compose run server ./main migrate`
+- Start the api server: `docker compose up`
 
 ## API Routes
 
@@ -53,7 +53,7 @@ For passwordless login following routes are available:
 
 ### Example API
 
-Besides /auth/_ the API provides two main routes /api/_ and /admin/\*, as an example to separate application and administration context. The latter requires to be logged in as administrator by providing the respective JWT in Authorization Header.
+Besides /auth/_the API provides two main routes /api/_ and /admin/\*, as an example to separate application and administration context. The latter requires to be logged in as administrator by providing the respective JWT in Authorization Header.
 
 Check [routes.md](routes.md) for a generated overview of the provided API routes.
 
@@ -71,9 +71,10 @@ Outgoing emails containing the login token will be print to stdout if no valid e
 
 Use one of the following bootstrapped users for login:
 
-- admin@boot.io (has access to admin panel)
-- user@boot.io
+- <admin@example.com> (has access to admin panel)
+- <user@example.com>
 
+TODO: deploy somewhere else...
 A deployed version can also be found on [Heroku](https://govue.herokuapp.com)
 
 ### Testing
@@ -94,7 +95,7 @@ By default viper will look at $HOME/.go-base.yaml for a config file. Setting you
 | DB_USER                 | string        | postgres                    | database user name                                                                                                                                                                                        |
 | DB_PASSWORD             | string        | postgres                    | database user password                                                                                                                                                                                    |
 | DB_DATABASE             | string        | postgres                    | database shema name                                                                                                                                                                                       |
-| AUTH_LOGIN_URL          | string        | http://localhost:3000/login | client login url as sent in login token email                                                                                                                                                             |
+| AUTH_LOGIN_URL          | string        | <http://localhost:3000/login> | client login url as sent in login token email                                                                                                                                                             |
 | AUTH_LOGIN_TOKEN_LENGTH | int           | 8                           | length of login token                                                                                                                                                                                     |
 | AUTH_LOGIN_TOKEN_EXPIRY | time.Duration | 11m                         | login token expiry                                                                                                                                                                                        |
 | AUTH_JWT_SECRET         | string        | random                      | jwt sign and verify key - value "random" creates random 32 char secret at startup (and automatically invalidates existing tokens on app restarts, so during dev you might want to set a fixed value here) |

api/admin/api.go

@@ -5,9 +5,9 @@ import (
 	"net/http"
 
 	"github.com/sirupsen/logrus"
+	"github.com/uptrace/bun"
 
 	"github.com/go-chi/chi/v5"
-	"github.com/go-pg/pg"
 
 	"github.com/dhax/go-base/auth/authorize"
 	"github.com/dhax/go-base/database"
@@ -30,8 +30,7 @@ type API struct {
 }
 
 // NewAPI configures and returns admin application API.
-func NewAPI(db *pg.DB) (*API, error) {
-
+func NewAPI(db *bun.DB) (*API, error) {
 	accountStore := database.NewAdmAccountStore(db)
 	accounts := NewAccountResource(accountStore)
 

api/api.go

@@ -82,8 +82,7 @@ func New(enableCORS bool) (*chi.Mux, error) {
 		w.Write([]byte("pong"))
 	})
 
-	client := "./public"
-	r.Get("/*", SPAHandler(client))
+	r.Get("/*", SPAHandler("public"))
 
 	return r, nil
 }

api/app/api.go

@@ -5,8 +5,8 @@ import (
 	"net/http"
 
 	"github.com/go-chi/chi/v5"
-	"github.com/go-pg/pg"
 	"github.com/sirupsen/logrus"
+	"github.com/uptrace/bun"
 
 	"github.com/dhax/go-base/database"
 	"github.com/dhax/go-base/logging"
@@ -26,7 +26,7 @@ type API struct {
 }
 
 // NewAPI configures and returns application API.
-func NewAPI(db *pg.DB) (*API, error) {
+func NewAPI(db *bun.DB) (*API, error) {
 	accountStore := database.NewAccountStore(db)
 	account := NewAccountResource(accountStore)
 

auth/jwt/token.go

@@ -3,24 +3,24 @@ package jwt
 import (
 	"time"
 
-	"github.com/go-pg/pg/orm"
+	"github.com/uptrace/bun"
 )
 
 // Token holds refresh jwt information.
 type Token struct {
-	ID        int       `json:"id,omitempty"`
-	CreatedAt time.Time `json:"created_at,omitempty"`
-	UpdatedAt time.Time `json:"updated_at,omitempty"`
-	AccountID int       `json:"-"`
+	ID        int       `bun:"id,pk,autoincrement" json:"id,omitempty"`
+	CreatedAt time.Time `bun:"created_at,nullzero,notnull,default:current_timestamp" json:"created_at,omitempty"`
+	UpdatedAt time.Time `bun:"updated_at,nullzero,notnull,default:current_timestamp" json:"updated_at,omitempty"`
+	AccountID int       `bun:"account_id,notnull" json:"-"`
 
-	Token      string    `json:"-"`
-	Expiry     time.Time `json:"-"`
-	Mobile     bool      `sql:",notnull" json:"mobile"`
-	Identifier string    `json:"identifier,omitempty"`
+	Token      string    `bun:"token,notnull" json:"-"`
+	Expiry     time.Time `bun:"expiry,notnull" json:"-"`
+	Mobile     bool      `bun:"mobile,notnull" json:"mobile"`
+	Identifier string    `bun:"identifier" json:"identifier,omitempty"`
 }
 
 // BeforeInsert hook executed before database insert operation.
-func (t *Token) BeforeInsert(db orm.DB) error {
+func (t *Token) BeforeInsert(db *bun.DB) error {
 	now := time.Now()
 	if t.CreatedAt.IsZero() {
 		t.CreatedAt = now
@@ -30,7 +30,7 @@ func (t *Token) BeforeInsert(db orm.DB) error {
 }
 
 // BeforeUpdate hook executed before database update operation.
-func (t *Token) BeforeUpdate(db orm.DB) error {
+func (t *Token) BeforeUpdate(db *bun.DB) error {
 	t.UpdatedAt = time.Now()
 	return nil
 }

auth/pwdless/account.go

@@ -6,28 +6,28 @@ import (
 
 	validation "github.com/go-ozzo/ozzo-validation"
 	"github.com/go-ozzo/ozzo-validation/is"
-	"github.com/go-pg/pg/orm"
+	"github.com/uptrace/bun"
 
 	"github.com/dhax/go-base/auth/jwt"
 )
 
 // Account represents an authenticated application user
 type Account struct {
-	ID        int       `json:"id"`
-	CreatedAt time.Time `json:"created_at,omitempty"`
-	UpdatedAt time.Time `json:"updated_at,omitempty"`
-	LastLogin time.Time `json:"last_login,omitempty"`
+	ID        int       `bun:"id,pk,autoincrement" json:"id"`
+	CreatedAt time.Time `bun:"created_at,nullzero,notnull,default:current_timestamp" json:"created_at,omitempty"`
+	UpdatedAt time.Time `bun:"updated_at,nullzero,notnull,default:current_timestamp" json:"updated_at,omitempty"`
+	LastLogin time.Time `bun:"last_login" json:"last_login,omitempty"`
 
-	Email  string   `json:"email"`
-	Name   string   `json:"name"`
-	Active bool     `sql:",notnull" json:"active"`
-	Roles  []string `pg:",array" json:"roles,omitempty"`
+	Email  string   `bun:"email,notnull" json:"email"`
+	Name   string   `bun:"name,notnull" json:"name"`
+	Active bool     `bun:"active,notnull" json:"active"`
+	Roles  []string `bun:"roles,array" json:"roles,omitempty"`
 
-	Token []jwt.Token `json:"token,omitempty"`
+	Token []jwt.Token `bun:"rel:has-many" json:"token,omitempty"`
 }
 
 // BeforeInsert hook executed before database insert operation.
-func (a *Account) BeforeInsert(db orm.DB) error {
+func (a *Account) BeforeInsert(db *bun.DB) error {
 	now := time.Now()
 	if a.CreatedAt.IsZero() {
 		a.CreatedAt = now
@@ -37,13 +37,13 @@ func (a *Account) BeforeInsert(db orm.DB) error {
 }
 
 // BeforeUpdate hook executed before database update operation.
-func (a *Account) BeforeUpdate(db orm.DB) error {
+func (a *Account) BeforeUpdate(db *bun.DB) error {
 	a.UpdatedAt = time.Now()
 	return a.Validate()
 }
 
 // BeforeDelete hook executed before database delete operation.
-func (a *Account) BeforeDelete(db orm.DB) error {
+func (a *Account) BeforeDelete(db *bun.DB) error {
 	return nil
 }
 

cmd/migrate.go

@@ -3,30 +3,16 @@ package cmd
 import (
 	"github.com/spf13/cobra"
 
-	"github.com/dhax/go-base/database/migrate"
+	"github.com/dhax/go-base/database/migrations"
 )
 
-var reset bool
-
 // migrateCmd represents the migrate command
 var migrateCmd = &cobra.Command{
 	Use:   "migrate",
-	Short: "use go-pg migration tool",
-	Long:  `migrate uses go-pg migration tool under the hood supporting the same commands and an additional reset command`,
+	Short: "use bun migration tool",
+	Long:  `run bun migrations`,
 	Run: func(cmd *cobra.Command, args []string) {
-		argsMig := args[:0]
-		for _, arg := range args {
-			switch arg {
-			case "migrate", "--db_debug", "--reset":
-			default:
-				argsMig = append(argsMig, arg)
-			}
-		}
-
-		if reset {
-			migrate.Reset()
-		}
-		migrate.Migrate(argsMig)
+		migrations.Migrate()
 	},
 }
 
@@ -42,5 +28,4 @@ func init() {
 	// Cobra supports local flags which will only run when this command
 	// is called directly, e.g.:
 	// migrateCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
-	migrateCmd.Flags().BoolVar(&reset, "reset", false, "migrate down to version 0 then up to latest. WARNING: all data will be lost!")
 }

database/accountStore.go

@@ -1,72 +1,94 @@
 package database
 
 import (
+	"context"
+	"database/sql"
+
 	"github.com/dhax/go-base/auth/jwt"
 	"github.com/dhax/go-base/auth/pwdless"
 	"github.com/dhax/go-base/models"
-	"github.com/go-pg/pg"
+	"github.com/uptrace/bun"
 )
 
 // AccountStore implements database operations for account management by user.
 type AccountStore struct {
-	db *pg.DB
+	db *bun.DB
 }
 
 // NewAccountStore returns an AccountStore.
-func NewAccountStore(db *pg.DB) *AccountStore {
+func NewAccountStore(db *bun.DB) *AccountStore {
 	return &AccountStore{
 		db: db,
 	}
 }
 
 // Get an account by ID.
 func (s *AccountStore) Get(id int) (*pwdless.Account, error) {
-	a := pwdless.Account{ID: id}
-	err := s.db.Model(&a).
-		Where("account.id = ?id").
-		Column("account.*", "Token").
-		First()
-	return &a, err
+	a := &pwdless.Account{ID: id}
+	err := s.db.NewSelect().
+		Model(a).
+		Where("id = ?", id).
+		Relation("Token").
+		Scan(context.Background())
+	return a, err
 }
 
 // Update an account.
 func (s *AccountStore) Update(a *pwdless.Account) error {
-	_, err := s.db.Model(a).
+	_, err := s.db.NewUpdate().
+		Model(a).
 		Column("email", "name").
 		WherePK().
-		Update()
+		Exec(context.Background())
 	return err
 }
 
 // Delete an account.
 func (s *AccountStore) Delete(a *pwdless.Account) error {
-	err := s.db.RunInTransaction(func(tx *pg.Tx) error {
-		if _, err := tx.Model(&jwt.Token{}).
-			Where("account_id = ?", a.ID).
-			Delete(); err != nil {
-			return err
-		}
-		if _, err := tx.Model(&models.Profile{}).
-			Where("account_id = ?", a.ID).
-			Delete(); err != nil {
-			return err
-		}
-		return tx.Delete(a)
-	})
-	return err
+	ctx := context.Background()
+	tx, err := s.db.BeginTx(ctx, &sql.TxOptions{})
+	if err != nil {
+		return err
+	}
+	if _, err := tx.NewDelete().
+		Model((*jwt.Token)(nil)).
+		Where("account_id = ?", a.ID).
+		Exec(ctx); err != nil {
+		tx.Rollback()
+		return err
+	}
+	if _, err := tx.NewDelete().
+		Model((*models.Profile)(nil)).
+		Where("account_id = ?", a.ID).
+		Exec(ctx); err != nil {
+		tx.Rollback()
+		return err
+	}
+	if _, err := tx.NewDelete().
+		Model(a).
+		WherePK().
+		Exec(ctx); err != nil {
+		tx.Rollback()
+	}
+	tx.Commit()
+	return nil
 }
 
 // UpdateToken updates a jwt refresh token.
 func (s *AccountStore) UpdateToken(t *jwt.Token) error {
-	_, err := s.db.Model(t).
+	_, err := s.db.NewUpdate().
+		Model(t).
 		Column("identifier").
 		WherePK().
-		Update()
+		Exec(context.Background())
 	return err
 }
 
 // DeleteToken deletes a jwt refresh token.
 func (s *AccountStore) DeleteToken(t *jwt.Token) error {
-	err := s.db.Delete(t)
+	_, err := s.db.NewDelete().
+		Model(t).
+		WherePK().
+		Exec(context.Background())
 	return err
 }