refactor: use more Go 1.26 features

Author: refringe

cmd/uncord/main.go

@@ -198,18 +198,14 @@ func run() error {
 	defer subCancel()
 	var wg sync.WaitGroup
 
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
+	wg.Go(func() {
 		blocklist.Run(subCtx, cfg.DisposableEmailBlocklistRefreshInterval)
-	}()
+	})
 
 	// The purge goroutine is started below after the attachment repository is initialised, because orphan attachment
 	// cleanup needs access to the repo and storage provider.
 	startPurgeGoroutine := func(attachRepo *attachment.PGRepository, storage media.StorageProvider) {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
+		wg.Go(func() {
 			purgeExpiredData(subCtx, userRepo, attachRepo, storage, cfg)
 
 			ticker := time.NewTicker(cfg.DataCleanupInterval)
@@ -222,16 +218,14 @@ func run() error {
 					purgeExpiredData(subCtx, userRepo, attachRepo, storage, cfg)
 				}
 			}
-		}()
+		})
 	}
 
 	// Start permission cache invalidation subscriber with reconnection.
 	permSub := permission.NewSubscriber(permCache, rdb, log.Logger)
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
+	wg.Go(func() {
 		runWithBackoff(subCtx, "permission-cache-subscriber", permSub.Run)
-	}()
+	})
 
 	// Load external templates from DATA_DIR (nil means use compiled-in defaults).
 	verificationTmpl, verifyPageTmpl, err := loadTemplates(cfg.DataDir)
@@ -301,11 +295,9 @@ func run() error {
 	// Start thumbnail worker with reconnection.
 	thumbWorker := media.NewThumbnailWorker(rdb, storage, attachmentRepo, log.Logger)
 	thumbWorker.EnsureStream(subCtx)
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
+	wg.Go(func() {
 		runWithBackoff(subCtx, "thumbnail-worker", thumbWorker.Run)
-	}()
+	})
 	authService, err := auth.NewService(userRepo, rdb, cfg, blocklist, emailSender, serverRepo, permPublisher, log.Logger)
 	if err != nil {
 		return fmt.Errorf("create auth service: %w", err)
@@ -329,11 +321,9 @@ func run() error {
 		DocumentStore:  documentStore,
 		Logger:         log.Logger,
 	})
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
+	wg.Go(func() {
 		runWithBackoff(subCtx, "gateway-hub", gatewayHub.Run)
-	}()
+	})
 
 	app := newFiberApp(cfg)
 
@@ -704,11 +694,11 @@ func newFiberApp(cfg *config.Config) *fiber.App {
 		// (e.g. Fiber's built-in 404/405). errors.AsType is a generic helper added in Go 1.26.
 		ErrorHandler: func(c fiber.Ctx, err error) error {
 			status := fiber.StatusInternalServerError
-			message := "An internal error occurred"
+			msg := "An internal error occurred"
 			apiCode := apierrors.InternalError
 			if e, ok := errors.AsType[*fiber.Error](err); ok {
 				status = e.Code
-				message = e.Message
+				msg = e.Message
 				apiCode = fiberStatusToAPICode(e.Code)
 			} else {
 				log.Error().Err(err).
@@ -719,7 +709,7 @@ func newFiberApp(cfg *config.Config) *fiber.App {
 			return c.Status(status).JSON(httputil.ErrorResponse{
 				Error: httputil.ErrorBody{
 					Code:    apiCode,
-					Message: message,
+					Message: msg,
 				},
 			})
 		},

internal/api/invite_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"net/http"
+	"slices"
 	"testing"
 	"time"
 
@@ -71,10 +72,7 @@ func (r *fakeInviteRepo) List(_ context.Context, after *uuid.UUID, limit int) ([
 	if start >= len(r.invites) {
 		return nil, nil
 	}
-	end := start + limit
-	if end > len(r.invites) {
-		end = len(r.invites)
-	}
+	end := min(start+limit, len(r.invites))
 	return r.invites[start:end], nil
 }
 
@@ -198,10 +196,8 @@ func newFakeInviteMemberRepo() *fakeInviteMemberRepo {
 }
 
 func (r *fakeInviteMemberRepo) IsBanned(_ context.Context, userID uuid.UUID) (bool, error) {
-	for _, id := range r.bans {
-		if id == userID {
-			return true, nil
-		}
+	if slices.Contains(r.bans, userID) {
+		return true, nil
 	}
 	return false, nil
 }

internal/api/member_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"net/http"
+	"slices"
 	"strings"
 	"testing"
 	"time"
@@ -44,10 +45,7 @@ func (r *fakeMemberRepo) List(_ context.Context, after *uuid.UUID, limit int) ([
 	if start >= len(r.members) {
 		return nil, nil
 	}
-	end := start + limit
-	if end > len(r.members) {
-		end = len(r.members)
-	}
+	end := min(start+limit, len(r.members))
 	return r.members[start:end], nil
 }
 
@@ -146,10 +144,7 @@ func (r *fakeMemberRepo) ListBans(_ context.Context, after *uuid.UUID, limit int
 	if start >= len(r.bans) {
 		return nil, nil
 	}
-	end := start + limit
-	if end > len(r.bans) {
-		end = len(r.bans)
-	}
+	end := min(start+limit, len(r.bans))
 	return r.bans[start:end], nil
 }
 
@@ -163,10 +158,8 @@ func (r *fakeMemberRepo) IsBanned(_ context.Context, userID uuid.UUID) (bool, er
 }
 
 func (r *fakeMemberRepo) AssignRole(_ context.Context, userID, roleID uuid.UUID) error {
-	for _, id := range r.roles[userID] {
-		if id == roleID {
-			return member.ErrAlreadyMember
-		}
+	if slices.Contains(r.roles[userID], roleID) {
+		return member.ErrAlreadyMember
 	}
 	r.roles[userID] = append(r.roles[userID], roleID)
 	// Update the member's RoleIDs so the re-fetched profile reflects the change.

internal/api/message_test.go

@@ -883,19 +883,20 @@ func TestCreateMessage_TooManyAttachments(t *testing.T) {
 	userID := uuid.New()
 
 	// Create 11 IDs to exceed the limit of 10.
-	ids := "["
+	var ids strings.Builder
+	ids.WriteString("[")
 	for i := range 11 {
 		if i > 0 {
-			ids += ","
+			ids.WriteString(",")
 		}
-		ids += `"` + uuid.New().String() + `"`
+		ids.WriteString(`"` + uuid.New().String() + `"`)
 	}
-	ids += "]"
+	ids.WriteString("]")
 
 	app := testMessageAppWithAttachments(t, msgRepo, attRepo, allowAllResolver(), userID)
 
 	resp := doReq(t, app, jsonReq(http.MethodPost, "/channels/"+channelID.String()+"/messages",
-		`{"content":"hello","attachment_ids":`+ids+`}`))
+		`{"content":"hello","attachment_ids":`+ids.String()+`}`))
 	body := readBody(t, resp)
 
 	if resp.StatusCode != fiber.StatusBadRequest {

internal/auth/mfa_crypto.go

@@ -29,9 +29,7 @@ func EncryptTOTPSecret(secret, hexKey string) (string, error) {
 	}
 
 	nonce := make([]byte, gcm.NonceSize())
-	if _, err := rand.Read(nonce); err != nil {
-		return "", fmt.Errorf("generate nonce: %w", err)
-	}
+	_, _ = rand.Read(nonce)
 
 	ciphertext := gcm.Seal(nonce, nonce, []byte(secret), nil)
 	return base64.StdEncoding.EncodeToString(ciphertext), nil
@@ -77,17 +75,15 @@ const recoveryCodeCount = 10
 
 // GenerateRecoveryCodes generates a set of recovery codes in the format "xxxx-xxxx-xxxx-xxxx-xxxx" where each group is
 // 4 hex characters. Each code represents 10 random bytes (80 bits of entropy).
-func GenerateRecoveryCodes() ([]string, error) {
+func GenerateRecoveryCodes() []string {
 	codes := make([]string, recoveryCodeCount)
 	for i := range codes {
 		b := make([]byte, 10)
-		if _, err := rand.Read(b); err != nil {
-			return nil, fmt.Errorf("generate recovery code: %w", err)
-		}
+		_, _ = rand.Read(b)
 		h := hex.EncodeToString(b)
 		codes[i] = h[:4] + "-" + h[4:8] + "-" + h[8:12] + "-" + h[12:16] + "-" + h[16:]
 	}
-	return codes, nil
+	return codes
 }
 
 // HashRecoveryCode hashes a recovery code using the same Argon2id parameters as passwords. The hyphen is stripped

internal/auth/mfa_crypto_test.go

@@ -65,10 +65,7 @@ func TestEncryptTOTPSecretInvalidKey(t *testing.T) {
 func TestGenerateRecoveryCodes(t *testing.T) {
 	t.Parallel()
 
-	codes, err := GenerateRecoveryCodes()
-	if err != nil {
-		t.Fatalf("GenerateRecoveryCodes() error = %v", err)
-	}
+	codes := GenerateRecoveryCodes()
 	if len(codes) != recoveryCodeCount {
 		t.Fatalf("GenerateRecoveryCodes() returned %d codes, want %d", len(codes), recoveryCodeCount)
 	}

internal/auth/mfa_pending_test.go

@@ -145,7 +145,7 @@ func TestResetMFASetupAttempts(t *testing.T) {
 	ctx := context.Background()
 	userID := uuid.New()
 
-	for i := 0; i < 3; i++ {
+	for range 3 {
 		if _, err := IncrementMFASetupAttempts(ctx, rdb, userID); err != nil {
 			t.Fatalf("IncrementMFASetupAttempts() error = %v", err)
 		}

internal/auth/service.go

@@ -166,10 +166,7 @@ func (s *Service) Register(ctx context.Context, req RegisterRequest) (*AuthResul
 		return nil, fmt.Errorf("hash password: %w", err)
 	}
 
-	verifyToken, err := generateSecureToken(verifyTokenBytes)
-	if err != nil {
-		return nil, fmt.Errorf("generate verification token: %w", err)
-	}
+	verifyToken := generateSecureToken(verifyTokenBytes)
 
 	userID, err := s.users.Create(ctx, user.CreateParams{
 		Email:        email,
@@ -330,10 +327,7 @@ func (s *Service) ResendVerification(ctx context.Context, userID uuid.UUID) erro
 		return ErrEmailAlreadyVerified
 	}
 
-	verifyToken, err := generateSecureToken(verifyTokenBytes)
-	if err != nil {
-		return fmt.Errorf("generate verification token: %w", err)
-	}
+	verifyToken := generateSecureToken(verifyTokenBytes)
 
 	err = s.users.ReplaceVerificationToken(ctx, userID, verifyToken, time.Now().Add(24*time.Hour), 60*time.Second)
 	if err != nil {
@@ -487,10 +481,7 @@ func (s *Service) ConfirmMFASetup(ctx context.Context, userID uuid.UUID, code st
 		return nil, ErrInvalidMFACode
 	}
 
-	codes, err := GenerateRecoveryCodes()
-	if err != nil {
-		return nil, fmt.Errorf("generate recovery codes: %w", err)
-	}
+	codes := GenerateRecoveryCodes()
 
 	hashes := make([]string, len(codes))
 	for i, c := range codes {
@@ -580,10 +571,7 @@ func (s *Service) RegenerateRecoveryCodes(ctx context.Context, userID uuid.UUID,
 		return nil, ErrMFANotEnabled
 	}
 
-	codes, err := GenerateRecoveryCodes()
-	if err != nil {
-		return nil, fmt.Errorf("generate recovery codes: %w", err)
-	}
+	codes := GenerateRecoveryCodes()
 
 	hashes := make([]string, len(codes))
 	for i, c := range codes {
@@ -753,10 +741,8 @@ func (s *Service) recordLoginAttempt(ctx context.Context, email, ip string, succ
 	}
 }
 
-func generateSecureToken(n int) (string, error) {
+func generateSecureToken(n int) string {
 	b := make([]byte, n)
-	if _, err := rand.Read(b); err != nil {
-		return "", err
-	}
-	return hex.EncodeToString(b), nil
+	_, _ = rand.Read(b)
+	return hex.EncodeToString(b)
 }

internal/category/category_test.go

@@ -15,11 +15,11 @@ func TestValidateName(t *testing.T) {
 		wantErr bool
 	}{
 		{"nil", nil, false},
-		{"empty after trim", ptr("   "), true},
-		{"one char", ptr("A"), false},
-		{"100 chars", ptr(strings.Repeat("a", 100)), false},
-		{"101 chars", ptr(strings.Repeat("a", 101)), true},
-		{"whitespace padded valid", ptr("  hello  "), false},
+		{"empty after trim", new("   "), true},
+		{"one char", new("A"), false},
+		{"100 chars", new(strings.Repeat("a", 100)), false},
+		{"101 chars", new(strings.Repeat("a", 101)), true},
+		{"whitespace padded valid", new("  hello  "), false},
 	}
 
 	for _, tt := range tests {
@@ -37,7 +37,7 @@ func TestValidateName(t *testing.T) {
 
 	t.Run("trims whitespace in place", func(t *testing.T) {
 		t.Parallel()
-		name := ptr("  hello  ")
+		name := new("  hello  ")
 		if err := ValidateName(name); err != nil {
 			t.Fatalf("unexpected error: %v", err)
 		}
@@ -87,9 +87,9 @@ func TestValidatePosition(t *testing.T) {
 		wantErr bool
 	}{
 		{"nil", nil, false},
-		{"zero", intPtr(0), false},
-		{"positive", intPtr(5), false},
-		{"negative", intPtr(-1), true},
+		{"zero", new(0), false},
+		{"positive", new(5), false},
+		{"negative", new(-1), true},
 	}
 
 	for _, tt := range tests {
@@ -105,6 +105,3 @@ func TestValidatePosition(t *testing.T) {
 		})
 	}
 }
-
-func ptr(s string) *string { return &s }
-func intPtr(n int) *int    { return &n }