feat: cleanup API

Author: roman-vanesyan

shield.go

@@ -2,6 +2,8 @@ package shield
 
 import (
 	"errors"
+	"log/slog"
+	"os"
 
 	"github.com/google/uuid"
 )
@@ -19,6 +21,8 @@ var (
 	ErrUserNotFound        = errors.New("shield: user not found")
 )
 
+var DefaultLogger = slog.New(slog.NewTextHandler(os.Stdout, nil))
+
 type User[T any] struct {
 	// ID is the user ID.
 	ID uuid.UUID

shieldpassword/form_handler.go

@@ -1,6 +1,7 @@
 package shieldpassword
 
 import (
+	"cmp"
 	"errors"
 	"fmt"
 	"net/http"
@@ -9,6 +10,7 @@ import (
 	"github.com/go-playground/mold/v4/scrubbers"
 	"github.com/go-playground/validator/v10"
 	"github.com/jackc/pgx/v5/pgxpool"
+	"go.inout.gg/foundations/debug"
 	"go.inout.gg/foundations/http/httperror"
 	"go.inout.gg/shield"
 )
@@ -35,29 +37,30 @@ type FormConfig[T any] struct {
 	PasswordFieldName  string // optional (default: DefaultFieldNamePassword)
 }
 
-// NewFormConfig[T] creates a new FormConfig[T] with the given configuration options.
-func NewFormConfig[T any](config ...func(*FormConfig[T])) *FormConfig[T] {
-	cfg := &FormConfig[T]{
-		FirstNameFieldName: DefaultFieldNameFirstName,
-		LastNameFieldName:  DefaultFieldNameLastName,
-		EmailFieldName:     DefaultFieldNameEmail,
-		PasswordFieldName:  DefaultFieldNamePassword,
+func (c *FormConfig[T]) defaults() {
+	c.FirstNameFieldName = cmp.Or(c.FirstNameFieldName, DefaultFieldNameEmail)
+	c.LastNameFieldName = cmp.Or(c.LastNameFieldName, DefaultFieldNameEmail)
+	c.EmailFieldName = cmp.Or(c.EmailFieldName, DefaultFieldNameEmail)
+	c.PasswordFieldName = cmp.Or(c.PasswordFieldName, DefaultFieldNameEmail)
+	if c.Config == nil {
+		c.Config = NewConfig[T]()
 	}
+}
 
-	for _, f := range config {
-		f(cfg)
-	}
+func (c *FormConfig[T]) assert() {
+	debug.Assert(c.Config != nil, "Config must be set")
+}
 
-	// Set defaults.
-	if cfg.Config == nil {
-		cfg.Config = NewConfig[T]()
+// NewFormConfig[T] creates a new FormConfig[T] with the given configuration options.
+func NewFormConfig[T any](opts ...func(*FormConfig[T])) *FormConfig[T] {
+	var config FormConfig[T]
+	for _, opt := range opts {
+		opt(&config)
 	}
 
-	return cfg
-}
+	config.defaults()
 
-func WithConfig[T any](config *Config[T]) func(*FormConfig[T]) {
-	return func(cfg *FormConfig[T]) { cfg.Config = config }
+	return &config
 }
 
 // FormHandler[T] is a wrapper around Handler handling HTTP form requests.
@@ -67,14 +70,25 @@ type FormHandler[T any] struct {
 }
 
 // NewFormHandler[T] creates a new FormHandler[T] with the given configuration.
+//
+// If config is nil, the default config is used.
 func NewFormHandler[T any](pool *pgxpool.Pool, config *FormConfig[T]) *FormHandler[T] {
-	return &FormHandler[T]{
-		&Handler[T]{
-			config: config.Config,
-			pool:   pool,
-		},
+	if config == nil {
+		config = NewFormConfig[T]()
+	}
+	config.assert()
+
+	h := FormHandler[T]{
+		NewHandler(pool, config.Config),
 		config,
 	}
+	h.assert()
+
+	return &h
+}
+
+func (h *FormHandler[T]) assert() {
+	debug.Assert(h.handler != nil, "handler must be set")
 }
 
 // userRegistrationForm is the form for user login.

shieldpassword/handler.go

@@ -1,6 +1,7 @@
 package shieldpassword
 
 import (
+	"cmp"
 	"context"
 	"fmt"
 	"log/slog"
@@ -24,9 +25,20 @@ var (
 
 // Config is the configuration for the password handler.
 type Config[T any] struct {
-	Logger         *slog.Logger
-	PasswordHasher PasswordHasher
-	Hijacker       Hijacker[T]
+	Logger           *slog.Logger
+	PasswordHasher   PasswordHasher
+	PasswordVerifier shieldpasswordverifier.PasswordVerifier
+	Hijacker         Hijacker[T]
+}
+
+func (c *Config[T]) defaults() {
+	c.Logger = cmp.Or(c.Logger, shield.DefaultLogger)
+	c.PasswordHasher = cmp.Or(c.PasswordHasher, DefaultPasswordHasher)
+}
+
+func (c *Config[T]) assert() {
+	debug.Assert(c.PasswordHasher != nil, "PasswordHasher must be set")
+	debug.Assert(c.Logger != nil, "Logger must be set")
 }
 
 // Hijacker also to hijack into the user registration and logging in sessions
@@ -46,42 +58,49 @@ type Hijacker[T any] interface {
 // NewConfig creates a new config.
 //
 // If no password hasher is configured, the DefaultPasswordHasher will be used.
-func NewConfig[T any](config ...func(*Config[T])) *Config[T] {
-	cfg := Config[T]{}
-
-	for _, c := range config {
-		c(&cfg)
-	}
-
-	if cfg.PasswordHasher == nil {
-		cfg.PasswordHasher = DefaultPasswordHasher
+func NewConfig[T any](opts ...func(*Config[T])) *Config[T] {
+	config := Config[T]{}
+	for _, opt := range opts {
+		opt(&config)
 	}
 
-	debug.Assert(cfg.PasswordHasher != nil, "PasswordHasher must be set")
+	config.defaults()
+	config.assert()
 
-	return &cfg
+	return &config
 }
 
 // WithPasswordHasher configures the password hasher.
 //
 // When setting a password hasher make sure to set it across all modules,
-// such as user registration, password reset and password verification.
+// i.e., user registration, password reset and password verification.
 func WithPasswordHasher[T any](hasher PasswordHasher) func(*Config[T]) {
 	return func(cfg *Config[T]) { cfg.PasswordHasher = hasher }
 }
 
-func WithLogger[T any](logger *slog.Logger) func(*Config[T]) {
-	return func(cfg *Config[T]) { cfg.Logger = logger }
-}
-
 func WithHijacker[T any](hijacker Hijacker[T]) func(*Config[T]) {
 	return func(cfg *Config[T]) { cfg.Hijacker = hijacker }
 }
 
 type Handler[T any] struct {
-	config           *Config[T]
-	pool             *pgxpool.Pool
-	PasswordVerifier shieldpasswordverifier.PasswordVerifier
+	pool   *pgxpool.Pool
+	config *Config[T]
+}
+
+func NewHandler[T any](pool *pgxpool.Pool, config *Config[T]) *Handler[T] {
+	if config == nil {
+		config = NewConfig[T]()
+	}
+	config.assert()
+
+	h := Handler[T]{pool, config}
+	h.assert()
+
+	return &h
+}
+
+func (h *Handler[T]) assert() {
+	debug.Assert(h.pool != nil, "Logger must be set")
 }
 
 func (h *Handler[T]) HandleUserRegistration(
@@ -147,6 +166,7 @@ func (h *Handler[T]) handleUserRegistrationTx(
 		Email: email,
 	}); err != nil {
 		if sqldb.IsUniqueViolationError(err) {
+			d("unique error violation")
 			return uid, ErrEmailAlreadyTaken
 		}
 

shieldpassword/handler_test.go

@@ -2,7 +2,6 @@ package shieldpassword
 
 import (
 	"context"
-	"log/slog"
 	"testing"
 	"time"
 
@@ -14,18 +13,9 @@ import (
 func TestUserRegistration(t *testing.T) {
 	ctx := context.Background()
 	db := testutil.MustDB(ctx, t)
-	logger := slog.Default()
-	config := &Config[any]{
-		PasswordHasher: DefaultPasswordHasher,
-		Logger:         logger,
-	}
+	config := NewConfig[any]()
 	pool := db.Pool()
-	h := &Handler[any]{
-		config:           config,
-		pool:             pool,
-		PasswordVerifier: nil,
-	}
-
+	h := NewHandler(pool, config)
 	t.Run("register user", func(t *testing.T) {
 		ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
 		defer cancel()

shieldpassword/shieldpassword.go

@@ -9,9 +9,7 @@ type PasswordHasher interface {
 	Verify(hashedPassword string, password string) (bool, error)
 }
 
-var (
-	// DefaultPasswordHasher is the default password hashing algorithm used across.
-	DefaultPasswordHasher = NewBcryptPasswordHasher(BcryptDefaultCost)
-)
+// DefaultPasswordHasher is the default password hashing algorithm used across.
+var DefaultPasswordHasher = NewBcryptPasswordHasher(BcryptDefaultCost)
 
 var d = debug.Debuglog("shield/password")

shieldpasswordreset/form_handler.go

@@ -6,6 +6,7 @@ import (
 	"net/http"
 
 	"github.com/jackc/pgx/v5/pgxpool"
+	"go.inout.gg/foundations/debug"
 	"go.inout.gg/foundations/http/httperror"
 	"go.inout.gg/shield"
 	"go.inout.gg/shield/shieldpassword"
@@ -29,8 +30,8 @@ type FormConfig struct {
 
 // FormHandler is a wrapper around Handler handling HTTP form requests.
 type FormHandler struct {
-	config  *FormConfig
 	handler *Handler
+	config  *FormConfig
 }
 
 // NewFormConfig creates a new FormConfig with the given configuration options.
@@ -72,18 +73,27 @@ type confirmForm struct {
 }
 
 // NewFormHandler creates a new FormHandler with the given configuration.
+//
+// If config is nil, it
 func NewFormHandler(
 	pool *pgxpool.Pool,
 	sender shieldsender.Sender,
 	config *FormConfig,
 ) *FormHandler {
-	handler := &Handler{
-		pool,
-		config.Config,
-		sender,
+	if config == nil {
+		config = NewFormConfig()
 	}
+	config.assert()
+
+	h := FormHandler{NewHandler(pool, sender, config.Config), config}
+	h.assert()
+
+	return &h
+}
 
-	return &FormHandler{config, handler}
+func (h *FormHandler) assert() {
+	debug.Assert(h.config != nil, "config must be set")
+	debug.Assert(h.handler != nil, "handler must be set")
 }
 
 func (h *FormHandler) parsePasswordResetRequestForm(