fix: service tokens (#102)

* fix: jwt service token duration

* feat: add bulk categorization mcp api

Author: skynet2

pkg/auth/jwt.go

@@ -164,7 +164,7 @@ func (j *Service) CreateServiceToken(
 func (j *Service) generateTokenInternal(req *GenerateTokenRequest) (*JwtClaims, string, error) {
 	claims := &JwtClaims{
 		RegisteredClaims: &jwt2.RegisteredClaims{
-			ExpiresAt: jwt2.NewNumericDate(time.Now().UTC().Add(j.ttl)),
+			ExpiresAt: jwt2.NewNumericDate(time.Now().UTC().Add(req.TTL)),
 			ID:        uuid.NewString(),
 		},
 		UserID:    req.User.ID,

pkg/auth/jwt_test.go

@@ -2,12 +2,13 @@ package auth_test
 
 import (
 	"context"
+	"testing"
+	"time"
+
 	"github.com/ft-t/go-money/pkg/auth"
 	"github.com/ft-t/go-money/pkg/database"
 	"github.com/golang-jwt/jwt/v5"
 	"github.com/stretchr/testify/assert"
-	"testing"
-	"time"
 )
 
 func TestJwtToken_Success(t *testing.T) {
@@ -166,11 +167,16 @@ func TestCreateServiceToken_Success(t *testing.T) {
 	keyGen := auth.NewKeyGenerator()
 	key := keyGen.Generate()
 
-	jwtGenerator, err := auth.NewService(string(keyGen.Serialize(key)), 5*time.Minute)
+	serviceTTL := 5 * time.Minute
+	requestTTL := 24 * time.Hour
+
+	jwtGenerator, err := auth.NewService(string(keyGen.Serialize(key)), serviceTTL)
 	assert.NoError(t, err)
 
+	beforeGeneration := time.Now().UTC()
+
 	claims, token, err := jwtGenerator.CreateServiceToken(context.TODO(), &auth.GenerateTokenRequest{
-		TTL: 24 * time.Hour,
+		TTL: requestTTL,
 		User: &database.User{
 			ID:    123,
 			Login: "testuser",
@@ -183,6 +189,11 @@ func TestCreateServiceToken_Success(t *testing.T) {
 	assert.EqualValues(t, 123, claims.UserID)
 	assert.Equal(t, auth.ServiceTokenType, claims.TokenType)
 	assert.NotEmpty(t, claims.ID)
+
+	expectedExpiresAt := beforeGeneration.Add(requestTTL)
+	actualExpiresAt := claims.ExpiresAt.Time
+
+	assert.WithinDuration(t, expectedExpiresAt, actualExpiresAt, 5*time.Second)
 }
 
 func TestCreateServiceToken_Failure(t *testing.T) {

pkg/mcp/server.go

@@ -60,20 +60,16 @@ func (s *Server) registerTools() {
 	)
 	s.mcpServer.AddTool(queryTool, s.handleQuery)
 
-	setTransactionCategoryTool := mcp.NewTool(
-		"set_transaction_category",
-		mcp.WithDescription("Set or clear the category of a transaction"),
-		mcp.WithNumber(
-			"transaction_id",
-			mcp.Description("The ID of the transaction to update"),
+	bulkSetTransactionCategoryTool := mcp.NewTool(
+		"bulk_set_transaction_category",
+		mcp.WithDescription("Set or clear categories for multiple transactions in a single call"),
+		mcp.WithArray(
+			"assignments",
+			mcp.Description("Array of objects with transaction_id (required) and category_id (optional, null to clear)"),
 			mcp.Required(),
 		),
-		mcp.WithNumber(
-			"category_id",
-			mcp.Description("The category ID to set (omit or null to clear category)"),
-		),
 	)
-	s.mcpServer.AddTool(setTransactionCategoryTool, s.handleSetTransactionCategory)
+	s.mcpServer.AddTool(bulkSetTransactionCategoryTool, s.handleBulkSetTransactionCategory)
 
 	createCategoryTool := mcp.NewTool(
 		"create_category",

pkg/mcp/transaction_category_tool.go

@@ -4,45 +4,48 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/ft-t/go-money/pkg/database"
 	"github.com/mark3labs/mcp-go/mcp"
 )
 
-func (s *Server) handleSetTransactionCategory(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+func (s *Server) handleBulkSetTransactionCategory(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
 	args := request.GetArguments()
 
-	transactionID, ok := args["transaction_id"].(float64)
-	if !ok {
-		return mcp.NewToolResultError("transaction_id parameter is required"), nil
-	}
-
-	var categoryID *int32
-	if catID, exists := args["category_id"]; exists && catID != nil {
-		catIDFloat, ok := catID.(float64)
-		if !ok {
-			return mcp.NewToolResultError("category_id must be a number or null"), nil
-		}
-		catIDInt := int32(catIDFloat)
-		categoryID = &catIDInt
+	assignmentsRaw, ok := args["assignments"].([]any)
+	if !ok || len(assignmentsRaw) == 0 {
+		return mcp.NewToolResultError("assignments parameter is required and must be a non-empty array"), nil
 	}
 
 	queryCtx, cancel := context.WithTimeout(ctx, queryTimeout)
 	defer cancel()
 
-	var tx database.Transaction
-	if err := s.db.WithContext(queryCtx).First(&tx, int64(transactionID)).Error; err != nil {
-		return mcp.NewToolResultError(fmt.Sprintf("transaction not found: %v", err)), nil
-	}
+	for i, item := range assignmentsRaw {
+		itemMap, ok := item.(map[string]any)
+		if !ok {
+			return mcp.NewToolResultError(fmt.Sprintf("assignment[%d] must be an object", i)), nil
+		}
 
-	tx.CategoryID = categoryID
+		txID, ok := itemMap["transaction_id"].(float64)
+		if !ok {
+			return mcp.NewToolResultError(fmt.Sprintf("assignment[%d].transaction_id is required and must be a number", i)), nil
+		}
 
-	if err := s.db.WithContext(queryCtx).Save(&tx).Error; err != nil {
-		return mcp.NewToolResultError(fmt.Sprintf("failed to update transaction: %v", err)), nil
-	}
+		var categoryID *int32
+		if catID, exists := itemMap["category_id"]; exists && catID != nil {
+			catIDFloat, ok := catID.(float64)
+			if !ok {
+				return mcp.NewToolResultError(fmt.Sprintf("assignment[%d].category_id must be a number or null", i)), nil
+			}
+			catIDInt := int32(catIDFloat)
+			categoryID = &catIDInt
+		}
 
-	if categoryID == nil {
-		return mcp.NewToolResultText(fmt.Sprintf("Transaction %d category cleared", int64(transactionID))), nil
+		if err := s.db.WithContext(queryCtx).
+			Table("transactions").
+			Where("id = ?", int64(txID)).
+			Update("category_id", categoryID).Error; err != nil {
+			return mcp.NewToolResultError(fmt.Sprintf("failed to update transaction %d: %v", int64(txID), err)), nil
+		}
 	}
 
-	return mcp.NewToolResultText(fmt.Sprintf("Transaction %d category set to %d", int64(transactionID), *categoryID)), nil
+	return mcp.NewToolResultText(fmt.Sprintf("Updated %d transactions", len(assignmentsRaw))), nil
 }

pkg/mcp/transaction_category_tool_test.go

@@ -3,7 +3,6 @@ package mcp_test
 import (
 	"context"
 	"testing"
-	"time"
 
 	"github.com/DATA-DOG/go-sqlmock"
 	"github.com/golang/mock/gomock"
@@ -15,26 +14,38 @@ import (
 	"github.com/ft-t/go-money/pkg/testingutils"
 )
 
-func TestServer_HandleSetTransactionCategory_Success(t *testing.T) {
+func TestServer_HandleBulkSetTransactionCategory_Success(t *testing.T) {
 	type tc struct {
-		name       string
-		txID       float64
-		categoryID any
-		expected   string
+		name        string
+		assignments []map[string]any
 	}
 
 	cases := []tc{
 		{
-			name:       "set category",
-			txID:       1,
-			categoryID: float64(5),
-			expected:   "Transaction 1 category set to 5",
+			name: "set single category",
+			assignments: []map[string]any{
+				{"transaction_id": float64(1), "category_id": float64(5)},
+			},
 		},
 		{
-			name:       "clear category with nil",
-			txID:       2,
-			categoryID: nil,
-			expected:   "Transaction 2 category cleared",
+			name: "set multiple categories",
+			assignments: []map[string]any{
+				{"transaction_id": float64(1), "category_id": float64(5)},
+				{"transaction_id": float64(2), "category_id": float64(10)},
+			},
+		},
+		{
+			name: "clear category",
+			assignments: []map[string]any{
+				{"transaction_id": float64(1), "category_id": nil},
+			},
+		},
+		{
+			name: "mixed set and clear",
+			assignments: []map[string]any{
+				{"transaction_id": float64(1), "category_id": float64(5)},
+				{"transaction_id": float64(2), "category_id": nil},
+			},
 		},
 	}
 
@@ -44,114 +55,102 @@ func TestServer_HandleSetTransactionCategory_Success(t *testing.T) {
 			gormDB, mockDB, mock := testingutils.GormMock()
 			defer func() { _ = mockDB.Close() }()
 
-			selectRows := sqlmock.NewRows([]string{
-				"id", "source_amount", "source_currency", "destination_amount",
-				"destination_currency", "source_account_id", "destination_account_id",
-				"category_id", "transaction_type", "created_at", "updated_at",
-			}).AddRow(
-				int64(c.txID), nil, "USD", nil, "USD", 1, 2, nil, 3,
-				time.Now(), time.Now(),
-			)
-			mock.ExpectQuery("SELECT \\* FROM \"transactions\"").WillReturnRows(selectRows)
-			mock.ExpectBegin()
-			mock.ExpectExec("UPDATE \"transactions\"").WillReturnResult(sqlmock.NewResult(0, 1))
-			mock.ExpectCommit()
-
-			catSvc := NewMockCategoryService(ctrl)
-			rulesSvc := NewMockRulesService(ctrl)
-			dryRunSvc := NewMockDryRunService(ctrl)
+			for range c.assignments {
+				mock.ExpectBegin()
+				mock.ExpectExec("UPDATE \"transactions\"").WillReturnResult(sqlmock.NewResult(0, 1))
+				mock.ExpectCommit()
+			}
 
 			server := gomcp.NewServer(&gomcp.ServerConfig{
 				DB:          gormDB,
 				Docs:        "test docs",
-				CategorySvc: catSvc,
-				RulesSvc:    rulesSvc,
-				DryRunSvc:   dryRunSvc,
+				CategorySvc: NewMockCategoryService(ctrl),
+				RulesSvc:    NewMockRulesService(ctrl),
+				DryRunSvc:   NewMockDryRunService(ctrl),
 			})
 
-			mcpServer := server.MCPServer()
-			tool := mcpServer.GetTool("set_transaction_category")
+			tool := server.MCPServer().GetTool("bulk_set_transaction_category")
 			require.NotNil(t, tool)
 
-			args := map[string]any{"transaction_id": c.txID}
-			if c.categoryID != nil {
-				args["category_id"] = c.categoryID
+			assignmentsAny := make([]any, len(c.assignments))
+			for i, a := range c.assignments {
+				assignmentsAny[i] = a
 			}
 
 			result, err := tool.Handler(context.Background(), mcp.CallToolRequest{
 				Params: mcp.CallToolParams{
-					Name:      "set_transaction_category",
-					Arguments: args,
+					Name:      "bulk_set_transaction_category",
+					Arguments: map[string]any{"assignments": assignmentsAny},
 				},
 			})
 
 			require.NoError(t, err)
 			require.NotNil(t, result)
 			assert.False(t, result.IsError)
-			assert.Contains(t, result.Content[0].(mcp.TextContent).Text, c.expected)
+			assert.Contains(t, result.Content[0].(mcp.TextContent).Text, "Updated")
 		})
 	}
 }
 
-func TestServer_HandleSetTransactionCategory_Failure(t *testing.T) {
+func TestServer_HandleBulkSetTransactionCategory_Failure(t *testing.T) {
 	type tc struct {
 		name          string
 		args          map[string]any
-		setupMock     func(sqlmock.Sqlmock)
 		expectedError string
 	}
 
 	cases := []tc{
 		{
-			name:          "missing transaction_id",
+			name:          "missing assignments",
 			args:          map[string]any{},
-			setupMock:     func(m sqlmock.Sqlmock) {},
-			expectedError: "transaction_id parameter is required",
+			expectedError: "assignments parameter is required",
 		},
 		{
-			name:          "invalid category_id type",
-			args:          map[string]any{"transaction_id": float64(1), "category_id": "invalid"},
-			setupMock:     func(m sqlmock.Sqlmock) {},
-			expectedError: "category_id must be a number or null",
+			name:          "empty assignments",
+			args:          map[string]any{"assignments": []any{}},
+			expectedError: "assignments parameter is required and must be a non-empty array",
 		},
 		{
-			name: "transaction not found",
-			args: map[string]any{"transaction_id": float64(999)},
-			setupMock: func(m sqlmock.Sqlmock) {
-				m.ExpectQuery("SELECT \\* FROM \"transactions\"").
-					WillReturnRows(sqlmock.NewRows([]string{"id"}))
-			},
-			expectedError: "transaction not found",
+			name:          "invalid assignment type",
+			args:          map[string]any{"assignments": []any{"not an object"}},
+			expectedError: "assignment[0] must be an object",
+		},
+		{
+			name: "missing transaction_id",
+			args: map[string]any{"assignments": []any{
+				map[string]any{"category_id": float64(5)},
+			}},
+			expectedError: "assignment[0].transaction_id is required",
+		},
+		{
+			name: "invalid category_id type",
+			args: map[string]any{"assignments": []any{
+				map[string]any{"transaction_id": float64(1), "category_id": "invalid"},
+			}},
+			expectedError: "assignment[0].category_id must be a number or null",
 		},
 	}
 
 	for _, c := range cases {
 		t.Run(c.name, func(t *testing.T) {
 			ctrl := gomock.NewController(t)
-			gormDB, mockDB, mock := testingutils.GormMock()
+			gormDB, mockDB, _ := testingutils.GormMock()
 			defer func() { _ = mockDB.Close() }()
 
-			c.setupMock(mock)
-
-			catSvc := NewMockCategoryService(ctrl)
-			rulesSvc := NewMockRulesService(ctrl)
-			dryRunSvc := NewMockDryRunService(ctrl)
-
 			server := gomcp.NewServer(&gomcp.ServerConfig{
 				DB:          gormDB,
 				Docs:        "test docs",
-				CategorySvc: catSvc,
-				RulesSvc:    rulesSvc,
-				DryRunSvc:   dryRunSvc,
+				CategorySvc: NewMockCategoryService(ctrl),
+				RulesSvc:    NewMockRulesService(ctrl),
+				DryRunSvc:   NewMockDryRunService(ctrl),
 			})
 
-			mcpServer := server.MCPServer()
-			tool := mcpServer.GetTool("set_transaction_category")
+			tool := server.MCPServer().GetTool("bulk_set_transaction_category")
 			require.NotNil(t, tool)
 
 			result, err := tool.Handler(context.Background(), mcp.CallToolRequest{
 				Params: mcp.CallToolParams{
-					Name:      "set_transaction_category",
+					Name:      "bulk_set_transaction_category",
 					Arguments: c.args,
 				},
 			})

pkg/testingutils/gorm.go

@@ -41,7 +41,7 @@ func FlushAllTables(config boilerplate.DbConfig) error {
 }
 
 func ensureThatItsLocal(config boilerplate.DbConfig) {
-	allowedHosts := []string{"localhost", "127.0.0.1", "postgres"}
+	allowedHosts := []string{"localhost", "127.0.0.1", "postgres", "tools.lan"}
 
 	for _, h := range allowedHosts {
 		if strings.EqualFold(h, config.Host) {