refactor(app): 🎨 improve structure / format of the code

greataped/app/models/repos/followers.go

@@ -1,8 +1,11 @@
 package repos
 
 import (
+	"contracts"
 	"db"
+	"errors"
 
+	"github.com/gofiber/fiber/v2"
 	"gorm.io/gorm"
 )
 
@@ -17,26 +20,54 @@ type Follower struct {
 }
 
 // CreateFollower creates a new entry in the followers's table
-func CreateFollower(follower *Follower) *gorm.DB {
-	return db.Executor.Create(follower)
+func CreateFollower(follower *Follower) error {
+	if err := db.Executor.Create(follower).Error; err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// FindFollower searches the followers table with the condition given
+func FindFollower(conds ...any) (*Follower, error) {
+	dest := &Follower{}
+	if err := db.Executor.Model(&Follower{}).Take(dest, conds...).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, &fiber.Error{
+				Code:    contracts.StatusNotFound,
+				Message: "follower not found",
+			}
+		} else {
+			return nil, &fiber.Error{
+				Code:    contracts.StatusInternalServerError,
+				Message: err.Error(),
+			}
+		}
+	}
+
+	return dest, nil
 }
 
 // FindFollowers finds the user's followers
-func FindFollowers(dest interface{}, userIden interface{}) *gorm.DB {
-	return db.Executor.Model(&Follower{}).Find(dest, "`target` = ?", userIden)
-}
+func FindFollowers(userIden interface{}) ([]Follower, error) {
+	followers := &[]Follower{}
+	if err := db.Executor.Model(&Follower{}).Find(followers, "`target` = ?", userIden).Error; err != nil {
+		return *followers, err
+	}
 
-// FindFollower searches the follower's table with the condition given
-func FindFollower(dest interface{}, conds ...interface{}) *gorm.DB {
-	return db.Executor.Model(&Follower{}).Take(dest, conds...)
+	return *followers, nil
 }
 
 // FindFollowerById searches the followers's table with the id given
-func FindFollowerById(dest interface{}, id uint64) *gorm.DB {
-	return FindFollower(dest, "id = ?", id)
+func FindFollowerById(id uint64) (*Follower, error) {
+	return FindFollower("id = ?", id)
 }
 
 // AcceptFollower accepts a follow request
-func AcceptFollower(id interface{}) *gorm.DB {
-	return db.Executor.Model(&Follower{}).Where("id = ?", id).Update("accepted", true)
+func AcceptFollower(id interface{}) error {
+	if err := db.Executor.Model(&Follower{}).Where("id = ?", id).Update("accepted", true).Error; err != nil {
+		return err
+	}
+
+	return nil
 }

greataped/app/models/repos/following.go

@@ -14,11 +14,20 @@ type Following struct {
 }
 
 // CreateFollowing creates a new entry in the following's table
-func CreateFollowing(following *Following) *gorm.DB {
-	return db.Executor.Create(following)
+func CreateFollowing(following *Following) error {
+	if err := db.Executor.Create(following).Error; err != nil {
+		return err
+	}
+
+	return nil
 }
 
 // FindFollowing finds what accounts the user is following
-func FindFollowing(dest interface{}, userIden interface{}) *gorm.DB {
-	return db.Executor.Model(&Follower{}).Find(dest, "`handle` = ?", userIden)
+func FindFollowing(userIden interface{}) ([]Following, error) {
+	followings := &[]Following{}
+	if err := db.Executor.Model(&Following{}).Find(followings, "`target` = ?", userIden).Error; err != nil {
+		return *followings, err
+	}
+
+	return *followings, nil
 }

greataped/app/routes/followers.go

@@ -3,7 +3,6 @@ package routes
 import (
 	"activitypub"
 	"app/models/domain"
-	"app/models/dto"
 	"app/models/repos"
 	"config"
 	. "contracts"
@@ -12,6 +11,15 @@ import (
 	"strconv"
 )
 
+// Followers	godoc
+// @Tags		ActivityPub
+// @Accept		json
+// @Produce		json
+// @Param		username path string true "Username"
+// @Success		200 {object} map[string]interface{}
+// @Router		/u/{username}/followers [get]
+func _() {}
+
 var Followers = route.New(HttpGet, "/u/:username/followers", func(x IContext) error {
 	username := domain.Username(x.Request().Params("username"))
 	if username.IsEmpty() {
@@ -39,14 +47,13 @@ var Followers = route.New(HttpGet, "/u/:username/followers", func(x IContext) er
 		actor := x.StringUtil().Format("%s://%s/u/%s", config.PROTOCOL, config.DOMAIN, username)
 		id := x.StringUtil().Format("%s://%s/u/%s/followers", config.PROTOCOL, config.DOMAIN, username)
 
-		followers := &[]dto.FollowerResponse{}
-		err := repos.FindFollowers(followers, actor).Error
+		followers, err := repos.FindFollowers(actor)
 		if err != nil {
 			return err
 		}
 
 		items := []string{}
-		for _, follower := range *followers {
+		for _, follower := range followers {
 			items = append(items, follower.Handle)
 		}
 
@@ -70,8 +77,8 @@ var AcceptFollowRequest = route.New(HttpPut, "/u/:username/followers/:id/accept"
 		return x.BadRequest("invalid_id")
 	}
 
-	follower := &repos.Follower{}
-	if err := repos.FindFollowerById(follower, followerId).Error; err != nil {
+	follower, err := repos.FindFollowerById(followerId)
+	if err != nil {
 		return err
 	}
 
@@ -94,7 +101,7 @@ var AcceptFollowRequest = route.New(HttpPut, "/u/:username/followers/:id/accept"
 		return err
 	}
 
-	if err := repos.AcceptFollower(follower.ID).Error; err != nil {
+	if err := repos.AcceptFollower(follower.ID); err != nil {
 		return err
 	}
 

greataped/app/routes/following.go

@@ -3,13 +3,21 @@ package routes
 import (
 	"activitypub"
 	"app/models/domain"
-	"app/models/dto"
 	"app/models/repos"
 	"config"
 	. "contracts"
 	"server/route"
 )
 
+// Following	godoc
+// @Tags		ActivityPub
+// @Accept		json
+// @Produce		json
+// @Param		username path string true "Username"
+// @Success		200 {object} map[string]interface{}
+// @Router		/u/{username}/following [get]
+func _() {}
+
 var Following = route.New(HttpGet, "/u/:username/following", func(x IContext) error {
 	username := domain.Username(x.Request().Params("username"))
 	if username.IsEmpty() {
@@ -37,14 +45,13 @@ var Following = route.New(HttpGet, "/u/:username/following", func(x IContext) er
 		actor := x.StringUtil().Format("%s://%s/u/%s", config.PROTOCOL, config.DOMAIN, username)
 		id := x.StringUtil().Format("%s://%s/u/%s/following", config.PROTOCOL, config.DOMAIN, username)
 
-		followings := &[]dto.FollowerResponse{}
-		err := repos.FindFollowing(followings, actor).Error
+		followings, err := repos.FindFollowing(actor)
 		if err != nil {
 			return err
 		}
 
 		items := []string{}
-		for _, following := range *followings {
+		for _, following := range followings {
 			items = append(items, following.Target)
 		}
 

greataped/app/routes/inbox.go

@@ -61,8 +61,8 @@ var InboxPost = route.New(HttpPost, "/u/:username/inbox", func(x IContext) error
 				Accepted:    false,
 			}
 
-			if err := repos.CreateFollower(follower); err.Error != nil {
-				return x.Conflict(err.Error)
+			if err := repos.CreateFollower(follower); err != nil {
+				return x.Conflict(err)
 			}
 
 			if user.Access == repos.ACCESS_PUBLIC {
@@ -78,8 +78,7 @@ var InboxPost = route.New(HttpPost, "/u/:username/inbox", func(x IContext) error
 					return err
 				}
 
-				err := repos.AcceptFollower(follower.ID).Error
-				if err != nil {
+				if err := repos.AcceptFollower(follower.ID); err != nil {
 					return err
 				}
 			}