feature: Change state management from global variables to object passing

This restructures dbcore (now the db package) and jwtcore (now the jwt
package) to use a single struct. There is now a state package, which
contains a struct with the full application state.

After this, instead of initializing the API routes directly in the main
function, the state object gets passed, and the API routes get
initialized with their accompanying code.

One fix done to reduce memory usage and increase speed is that the
validator object is now persistent across requests, instead of
recreating it each time. This should speed things up slightly, and
improve memory usage.

One additional chore done is that the database models have been moved to
be a seperate file from the DB initialization itself.

backend/api/controllers/v1/backends/create.go

@@ -7,13 +7,12 @@ import (
 	"net/http"
 
 	"git.terah.dev/imterah/hermes/backend/api/backendruntime"
-	"git.terah.dev/imterah/hermes/backend/api/dbcore"
-	"git.terah.dev/imterah/hermes/backend/api/jwtcore"
+	"git.terah.dev/imterah/hermes/backend/api/db"
 	"git.terah.dev/imterah/hermes/backend/api/permissions"
+	"git.terah.dev/imterah/hermes/backend/api/state"
 	"git.terah.dev/imterah/hermes/backend/commonbackend"
 	"github.com/charmbracelet/log"
 	"github.com/gin-gonic/gin"
-	"github.com/go-playground/validator/v10"
 )
 
 type BackendCreationRequest struct {
@@ -24,131 +23,114 @@ type BackendCreationRequest struct {
 	BackendParameters interface{} `json:"connectionDetails" validate:"required"`
 }
 
-func CreateBackend(c *gin.Context) {
-	var req BackendCreationRequest
+func SetupCreateBackend(state *state.State) {
+	state.Engine.POST("/api/v1/backends/create", func(c *gin.Context) {
+		var req BackendCreationRequest
 
-	if err := c.BindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
-		})
+		if err := c.BindJSON(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
+			})
 
-		return
-	}
+			return
+		}
 
-	if err := validator.New().Struct(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
-		})
+		if err := state.Validator.Struct(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
+			})
 
-		return
-	}
+			return
+		}
 
-	user, err := jwtcore.GetUserFromJWT(req.Token)
+		user, err := state.JWT.GetUserFromJWT(req.Token)
 
-	if err != nil {
-		if err.Error() == "token is expired" || err.Error() == "user does not exist" {
+		if err != nil {
+			if err.Error() == "token is expired" || err.Error() == "user does not exist" {
+				c.JSON(http.StatusForbidden, gin.H{
+					"error": err.Error(),
+				})
+
+				return
+			} else {
+				log.Warnf("Failed to get user from the provided JWT token: %s", err.Error())
+
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"error": "Failed to parse token",
+				})
+
+				return
+			}
+		}
+
+		if !permissions.UserHasPermission(user, "backends.add") {
 			c.JSON(http.StatusForbidden, gin.H{
-				"error": err.Error(),
-			})
-
-			return
-		} else {
-			log.Warnf("Failed to get user from the provided JWT token: %s", err.Error())
-
-			c.JSON(http.StatusInternalServerError, gin.H{
-				"error": "Failed to parse token",
+				"error": "Missing permissions",
 			})
 
 			return
 		}
-	}
 
-	if !permissions.UserHasPermission(user, "backends.add") {
-		c.JSON(http.StatusForbidden, gin.H{
-			"error": "Missing permissions",
-		})
+		var backendParameters []byte
 
-		return
-	}
+		switch parameters := req.BackendParameters.(type) {
+		case string:
+			backendParameters = []byte(parameters)
+		case map[string]interface{}:
+			backendParameters, err = json.Marshal(parameters)
 
-	var backendParameters []byte
+			if err != nil {
+				log.Warnf("Failed to marshal JSON recieved as BackendParameters: %s", err.Error())
 
-	switch parameters := req.BackendParameters.(type) {
-	case string:
-		backendParameters = []byte(parameters)
-	case map[string]interface{}:
-		backendParameters, err = json.Marshal(parameters)
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"error": "Failed to prepare parameters",
+				})
+
+				return
+			}
+		default:
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Invalid type for connectionDetails (recieved %T)", parameters),
+			})
+
+			return
+		}
+
+		var backendRuntimeFilePath string
+
+		for _, runtime := range backendruntime.AvailableBackends {
+			if runtime.Name == req.Backend {
+				backendRuntimeFilePath = runtime.Path
+			}
+		}
+
+		if backendRuntimeFilePath == "" {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": "Unsupported backend recieved",
+			})
+
+			return
+		}
+
+		backend := backendruntime.NewBackend(backendRuntimeFilePath)
+		err = backend.Start()
 
 		if err != nil {
-			log.Warnf("Failed to marshal JSON recieved as BackendParameters: %s", err.Error())
+			log.Warnf("Failed to start backend: %s", err.Error())
 
 			c.JSON(http.StatusInternalServerError, gin.H{
-				"error": "Failed to prepare parameters",
+				"error": "Failed to start backend",
 			})
 
 			return
 		}
-	default:
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Invalid type for connectionDetails (recieved %T)", parameters),
+
+		backendParamCheckResponse, err := backend.ProcessCommand(&commonbackend.CheckServerParameters{
+			Arguments: backendParameters,
 		})
 
-		return
-	}
-
-	var backendRuntimeFilePath string
-
-	for _, runtime := range backendruntime.AvailableBackends {
-		if runtime.Name == req.Backend {
-			backendRuntimeFilePath = runtime.Path
-		}
-	}
-
-	if backendRuntimeFilePath == "" {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": "Unsupported backend recieved",
-		})
-
-		return
-	}
-
-	backend := backendruntime.NewBackend(backendRuntimeFilePath)
-	err = backend.Start()
-
-	if err != nil {
-		log.Warnf("Failed to start backend: %s", err.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to start backend",
-		})
-
-		return
-	}
-
-	backendParamCheckResponse, err := backend.ProcessCommand(&commonbackend.CheckServerParameters{
-		Arguments: backendParameters,
-	})
-
-	if err != nil {
-		log.Warnf("Failed to get response for backend: %s", err.Error())
-
-		err = backend.Stop()
-
 		if err != nil {
-			log.Warnf("Failed to stop backend: %s", err.Error())
-		}
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to get status response from backend",
-		})
-
-		return
-	}
-
-	switch responseMessage := backendParamCheckResponse.(type) {
-	case *commonbackend.CheckParametersResponse:
-		if responseMessage.InResponseTo != "checkServerParameters" {
-			log.Errorf("Got illegal response to CheckServerParameters: %s", responseMessage.InResponseTo)
+			log.Warnf("Failed to get response for backend: %s", err.Error())
 
 			err = backend.Stop()
 
@@ -163,107 +145,126 @@ func CreateBackend(c *gin.Context) {
 			return
 		}
 
-		if !responseMessage.IsValid {
+		switch responseMessage := backendParamCheckResponse.(type) {
+		case *commonbackend.CheckParametersResponse:
+			if responseMessage.InResponseTo != "checkServerParameters" {
+				log.Errorf("Got illegal response to CheckServerParameters: %s", responseMessage.InResponseTo)
+
+				err = backend.Stop()
+
+				if err != nil {
+					log.Warnf("Failed to stop backend: %s", err.Error())
+				}
+
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"error": "Failed to get status response from backend",
+				})
+
+				return
+			}
+
+			if !responseMessage.IsValid {
+				err = backend.Stop()
+
+				if err != nil {
+					log.Warnf("Failed to stop backend: %s", err.Error())
+				}
+
+				var errorMessage string
+
+				if responseMessage.Message == "" {
+					errorMessage = "Unkown error while trying to parse connectionDetails"
+				} else {
+					errorMessage = fmt.Sprintf("Invalid backend parameters: %s", responseMessage.Message)
+				}
+
+				c.JSON(http.StatusBadRequest, gin.H{
+					"error": errorMessage,
+				})
+
+				return
+			}
+		default:
+			log.Warnf("Got illegal response type for backend: %T", responseMessage)
+		}
+
+		log.Info("Passed backend checks successfully")
+
+		backendInDatabase := &db.Backend{
+			UserID:            user.ID,
+			Name:              req.Name,
+			Description:       req.Description,
+			Backend:           req.Backend,
+			BackendParameters: base64.StdEncoding.EncodeToString(backendParameters),
+		}
+
+		if result := state.DB.DB.Create(&backendInDatabase); result.Error != nil {
+			log.Warnf("Failed to create backend: %s", result.Error.Error())
+
 			err = backend.Stop()
 
 			if err != nil {
 				log.Warnf("Failed to stop backend: %s", err.Error())
 			}
 
-			var errorMessage string
-
-			if responseMessage.Message == "" {
-				errorMessage = "Unkown error while trying to parse connectionDetails"
-			} else {
-				errorMessage = fmt.Sprintf("Invalid backend parameters: %s", responseMessage.Message)
-			}
-
-			c.JSON(http.StatusBadRequest, gin.H{
-				"error": errorMessage,
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to add backend into database",
 			})
 
 			return
 		}
-	default:
-		log.Warnf("Got illegal response type for backend: %T", responseMessage)
-	}
 
-	log.Info("Passed backend checks successfully")
-
-	backendInDatabase := &dbcore.Backend{
-		UserID:            user.ID,
-		Name:              req.Name,
-		Description:       req.Description,
-		Backend:           req.Backend,
-		BackendParameters: base64.StdEncoding.EncodeToString(backendParameters),
-	}
-
-	if result := dbcore.DB.Create(&backendInDatabase); result.Error != nil {
-		log.Warnf("Failed to create backend: %s", result.Error.Error())
-
-		err = backend.Stop()
-
-		if err != nil {
-			log.Warnf("Failed to stop backend: %s", err.Error())
-		}
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to add backend into database",
+		backendStartResponse, err := backend.ProcessCommand(&commonbackend.Start{
+			Arguments: backendParameters,
 		})
 
-		return
-	}
-
-	backendStartResponse, err := backend.ProcessCommand(&commonbackend.Start{
-		Arguments: backendParameters,
-	})
-
-	if err != nil {
-		log.Warnf("Failed to get response for backend: %s", err.Error())
-
-		err = backend.Stop()
-
 		if err != nil {
-			log.Warnf("Failed to stop backend: %s", err.Error())
-		}
+			log.Warnf("Failed to get response for backend: %s", err.Error())
 
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to get status response from backend",
-		})
-
-		return
-	}
-
-	switch responseMessage := backendStartResponse.(type) {
-	case *commonbackend.BackendStatusResponse:
-		if !responseMessage.IsRunning {
 			err = backend.Stop()
 
 			if err != nil {
-				log.Warnf("Failed to start backend: %s", err.Error())
+				log.Warnf("Failed to stop backend: %s", err.Error())
 			}
 
-			var errorMessage string
-
-			if responseMessage.Message == "" {
-				errorMessage = "Unkown error while trying to start the backend"
-			} else {
-				errorMessage = fmt.Sprintf("Failed to start backend: %s", responseMessage.Message)
-			}
-
-			c.JSON(http.StatusBadRequest, gin.H{
-				"error": errorMessage,
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to get status response from backend",
 			})
 
 			return
 		}
-	default:
-		log.Warnf("Got illegal response type for backend: %T", responseMessage)
-	}
 
-	backendruntime.RunningBackends[backendInDatabase.ID] = backend
+		switch responseMessage := backendStartResponse.(type) {
+		case *commonbackend.BackendStatusResponse:
+			if !responseMessage.IsRunning {
+				err = backend.Stop()
 
-	c.JSON(http.StatusOK, gin.H{
-		"success": true,
+				if err != nil {
+					log.Warnf("Failed to start backend: %s", err.Error())
+				}
+
+				var errorMessage string
+
+				if responseMessage.Message == "" {
+					errorMessage = "Unkown error while trying to start the backend"
+				} else {
+					errorMessage = fmt.Sprintf("Failed to start backend: %s", responseMessage.Message)
+				}
+
+				c.JSON(http.StatusBadRequest, gin.H{
+					"error": errorMessage,
+				})
+
+				return
+			}
+		default:
+			log.Warnf("Got illegal response type for backend: %T", responseMessage)
+		}
+
+		backendruntime.RunningBackends[backendInDatabase.ID] = backend
+
+		c.JSON(http.StatusOK, gin.H{
+			"success": true,
+		})
 	})
 }

backend/api/controllers/v1/backends/lookup.go

@@ -7,12 +7,11 @@ import (
 	"strings"
 
 	"git.terah.dev/imterah/hermes/backend/api/backendruntime"
-	"git.terah.dev/imterah/hermes/backend/api/dbcore"
-	"git.terah.dev/imterah/hermes/backend/api/jwtcore"
+	"git.terah.dev/imterah/hermes/backend/api/db"
 	"git.terah.dev/imterah/hermes/backend/api/permissions"
+	"git.terah.dev/imterah/hermes/backend/api/state"
 	"github.com/charmbracelet/log"
 	"github.com/gin-gonic/gin"
-	"github.com/go-playground/validator/v10"
 )
 
 type BackendLookupRequest struct {
@@ -38,95 +37,80 @@ type LookupResponse struct {
 	Data    []*SanitizedBackend `json:"data"`
 }
 
-func LookupBackend(c *gin.Context) {
-	var req BackendLookupRequest
+func SetupLookupBackend(state *state.State) {
+	state.Engine.POST("/api/v1/backends/lookup", func(c *gin.Context) {
+		var req BackendLookupRequest
 
-	if err := c.BindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
-		})
-
-		return
-	}
-
-	if err := validator.New().Struct(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
-		})
-
-		return
-	}
-
-	user, err := jwtcore.GetUserFromJWT(req.Token)
-
-	if err != nil {
-		if err.Error() == "token is expired" || err.Error() == "user does not exist" {
-			c.JSON(http.StatusForbidden, gin.H{
-				"error": err.Error(),
-			})
-
-			return
-		} else {
-			log.Warnf("Failed to get user from the provided JWT token: %s", err.Error())
-
-			c.JSON(http.StatusInternalServerError, gin.H{
-				"error": "Failed to parse token",
+		if err := c.BindJSON(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
 			})
 
 			return
 		}
-	}
 
-	if !permissions.UserHasPermission(user, "backends.visible") {
-		c.JSON(http.StatusForbidden, gin.H{
-			"error": "Missing permissions",
-		})
+		if err := state.Validator.Struct(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
+			})
 
-		return
-	}
+			return
+		}
 
-	backends := []dbcore.Backend{}
-	queryString := []string{}
-	queryParameters := []interface{}{}
+		user, err := state.JWT.GetUserFromJWT(req.Token)
 
-	if req.BackendID != nil {
-		queryString = append(queryString, "id = ?")
-		queryParameters = append(queryParameters, req.BackendID)
-	}
+		if err != nil {
+			if err.Error() == "token is expired" || err.Error() == "user does not exist" {
+				c.JSON(http.StatusForbidden, gin.H{
+					"error": err.Error(),
+				})
 
-	if req.Name != nil {
-		queryString = append(queryString, "name = ?")
-		queryParameters = append(queryParameters, req.Name)
-	}
+				return
+			} else {
+				log.Warnf("Failed to get user from the provided JWT token: %s", err.Error())
 
-	if req.Description != nil {
-		queryString = append(queryString, "description = ?")
-		queryParameters = append(queryParameters, req.Description)
-	}
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"error": "Failed to parse token",
+				})
 
-	if req.Backend != nil {
-		queryString = append(queryString, "is_bot = ?")
-		queryParameters = append(queryParameters, req.Backend)
-	}
+				return
+			}
+		}
 
-	if err := dbcore.DB.Where(strings.Join(queryString, " AND "), queryParameters...).Find(&backends).Error; err != nil {
-		log.Warnf("Failed to get backends: %s", err.Error())
+		if !permissions.UserHasPermission(user, "backends.visible") {
+			c.JSON(http.StatusForbidden, gin.H{
+				"error": "Missing permissions",
+			})
 
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to get backends",
-		})
+			return
+		}
 
-		return
-	}
+		backends := []db.Backend{}
+		queryString := []string{}
+		queryParameters := []interface{}{}
 
-	sanitizedBackends := make([]*SanitizedBackend, len(backends))
-	hasSecretVisibility := permissions.UserHasPermission(user, "backends.secretVis")
+		if req.BackendID != nil {
+			queryString = append(queryString, "id = ?")
+			queryParameters = append(queryParameters, req.BackendID)
+		}
 
-	for backendIndex, backend := range backends {
-		foundBackend, ok := backendruntime.RunningBackends[backend.ID]
+		if req.Name != nil {
+			queryString = append(queryString, "name = ?")
+			queryParameters = append(queryParameters, req.Name)
+		}
 
-		if !ok {
-			log.Warnf("Failed to get backend #%d controller", backend.ID)
+		if req.Description != nil {
+			queryString = append(queryString, "description = ?")
+			queryParameters = append(queryParameters, req.Description)
+		}
+
+		if req.Backend != nil {
+			queryString = append(queryString, "is_bot = ?")
+			queryParameters = append(queryParameters, req.Backend)
+		}
+
+		if err := state.DB.DB.Where(strings.Join(queryString, " AND "), queryParameters...).Find(&backends).Error; err != nil {
+			log.Warnf("Failed to get backends: %s", err.Error())
 
 			c.JSON(http.StatusInternalServerError, gin.H{
 				"error": "Failed to get backends",
@@ -135,29 +119,46 @@ func LookupBackend(c *gin.Context) {
 			return
 		}
 
-		sanitizedBackends[backendIndex] = &SanitizedBackend{
-			BackendID:   backend.ID,
-			OwnerID:     backend.UserID,
-			Name:        backend.Name,
-			Description: backend.Description,
-			Backend:     backend.Backend,
-			Logs:        foundBackend.Logs,
-		}
+		sanitizedBackends := make([]*SanitizedBackend, len(backends))
+		hasSecretVisibility := permissions.UserHasPermission(user, "backends.secretVis")
 
-		if backend.UserID == user.ID || hasSecretVisibility {
-			backendParametersBytes, err := base64.StdEncoding.DecodeString(backend.BackendParameters)
+		for backendIndex, backend := range backends {
+			foundBackend, ok := backendruntime.RunningBackends[backend.ID]
 
-			if err != nil {
-				log.Warnf("Failed to decode base64 backend parameters: %s", err.Error())
+			if !ok {
+				log.Warnf("Failed to get backend #%d controller", backend.ID)
+
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"error": "Failed to get backends",
+				})
+
+				return
 			}
 
-			backendParameters := string(backendParametersBytes)
-			sanitizedBackends[backendIndex].BackendParameters = &backendParameters
-		}
-	}
+			sanitizedBackends[backendIndex] = &SanitizedBackend{
+				BackendID:   backend.ID,
+				OwnerID:     backend.UserID,
+				Name:        backend.Name,
+				Description: backend.Description,
+				Backend:     backend.Backend,
+				Logs:        foundBackend.Logs,
+			}
 
-	c.JSON(http.StatusOK, &LookupResponse{
-		Success: true,
-		Data:    sanitizedBackends,
+			if backend.UserID == user.ID || hasSecretVisibility {
+				backendParametersBytes, err := base64.StdEncoding.DecodeString(backend.BackendParameters)
+
+				if err != nil {
+					log.Warnf("Failed to decode base64 backend parameters: %s", err.Error())
+				}
+
+				backendParameters := string(backendParametersBytes)
+				sanitizedBackends[backendIndex].BackendParameters = &backendParameters
+			}
+		}
+
+		c.JSON(http.StatusOK, &LookupResponse{
+			Success: true,
+			Data:    sanitizedBackends,
+		})
 	})
 }

backend/api/controllers/v1/backends/remove.go

@@ -5,12 +5,11 @@ import (
 	"net/http"
 
 	"git.terah.dev/imterah/hermes/backend/api/backendruntime"
-	"git.terah.dev/imterah/hermes/backend/api/dbcore"
-	"git.terah.dev/imterah/hermes/backend/api/jwtcore"
+	"git.terah.dev/imterah/hermes/backend/api/db"
 	"git.terah.dev/imterah/hermes/backend/api/permissions"
+	"git.terah.dev/imterah/hermes/backend/api/state"
 	"github.com/charmbracelet/log"
 	"github.com/gin-gonic/gin"
-	"github.com/go-playground/validator/v10"
 )
 
 type BackendRemovalRequest struct {
@@ -18,106 +17,108 @@ type BackendRemovalRequest struct {
 	BackendID uint   `json:"id" validate:"required"`
 }
 
-func RemoveBackend(c *gin.Context) {
-	var req BackendRemovalRequest
+func SetupRemoveBackend(state *state.State) {
+	state.Engine.POST("/api/v1/backends/remove", func(c *gin.Context) {
+		var req BackendRemovalRequest
 
-	if err := c.BindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
-		})
-
-		return
-	}
-
-	if err := validator.New().Struct(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
-		})
-
-		return
-	}
-
-	user, err := jwtcore.GetUserFromJWT(req.Token)
-
-	if err != nil {
-		if err.Error() == "token is expired" || err.Error() == "user does not exist" {
-			c.JSON(http.StatusForbidden, gin.H{
-				"error": err.Error(),
-			})
-
-			return
-		} else {
-			log.Warnf("Failed to get user from the provided JWT token: %s", err.Error())
-
-			c.JSON(http.StatusInternalServerError, gin.H{
-				"error": "Failed to parse token",
+		if err := c.BindJSON(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
 			})
 
 			return
 		}
-	}
 
-	if !permissions.UserHasPermission(user, "backends.remove") {
-		c.JSON(http.StatusForbidden, gin.H{
-			"error": "Missing permissions",
-		})
+		if err := state.Validator.Struct(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
+			})
 
-		return
-	}
+			return
+		}
 
-	var backend *dbcore.Backend
-	backendRequest := dbcore.DB.Where("id = ?", req.BackendID).Find(&backend)
-
-	if backendRequest.Error != nil {
-		log.Warnf("failed to find if backend exists or not: %s", backendRequest.Error.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to find if backend exists",
-		})
-
-		return
-	}
-
-	backendExists := backendRequest.RowsAffected > 0
-
-	if !backendExists {
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Backend doesn't exist",
-		})
-
-		return
-	}
-
-	if err := dbcore.DB.Delete(backend).Error; err != nil {
-		log.Warnf("failed to delete backend: %s", err.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to delete backend",
-		})
-
-		return
-	}
-
-	backendInstance, ok := backendruntime.RunningBackends[req.BackendID]
-
-	if ok {
-		err = backendInstance.Stop()
+		user, err := state.JWT.GetUserFromJWT(req.Token)
 
 		if err != nil {
-			log.Warnf("Failed to stop backend: %s", err.Error())
+			if err.Error() == "token is expired" || err.Error() == "user does not exist" {
+				c.JSON(http.StatusForbidden, gin.H{
+					"error": err.Error(),
+				})
 
-			c.JSON(http.StatusInternalServerError, gin.H{
-				"error": "Backend deleted, but failed to stop",
+				return
+			} else {
+				log.Warnf("Failed to get user from the provided JWT token: %s", err.Error())
+
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"error": "Failed to parse token",
+				})
+
+				return
+			}
+		}
+
+		if !permissions.UserHasPermission(user, "backends.remove") {
+			c.JSON(http.StatusForbidden, gin.H{
+				"error": "Missing permissions",
 			})
 
-			delete(backendruntime.RunningBackends, req.BackendID)
 			return
 		}
 
-		delete(backendruntime.RunningBackends, req.BackendID)
-	}
+		var backend *db.Backend
+		backendRequest := state.DB.DB.Where("id = ?", req.BackendID).Find(&backend)
 
-	c.JSON(http.StatusOK, gin.H{
-		"success": true,
+		if backendRequest.Error != nil {
+			log.Warnf("failed to find if backend exists or not: %s", backendRequest.Error.Error())
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to find if backend exists",
+			})
+
+			return
+		}
+
+		backendExists := backendRequest.RowsAffected > 0
+
+		if !backendExists {
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Backend doesn't exist",
+			})
+
+			return
+		}
+
+		if err := state.DB.DB.Delete(backend).Error; err != nil {
+			log.Warnf("failed to delete backend: %s", err.Error())
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to delete backend",
+			})
+
+			return
+		}
+
+		backendInstance, ok := backendruntime.RunningBackends[req.BackendID]
+
+		if ok {
+			err = backendInstance.Stop()
+
+			if err != nil {
+				log.Warnf("Failed to stop backend: %s", err.Error())
+
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"error": "Backend deleted, but failed to stop",
+				})
+
+				delete(backendruntime.RunningBackends, req.BackendID)
+				return
+			}
+
+			delete(backendruntime.RunningBackends, req.BackendID)
+		}
+
+		c.JSON(http.StatusOK, gin.H{
+			"success": true,
+		})
 	})
 }

backend/api/controllers/v1/proxies/connections.go

@@ -5,13 +5,12 @@ import (
 	"net/http"
 
 	"git.terah.dev/imterah/hermes/backend/api/backendruntime"
-	"git.terah.dev/imterah/hermes/backend/api/dbcore"
-	"git.terah.dev/imterah/hermes/backend/api/jwtcore"
+	"git.terah.dev/imterah/hermes/backend/api/db"
 	"git.terah.dev/imterah/hermes/backend/api/permissions"
+	"git.terah.dev/imterah/hermes/backend/api/state"
 	"git.terah.dev/imterah/hermes/backend/commonbackend"
 	"github.com/charmbracelet/log"
 	"github.com/gin-gonic/gin"
-	"github.com/go-playground/validator/v10"
 )
 
 type ConnectionsRequest struct {
@@ -37,127 +36,130 @@ type ConnectionsResponse struct {
 	Data    []*SanitizedConnection `json:"data"`
 }
 
-func GetConnections(c *gin.Context) {
-	var req ConnectionsRequest
+func SetupGetConnections(state *state.State) {
+	state.Engine.POST("/api/v1/forward/connections", func(c *gin.Context) {
+		var req ConnectionsRequest
 
-	if err := c.BindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
-		})
-
-		return
-	}
-
-	if err := validator.New().Struct(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
-		})
-
-		return
-	}
-
-	user, err := jwtcore.GetUserFromJWT(req.Token)
-	if err != nil {
-		if err.Error() == "token is expired" || err.Error() == "user does not exist" {
-			c.JSON(http.StatusForbidden, gin.H{
-				"error": err.Error(),
-			})
-
-			return
-		} else {
-			log.Warnf("Failed to get user from the provided JWT token: %s", err.Error())
-
-			c.JSON(http.StatusInternalServerError, gin.H{
-				"error": "Failed to parse token",
+		if err := c.BindJSON(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
 			})
 
 			return
 		}
-	}
 
-	if !permissions.UserHasPermission(user, "routes.visibleConn") {
-		c.JSON(http.StatusForbidden, gin.H{
-			"error": "Missing permissions",
-		})
+		if err := state.Validator.Struct(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
+			})
 
-		return
-	}
+			return
+		}
 
-	var proxy dbcore.Proxy
-	proxyRequest := dbcore.DB.Where("id = ?", req.Id).First(&proxy)
+		user, err := state.JWT.GetUserFromJWT(req.Token)
 
-	if proxyRequest.Error != nil {
-		log.Warnf("failed to find proxy: %s", proxyRequest.Error.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to find forward entry",
-		})
-
-		return
-	}
-
-	proxyExists := proxyRequest.RowsAffected > 0
-
-	if !proxyExists {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": "No forward entry found",
-		})
-
-		return
-	}
-
-	backendRuntime, ok := backendruntime.RunningBackends[proxy.BackendID]
-
-	if !ok {
-		log.Warnf("Couldn't fetch backend runtime from backend ID #%d", proxy.BackendID)
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Couldn't fetch backend runtime",
-		})
-
-		return
-	}
-
-	backendResponse, err := backendRuntime.ProcessCommand(&commonbackend.ProxyConnectionsRequest{})
-
-	if err != nil {
-		log.Warnf("Failed to get response for backend: %s", err.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to get status response from backend",
-		})
-
-		return
-	}
-
-	switch responseMessage := backendResponse.(type) {
-	case *commonbackend.ProxyConnectionsResponse:
-		sanitizedConnections := []*SanitizedConnection{}
-
-		for _, connection := range responseMessage.Connections {
-			if connection.SourceIP == proxy.SourceIP && connection.SourcePort == proxy.SourcePort && proxy.DestinationPort == proxy.DestinationPort {
-				sanitizedConnections = append(sanitizedConnections, &SanitizedConnection{
-					ClientIP: connection.ClientIP,
-					Port:     connection.ClientPort,
-
-					ConnectionDetails: &ConnectionDetailsForConnection{
-						SourceIP:   proxy.SourceIP,
-						SourcePort: proxy.SourcePort,
-						DestPort:   proxy.DestinationPort,
-					},
+		if err != nil {
+			if err.Error() == "token is expired" || err.Error() == "user does not exist" {
+				c.JSON(http.StatusForbidden, gin.H{
+					"error": err.Error(),
 				})
+
+				return
+			} else {
+				log.Warnf("Failed to get user from the provided JWT token: %s", err.Error())
+
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"error": "Failed to parse token",
+				})
+
+				return
 			}
 		}
 
-		c.JSON(http.StatusOK, &ConnectionsResponse{
-			Success: true,
-			Data:    sanitizedConnections,
-		})
-	default:
-		log.Warnf("Got illegal response type for backend: %T", responseMessage)
+		if !permissions.UserHasPermission(user, "routes.visibleConn") {
+			c.JSON(http.StatusForbidden, gin.H{
+				"error": "Missing permissions",
+			})
 
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Got illegal response type",
-		})
-	}
+			return
+		}
+
+		var proxy db.Proxy
+		proxyRequest := state.DB.DB.Where("id = ?", req.Id).First(&proxy)
+
+		if proxyRequest.Error != nil {
+			log.Warnf("failed to find proxy: %s", proxyRequest.Error.Error())
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to find forward entry",
+			})
+
+			return
+		}
+
+		proxyExists := proxyRequest.RowsAffected > 0
+
+		if !proxyExists {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": "No forward entry found",
+			})
+
+			return
+		}
+
+		backendRuntime, ok := backendruntime.RunningBackends[proxy.BackendID]
+
+		if !ok {
+			log.Warnf("Couldn't fetch backend runtime from backend ID #%d", proxy.BackendID)
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Couldn't fetch backend runtime",
+			})
+
+			return
+		}
+
+		backendResponse, err := backendRuntime.ProcessCommand(&commonbackend.ProxyConnectionsRequest{})
+
+		if err != nil {
+			log.Warnf("Failed to get response for backend: %s", err.Error())
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to get status response from backend",
+			})
+
+			return
+		}
+
+		switch responseMessage := backendResponse.(type) {
+		case *commonbackend.ProxyConnectionsResponse:
+			sanitizedConnections := []*SanitizedConnection{}
+
+			for _, connection := range responseMessage.Connections {
+				if connection.SourceIP == proxy.SourceIP && connection.SourcePort == proxy.SourcePort && proxy.DestinationPort == proxy.DestinationPort {
+					sanitizedConnections = append(sanitizedConnections, &SanitizedConnection{
+						ClientIP: connection.ClientIP,
+						Port:     connection.ClientPort,
+
+						ConnectionDetails: &ConnectionDetailsForConnection{
+							SourceIP:   proxy.SourceIP,
+							SourcePort: proxy.SourcePort,
+							DestPort:   proxy.DestinationPort,
+						},
+					})
+				}
+			}
+
+			c.JSON(http.StatusOK, &ConnectionsResponse{
+				Success: true,
+				Data:    sanitizedConnections,
+			})
+		default:
+			log.Warnf("Got illegal response type for backend: %T", responseMessage)
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Got illegal response type",
+			})
+		}
+	})
 }

backend/api/controllers/v1/proxies/create.go

@@ -5,13 +5,12 @@ import (
 	"net/http"
 
 	"git.terah.dev/imterah/hermes/backend/api/backendruntime"
-	"git.terah.dev/imterah/hermes/backend/api/dbcore"
-	"git.terah.dev/imterah/hermes/backend/api/jwtcore"
+	"git.terah.dev/imterah/hermes/backend/api/db"
 	"git.terah.dev/imterah/hermes/backend/api/permissions"
+	"git.terah.dev/imterah/hermes/backend/api/state"
 	"git.terah.dev/imterah/hermes/backend/commonbackend"
 	"github.com/charmbracelet/log"
 	"github.com/gin-gonic/gin"
-	"github.com/go-playground/validator/v10"
 )
 
 type ProxyCreationRequest struct {
@@ -26,150 +25,153 @@ type ProxyCreationRequest struct {
 	AutoStart       *bool   `json:"autoStart"`
 }
 
-func CreateProxy(c *gin.Context) {
-	var req ProxyCreationRequest
+func SetupCreateProxy(state *state.State) {
+	state.Engine.POST("/api/v1/forward/create", func(c *gin.Context) {
+		var req ProxyCreationRequest
 
-	if err := c.BindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
-		})
-
-		return
-	}
-
-	if err := validator.New().Struct(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
-		})
-
-		return
-	}
-
-	user, err := jwtcore.GetUserFromJWT(req.Token)
-	if err != nil {
-		if err.Error() == "token is expired" || err.Error() == "user does not exist" {
-			c.JSON(http.StatusForbidden, gin.H{
-				"error": err.Error(),
-			})
-
-			return
-		} else {
-			log.Warnf("Failed to get user from the provided JWT token: %s", err.Error())
-
-			c.JSON(http.StatusInternalServerError, gin.H{
-				"error": "Failed to parse token",
-			})
-
-			return
-		}
-	}
-
-	if !permissions.UserHasPermission(user, "routes.add") {
-		c.JSON(http.StatusForbidden, gin.H{
-			"error": "Missing permissions",
-		})
-
-		return
-	}
-
-	if req.Protocol != "tcp" && req.Protocol != "udp" {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": "Protocol must be either 'tcp' or 'udp'",
-		})
-
-		return
-	}
-
-	var backend dbcore.Backend
-	backendRequest := dbcore.DB.Where("id = ?", req.ProviderID).First(&backend)
-
-	if backendRequest.Error != nil {
-		log.Warnf("failed to find if backend exists or not: %s", backendRequest.Error.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to find if backend exists",
-		})
-	}
-
-	backendExists := backendRequest.RowsAffected > 0
-
-	if !backendExists {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": "Could not find backend",
-		})
-	}
-
-	autoStart := false
-
-	if req.AutoStart != nil {
-		autoStart = *req.AutoStart
-	}
-
-	proxy := &dbcore.Proxy{
-		UserID:          user.ID,
-		BackendID:       req.ProviderID,
-		Name:            req.Name,
-		Description:     req.Description,
-		Protocol:        req.Protocol,
-		SourceIP:        req.SourceIP,
-		SourcePort:      req.SourcePort,
-		DestinationPort: req.DestinationPort,
-		AutoStart:       autoStart,
-	}
-
-	if result := dbcore.DB.Create(proxy); result.Error != nil {
-		log.Warnf("failed to create proxy: %s", result.Error.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to add forward rule to database",
-		})
-
-		return
-	}
-
-	if autoStart {
-		backend, ok := backendruntime.RunningBackends[proxy.BackendID]
-
-		if !ok {
-			log.Warnf("Couldn't fetch backend runtime from backend ID #%d", proxy.BackendID)
-
-			c.JSON(http.StatusOK, gin.H{
-				"success": true,
-				"id":      proxy.ID,
+		if err := c.BindJSON(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
 			})
 
 			return
 		}
 
-		backendResponse, err := backend.ProcessCommand(&commonbackend.AddProxy{
-			SourceIP:   proxy.SourceIP,
-			SourcePort: proxy.SourcePort,
-			DestPort:   proxy.DestinationPort,
-			Protocol:   proxy.Protocol,
-		})
+		if err := state.Validator.Struct(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
+			})
+
+			return
+		}
+
+		user, err := state.JWT.GetUserFromJWT(req.Token)
 
 		if err != nil {
-			log.Warnf("Failed to get response for backend #%d: %s", proxy.BackendID, err.Error())
+			if err.Error() == "token is expired" || err.Error() == "user does not exist" {
+				c.JSON(http.StatusForbidden, gin.H{
+					"error": err.Error(),
+				})
 
-			c.JSON(http.StatusInternalServerError, gin.H{
-				"error": "failed to get response from backend",
+				return
+			} else {
+				log.Warnf("Failed to get user from the provided JWT token: %s", err.Error())
+
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"error": "Failed to parse token",
+				})
+
+				return
+			}
+		}
+
+		if !permissions.UserHasPermission(user, "routes.add") {
+			c.JSON(http.StatusForbidden, gin.H{
+				"error": "Missing permissions",
 			})
 
 			return
 		}
 
-		switch responseMessage := backendResponse.(type) {
-		case *commonbackend.ProxyStatusResponse:
-			if !responseMessage.IsActive {
-				log.Warnf("Failed to start proxy for backend #%d", proxy.BackendID)
-			}
-		default:
-			log.Errorf("Got illegal response type for backend #%d: %T", proxy.BackendID, responseMessage)
-		}
-	}
+		if req.Protocol != "tcp" && req.Protocol != "udp" {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": "Protocol must be either 'tcp' or 'udp'",
+			})
 
-	c.JSON(http.StatusOK, gin.H{
-		"success": true,
-		"id":      proxy.ID,
+			return
+		}
+
+		var backend db.Backend
+		backendRequest := state.DB.DB.Where("id = ?", req.ProviderID).First(&backend)
+
+		if backendRequest.Error != nil {
+			log.Warnf("failed to find if backend exists or not: %s", backendRequest.Error.Error())
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to find if backend exists",
+			})
+		}
+
+		backendExists := backendRequest.RowsAffected > 0
+
+		if !backendExists {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": "Could not find backend",
+			})
+		}
+
+		autoStart := false
+
+		if req.AutoStart != nil {
+			autoStart = *req.AutoStart
+		}
+
+		proxy := &db.Proxy{
+			UserID:          user.ID,
+			BackendID:       req.ProviderID,
+			Name:            req.Name,
+			Description:     req.Description,
+			Protocol:        req.Protocol,
+			SourceIP:        req.SourceIP,
+			SourcePort:      req.SourcePort,
+			DestinationPort: req.DestinationPort,
+			AutoStart:       autoStart,
+		}
+
+		if result := state.DB.DB.Create(proxy); result.Error != nil {
+			log.Warnf("failed to create proxy: %s", result.Error.Error())
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to add forward rule to database",
+			})
+
+			return
+		}
+
+		if autoStart {
+			backend, ok := backendruntime.RunningBackends[proxy.BackendID]
+
+			if !ok {
+				log.Warnf("Couldn't fetch backend runtime from backend ID #%d", proxy.BackendID)
+
+				c.JSON(http.StatusOK, gin.H{
+					"success": true,
+					"id":      proxy.ID,
+				})
+
+				return
+			}
+
+			backendResponse, err := backend.ProcessCommand(&commonbackend.AddProxy{
+				SourceIP:   proxy.SourceIP,
+				SourcePort: proxy.SourcePort,
+				DestPort:   proxy.DestinationPort,
+				Protocol:   proxy.Protocol,
+			})
+
+			if err != nil {
+				log.Warnf("Failed to get response for backend #%d: %s", proxy.BackendID, err.Error())
+
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"error": "failed to get response from backend",
+				})
+
+				return
+			}
+
+			switch responseMessage := backendResponse.(type) {
+			case *commonbackend.ProxyStatusResponse:
+				if !responseMessage.IsActive {
+					log.Warnf("Failed to start proxy for backend #%d", proxy.BackendID)
+				}
+			default:
+				log.Errorf("Got illegal response type for backend #%d: %T", proxy.BackendID, responseMessage)
+			}
+		}
+
+		c.JSON(http.StatusOK, gin.H{
+			"success": true,
+			"id":      proxy.ID,
+		})
 	})
 }

backend/api/controllers/v1/proxies/lookup.go

@@ -5,12 +5,11 @@ import (
 	"net/http"
 	"strings"
 
-	"git.terah.dev/imterah/hermes/backend/api/dbcore"
-	"git.terah.dev/imterah/hermes/backend/api/jwtcore"
+	"git.terah.dev/imterah/hermes/backend/api/db"
 	"git.terah.dev/imterah/hermes/backend/api/permissions"
+	"git.terah.dev/imterah/hermes/backend/api/state"
 	"github.com/charmbracelet/log"
 	"github.com/gin-gonic/gin"
-	"github.com/go-playground/validator/v10"
 )
 
 type ProxyLookupRequest struct {
@@ -43,141 +42,143 @@ type ProxyLookupResponse struct {
 	Data    []*SanitizedProxy `json:"data"`
 }
 
-func LookupProxy(c *gin.Context) {
-	var req ProxyLookupRequest
+func SetupLookupProxy(state *state.State) {
+	state.Engine.POST("/api/v1/forward/lookup", func(c *gin.Context) {
+		var req ProxyLookupRequest
 
-	if err := c.BindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
-		})
-
-		return
-	}
-
-	if err := validator.New().Struct(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
-		})
-
-		return
-	}
-
-	user, err := jwtcore.GetUserFromJWT(req.Token)
-
-	if err != nil {
-		if err.Error() == "token is expired" || err.Error() == "user does not exist" {
-			c.JSON(http.StatusForbidden, gin.H{
-				"error": err.Error(),
+		if err := c.BindJSON(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
 			})
 
 			return
-		} else {
-			log.Warnf("Failed to get user from the provided JWT token: %s", err.Error())
+		}
+
+		if err := state.Validator.Struct(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
+			})
+
+			return
+		}
+
+		user, err := state.JWT.GetUserFromJWT(req.Token)
+
+		if err != nil {
+			if err.Error() == "token is expired" || err.Error() == "user does not exist" {
+				c.JSON(http.StatusForbidden, gin.H{
+					"error": err.Error(),
+				})
+
+				return
+			} else {
+				log.Warnf("Failed to get user from the provided JWT token: %s", err.Error())
+
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"error": "Failed to parse token",
+				})
+
+				return
+			}
+		}
+
+		if !permissions.UserHasPermission(user, "routes.visible") {
+			c.JSON(http.StatusForbidden, gin.H{
+				"error": "Missing permissions",
+			})
+
+			return
+		}
+
+		if req.Protocol != nil {
+			if *req.Protocol != "tcp" && *req.Protocol != "udp" {
+				c.JSON(http.StatusBadRequest, gin.H{
+					"error": "Protocol specified in body must either be 'tcp' or 'udp'",
+				})
+
+				return
+			}
+		}
+
+		proxies := []db.Proxy{}
+
+		queryString := []string{}
+		queryParameters := []interface{}{}
+
+		if req.Id != nil {
+			queryString = append(queryString, "id = ?")
+			queryParameters = append(queryParameters, req.Id)
+		}
+
+		if req.Name != nil {
+			queryString = append(queryString, "name = ?")
+			queryParameters = append(queryParameters, req.Name)
+		}
+
+		if req.Description != nil {
+			queryString = append(queryString, "description = ?")
+			queryParameters = append(queryParameters, req.Description)
+		}
+
+		if req.SourceIP != nil {
+			queryString = append(queryString, "name = ?")
+			queryParameters = append(queryParameters, req.Name)
+		}
+
+		if req.SourcePort != nil {
+			queryString = append(queryString, "source_port = ?")
+			queryParameters = append(queryParameters, req.SourcePort)
+		}
+
+		if req.DestinationPort != nil {
+			queryString = append(queryString, "destination_port = ?")
+			queryParameters = append(queryParameters, req.DestinationPort)
+		}
+
+		if req.ProviderID != nil {
+			queryString = append(queryString, "backend_id = ?")
+			queryParameters = append(queryParameters, req.ProviderID)
+		}
+
+		if req.AutoStart != nil {
+			queryString = append(queryString, "auto_start = ?")
+			queryParameters = append(queryParameters, req.AutoStart)
+		}
+
+		if req.Protocol != nil {
+			queryString = append(queryString, "protocol = ?")
+			queryParameters = append(queryParameters, req.Protocol)
+		}
+
+		if err := state.DB.DB.Where(strings.Join(queryString, " AND "), queryParameters...).Find(&proxies).Error; err != nil {
+			log.Warnf("failed to get proxies: %s", err.Error())
 
 			c.JSON(http.StatusInternalServerError, gin.H{
-				"error": "Failed to parse token",
+				"error": "Failed to get proxies",
 			})
 
 			return
 		}
-	}
 
-	if !permissions.UserHasPermission(user, "routes.visible") {
-		c.JSON(http.StatusForbidden, gin.H{
-			"error": "Missing permissions",
-		})
+		sanitizedProxies := make([]*SanitizedProxy, len(proxies))
 
-		return
-	}
-
-	if req.Protocol != nil {
-		if *req.Protocol != "tcp" && *req.Protocol != "udp" {
-			c.JSON(http.StatusBadRequest, gin.H{
-				"error": "Protocol specified in body must either be 'tcp' or 'udp'",
-			})
-
-			return
+		for proxyIndex, proxy := range proxies {
+			sanitizedProxies[proxyIndex] = &SanitizedProxy{
+				Id:              proxy.ID,
+				Name:            proxy.Name,
+				Description:     proxy.Description,
+				Protcol:         proxy.Protocol,
+				SourceIP:        proxy.SourceIP,
+				SourcePort:      proxy.SourcePort,
+				DestinationPort: proxy.DestinationPort,
+				ProviderID:      proxy.BackendID,
+				AutoStart:       proxy.AutoStart,
+			}
 		}
-	}
 
-	proxies := []dbcore.Proxy{}
-
-	queryString := []string{}
-	queryParameters := []interface{}{}
-
-	if req.Id != nil {
-		queryString = append(queryString, "id = ?")
-		queryParameters = append(queryParameters, req.Id)
-	}
-
-	if req.Name != nil {
-		queryString = append(queryString, "name = ?")
-		queryParameters = append(queryParameters, req.Name)
-	}
-
-	if req.Description != nil {
-		queryString = append(queryString, "description = ?")
-		queryParameters = append(queryParameters, req.Description)
-	}
-
-	if req.SourceIP != nil {
-		queryString = append(queryString, "name = ?")
-		queryParameters = append(queryParameters, req.Name)
-	}
-
-	if req.SourcePort != nil {
-		queryString = append(queryString, "source_port = ?")
-		queryParameters = append(queryParameters, req.SourcePort)
-	}
-
-	if req.DestinationPort != nil {
-		queryString = append(queryString, "destination_port = ?")
-		queryParameters = append(queryParameters, req.DestinationPort)
-	}
-
-	if req.ProviderID != nil {
-		queryString = append(queryString, "backend_id = ?")
-		queryParameters = append(queryParameters, req.ProviderID)
-	}
-
-	if req.AutoStart != nil {
-		queryString = append(queryString, "auto_start = ?")
-		queryParameters = append(queryParameters, req.AutoStart)
-	}
-
-	if req.Protocol != nil {
-		queryString = append(queryString, "protocol = ?")
-		queryParameters = append(queryParameters, req.Protocol)
-	}
-
-	if err := dbcore.DB.Where(strings.Join(queryString, " AND "), queryParameters...).Find(&proxies).Error; err != nil {
-		log.Warnf("failed to get proxies: %s", err.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to get proxies",
+		c.JSON(http.StatusOK, &ProxyLookupResponse{
+			Success: true,
+			Data:    sanitizedProxies,
 		})
-
-		return
-	}
-
-	sanitizedProxies := make([]*SanitizedProxy, len(proxies))
-
-	for proxyIndex, proxy := range proxies {
-		sanitizedProxies[proxyIndex] = &SanitizedProxy{
-			Id:              proxy.ID,
-			Name:            proxy.Name,
-			Description:     proxy.Description,
-			Protcol:         proxy.Protocol,
-			SourceIP:        proxy.SourceIP,
-			SourcePort:      proxy.SourcePort,
-			DestinationPort: proxy.DestinationPort,
-			ProviderID:      proxy.BackendID,
-			AutoStart:       proxy.AutoStart,
-		}
-	}
-
-	c.JSON(http.StatusOK, &ProxyLookupResponse{
-		Success: true,
-		Data:    sanitizedProxies,
 	})
 }

backend/api/controllers/v1/proxies/remove.go

@@ -5,13 +5,12 @@ import (
 	"net/http"
 
 	"git.terah.dev/imterah/hermes/backend/api/backendruntime"
-	"git.terah.dev/imterah/hermes/backend/api/dbcore"
-	"git.terah.dev/imterah/hermes/backend/api/jwtcore"
+	"git.terah.dev/imterah/hermes/backend/api/db"
 	"git.terah.dev/imterah/hermes/backend/api/permissions"
+	"git.terah.dev/imterah/hermes/backend/api/state"
 	"git.terah.dev/imterah/hermes/backend/commonbackend"
 	"github.com/charmbracelet/log"
 	"github.com/gin-gonic/gin"
-	"github.com/go-playground/validator/v10"
 )
 
 type ProxyRemovalRequest struct {
@@ -19,134 +18,133 @@ type ProxyRemovalRequest struct {
 	ID    uint   `validate:"required" json:"id"`
 }
 
-func RemoveProxy(c *gin.Context) {
-	var req ProxyRemovalRequest
+func SetupRemoveProxy(state *state.State) {
+	state.Engine.POST("/api/v1/forward/remove", func(c *gin.Context) {
+		var req ProxyRemovalRequest
 
-	if err := c.BindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
-		})
+		if err := c.BindJSON(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
+			})
 
-		return
-	}
+			return
+		}
 
-	if err := validator.New().Struct(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
-		})
+		if err := state.Validator.Struct(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
+			})
 
-		return
-	}
+			return
+		}
 
-	user, err := jwtcore.GetUserFromJWT(req.Token)
-	if err != nil {
-		if err.Error() == "token is expired" || err.Error() == "user does not exist" {
+		user, err := state.JWT.GetUserFromJWT(req.Token)
+
+		if err != nil {
+			if err.Error() == "token is expired" || err.Error() == "user does not exist" {
+				c.JSON(http.StatusForbidden, gin.H{
+					"error": err.Error(),
+				})
+
+				return
+			} else {
+				log.Warnf("Failed to get user from the provided JWT token: %s", err.Error())
+
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"error": "Failed to parse token",
+				})
+
+				return
+			}
+		}
+
+		if !permissions.UserHasPermission(user, "routes.remove") {
 			c.JSON(http.StatusForbidden, gin.H{
-				"error": err.Error(),
-			})
-
-			return
-		} else {
-			log.Warnf("Failed to get user from the provided JWT token: %s", err.Error())
-
-			c.JSON(http.StatusInternalServerError, gin.H{
-				"error": "Failed to parse token",
+				"error": "Missing permissions",
 			})
 
 			return
 		}
-	}
 
-	if !permissions.UserHasPermission(user, "routes.remove") {
-		c.JSON(http.StatusForbidden, gin.H{
-			"error": "Missing permissions",
-		})
+		var proxy *db.Proxy
+		proxyRequest := state.DB.DB.Where("id = ?", req.ID).Find(&proxy)
 
-		return
-	}
+		if proxyRequest.Error != nil {
+			log.Warnf("failed to find if proxy exists or not: %s", proxyRequest.Error.Error())
 
-	var proxy *dbcore.Proxy
-	proxyRequest := dbcore.DB.Where("id = ?", req.ID).Find(&proxy)
-
-	if proxyRequest.Error != nil {
-		log.Warnf("failed to find if proxy exists or not: %s", proxyRequest.Error.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to find if forward rule exists",
-		})
-
-		return
-	}
-
-	proxyExists := proxyRequest.RowsAffected > 0
-
-	if !proxyExists {
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Forward rule doesn't exist",
-		})
-
-		return
-	}
-
-	if err := dbcore.DB.Delete(proxy).Error; err != nil {
-		log.Warnf("failed to delete proxy: %s", err.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to delete forward rule",
-		})
-
-		return
-	}
-
-	backend, ok := backendruntime.RunningBackends[proxy.BackendID]
-
-	if !ok {
-		log.Warnf("Couldn't fetch backend runtime from backend ID #%d", proxy.BackendID)
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Couldn't fetch backend runtime",
-		})
-
-		return
-	}
-
-	backendResponse, err := backend.ProcessCommand(&commonbackend.RemoveProxy{
-		SourceIP:   proxy.SourceIP,
-		SourcePort: proxy.SourcePort,
-		DestPort:   proxy.DestinationPort,
-		Protocol:   proxy.Protocol,
-	})
-
-	if err != nil {
-		log.Warnf("Failed to get response for backend #%d: %s", proxy.BackendID, err.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to get response from backend. Proxy was still successfully deleted",
-		})
-
-		return
-	}
-
-	switch responseMessage := backendResponse.(type) {
-	case *commonbackend.ProxyStatusResponse:
-		if responseMessage.IsActive {
 			c.JSON(http.StatusInternalServerError, gin.H{
-				"error": "Failed to stop proxy. Proxy was still successfully deleted",
+				"error": "Failed to find if forward rule exists",
 			})
 
 			return
 		}
-	default:
-		log.Errorf("Got illegal response type for backend #%d: %T", proxy.BackendID, responseMessage)
 
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Got invalid response from backend. Proxy was still successfully deleted",
+		proxyExists := proxyRequest.RowsAffected > 0
+
+		if !proxyExists {
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Forward rule doesn't exist",
+			})
+
+			return
+		}
+
+		if err := state.DB.DB.Delete(proxy).Error; err != nil {
+			log.Warnf("failed to delete proxy: %s", err.Error())
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to delete forward rule",
+			})
+
+			return
+		}
+
+		backend, ok := backendruntime.RunningBackends[proxy.BackendID]
+
+		if !ok {
+			log.Warnf("Couldn't fetch backend runtime from backend ID #%d", proxy.BackendID)
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Couldn't fetch backend runtime",
+			})
+
+			return
+		}
+
+		backendResponse, err := backend.ProcessCommand(&commonbackend.RemoveProxy{
+			SourceIP:   proxy.SourceIP,
+			SourcePort: proxy.SourcePort,
+			DestPort:   proxy.DestinationPort,
+			Protocol:   proxy.Protocol,
 		})
 
-		return
-	}
+		if err != nil {
+			log.Warnf("Failed to get response for backend #%d: %s", proxy.BackendID, err.Error())
 
-	c.JSON(http.StatusOK, gin.H{
-		"success": true,
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to get response from backend. Proxy was still successfully deleted",
+			})
+
+			return
+		}
+
+		switch responseMessage := backendResponse.(type) {
+		case *commonbackend.ProxyStatusResponse:
+			if responseMessage.IsActive {
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"error": "Failed to stop proxy. Proxy was still successfully deleted",
+				})
+			} else {
+				c.JSON(http.StatusOK, gin.H{
+					"success": true,
+				})
+			}
+		default:
+			log.Errorf("Got illegal response type for backend #%d: %T", proxy.BackendID, responseMessage)
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Got invalid response from backend. Proxy was still successfully deleted",
+			})
+		}
 	})
 }

backend/api/controllers/v1/proxies/start.go

@@ -5,13 +5,12 @@ import (
 	"net/http"
 
 	"git.terah.dev/imterah/hermes/backend/api/backendruntime"
-	"git.terah.dev/imterah/hermes/backend/api/dbcore"
-	"git.terah.dev/imterah/hermes/backend/api/jwtcore"
+	"git.terah.dev/imterah/hermes/backend/api/db"
 	"git.terah.dev/imterah/hermes/backend/api/permissions"
+	"git.terah.dev/imterah/hermes/backend/api/state"
 	"git.terah.dev/imterah/hermes/backend/commonbackend"
 	"github.com/charmbracelet/log"
 	"github.com/gin-gonic/gin"
-	"github.com/go-playground/validator/v10"
 )
 
 type ProxyStartRequest struct {
@@ -19,124 +18,119 @@ type ProxyStartRequest struct {
 	ID    uint   `validate:"required" json:"id"`
 }
 
-func StartProxy(c *gin.Context) {
-	var req ProxyStartRequest
+func SetupStartProxy(state *state.State) {
+	state.Engine.POST("/api/v1/forward/start", func(c *gin.Context) {
+		var req ProxyStartRequest
 
-	if err := c.BindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
-		})
+		if err := c.BindJSON(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
+			})
 
-		return
-	}
+			return
+		}
 
-	if err := validator.New().Struct(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
-		})
+		if err := state.Validator.Struct(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
+			})
 
-		return
-	}
+			return
+		}
 
-	user, err := jwtcore.GetUserFromJWT(req.Token)
-	if err != nil {
-		if err.Error() == "token is expired" || err.Error() == "user does not exist" {
+		user, err := state.JWT.GetUserFromJWT(req.Token)
+
+		if err != nil {
+			if err.Error() == "token is expired" || err.Error() == "user does not exist" {
+				c.JSON(http.StatusForbidden, gin.H{
+					"error": err.Error(),
+				})
+
+				return
+			} else {
+				log.Warnf("Failed to get user from the provided JWT token: %s", err.Error())
+
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"error": "Failed to parse token",
+				})
+
+				return
+			}
+		}
+
+		if !permissions.UserHasPermission(user, "routes.start") {
 			c.JSON(http.StatusForbidden, gin.H{
-				"error": err.Error(),
-			})
-
-			return
-		} else {
-			log.Warnf("Failed to get user from the provided JWT token: %s", err.Error())
-
-			c.JSON(http.StatusInternalServerError, gin.H{
-				"error": "Failed to parse token",
-			})
-
-			return
-		}
-	}
-
-	if !permissions.UserHasPermission(user, "routes.start") {
-		c.JSON(http.StatusForbidden, gin.H{
-			"error": "Missing permissions",
-		})
-
-		return
-	}
-
-	var proxy *dbcore.Proxy
-	proxyRequest := dbcore.DB.Where("id = ?", req.ID).Find(&proxy)
-
-	if proxyRequest.Error != nil {
-		log.Warnf("failed to find if proxy exists or not: %s", proxyRequest.Error.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to find if forward rule exists",
-		})
-
-		return
-	}
-
-	proxyExists := proxyRequest.RowsAffected > 0
-
-	if !proxyExists {
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Forward rule doesn't exist",
-		})
-
-		return
-	}
-
-	backend, ok := backendruntime.RunningBackends[proxy.BackendID]
-
-	if !ok {
-		log.Warnf("Couldn't fetch backend runtime from backend ID #%d", proxy.BackendID)
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Couldn't fetch backend runtime",
-		})
-
-		return
-	}
-
-	backendResponse, err := backend.ProcessCommand(&commonbackend.AddProxy{
-		SourceIP:   proxy.SourceIP,
-		SourcePort: proxy.SourcePort,
-		DestPort:   proxy.DestinationPort,
-		Protocol:   proxy.Protocol,
-	})
-
-	switch responseMessage := backendResponse.(type) {
-	case error:
-		log.Warnf("Failed to get response for backend #%d: %s", proxy.BackendID, responseMessage.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "failed to get response from backend",
-		})
-
-		return
-	case *commonbackend.ProxyStatusResponse:
-		if !responseMessage.IsActive {
-			c.JSON(http.StatusInternalServerError, gin.H{
-				"error": "failed to start proxy",
+				"error": "Missing permissions",
 			})
 
 			return
 		}
 
-		break
-	default:
-		log.Errorf("Got illegal response type for backend #%d: %T", proxy.BackendID, responseMessage)
+		var proxy *db.Proxy
+		proxyRequest := state.DB.DB.Where("id = ?", req.ID).Find(&proxy)
 
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Got invalid response from backend. Proxy was still successfully deleted",
+		if proxyRequest.Error != nil {
+			log.Warnf("failed to find if proxy exists or not: %s", proxyRequest.Error.Error())
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to find if forward rule exists",
+			})
+
+			return
+		}
+
+		proxyExists := proxyRequest.RowsAffected > 0
+
+		if !proxyExists {
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Forward rule doesn't exist",
+			})
+
+			return
+		}
+
+		backend, ok := backendruntime.RunningBackends[proxy.BackendID]
+
+		if !ok {
+			log.Warnf("Couldn't fetch backend runtime from backend ID #%d", proxy.BackendID)
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Couldn't fetch backend runtime",
+			})
+
+			return
+		}
+
+		backendResponse, err := backend.ProcessCommand(&commonbackend.AddProxy{
+			SourceIP:   proxy.SourceIP,
+			SourcePort: proxy.SourcePort,
+			DestPort:   proxy.DestinationPort,
+			Protocol:   proxy.Protocol,
 		})
 
-		return
-	}
+		switch responseMessage := backendResponse.(type) {
+		case error:
+			log.Warnf("Failed to get response for backend #%d: %s", proxy.BackendID, responseMessage.Error())
 
-	c.JSON(http.StatusOK, gin.H{
-		"success": true,
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "failed to get response from backend",
+			})
+		case *commonbackend.ProxyStatusResponse:
+			if !responseMessage.IsActive {
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"error": "failed to start proxy",
+				})
+			} else {
+				c.JSON(http.StatusOK, gin.H{
+					"success": true,
+				})
+			}
+		default:
+			log.Errorf("Got illegal response type for backend #%d: %T", proxy.BackendID, responseMessage)
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Got invalid response from backend. Proxy was likely still successfully started",
+			})
+		}
 	})
 }

backend/api/controllers/v1/proxies/stop.go

@@ -5,13 +5,12 @@ import (
 	"net/http"
 
 	"git.terah.dev/imterah/hermes/backend/api/backendruntime"
-	"git.terah.dev/imterah/hermes/backend/api/dbcore"
-	"git.terah.dev/imterah/hermes/backend/api/jwtcore"
+	"git.terah.dev/imterah/hermes/backend/api/db"
 	"git.terah.dev/imterah/hermes/backend/api/permissions"
+	"git.terah.dev/imterah/hermes/backend/api/state"
 	"git.terah.dev/imterah/hermes/backend/commonbackend"
 	"github.com/charmbracelet/log"
 	"github.com/gin-gonic/gin"
-	"github.com/go-playground/validator/v10"
 )
 
 type ProxyStopRequest struct {
@@ -19,124 +18,119 @@ type ProxyStopRequest struct {
 	ID    uint   `validate:"required" json:"id"`
 }
 
-func StopProxy(c *gin.Context) {
-	var req ProxyStopRequest
+func SetupStopProxy(state *state.State) {
+	state.Engine.POST("/api/v1/forward/stop", func(c *gin.Context) {
+		var req ProxyStartRequest
 
-	if err := c.BindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
-		})
+		if err := c.BindJSON(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
+			})
 
-		return
-	}
+			return
+		}
 
-	if err := validator.New().Struct(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
-		})
+		if err := state.Validator.Struct(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
+			})
 
-		return
-	}
+			return
+		}
 
-	user, err := jwtcore.GetUserFromJWT(req.Token)
-	if err != nil {
-		if err.Error() == "token is expired" || err.Error() == "user does not exist" {
+		user, err := state.JWT.GetUserFromJWT(req.Token)
+
+		if err != nil {
+			if err.Error() == "token is expired" || err.Error() == "user does not exist" {
+				c.JSON(http.StatusForbidden, gin.H{
+					"error": err.Error(),
+				})
+
+				return
+			} else {
+				log.Warnf("Failed to get user from the provided JWT token: %s", err.Error())
+
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"error": "Failed to parse token",
+				})
+
+				return
+			}
+		}
+
+		if !permissions.UserHasPermission(user, "routes.stop") {
 			c.JSON(http.StatusForbidden, gin.H{
-				"error": err.Error(),
-			})
-
-			return
-		} else {
-			log.Warnf("Failed to get user from the provided JWT token: %s", err.Error())
-
-			c.JSON(http.StatusInternalServerError, gin.H{
-				"error": "Failed to parse token",
+				"error": "Missing permissions",
 			})
 
 			return
 		}
-	}
 
-	if !permissions.UserHasPermission(user, "routes.stop") {
-		c.JSON(http.StatusForbidden, gin.H{
-			"error": "Missing permissions",
-		})
+		var proxy *db.Proxy
+		proxyRequest := state.DB.DB.Where("id = ?", req.ID).Find(&proxy)
 
-		return
-	}
+		if proxyRequest.Error != nil {
+			log.Warnf("failed to find if proxy exists or not: %s", proxyRequest.Error.Error())
 
-	var proxy *dbcore.Proxy
-	proxyRequest := dbcore.DB.Where("id = ?", req.ID).Find(&proxy)
-
-	if proxyRequest.Error != nil {
-		log.Warnf("failed to find if proxy exists or not: %s", proxyRequest.Error.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to find if forward rule exists",
-		})
-
-		return
-	}
-
-	proxyExists := proxyRequest.RowsAffected > 0
-
-	if !proxyExists {
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Forward rule doesn't exist",
-		})
-
-		return
-	}
-
-	backend, ok := backendruntime.RunningBackends[proxy.BackendID]
-
-	if !ok {
-		log.Warnf("Couldn't fetch backend runtime from backend ID #%d", proxy.BackendID)
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Couldn't fetch backend runtime",
-		})
-
-		return
-	}
-
-	backendResponse, err := backend.ProcessCommand(&commonbackend.RemoveProxy{
-		SourceIP:   proxy.SourceIP,
-		SourcePort: proxy.SourcePort,
-		DestPort:   proxy.DestinationPort,
-		Protocol:   proxy.Protocol,
-	})
-
-	if err != nil {
-		log.Warnf("Failed to get response for backend #%d: %s", proxy.BackendID, err.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "failed to get response from backend",
-		})
-
-		return
-	}
-
-	switch responseMessage := backendResponse.(type) {
-	case *commonbackend.ProxyStatusResponse:
-		if responseMessage.IsActive {
 			c.JSON(http.StatusInternalServerError, gin.H{
-				"error": "failed to stop proxy",
+				"error": "Failed to find if forward rule exists",
 			})
 
 			return
 		}
-	default:
-		log.Errorf("Got illegal response type for backend #%d: %T", proxy.BackendID, responseMessage)
 
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Got invalid response from backend. Proxy was still successfully deleted",
+		proxyExists := proxyRequest.RowsAffected > 0
+
+		if !proxyExists {
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Forward rule doesn't exist",
+			})
+
+			return
+		}
+
+		backend, ok := backendruntime.RunningBackends[proxy.BackendID]
+
+		if !ok {
+			log.Warnf("Couldn't fetch backend runtime from backend ID #%d", proxy.BackendID)
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Couldn't fetch backend runtime",
+			})
+
+			return
+		}
+
+		backendResponse, err := backend.ProcessCommand(&commonbackend.RemoveProxy{
+			SourceIP:   proxy.SourceIP,
+			SourcePort: proxy.SourcePort,
+			DestPort:   proxy.DestinationPort,
+			Protocol:   proxy.Protocol,
 		})
 
-		return
-	}
+		switch responseMessage := backendResponse.(type) {
+		case error:
+			log.Warnf("Failed to get response for backend #%d: %s", proxy.BackendID, responseMessage.Error())
 
-	c.JSON(http.StatusOK, gin.H{
-		"success": true,
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "failed to get response from backend",
+			})
+		case *commonbackend.ProxyStatusResponse:
+			if responseMessage.IsActive {
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"error": "failed to stop proxy",
+				})
+			} else {
+				c.JSON(http.StatusOK, gin.H{
+					"success": true,
+				})
+			}
+		default:
+			log.Errorf("Got illegal response type for backend #%d: %T", proxy.BackendID, responseMessage)
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Got invalid response from backend. Proxy was likely still successfully stopped",
+			})
+		}
 	})
 }

backend/api/controllers/v1/users/create.go

@@ -7,11 +7,9 @@ import (
 	"net/http"
 	"strings"
 
-	"github.com/go-playground/validator/v10"
-
-	"git.terah.dev/imterah/hermes/backend/api/dbcore"
-	"git.terah.dev/imterah/hermes/backend/api/jwtcore"
+	"git.terah.dev/imterah/hermes/backend/api/db"
 	permissionHelper "git.terah.dev/imterah/hermes/backend/api/permissions"
+	"git.terah.dev/imterah/hermes/backend/api/state"
 	"github.com/charmbracelet/log"
 	"github.com/gin-gonic/gin"
 	"golang.org/x/crypto/bcrypt"
@@ -22,142 +20,141 @@ type UserCreationRequest struct {
 	Email    string `validate:"required"`
 	Password string `validate:"required"`
 	Username string `validate:"required"`
-
-	// TODO: implement support
-	ExistingUserToken string `json:"token"`
-	IsBot             bool
+	IsBot    bool
 }
 
-func CreateUser(c *gin.Context) {
-	if !signupEnabled && !unsafeSignup {
-		c.JSON(http.StatusForbidden, gin.H{
-			"error": "Signing up is not enabled at this time.",
-		})
+func SetupCreateUser(state *state.State) {
+	state.Engine.POST("/api/v1/users/create", func(c *gin.Context) {
+		if !signupEnabled && !unsafeSignup {
+			c.JSON(http.StatusForbidden, gin.H{
+				"error": "Signing up is not enabled at this time.",
+			})
 
-		return
-	}
-
-	var req UserCreationRequest
-
-	if err := c.BindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
-		})
-
-		return
-	}
-
-	if err := validator.New().Struct(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
-		})
-
-		return
-	}
-
-	var user *dbcore.User
-	userRequest := dbcore.DB.Where("email = ? OR username = ?", req.Email, req.Username).Find(&user)
-
-	if userRequest.Error != nil {
-		log.Warnf("failed to find if user exists or not: %s", userRequest.Error.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to find if user exists",
-		})
-
-		return
-	}
-
-	userExists := userRequest.RowsAffected > 0
-
-	if userExists {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": "User already exists",
-		})
-
-		return
-	}
-
-	passwordHashed, err := bcrypt.GenerateFromPassword([]byte(req.Password), bcrypt.DefaultCost)
-
-	if err != nil {
-		log.Warnf("Failed to generate password for client upon signup: %s", err.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to generate password hash",
-		})
-
-		return
-	}
-
-	permissions := []dbcore.Permission{}
-
-	for _, permission := range permissionHelper.DefaultPermissionNodes {
-		permissionEnabledState := false
-
-		if unsafeSignup || strings.HasPrefix(permission, "routes.") || permission == "permissions.see" {
-			permissionEnabledState = true
+			return
 		}
 
-		permissions = append(permissions, dbcore.Permission{
-			PermissionNode: permission,
-			HasPermission:  permissionEnabledState,
-		})
-	}
+		var req UserCreationRequest
 
-	tokenRandomData := make([]byte, 80)
+		if err := c.BindJSON(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
+			})
 
-	if _, err := rand.Read(tokenRandomData); err != nil {
-		log.Warnf("Failed to read random data to use as token: %s", err.Error())
+			return
+		}
 
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to generate refresh token",
-		})
+		if err := state.Validator.Struct(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
+			})
 
-		return
-	}
+			return
+		}
 
-	user = &dbcore.User{
-		Email:       req.Email,
-		Username:    req.Username,
-		Name:        req.Name,
-		IsBot:       &req.IsBot,
-		Password:    base64.StdEncoding.EncodeToString(passwordHashed),
-		Permissions: permissions,
-		Tokens: []dbcore.Token{
-			{
-				Token:          base64.StdEncoding.EncodeToString(tokenRandomData),
-				DisableExpiry:  forceNoExpiryTokens,
-				CreationIPAddr: c.ClientIP(),
+		var user *db.User
+		userRequest := state.DB.DB.Where("email = ? OR username = ?", req.Email, req.Username).Find(&user)
+
+		if userRequest.Error != nil {
+			log.Warnf("failed to find if user exists or not: %s", userRequest.Error.Error())
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to find if user exists",
+			})
+
+			return
+		}
+
+		userExists := userRequest.RowsAffected > 0
+
+		if userExists {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": "User already exists",
+			})
+
+			return
+		}
+
+		passwordHashed, err := bcrypt.GenerateFromPassword([]byte(req.Password), bcrypt.DefaultCost)
+
+		if err != nil {
+			log.Warnf("Failed to generate password for client upon signup: %s", err.Error())
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to generate password hash",
+			})
+
+			return
+		}
+
+		permissions := []db.Permission{}
+
+		for _, permission := range permissionHelper.DefaultPermissionNodes {
+			permissionEnabledState := false
+
+			if unsafeSignup || strings.HasPrefix(permission, "routes.") || permission == "permissions.see" {
+				permissionEnabledState = true
+			}
+
+			permissions = append(permissions, db.Permission{
+				PermissionNode: permission,
+				HasPermission:  permissionEnabledState,
+			})
+		}
+
+		tokenRandomData := make([]byte, 80)
+
+		if _, err := rand.Read(tokenRandomData); err != nil {
+			log.Warnf("Failed to read random data to use as token: %s", err.Error())
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to generate refresh token",
+			})
+
+			return
+		}
+
+		user = &db.User{
+			Email:       req.Email,
+			Username:    req.Username,
+			Name:        req.Name,
+			IsBot:       &req.IsBot,
+			Password:    base64.StdEncoding.EncodeToString(passwordHashed),
+			Permissions: permissions,
+			Tokens: []db.Token{
+				{
+					Token:          base64.StdEncoding.EncodeToString(tokenRandomData),
+					DisableExpiry:  forceNoExpiryTokens,
+					CreationIPAddr: c.ClientIP(),
+				},
 			},
-		},
-	}
+		}
 
-	if result := dbcore.DB.Create(&user); result.Error != nil {
-		log.Warnf("Failed to create user: %s", result.Error.Error())
+		if result := state.DB.DB.Create(&user); result.Error != nil {
+			log.Warnf("Failed to create user: %s", result.Error.Error())
 
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to add user into database",
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to add user into database",
+			})
+
+			return
+		}
+
+		jwt, err := state.JWT.Generate(user.ID)
+
+		if err != nil {
+			log.Warnf("Failed to generate JWT: %s", err.Error())
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to generate refresh token",
+			})
+
+			return
+		}
+
+		c.JSON(http.StatusOK, gin.H{
+			"success":      true,
+			"token":        jwt,
+			"refreshToken": base64.StdEncoding.EncodeToString(tokenRandomData),
 		})
-
-		return
-	}
-
-	jwt, err := jwtcore.Generate(user.ID)
-
-	if err != nil {
-		log.Warnf("Failed to generate JWT: %s", err.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to generate refresh token",
-		})
-
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{
-		"success":      true,
-		"token":        jwt,
-		"refreshToken": base64.StdEncoding.EncodeToString(tokenRandomData),
 	})
 }

backend/api/controllers/v1/users/login.go

@@ -6,11 +6,10 @@ import (
 	"fmt"
 	"net/http"
 
-	"git.terah.dev/imterah/hermes/backend/api/dbcore"
-	"git.terah.dev/imterah/hermes/backend/api/jwtcore"
+	"git.terah.dev/imterah/hermes/backend/api/db"
+	"git.terah.dev/imterah/hermes/backend/api/state"
 	"github.com/charmbracelet/log"
 	"github.com/gin-gonic/gin"
-	"github.com/go-playground/validator/v10"
 	"golang.org/x/crypto/bcrypt"
 )
 
@@ -21,137 +20,139 @@ type UserLoginRequest struct {
 	Password string `validate:"required"`
 }
 
-func LoginUser(c *gin.Context) {
-	var req UserLoginRequest
+func SetupLoginUser(state *state.State) {
+	state.Engine.POST("/api/v1/users/login", func(c *gin.Context) {
+		var req UserLoginRequest
 
-	if err := c.BindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
+		if err := c.BindJSON(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
+			})
+
+			return
+		}
+
+		if err := state.Validator.Struct(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
+			})
+
+			return
+		}
+
+		if req.Email == nil && req.Username == nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": "Missing both email and username in body",
+			})
+
+			return
+		}
+
+		userFindRequestArguments := make([]interface{}, 1)
+		userFindRequest := ""
+
+		if req.Email != nil {
+			userFindRequestArguments[0] = &req.Email
+			userFindRequest += "email = ?"
+		}
+
+		if req.Username != nil {
+			userFindRequestArguments[0] = &req.Username
+			userFindRequest += "username = ?"
+		}
+
+		var user *db.User
+		userRequest := state.DB.DB.Where(userFindRequest, userFindRequestArguments...).Find(&user)
+
+		if userRequest.Error != nil {
+			log.Warnf("failed to find if user exists or not: %s", userRequest.Error.Error())
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to find if user exists",
+			})
+
+			return
+		}
+
+		userExists := userRequest.RowsAffected > 0
+
+		if !userExists {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": "User not found",
+			})
+
+			return
+		}
+
+		decodedPassword := make([]byte, base64.StdEncoding.DecodedLen(len(user.Password)))
+		_, err := base64.StdEncoding.Decode(decodedPassword, []byte(user.Password))
+
+		if err != nil {
+			log.Warnf("failed to decode password in database: %s", err.Error())
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to parse database result for password",
+			})
+
+			return
+		}
+
+		err = bcrypt.CompareHashAndPassword(decodedPassword, []byte(req.Password))
+
+		if err != nil {
+			c.JSON(http.StatusForbidden, gin.H{
+				"error": "Invalid password",
+			})
+
+			return
+		}
+
+		tokenRandomData := make([]byte, 80)
+
+		if _, err := rand.Read(tokenRandomData); err != nil {
+			log.Warnf("Failed to read random data to use as token: %s", err.Error())
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to generate refresh token",
+			})
+
+			return
+		}
+
+		token := &db.Token{
+			UserID: user.ID,
+
+			Token:          base64.StdEncoding.EncodeToString(tokenRandomData),
+			DisableExpiry:  forceNoExpiryTokens,
+			CreationIPAddr: c.ClientIP(),
+		}
+
+		if result := state.DB.DB.Create(&token); result.Error != nil {
+			log.Warnf("Failed to create user: %s", result.Error.Error())
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to add refresh token into database",
+			})
+
+			return
+		}
+
+		jwt, err := state.JWT.Generate(user.ID)
+
+		if err != nil {
+			log.Warnf("Failed to generate JWT: %s", err.Error())
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to generate refresh token",
+			})
+
+			return
+		}
+
+		c.JSON(http.StatusOK, gin.H{
+			"success":      true,
+			"token":        jwt,
+			"refreshToken": base64.StdEncoding.EncodeToString(tokenRandomData),
 		})
-
-		return
-	}
-
-	if err := validator.New().Struct(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
-		})
-
-		return
-	}
-
-	if req.Email == nil && req.Username == nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": "Missing both email and username in body",
-		})
-
-		return
-	}
-
-	userFindRequestArguments := make([]interface{}, 1)
-	userFindRequest := ""
-
-	if req.Email != nil {
-		userFindRequestArguments[0] = &req.Email
-		userFindRequest += "email = ?"
-	}
-
-	if req.Username != nil {
-		userFindRequestArguments[0] = &req.Username
-		userFindRequest += "username = ?"
-	}
-
-	var user *dbcore.User
-	userRequest := dbcore.DB.Where(userFindRequest, userFindRequestArguments...).Find(&user)
-
-	if userRequest.Error != nil {
-		log.Warnf("failed to find if user exists or not: %s", userRequest.Error.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to find if user exists",
-		})
-
-		return
-	}
-
-	userExists := userRequest.RowsAffected > 0
-
-	if !userExists {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": "User not found",
-		})
-
-		return
-	}
-
-	decodedPassword := make([]byte, base64.StdEncoding.DecodedLen(len(user.Password)))
-	_, err := base64.StdEncoding.Decode(decodedPassword, []byte(user.Password))
-
-	if err != nil {
-		log.Warnf("failed to decode password in database: %s", err.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to parse database result for password",
-		})
-
-		return
-	}
-
-	err = bcrypt.CompareHashAndPassword(decodedPassword, []byte(req.Password))
-
-	if err != nil {
-		c.JSON(http.StatusForbidden, gin.H{
-			"error": "Invalid password",
-		})
-
-		return
-	}
-
-	tokenRandomData := make([]byte, 80)
-
-	if _, err := rand.Read(tokenRandomData); err != nil {
-		log.Warnf("Failed to read random data to use as token: %s", err.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to generate refresh token",
-		})
-
-		return
-	}
-
-	token := &dbcore.Token{
-		UserID: user.ID,
-
-		Token:          base64.StdEncoding.EncodeToString(tokenRandomData),
-		DisableExpiry:  forceNoExpiryTokens,
-		CreationIPAddr: c.ClientIP(),
-	}
-
-	if result := dbcore.DB.Create(&token); result.Error != nil {
-		log.Warnf("Failed to create user: %s", result.Error.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to add refresh token into database",
-		})
-
-		return
-	}
-
-	jwt, err := jwtcore.Generate(user.ID)
-
-	if err != nil {
-		log.Warnf("Failed to generate JWT: %s", err.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to generate refresh token",
-		})
-
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{
-		"success":      true,
-		"token":        jwt,
-		"refreshToken": base64.StdEncoding.EncodeToString(tokenRandomData),
 	})
 }

backend/api/controllers/v1/users/lookup.go

@@ -5,12 +5,11 @@ import (
 	"net/http"
 	"strings"
 
-	"git.terah.dev/imterah/hermes/backend/api/dbcore"
-	"git.terah.dev/imterah/hermes/backend/api/jwtcore"
+	"git.terah.dev/imterah/hermes/backend/api/db"
 	"git.terah.dev/imterah/hermes/backend/api/permissions"
+	"git.terah.dev/imterah/hermes/backend/api/state"
 	"github.com/charmbracelet/log"
 	"github.com/gin-gonic/gin"
-	"github.com/go-playground/validator/v10"
 )
 
 type UserLookupRequest struct {
@@ -35,102 +34,104 @@ type LookupResponse struct {
 	Data    []*SanitizedUsers `json:"data"`
 }
 
-func LookupUser(c *gin.Context) {
-	var req UserLookupRequest
+func SetupLookupUser(state *state.State) {
+	state.Engine.POST("/api/v1/users/lookup", func(c *gin.Context) {
+		var req UserLookupRequest
 
-	if err := c.BindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
-		})
-
-		return
-	}
-
-	if err := validator.New().Struct(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
-		})
-
-		return
-	}
-
-	user, err := jwtcore.GetUserFromJWT(req.Token)
-
-	if err != nil {
-		if err.Error() == "token is expired" || err.Error() == "user does not exist" {
-			c.JSON(http.StatusForbidden, gin.H{
-				"error": err.Error(),
+		if err := c.BindJSON(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
 			})
 
 			return
-		} else {
-			log.Warnf("Failed to get user from the provided JWT token: %s", err.Error())
+		}
+
+		if err := state.Validator.Struct(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
+			})
+
+			return
+		}
+
+		user, err := state.JWT.GetUserFromJWT(req.Token)
+
+		if err != nil {
+			if err.Error() == "token is expired" || err.Error() == "user does not exist" {
+				c.JSON(http.StatusForbidden, gin.H{
+					"error": err.Error(),
+				})
+
+				return
+			} else {
+				log.Warnf("Failed to get user from the provided JWT token: %s", err.Error())
+
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"error": "Failed to parse token",
+				})
+
+				return
+			}
+		}
+
+		users := []db.User{}
+		queryString := []string{}
+		queryParameters := []interface{}{}
+
+		if !permissions.UserHasPermission(user, "users.lookup") {
+			queryString = append(queryString, "id = ?")
+			queryParameters = append(queryParameters, user.ID)
+		} else if permissions.UserHasPermission(user, "users.lookup") && req.UID != nil {
+			queryString = append(queryString, "id = ?")
+			queryParameters = append(queryParameters, req.UID)
+		}
+
+		if req.Name != nil {
+			queryString = append(queryString, "name = ?")
+			queryParameters = append(queryParameters, req.Name)
+		}
+
+		if req.Email != nil {
+			queryString = append(queryString, "email = ?")
+			queryParameters = append(queryParameters, req.Email)
+		}
+
+		if req.IsBot != nil {
+			queryString = append(queryString, "is_bot = ?")
+			queryParameters = append(queryParameters, req.IsBot)
+		}
+
+		if err := state.DB.DB.Where(strings.Join(queryString, " AND "), queryParameters...).Find(&users).Error; err != nil {
+			log.Warnf("Failed to get users: %s", err.Error())
 
 			c.JSON(http.StatusInternalServerError, gin.H{
-				"error": "Failed to parse token",
+				"error": "Failed to get users",
 			})
 
 			return
 		}
-	}
 
-	users := []dbcore.User{}
-	queryString := []string{}
-	queryParameters := []interface{}{}
+		sanitizedUsers := make([]*SanitizedUsers, len(users))
 
-	if !permissions.UserHasPermission(user, "users.lookup") {
-		queryString = append(queryString, "id = ?")
-		queryParameters = append(queryParameters, user.ID)
-	} else if permissions.UserHasPermission(user, "users.lookup") && req.UID != nil {
-		queryString = append(queryString, "id = ?")
-		queryParameters = append(queryParameters, req.UID)
-	}
+		for userIndex, user := range users {
+			isBot := false
 
-	if req.Name != nil {
-		queryString = append(queryString, "name = ?")
-		queryParameters = append(queryParameters, req.Name)
-	}
+			if user.IsBot != nil {
+				isBot = *user.IsBot
+			}
 
-	if req.Email != nil {
-		queryString = append(queryString, "email = ?")
-		queryParameters = append(queryParameters, req.Email)
-	}
+			sanitizedUsers[userIndex] = &SanitizedUsers{
+				UID:      user.ID,
+				Name:     user.Name,
+				Email:    user.Email,
+				Username: user.Username,
+				IsBot:    isBot,
+			}
+		}
 
-	if req.IsBot != nil {
-		queryString = append(queryString, "is_bot = ?")
-		queryParameters = append(queryParameters, req.IsBot)
-	}
-
-	if err := dbcore.DB.Where(strings.Join(queryString, " AND "), queryParameters...).Find(&users).Error; err != nil {
-		log.Warnf("Failed to get users: %s", err.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to get users",
+		c.JSON(http.StatusOK, &LookupResponse{
+			Success: true,
+			Data:    sanitizedUsers,
 		})
-
-		return
-	}
-
-	sanitizedUsers := make([]*SanitizedUsers, len(users))
-
-	for userIndex, user := range users {
-		isBot := false
-
-		if user.IsBot != nil {
-			isBot = *user.IsBot
-		}
-
-		sanitizedUsers[userIndex] = &SanitizedUsers{
-			UID:      user.ID,
-			Name:     user.Name,
-			Email:    user.Email,
-			Username: user.Username,
-			IsBot:    isBot,
-		}
-	}
-
-	c.JSON(http.StatusOK, &LookupResponse{
-		Success: true,
-		Data:    sanitizedUsers,
 	})
 }

backend/api/controllers/v1/users/refresh.go

@@ -5,113 +5,114 @@ import (
 	"net/http"
 	"time"
 
-	"git.terah.dev/imterah/hermes/backend/api/dbcore"
-	"git.terah.dev/imterah/hermes/backend/api/jwtcore"
+	"git.terah.dev/imterah/hermes/backend/api/db"
+	"git.terah.dev/imterah/hermes/backend/api/state"
 	"github.com/charmbracelet/log"
 	"github.com/gin-gonic/gin"
-	"github.com/go-playground/validator/v10"
 )
 
 type UserRefreshRequest struct {
 	Token string `validate:"required"`
 }
 
-func RefreshUserToken(c *gin.Context) {
-	var req UserRefreshRequest
+func SetupRefreshUserToken(state *state.State) {
+	state.Engine.POST("/api/v1/users/refresh", func(c *gin.Context) {
+		var req UserRefreshRequest
 
-	if err := c.BindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
-		})
+		if err := c.BindJSON(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
+			})
 
-		return
-	}
-
-	if err := validator.New().Struct(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
-		})
-
-		return
-	}
-
-	var tokenInDatabase *dbcore.Token
-	tokenRequest := dbcore.DB.Where("token = ?", req.Token).Find(&tokenInDatabase)
-
-	if tokenRequest.Error != nil {
-		log.Warnf("failed to find if token exists or not: %s", tokenRequest.Error.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to find if token exists",
-		})
-
-		return
-	}
-
-	tokenExists := tokenRequest.RowsAffected > 0
-
-	if !tokenExists {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": "Token not found",
-		})
-
-		return
-	}
-
-	// First, we check to make sure that the key expiry is disabled before checking if the key is expired.
-	// Then, we check if the IP addresses differ, or if it has been 7 days since the token has been created.
-	if !tokenInDatabase.DisableExpiry && (c.ClientIP() != tokenInDatabase.CreationIPAddr || time.Now().Before(tokenInDatabase.CreatedAt.Add((24*7)*time.Hour))) {
-		c.JSON(http.StatusForbidden, gin.H{
-			"error": "Token has expired",
-		})
-
-		tx := dbcore.DB.Delete(tokenInDatabase)
-
-		if tx.Error != nil {
-			log.Warnf("Failed to delete expired token from database: %s", tx.Error.Error())
+			return
 		}
 
-		return
-	}
+		if err := state.Validator.Struct(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
+			})
 
-	// Get the user to check if the user exists before doing anything
-	var user *dbcore.User
-	userRequest := dbcore.DB.Where("id = ?", tokenInDatabase.UserID).Find(&user)
+			return
+		}
 
-	if tokenRequest.Error != nil {
-		log.Warnf("failed to find if token user or not: %s", userRequest.Error.Error())
+		var tokenInDatabase *db.Token
+		tokenRequest := state.DB.DB.Where("token = ?", req.Token).Find(&tokenInDatabase)
 
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to find user",
+		if tokenRequest.Error != nil {
+			log.Warnf("failed to find if token exists or not: %s", tokenRequest.Error.Error())
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to find if token exists",
+			})
+
+			return
+		}
+
+		tokenExists := tokenRequest.RowsAffected > 0
+
+		if !tokenExists {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": "Token not found",
+			})
+
+			return
+		}
+
+		// First, we check to make sure that the key expiry is disabled before checking if the key is expired.
+		// Then, we check if the IP addresses differ, or if it has been 7 days since the token has been created.
+		if !tokenInDatabase.DisableExpiry && (c.ClientIP() != tokenInDatabase.CreationIPAddr || time.Now().Before(tokenInDatabase.CreatedAt.Add((24*7)*time.Hour))) {
+			c.JSON(http.StatusForbidden, gin.H{
+				"error": "Token has expired",
+			})
+
+			tx := state.DB.DB.Delete(tokenInDatabase)
+
+			if tx.Error != nil {
+				log.Warnf("Failed to delete expired token from database: %s", tx.Error.Error())
+			}
+
+			return
+		}
+
+		// Get the user to check if the user exists before doing anything
+		var user *db.User
+		userRequest := state.DB.DB.Where("id = ?", tokenInDatabase.UserID).Find(&user)
+
+		if tokenRequest.Error != nil {
+			log.Warnf("failed to find if token user or not: %s", userRequest.Error.Error())
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to find user",
+			})
+
+			return
+		}
+
+		userExists := userRequest.RowsAffected > 0
+
+		if !userExists {
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "User not found",
+			})
+
+			return
+		}
+
+		jwt, err := state.JWT.Generate(user.ID)
+
+		if err != nil {
+			log.Warnf("Failed to generate JWT: %s", err.Error())
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to generate refresh token",
+			})
+
+			return
+		}
+
+		c.JSON(http.StatusOK, gin.H{
+			"success": true,
+			"token":   jwt,
 		})
-
-		return
-	}
-
-	userExists := userRequest.RowsAffected > 0
-
-	if !userExists {
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "User not found",
-		})
-
-		return
-	}
-
-	jwt, err := jwtcore.Generate(user.ID)
-
-	if err != nil {
-		log.Warnf("Failed to generate JWT: %s", err.Error())
-
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to generate refresh token",
-		})
-
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{
-		"success": true,
-		"token":   jwt,
 	})
 }

backend/api/controllers/v1/users/remove.go

@@ -4,12 +4,11 @@ import (
 	"fmt"
 	"net/http"
 
-	"git.terah.dev/imterah/hermes/backend/api/dbcore"
-	"git.terah.dev/imterah/hermes/backend/api/jwtcore"
+	"git.terah.dev/imterah/hermes/backend/api/db"
 	"git.terah.dev/imterah/hermes/backend/api/permissions"
+	"git.terah.dev/imterah/hermes/backend/api/state"
 	"github.com/charmbracelet/log"
 	"github.com/gin-gonic/gin"
-	"github.com/go-playground/validator/v10"
 )
 
 type UserRemovalRequest struct {
@@ -17,89 +16,91 @@ type UserRemovalRequest struct {
 	UID   *uint  `json:"uid"`
 }
 
-func RemoveUser(c *gin.Context) {
-	var req UserRemovalRequest
+func SetupRemoveUser(state *state.State) {
+	state.Engine.POST("/api/v1/users/remove", func(c *gin.Context) {
+		var req UserRemovalRequest
 
-	if err := c.BindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
-		})
-
-		return
-	}
-
-	if err := validator.New().Struct(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
-		})
-
-		return
-	}
-
-	user, err := jwtcore.GetUserFromJWT(req.Token)
-
-	if err != nil {
-		if err.Error() == "token is expired" || err.Error() == "user does not exist" {
-			c.JSON(http.StatusForbidden, gin.H{
-				"error": err.Error(),
-			})
-
-			return
-		} else {
-			log.Warnf("Failed to get user from the provided JWT token: %s", err.Error())
-
-			c.JSON(http.StatusInternalServerError, gin.H{
-				"error": "Failed to parse token",
-			})
-
-			return
-		}
-	}
-
-	uid := user.ID
-
-	if req.UID != nil {
-		uid = *req.UID
-
-		if uid != user.ID && !permissions.UserHasPermission(user, "users.remove") {
-			c.JSON(http.StatusForbidden, gin.H{
-				"error": "Missing permissions",
-			})
-
-			return
-		}
-	}
-
-	// Make sure the user exists first if we have a custom UserID
-
-	if uid != user.ID {
-		var customUser *dbcore.User
-		userRequest := dbcore.DB.Where("id = ?", uid).Find(customUser)
-
-		if userRequest.Error != nil {
-			log.Warnf("failed to find if user exists or not: %s", userRequest.Error.Error())
-
-			c.JSON(http.StatusInternalServerError, gin.H{
-				"error": "Failed to find if user exists",
-			})
-
-			return
-		}
-
-		userExists := userRequest.RowsAffected > 0
-
-		if !userExists {
+		if err := c.BindJSON(&req); err != nil {
 			c.JSON(http.StatusBadRequest, gin.H{
-				"error": "User doesn't exist",
+				"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
 			})
 
 			return
 		}
-	}
 
-	dbcore.DB.Select("Tokens", "Permissions", "Proxys", "Backends").Where("id = ?", uid).Delete(user)
+		if err := state.Validator.Struct(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
+			})
 
-	c.JSON(http.StatusOK, gin.H{
-		"success": true,
+			return
+		}
+
+		user, err := state.JWT.GetUserFromJWT(req.Token)
+
+		if err != nil {
+			if err.Error() == "token is expired" || err.Error() == "user does not exist" {
+				c.JSON(http.StatusForbidden, gin.H{
+					"error": err.Error(),
+				})
+
+				return
+			} else {
+				log.Warnf("Failed to get user from the provided JWT token: %s", err.Error())
+
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"error": "Failed to parse token",
+				})
+
+				return
+			}
+		}
+
+		uid := user.ID
+
+		if req.UID != nil {
+			uid = *req.UID
+
+			if uid != user.ID && !permissions.UserHasPermission(user, "users.remove") {
+				c.JSON(http.StatusForbidden, gin.H{
+					"error": "Missing permissions",
+				})
+
+				return
+			}
+		}
+
+		// Make sure the user exists first if we have a custom UserID
+
+		if uid != user.ID {
+			var customUser *db.User
+			userRequest := state.DB.DB.Where("id = ?", uid).Find(customUser)
+
+			if userRequest.Error != nil {
+				log.Warnf("failed to find if user exists or not: %s", userRequest.Error.Error())
+
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"error": "Failed to find if user exists",
+				})
+
+				return
+			}
+
+			userExists := userRequest.RowsAffected > 0
+
+			if !userExists {
+				c.JSON(http.StatusBadRequest, gin.H{
+					"error": "User doesn't exist",
+				})
+
+				return
+			}
+		}
+
+		state.DB.DB.Select("Tokens", "Permissions", "Proxys", "Backends").Where("id = ?", uid).Delete(user)
+
+		c.JSON(http.StatusOK, gin.H{
+			"success": true,
+		})
 	})
 }