Refactor database interface to use *sql.DB directly

Simplified the database layer by removing custom interface wrappers
and using standard library *sql.DB and *sql.Tx types directly.

Changes:
- Removed DBConnection and DBTransaction interfaces from database.go
- Removed NewDBConnection() wrapper function
- Updated TokenGenerator to use *sql.DB instead of DBConnection
- Updated all validation and revocation methods to accept *sql.Tx
- Updated TableManager to work with *sql.DB directly
- Updated all tests to use db.Begin() instead of custom wrappers
- Fixed GeneratorConfig.DB field (was DBConn)
- Updated documentation in doc.go with correct API usage

Benefits:
- Simpler API with fewer abstractions
- Works directly with database/sql standard library
- Compatible with GORM (via gormDB.DB()) and Bun (share same *sql.DB)
- Easier to understand and maintain
- No unnecessary wrapper layers

Breaking changes:
- GeneratorConfig.DBConn renamed to GeneratorConfig.DB
- Removed NewDBConnection() function - pass *sql.DB directly
- ValidateAccess/ValidateRefresh now accept *sql.Tx instead of DBTransaction
- Token.Revoke/CheckNotRevoked now accept *sql.Tx instead of DBTransaction

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

hws/logger.go

@@ -5,21 +5,61 @@ import (
 	"fmt"
 	"net/url"
 
-	"github.com/rs/zerolog"
+	"git.haelnorr.com/h/golib/hlog"
 )
 
 type logger struct {
-	logger       *zerolog.Logger
+	logger       *hlog.Logger
 	ignoredPaths []string
 }
 
+// TODO: add tests to make sure all the fields are correctly set
+func (s *Server) LogError(err HWSError) {
+	if s.logger == nil {
+		return
+	}
+	switch err.Level {
+	case ErrorDEBUG:
+		s.logger.logger.Debug().Err(err.Error).Msg(err.Message)
+		return
+	case ErrorINFO:
+		s.logger.logger.Info().Err(err.Error).Msg(err.Message)
+		return
+	case ErrorWARN:
+		s.logger.logger.Warn().Err(err.Error).Msg(err.Message)
+		return
+	case ErrorERROR:
+		s.logger.logger.Error().Err(err.Error).Msg(err.Message)
+		return
+	case ErrorFATAL:
+		s.logger.logger.Fatal().Err(err.Error).Msg(err.Message)
+		return
+	case ErrorPANIC:
+		s.logger.logger.Panic().Err(err.Error).Msg(err.Message)
+		return
+	default:
+		s.logger.logger.Error().Err(err.Error).Msg(err.Message)
+	}
+}
+
+func (server *Server) LogFatal(err error) {
+	if err == nil {
+		err = errors.New("LogFatal was called with a nil error")
+	}
+	if server.logger == nil {
+		fmt.Printf("FATAL - %s: %s", "A fatal error has occured", err.Error())
+		return
+	}
+	server.logger.logger.Fatal().Err(err).Msg("A fatal error has occured")
+}
+
 // Server.AddLogger adds a logger to the server to use for request logging.
-func (server *Server) AddLogger(zlogger *zerolog.Logger) error {
-	if zlogger == nil {
+func (server *Server) AddLogger(hlogger *hlog.Logger) error {
+	if hlogger == nil {
 		return errors.New("Unable to add logger, no logger provided")
 	}
 	server.logger = &logger{
-		logger: zlogger,
+		logger: hlogger,
 	}
 	return nil
 }