refactor: lint

internal/database/database.go

@@ -8,22 +8,23 @@ import (
 	"gorm.io/gorm"
 )
 
+//nolint:gochecknoglobals // gorm suggests to do this in the examples
 var Database *gorm.DB
 
 func Init(dsn string) error {
 	var err error
 
 	Database, err = gorm.Open(postgres.Open(dsn), &gorm.Config{
-		PrepareStmt:            true,
+		PrepareStmt: true,
 	})
 
 	if err != nil {
-		return fmt.Errorf("Can't open database: %s", err.Error())
+		return fmt.Errorf("can't open database: %w", err)
 	}
 
 	if err = Database.AutoMigrate(&models.Publisher{}); err != nil {
-		return fmt.Errorf("Can't migrate database: %s", err.Error())
+		return fmt.Errorf("can't migrate database: %w", err)
 	}
 
-	return  nil
+	return nil
 }

internal/handlers/publishers.go

@@ -1,98 +1,99 @@
 package handlers
 
 import (
+	"errors"
+
 	"github.com/gofiber/fiber/v2"
 	"gorm.io/gorm"
 
 	db "github.com/italia/developers-italia-api/internal/database"
 	"github.com/italia/developers-italia-api/internal/models"
 )
 
-func GetPublishers(c *fiber.Ctx) error {
+func GetPublishers(ctx *fiber.Ctx) error {
 	var publishers []models.Publisher
 
 	db.Database.Find(&publishers)
 
-	return c.JSON(&publishers)
+	return ctx.JSON(&publishers)
 }
 
-func GetPublisher(c *fiber.Ctx) error {
+func GetPublisher(ctx *fiber.Ctx) error {
 	var publisher models.Publisher
 
-	if err := db.Database.First(&publisher, c.Params("id")).Error; err != nil {
-		switch err {
-		case gorm.ErrRecordNotFound:
-			return c.Status(fiber.StatusNotFound).JSON(fiber.Map{
-				"message": err.Error(),
-			})
-		default:
-			return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+	if err := db.Database.First(&publisher, ctx.Params("id")).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return ctx.Status(fiber.StatusNotFound).JSON(fiber.Map{
 				"message": err.Error(),
 			})
 		}
+
+		return ctx.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": err.Error(),
+		})
 	}
 
-	return c.JSON(&publisher)
+	return ctx.JSON(&publisher)
 }
 
-func PostPublisher(c *fiber.Ctx) error {
+func PostPublisher(ctx *fiber.Ctx) error {
 	var publisher models.Publisher
 
-	if err := c.BodyParser(&publisher); err != nil {
-		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+	if err := ctx.BodyParser(&publisher); err != nil {
+		return ctx.Status(fiber.StatusBadRequest).JSON(fiber.Map{
 			"message": err.Error(),
 		})
 	}
 
 	if err := db.Database.Create(&publisher).Error; err != nil {
-		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+		return ctx.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
 			"message": err.Error(),
 		})
 	}
 
-	return c.JSON(&publisher)
+	return ctx.JSON(&publisher)
 }
 
-func PatchPublisher(c *fiber.Ctx) error {
+func PatchPublisher(ctx *fiber.Ctx) error {
 	var publisher models.Publisher
 
-	if err := c.BodyParser(&publisher); err != nil {
-		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+	if err := ctx.BodyParser(&publisher); err != nil {
+		return ctx.Status(fiber.StatusBadRequest).JSON(fiber.Map{
 			"message": err.Error(),
 		})
 	}
-	query := db.Database.Model(models.Publisher{}).Where("id = ?", c.Params("id"))
+
+	query := db.Database.Model(models.Publisher{}).Where("id = ?", ctx.Params("id"))
+
 	if err := query.Updates(&publisher).Error; err != nil {
-		switch err {
-		case gorm.ErrRecordNotFound:
-			return c.Status(fiber.StatusNotFound).JSON(fiber.Map{
-				"message": err.Error(),
-			})
-		default:
-			return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return ctx.Status(fiber.StatusNotFound).JSON(fiber.Map{
 				"message": err.Error(),
 			})
 		}
+
+		return ctx.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": err.Error(),
+		})
 	}
 
-	return c.JSON(&publisher)
+	return ctx.JSON(&publisher)
 }
 
-func DeletePublisher(c *fiber.Ctx) error {
+func DeletePublisher(ctx *fiber.Ctx) error {
 	var publisher models.Publisher
 
-	if err := db.Database.Delete(&publisher, c.Params("id")).Error; err != nil {
-		switch err {
-		case gorm.ErrRecordNotFound:
-			return c.Status(fiber.StatusNotFound).JSON(fiber.Map{
-				"message": err.Error(),
-			})
-		default:
-			return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+	if err := db.Database.Delete(&publisher, ctx.Params("id")).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return ctx.Status(fiber.StatusNotFound).JSON(fiber.Map{
 				"message": err.Error(),
 			})
 		}
+
+		return ctx.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": err.Error(),
+		})
 	}
 
-	return c.JSON(&publisher)
+	return ctx.JSON(&publisher)
 }