Go Gin Mvc

Use this convention for startup files so every backend keeps the same initialization flow.

app/app_config.go (logger setup)

package app

import (
    "os"

    log "github.com/sirupsen/logrus"
)

func init() {
    log.SetOutput(os.Stdout)
    // log.SetFormatter(&log.JSONFormatter{}) // enable in production if needed
    log.SetLevel(log.DebugLevel)
    log.Info("Starting logger system")
}

app/router.go (engine + middleware + server start)

package app

import (
    "github.com/gin-contrib/cors"
    "github.com/gin-gonic/gin"
    log "github.com/sirupsen/logrus"
)

var (
    router *gin.Engine
)

func init() {
    router = gin.Default()
    router.Use(cors.Default())
    router.Static("/static", "./static") // optional static files
}

func StartRoute() {
    mapUrls()
    log.Info("Starting server")
    router.Run(":8090")
}

app/url_mappings.go (centralized endpoint map)

package app

import (
    entityController "project/controllers/entity"
    log "github.com/sirupsen/logrus"
)

func mapUrls() {
    // Entity mapping
    router.GET("/entity/:id", entityController.GetEntityById)
    router.GET("/entities", entityController.GetEntities)
    router.POST("/entity", entityController.EntityInsert)
    router.DELETE("/entity/:id", entityController.DeleteEntityById)

    log.Info("Finishing mappings configurations")
}

Bootstrap rules:

• Keep logger initialization in app_config.go.
• Keep gin engine initialization in router.go.
• Keep route registrations centralized in url_mappings.go.
• Keep startup sequence: init logger -> init router -> map urls -> run server.
• Group routes by domain (user, hotel, booking, amenitie, etc.) and keep naming consistent.
• Do not place business logic inside route mapping files.

Canonical Function Conventions

Use generic signatures only to show shape and flow. These are templates, not project-specific implementations.

Controller: Get By Id (Generic Template)

func GetEntityById(c *gin.Context) {
    log.Debug("Entity id to load: " + c.Param("id"))

    id, _ := strconv.Atoi(c.Param("id")) // id is expected numeric
    var entityDto dto.EntityDto

    entityDto, err := service.EntityService.GetEntityById(id)
    if err != nil {
        c.JSON(err.Status(), err)
        return
    }

    c.JSON(http.StatusOK, entityDto)
}

DAO: Get By Id (Generic Template)

func GetEntityById(id int) model.Entity {
    var entity model.Entity

    Db.Where("id = ?", id).First(&entity)
    log.Debug("Entity: ", entity)

    return entity
}

Service: Get By Id (Generic Template)

func (a *entityService) GetEntityById(id int) (dto.EntityDto, e.ApiError) {
    var entity model.Entity = entityDAO.GetEntityById(id)
    var entityDto dto.EntityDto

    if entity.Id == 0 {
        return entityDto, e.NewBadRequestApiError("resource not found")
    }

    entityDto.Id = entity.Id
    entityDto.Name = entity.Name
    entityDto.Description = entity.Description

    return entityDto, nil
}

Use this same structure for any domain entity and preserve function flow order.

DTO Structure Patterns

Use DTOs to define API contracts, not database schema.

Request DTO (input validation)

type CreateEntityRequest struct {
    Name        string  `json:"name" binding:"required,min=3,max=80"`
    Description string  `json:"description" binding:"max=255"`
    Capacity    int     `json:"capacity" binding:"required,gte=1"`
    HourlyRate  float64 `json:"hourly_rate" binding:"required,gte=0"`
}

Response DTO (output contract)

type EntityDto struct {
    Id          int     `json:"id"`
    Name        string  `json:"name"`
    Description string  `json:"description"`
    Capacity    int     `json:"capacity"`
    HourlyRate  float64 `json:"hourly_rate"`
}

Rules for DTOs:

• Place request DTOs in dto/request.
• Place response DTOs in dto/response (or shared dto package if project uses that convention).
• Keep validation tags in request DTOs.
• Avoid exposing internal fields (password hash, soft-delete flags, internal IDs from related systems).

Model Structure Patterns

Use models to represent persistence and relations.

type Entity struct {
    Id          int       `gorm:"primaryKey;autoIncrement"`
    Name        string    `gorm:"size:80;not null"`
    Description string    `gorm:"size:255"`
    Capacity    int       `gorm:"not null"`
    HourlyRate  float64   `gorm:"not null"`
    CreatedAt   time.Time
    UpdatedAt   time.Time
}

Rules for Models:

• Place models in models/.
• Use GORM tags for DB constraints and indexes.
• Keep model focused on storage shape and relations.
• Do not return model directly from controller when response contract must be controlled; map to DTO in service.
• Add relation fields only when needed by real queries/use cases.

Layer Rules

1. Controller = Thin

• Read params/body/query.
• Delegate to service.
• Return HTTP response.
• Do not include DB queries.
• Do not include business rules.

2. Service = Business Logic

• Validate domain invariants.
• Orchestrate one or multiple DAO calls.
• Map model to DTO.
• Return e.ApiError when business flow fails.

3. DAO = Data Access

• GORM queries only.
• No HTTP concerns.
• No DTO mapping.
• No orchestration logic.

Implementation Playbook

When creating a new endpoint, execute in this order:

1. Define request DTO (dto/request).
2. Define/confirm response DTO (dto/response or entity dto).
3. Implement DAO method (query/persistence).
4. Implement service method (validation + mapping + orchestration).
5. Implement controller handler (bind + call + response).
6. Register route in app/router.go with correct middleware group.
7. Validate with go test ./....

Error Contract

Default behavior for generated code:

• Service returns (result, e.ApiError).
• Controller handles error with c.JSON(err.Status(), err).
• Not found pattern for entity-by-id: check entity.Id == 0 in service.

Prefer these statuses:

• 400: invalid input / business precondition failed.
• 401: missing or invalid token.
• 403: authenticated but forbidden.
• 404: resource not found (if project uses this semantic).
• 500: unexpected infrastructure failure.

JWT Pattern

Use golang-jwt/jwt/v5 and keep auth logic in dedicated auth service/helpers.

Checklist:

• Include user id and role claims.
• Include token expiration.
• Read secret from env/config.
• Never hardcode secrets.

Rules

Always check and handle errors immediately after each operation:

• Param parsing.
• JSON binding.
• DAO calls.
• Service calls.
• Token generation/validation.
• DB writes.

Naming

Decision Tree

New endpoint?        → controller + route
Business logic?      → service
DB operation?        → dao
Validation?          → dto/request + binding
Response format?     → dto/response
New model?           → models/

Route Group Pattern

Use three route groups in router mapping:

1. Public routes: no auth middleware.
2. Protected routes: AuthMiddleware().
3. Admin routes: AuthMiddleware() + AdminOnly().

Commands

go mod init workhub
go get github.com/gin-gonic/gin
go get gorm.io/gorm gorm.io/driver/mysql
go get github.com/golang-jwt/jwt/v5
go get github.com/joho/godotenv
go run main.go
go test ./...

Quality Checklist Before Finishing

• Controller has no business logic.
• Service has no HTTP objects.
• DAO has no DTO logic.
• Model to DTO mapping is explicit.
• Error path exists for every external call.
• Route is in correct auth group.
• Build/tests run clean.

Endpoints