refactor: migrate API key functionality to single apikey module

backend/internal/middleware/api_key_auth.go

@@ -2,19 +2,20 @@ package middleware
 
 import (
 	"github.com/gin-gonic/gin"
+	"github.com/pocket-id/pocket-id/backend/internal/apikey"
 	"github.com/pocket-id/pocket-id/backend/internal/common"
 	"github.com/pocket-id/pocket-id/backend/internal/service"
 )
 
 type ApiKeyAuthMiddleware struct {
-	apiKeyService *service.ApiKeyService
-	jwtService    *service.JwtService
+	apiKeyModule *apikey.Module
+	jwtService   *service.JwtService
 }
 
-func NewApiKeyAuthMiddleware(apiKeyService *service.ApiKeyService, jwtService *service.JwtService) *ApiKeyAuthMiddleware {
+func NewApiKeyAuthMiddleware(apiKeyModule *apikey.Module, jwtService *service.JwtService) *ApiKeyAuthMiddleware {
 	return &ApiKeyAuthMiddleware{
-		apiKeyService: apiKeyService,
-		jwtService:    jwtService,
+		apiKeyModule: apiKeyModule,
+		jwtService:   jwtService,
 	}
 }
 
@@ -36,7 +37,7 @@ func (m *ApiKeyAuthMiddleware) Add(adminRequired bool) gin.HandlerFunc {
 func (m *ApiKeyAuthMiddleware) Verify(c *gin.Context, adminRequired bool) (userID string, isAdmin bool, err error) {
 	apiKey := c.GetHeader("X-API-Key")
 
-	user, err := m.apiKeyService.ValidateApiKey(c.Request.Context(), apiKey)
+	user, err := m.apiKeyModule.ValidateApiKey(c.Request.Context(), apiKey)
 	if err != nil {
 		return "", false, &common.NotSignedInError{}
 	}

backend/internal/middleware/auth_middleware.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 
 	"github.com/gin-gonic/gin"
+	"github.com/pocket-id/pocket-id/backend/internal/apikey"
 	"github.com/pocket-id/pocket-id/backend/internal/common"
 	"github.com/pocket-id/pocket-id/backend/internal/service"
 )
@@ -22,12 +23,12 @@ type AuthOptions struct {
 }
 
 func NewAuthMiddleware(
-	apiKeyService *service.ApiKeyService,
+	apiKeyModule *apikey.Module,
 	userService *service.UserService,
 	jwtService *service.JwtService,
 ) *AuthMiddleware {
 	return &AuthMiddleware{
-		apiKeyMiddleware: NewApiKeyAuthMiddleware(apiKeyService, jwtService),
+		apiKeyMiddleware: NewApiKeyAuthMiddleware(apiKeyModule, jwtService),
 		jwtMiddleware:    NewJwtAuthMiddleware(jwtService, userService),
 		options: AuthOptions{
 			AdminRequired:   true,

backend/internal/middleware/auth_middleware_test.go

@@ -11,11 +11,12 @@ import (
 	"github.com/stretchr/testify/require"
 	"gorm.io/gorm"
 
+	"github.com/pocket-id/pocket-id/backend/internal/apikey"
 	"github.com/pocket-id/pocket-id/backend/internal/common"
-	"github.com/pocket-id/pocket-id/backend/internal/dto"
 	"github.com/pocket-id/pocket-id/backend/internal/model"
 	datatype "github.com/pocket-id/pocket-id/backend/internal/model/types"
 	"github.com/pocket-id/pocket-id/backend/internal/service"
+	"github.com/pocket-id/pocket-id/backend/internal/utils"
 	testutils "github.com/pocket-id/pocket-id/backend/internal/utils/testing"
 )
 
@@ -38,20 +39,23 @@ func TestWithApiKeyAuthDisabled(t *testing.T) {
 	require.NoError(t, err)
 
 	userService := service.NewUserService(db, jwtService, nil, nil, appConfigService, nil, nil, nil, nil)
-	apiKeyService, err := service.NewApiKeyService(t.Context(), db, nil)
+	apiKeyModule, err := apikey.New(t.Context(), apikey.Dependencies{DB: db})
 	require.NoError(t, err)
 
-	authMiddleware := NewAuthMiddleware(apiKeyService, userService, jwtService)
+	authMiddleware := NewAuthMiddleware(apiKeyModule, userService, jwtService)
 
 	user := createUserForAuthMiddlewareTest(t, db)
 	jwtToken, err := jwtService.GenerateAccessToken(user, "")
 	require.NoError(t, err)
 
-	_, apiKeyToken, err := apiKeyService.CreateApiKey(t.Context(), user.ID, dto.ApiKeyCreateDto{
+	apiKeyToken := "middleware-test-api-key-raw-token"
+	apiKeyRecord := apikey.ApiKey{
 		Name:      "Middleware API Key",
+		Key:       utils.CreateSha256Hash(apiKeyToken),
+		UserID:    user.ID,
 		ExpiresAt: datatype.DateTime(time.Now().Add(24 * time.Hour)),
-	})
-	require.NoError(t, err)
+	}
+	require.NoError(t, db.Create(&apiKeyRecord).Error)
 
 	router := gin.New()
 	router.Use(NewErrorHandlerMiddleware().Add())