implementing auth module

Author: codetheuri

cmd/genmodule/main.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"bufio"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -25,8 +26,9 @@ import (
 	{{.ModuleName}}Services "{{.ProjectRoot}}/internal/app/modules/{{.ModuleName}}/services"
 	"{{.ProjectRoot}}/pkg/logger"
 	"{{.ProjectRoot}}/pkg/validators"
-	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/chi"
 	"gorm.io/gorm"
+	"net/http"
 )
 
 // Module represents the {{.CapitalizedModuleName}} module.
@@ -37,7 +39,7 @@ type Module struct {
 
 // NewModule initializes  {{.CapitalizedModuleName}} module.
 func NewModule(db *gorm.DB, log logger.Logger, validator *validators.Validator) *Module {
-     repo := {{.ModuleName}}Repositories.NewGorm{{.CapitalizedModuleName}}Repository(db, log)
+     repo := {{.ModuleName}}Repositories.New{{.CapitalizedModuleName}}Repository(db, log)
 	 service := {{.ModuleName}}Services.New{{.CapitalizedModuleName}}Service(repo, validator, log)
 	 handler := {{.ModuleName}}Handlers.New{{.CapitalizedModuleName}}Handler(service, log)
 
@@ -49,31 +51,35 @@ func NewModule(db *gorm.DB, log logger.Logger, validator *validators.Validator)
 // RegisterRoutes registers the routes for the {{.CapitalizedModuleName}} module.
 func (m *Module) RegisterRoutes(r chi.Router) {
 	// Register the routes for the {{.ModuleName}} module
-	r.Route("/{{.ModuleName}}s", func(r chi.Router) {
-		r.Post("/", m.Handlers.Create{{.CapitalizedModuleName}})
-		r.Get("/", m.Handlers.GetAll{{.CapitalizedModuleName}}s)
+	r.Route("/{{.ModuleName}}", func(r chi.Router) {
+	r.Get("/test", func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte("Module {{.ModuleName}} is working!"))
+	})
+		//r.Post("/", m.Handlers.Create{{.CapitalizedModuleName}})
+		//r.Get("/", m.Handlers.GetAll{{.CapitalizedModuleName}}s)
 		
 	})
 }
 `
 
 const handlersGoTemplate = `package handlers
 import (
-   	"context"
-	"net/http"
+   //	"context"
+	//"net/http"
 	{{.ModuleName}}Services "{{.ProjectRoot}}/internal/app/modules/{{.ModuleName}}/services"
 	"{{.ProjectRoot}}/pkg/logger"
-	"{{.ProjectRoot}}/pkg/web"
-	"{{.ProjectRoot}}/internal/app/modules/{{.ModuleName}}/models"
+	//"{{.ProjectRoot}}/pkg/web"
+	//"{{.ProjectRoot}}/internal/app/modules/{{.ModuleName}}/models"
 )
 
 type {{.CapitalizedModuleName}}Handler struct {
-       {{.ModuleName}}Service *{{.ModuleName}}Services.{{.CapitalizedModuleName}}Service
+       {{.ModuleName}}Service {{.ModuleName}}Services.{{.CapitalizedModuleName}}Service
 	   log logger.Logger
 }
 
 // constructor for {{.CapitalizedModuleName}}Handler
-func New{{.CapitalizedModuleName}}Handler({{.ModuleName}}Service *{{.ModuleName}}Services.{{.CapitalizedModuleName}}Service, log logger.Logger) *{{.CapitalizedModuleName}}Handler {
+func New{{.CapitalizedModuleName}}Handler({{.ModuleName}}Service {{.ModuleName}}Services.{{.CapitalizedModuleName}}Service, log logger.Logger) *{{.CapitalizedModuleName}}Handler {
 	return &{{.CapitalizedModuleName}}Handler{
 		{{.ModuleName}}Service: {{.ModuleName}}Service,
 		log: log,
@@ -93,9 +99,9 @@ func New{{.CapitalizedModuleName}}Handler({{.ModuleName}}Service *{{.ModuleName}
 
 const servicesGoTemplate = `package services
 import (
-	"context"
+	//"context"
 	{{.ModuleName}}Repositories "{{.ProjectRoot}}/internal/app/modules/{{.ModuleName}}/repositories"
-	"{{.ProjectRoot}}/internal/app/modules/{{.ModuleName}}/models"
+	//"{{.ProjectRoot}}/internal/app/modules/{{.ModuleName}}/models"
 	"{{.ProjectRoot}}/pkg/logger"
 	"{{.ProjectRoot}}/pkg/validators"
 )
@@ -105,15 +111,15 @@ type {{.CapitalizedModuleName}}Service interface {
 	//Get{{.CapitalizedModuleName}}ByID(ctx context.Context, id int) (*models.{{.CapitalizedModuleName}}, error)
 }
 
-type {{.CapitalizedModuleName}}Service struct {
-	{{.ModuleName}}Repo {{.ModuleName}}Repositories.{{.CapitalizedModuleName}}Repository
+type {{.ModuleName}}Service struct {
+	Repo {{.ModuleName}}Repositories.{{.CapitalizedModuleName}}Repository
 	validator *validators.Validator
 	log logger.Logger
 }
 
 //service constructor
-func New{{.CapitalizedModuleName}}Service({{.ModuleName}}Repo {{.ModuleName}}Repositories.{{.CapitalizedModuleName}}Repository, validator *validators.Validator, log logger.Logger) *{{.CapitalizedModuleName}}Service {
-	return &{{.CapitalizedModuleName}}Service{
+func New{{.CapitalizedModuleName}}Service(Repo {{.ModuleName}}Repositories.{{.CapitalizedModuleName}}Repository, validator *validators.Validator, log logger.Logger) {{.CapitalizedModuleName}}Service {
+	return &{{.ModuleName}}Service{
 		Repo: Repo,
 		validator: validator,
 		log: log,
@@ -129,8 +135,8 @@ func New{{.CapitalizedModuleName}}Service({{.ModuleName}}Repo {{.ModuleName}}Rep
 `
 const repositoriesGoTemplate = `package repositories
  import (
-      "context"
-	  "{{.ProjectRoot}}/internal/app/modules/{{.ModuleName}}/models"
+    //  "context"
+	//  "{{.ProjectRoot}}/internal/app/modules/{{.ModuleName}}/models"
 	  "{{.ProjectRoot}}/pkg/logger"
 	  "gorm.io/gorm"
  )
@@ -139,11 +145,17 @@ const repositoriesGoTemplate = `package repositories
 	// Example method:
 	// Create{{.CapitalizedModuleName}}(ctx context.Context, {{.ModuleName}} *models.{{.CapitalizedModuleName}}) error
 }
-	type gorm{{.CapitalizedModuleName}}Repository struct {
+	type {{.ModuleName}}Repository struct {
 	db *gorm.DB
 	log logger.Logger 
 	}
-
+	// repo constructor
+func New{{.CapitalizedModuleName}}Repository(db *gorm.DB, log logger.Logger) {{.CapitalizedModuleName}}Repository {	
+	return &{{.ModuleName}}Repository{
+		db: db,
+		log: log,
+	}
+	}
 	//repos methods
 	//eg.
 	// func (r *gorm{{.CapitalizedModuleName}}Repository) Create{{.CapitalizedModuleName}}(ctx context.Context, {{.ModuleName}} *models.{{.CapitalizedModuleName}}) error {
@@ -162,13 +174,36 @@ func main(){
 	moduleName := strings.ToLower(os.Args[1])
 	capitalizedModuleName := strings.ToUpper(moduleName[:1]) + moduleName[1:]
 
+	if strings.Contains(moduleName, "-") || strings.Contains(moduleName, "_") {
+		fmt.Println("Module name cannot contain '-' or '_' characters. Please use a valid module name.")
+		os.Exit(1)
+	}
+	if moduleName == "main" || moduleName == "cmd" || moduleName == "internal" || moduleName == "pkg" {
+		fmt.Printf("Module name '%s' is reserved. Please choose a different name.\n", moduleName)
+		os.Exit(1)
+	}
+
 	moduleData := ModuleData{
 		ModuleName: moduleName,
 		CapitalizedModuleName: capitalizedModuleName,
 		ProjectRoot: projectGoModulePath,
 	}
 	basePath := filepath.Join("internal", "app", "modules", moduleName)
 
+	if _, err := os.Stat(basePath); !os.IsNotExist(err) {
+		reader := bufio.NewReader(os.Stdin)
+		fmt.Printf("Module '%s' already exists at %s . Overwrite? (Y/N): ", moduleName, basePath)
+
+		response, _ := reader.ReadString('\n')
+		response = strings.ToLower(strings.TrimSpace(response))
+
+		if response != "y"{
+			fmt.Println("Operation cancelled")
+			os.Exit(0)
+		}
+		fmt.Printf("proceeding to overwrite module '%s'....\n", moduleName)
+	}
+
 	dirs := []string{
 		basePath,
 		filepath.Join(basePath, "handlers"),
@@ -216,7 +251,7 @@ func main(){
 
 	fmt.Printf("\nModule '%s' generated successfully. Remember to:\n", moduleName)
 	fmt.Println("- Add it to 'internal/bootstrap/app.go' in the appModules slice.")
-	fmt.Printf("- **Crucially, create your model file(s) in 'internal/app/modules/%s/models/' (e.g., %s.go) and define your structs with 'package models'.**", moduleName, moduleName)
+	fmt.Printf("- **Crucially, create your model file(s) in 'internal/app/modules/%s/models/'.**\n",  moduleName)
 	fmt.Println("- Adjust generated boilerplate code (e.g., imports, methods, model usage).")
 	fmt.Println("- Run 'go mod tidy' after adding to app.go.")
 

config/config.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"strconv"
+	"time"
 
 	"github.com/codetheuri/todolist/pkg/errors"
 	"gorm.io/driver/mysql"
@@ -27,6 +28,7 @@ type Config struct {
 	ServerPort        int
 	LOG_LEVEL         string
 	JWTSecret         string
+	AccessTokenTTL    time.Duration `mapstructure:"ACCESS_TOKEN_TTL"`
 	AppName           string
 	AppVersion        string
 	AppMode           string
@@ -50,6 +52,7 @@ func LoadConfig() (*Config, error) {
 		DBDriver:          os.Getenv("DB_DRIVER"),
 		LOG_LEVEL:         os.Getenv("LOG_LEVEL"),
 		JWTSecret:         os.Getenv("JWT_SECRET"),
+		// AccessTokenTTL:    os.Getenv("ACCESS_TOKEN_TTL"),
 		AppName:           os.Getenv("APP_NAME"),
 		AppVersion:        os.Getenv("APP_VERSION"),
 		AppMode:           os.Getenv("APP_MODE"),
@@ -82,6 +85,7 @@ func LoadConfig() (*Config, error) {
 	if err != nil {
 		return nil, errors.ConfigError(fmt.Sprintf("Invalid SERVER_PORT value : %s", serverPortStr), err)
 	}
+
 	cfg.ServerPort = serverPort
 
 	//basic validation

database/migrations/20250717130322_create_auth_tables.go

@@ -0,0 +1,72 @@
+package migrations
+
+import (
+	"log"
+
+	"github.com/codetheuri/todolist/internal/app/modules/auth/models"
+	"gorm.io/gorm"
+)
+
+// Createauthtables struct implements migration interface
+		type Createauthtables struct {}
+
+		func (m *Createauthtables) Version() string{
+			return "20250717130322"
+			}
+		func (m *Createauthtables) Name() string {
+			return "create_auth_tables"
+		}	
+			//up migration method
+		func (m *Createauthtables) Up(tx *gorm.DB) error {
+		log.Printf("Running Up migration: %s", m.Name())
+		// Add your migration logic here
+		//example : 
+		// 1. using SQL calls
+		// if  err := tx.Exec("CREATE TABLE IF NOT EXISTS example (id INT PRIMARY KEY)").Error; err != nil {
+		// 	return err
+		// }
+
+		// 2. using gorm methods
+		//type NewModel struct {
+		// gorm.Model
+		// Field1 string
+		//}
+		// if err := tx.AutoMigrate(&NewModel{}); err != nil {
+		// 	return err
+		// }
+		if err:= tx.AutoMigrate(&models.User{}); err!= nil {
+			return err
+		} 
+		if err := tx.AutoMigrate(&models.RevokedToken{}); err != nil {
+			return err
+		}
+		log.Printf("Successfully applied Up migration: %s", m.Name())
+		return nil
+		}
+		//down migration method
+		func (m *Createauthtables) Down(tx *gorm.DB) error {
+		log.Printf("Running Down migration: %s", m.Name())
+		// Example:
+		// 1. using SQL calls
+		// if err := tx.Exec("DROP TABLE IF EXISTS example").Error; err != nil {
+		// 	return err
+		// }
+
+		// 2. using gorm methods
+		// if err := tx.Migrator().DropTable("new_models"); err != nil {
+		// 	return err
+		// }
+		if err := tx.Migrator().DropTable(&models.User{}); err != nil {
+			return err
+		}
+		if err := tx.Migrator().DropTable(&models.RevokedToken{}); err != nil {
+			return err
+		}
+		log.Printf("Successfully applied Down migration: %s", m.Name())
+		return nil
+		}
+
+		func init() {
+		  // Register the migration
+		  RegisteredMigrations = append(RegisteredMigrations, &Createauthtables{})
+		}

go.mod

@@ -28,7 +28,7 @@ require (
 	github.com/go-playground/validator/v10 v10.26.0
 	github.com/leodido/go-urn v1.4.0 // indirect
 	github.com/lib/pq v1.10.9
-	golang.org/x/crypto v0.33.0 // indirect
+	golang.org/x/crypto v0.33.0
 	golang.org/x/net v0.34.0
 	golang.org/x/sys v0.30.0 // indirect
 	golang.org/x/text v0.22.0 // indirect

internal/app/modules/auth/handlers/handler.go

@@ -1,20 +1,23 @@
 package handlers
-
 import (
+   //	"context"
+	//"net/http"
 	authServices "github.com/codetheuri/todolist/internal/app/modules/auth/services"
 	"github.com/codetheuri/todolist/pkg/logger"
+	//"github.com/codetheuri/todolist/pkg/web"
+	//"github.com/codetheuri/todolist/internal/app/modules/auth/models"
 )
 
 type AuthHandler struct {
-	authService *authServices.AuthService
-	log         logger.Logger
+       authService authServices.AuthService
+	   log logger.Logger
 }
 
 // constructor for AuthHandler
-func NewAuthHandler(authService *authServices.AuthService, log logger.Logger) *AuthHandler {
+func NewAuthHandler(authService authServices.AuthService, log logger.Logger) *AuthHandler {
 	return &AuthHandler{
 		authService: authService,
-		log:         log,
+		log: log,
 	}
 }
 

internal/app/modules/auth/models/revoked_token.go

@@ -0,0 +1,13 @@
+package models
+
+import (
+	"time"
+
+	"gorm.io/gorm"
+)
+
+type RevokedToken struct {
+	gorm.Model
+	JTI       string    `gorm:"unique;not null;size:255" json:"jti"`
+	ExpiresAt time.Time `gorm:"not null" json:"expires_at"`
+}

internal/app/modules/auth/models/user.go

@@ -0,0 +1,10 @@
+package models
+
+import "gorm.io/gorm"
+
+type User struct {
+	gorm.Model
+	Email    string `gorm:"unique;not null" json:"email" validate:"required,email"`
+	Password string `gorm:"not null" json:"-" validate:"required,min=8"`
+	Role     string `gorm:"not null;default:'user'" json:"role"`
+}