[lint] minor fixes

Author: capcom6

internal/sms-gateway/handlers/messages/3rdparty.go

@@ -2,7 +2,6 @@ package messages
 
 import (
 	"errors"
-	"fmt"
 	"strconv"
 	"time"
 
@@ -144,7 +143,14 @@ func (h *ThirdPartyController) post(user models.User, c *fiber.Ctx) error {
 			return fiber.NewError(fiber.StatusConflict, err.Error())
 		}
 
-		return fmt.Errorf("failed to enqueue message: %w", err)
+		h.Logger.Error(
+			"failed to enqueue message",
+			zap.Error(err),
+			zap.String("user_id", user.ID),
+			zap.String("device_id", req.DeviceID),
+		)
+
+		return fiber.NewError(fiber.StatusInternalServerError, "Failed to enqueue message. Please contact support")
 	}
 
 	location, err := c.GetRouteURL(route3rdPartyGetMessage, fiber.Map{

internal/sms-gateway/modules/messages/models.go

@@ -73,7 +73,7 @@ func (m *Message) GetTextContent() (*TextMessageContent, error) {
 
 	content := new(TextMessageContent)
 
-	err := json.Unmarshal([]byte(m.Content), &content)
+	err := json.Unmarshal([]byte(m.Content), content)
 	if err != nil {
 		return nil, fmt.Errorf("failed to unmarshal text content: %w", err)
 	}

internal/sms-gateway/modules/messages/repository.go

@@ -155,7 +155,7 @@ func (r *Repository) UpdateState(message *Message) error {
 		}
 
 		for _, v := range message.Recipients {
-			if err := tx.Model(&MessageRecipient{}).
+			if err := tx.Model((*MessageRecipient)(nil)).
 				Where("message_id = ? AND phone_number = ?", message.ID, v.PhoneNumber).
 				Select("state", "error").
 				Updates(map[string]any{"state": v.State, "error": v.Error}).Error; err != nil {

internal/sms-gateway/modules/messages/service.go

@@ -173,37 +173,71 @@ func (s *Service) GetState(user models.User, id string) (*MessageStateOut, error
 	return dto, nil
 }
 
-func (s *Service) Enqueue(device models.Device, message MessageIn, opts EnqueueOptions) (MessageStateOut, error) {
-	state := MessageStateOut{
+func (s *Service) Enqueue(device models.Device, message MessageIn, opts EnqueueOptions) (*MessageStateOut, error) {
+	msg, err := s.prepareMessage(device, message, opts)
+	if err != nil {
+		return nil, err
+	}
+
+	state := &MessageStateOut{
 		DeviceID: device.ID,
 		MessageStateIn: MessageStateIn{
-			State:      ProcessingStatePending,
-			Recipients: make([]smsgateway.RecipientState, len(message.PhoneNumbers)),
+			ID:    msg.ExtID,
+			State: ProcessingStatePending,
+			Recipients: lo.Map(
+				msg.Recipients,
+				func(item MessageRecipient, _ int) smsgateway.RecipientState { return modelToRecipientState(item) },
+			),
+			States: map[string]time.Time{},
 		},
+		IsHashed:    false,
+		IsEncrypted: msg.IsEncrypted,
 	}
 
+	if insErr := s.messages.Insert(msg); insErr != nil {
+		return state, insErr
+	}
+
+	if cacheErr := s.cache.Set(context.Background(), device.UserID, msg.ExtID, anys.AsPointer(modelToMessageState(*msg))); cacheErr != nil {
+		s.logger.Warn("failed to cache message", zap.String("id", msg.ExtID), zap.Error(cacheErr))
+	}
+	s.metrics.IncTotal(string(msg.State))
+
+	go func(userID, deviceID string) {
+		if ntfErr := s.eventsSvc.Notify(userID, &deviceID, events.NewMessageEnqueuedEvent()); ntfErr != nil {
+			s.logger.Error(
+				"failed to notify device",
+				zap.Error(ntfErr),
+				zap.String("user_id", userID),
+				zap.String("device_id", deviceID),
+			)
+		}
+	}(device.UserID, device.ID)
+
+	return state, nil
+}
+
+func (s *Service) prepareMessage(device models.Device, message MessageIn, opts EnqueueOptions) (*Message, error) {
 	var phone string
 	var err error
 	for i, v := range message.PhoneNumbers {
 		if message.IsEncrypted || opts.SkipPhoneValidation {
 			phone = v
 		} else {
 			if phone, err = cleanPhoneNumber(v); err != nil {
-				return state, fmt.Errorf("failed to use phone in row %d: %w", i+1, err)
+				return nil, fmt.Errorf("failed to use phone in row %d: %w", i+1, err)
 			}
 		}
 
 		message.PhoneNumbers[i] = phone
-
-		state.Recipients[i] = smsgateway.RecipientState{
-			PhoneNumber: phone,
-			State:       smsgateway.ProcessingStatePending,
-		}
 	}
 
 	validUntil := message.ValidUntil
 	if message.TTL != nil && *message.TTL > 0 {
-		validUntil = anys.AsPointer(time.Now().Add(time.Duration(*message.TTL) * time.Second))
+		//nolint:gosec // not a problem
+		validUntil = anys.AsPointer(
+			time.Now().Add(time.Duration(*message.TTL) * time.Second),
+		)
 	}
 
 	msg := Message{
@@ -221,43 +255,22 @@ func (s *Service) Enqueue(device models.Device, message MessageIn, opts EnqueueO
 	}
 
 	if message.TextContent != nil {
-		if err := msg.SetTextContent(*message.TextContent); err != nil {
-			return state, fmt.Errorf("failed to set text content: %w", err)
+		if setErr := msg.SetTextContent(*message.TextContent); setErr != nil {
+			return nil, fmt.Errorf("failed to set text content: %w", setErr)
 		}
 	} else if message.DataContent != nil {
-		if err := msg.SetDataContent(*message.DataContent); err != nil {
-			return state, fmt.Errorf("failed to set data content: %w", err)
+		if setErr := msg.SetDataContent(*message.DataContent); setErr != nil {
+			return nil, fmt.Errorf("failed to set data content: %w", setErr)
 		}
 	} else {
-		return state, ErrNoContent
+		return nil, ErrNoContent
 	}
 
 	if msg.ExtID == "" {
 		msg.ExtID = s.idgen()
 	}
-	state.ID = msg.ExtID
-
-	if err := s.messages.Insert(&msg); err != nil {
-		return state, err
-	}
-
-	if err := s.cache.Set(context.Background(), device.UserID, msg.ExtID, anys.AsPointer(modelToMessageState(msg))); err != nil {
-		s.logger.Warn("failed to cache message", zap.String("id", msg.ExtID), zap.Error(err))
-	}
-	s.metrics.IncTotal(string(msg.State))
 
-	go func(userID, deviceID string) {
-		if err := s.eventsSvc.Notify(userID, &deviceID, events.NewMessageEnqueuedEvent()); err != nil {
-			s.logger.Error(
-				"failed to notify device",
-				zap.Error(err),
-				zap.String("user_id", userID),
-				zap.String("device_id", deviceID),
-			)
-		}
-	}(device.UserID, device.ID)
-
-	return state, nil
+	return &msg, nil
 }
 
 func (s *Service) ExportInbox(device models.Device, since, until time.Time) error {

internal/sms-gateway/online/metrics.go

@@ -5,7 +5,7 @@ import (
 	"github.com/prometheus/client_golang/prometheus/promauto"
 )
 
-// Metric constants
+// Metric constants.
 const (
 	metricStatusSetTotal     = "status_set_total"
 	metricCacheOperations    = "cache_operations_total"
@@ -24,7 +24,7 @@ const (
 	statusError   = "error"
 )
 
-// metrics contains all Prometheus metrics for the online module
+// metrics contains all Prometheus metrics for the online module.
 type metrics struct {
 	statusSetCounter   *prometheus.CounterVec
 	cacheOperations    *prometheus.CounterVec
@@ -34,7 +34,7 @@ type metrics struct {
 	batchSize          prometheus.Gauge
 }
 
-// newMetrics creates and initializes all online metrics
+// newMetrics creates and initializes all online metrics.
 func newMetrics() *metrics {
 	return &metrics{
 		statusSetCounter: promauto.NewCounterVec(prometheus.CounterOpts{
@@ -83,7 +83,7 @@ func newMetrics() *metrics {
 	}
 }
 
-// IncrementStatusSet increments the status set counter
+// IncrementStatusSet increments the status set counter.
 func (m *metrics) IncrementStatusSet(success bool) {
 	status := statusSuccess
 	if !success {
@@ -92,31 +92,31 @@ func (m *metrics) IncrementStatusSet(success bool) {
 	m.statusSetCounter.WithLabelValues(status).Inc()
 }
 
-// IncrementCacheOperation increments cache operation counter
+// IncrementCacheOperation increments cache operation counter.
 func (m *metrics) IncrementCacheOperation(operation, status string) {
 	m.cacheOperations.WithLabelValues(operation, status).Inc()
 }
 
-// ObserveCacheLatency observes cache operation latency
+// ObserveCacheLatency observes cache operation latency.
 func (m *metrics) ObserveCacheLatency(f func()) {
 	timer := prometheus.NewTimer(m.cacheLatency)
 	f()
 	timer.ObserveDuration()
 }
 
-// ObservePersistenceLatency observes persistence operation latency
+// ObservePersistenceLatency observes persistence operation latency.
 func (m *metrics) ObservePersistenceLatency(f func()) {
 	timer := prometheus.NewTimer(m.persistenceLatency)
 	f()
 	timer.ObserveDuration()
 }
 
-// IncrementPersistenceError increments persistence error counter
+// IncrementPersistenceError increments persistence error counter.
 func (m *metrics) IncrementPersistenceError() {
 	m.persistenceErrors.Inc()
 }
 
-// SetBatchSize sets the current batch size
+// SetBatchSize sets the current batch size.
 func (m *metrics) SetBatchSize(size int) {
 	m.batchSize.Set(float64(size))
 }

internal/sms-gateway/online/service.go

@@ -96,9 +96,9 @@ func (s *service) persist(ctx context.Context) error {
 		s.logger.Debug("Drained cache", zap.Int("count", len(items)))
 
 		timestamps := maps.MapValues(items, func(v []byte) time.Time {
-			t, err := time.Parse(time.RFC3339, string(v))
-			if err != nil {
-				s.logger.Warn("failed to parse last seen", zap.String("last_seen", string(v)), zap.Error(err))
+			t, parseErr := time.Parse(time.RFC3339, string(v))
+			if parseErr != nil {
+				s.logger.Warn("failed to parse last seen", zap.String("last_seen", string(v)), zap.Error(parseErr))
 				return time.Now().UTC()
 			}
 
@@ -107,8 +107,8 @@ func (s *service) persist(ctx context.Context) error {
 
 		s.logger.Debug("Parsed last seen timestamps", zap.Int("count", len(timestamps)))
 
-		if err := s.devicesSvc.SetLastSeen(ctx, timestamps); err != nil {
-			persistErr = fmt.Errorf("failed to set last seen: %w", err)
+		if seenErr := s.devicesSvc.SetLastSeen(ctx, timestamps); seenErr != nil {
+			persistErr = fmt.Errorf("failed to set last seen: %w", seenErr)
 			s.metrics.IncrementPersistenceError()
 			return
 		}

internal/worker/locker/mysql.go

@@ -26,6 +26,7 @@ func NewMySQLLocker(db *sql.DB, prefix string, timeout time.Duration) Locker {
 		prefix:  prefix,
 		timeout: timeout,
 
+		mu:    sync.Mutex{},
 		conns: make(map[string]*sql.Conn),
 	}
 }
@@ -41,9 +42,9 @@ func (m *mySQLLocker) AcquireLock(ctx context.Context, key string) error {
 	}
 
 	var res sql.NullInt64
-	if err := conn.QueryRowContext(ctx, "SELECT GET_LOCK(?, ?)", name, m.timeout.Seconds()).Scan(&res); err != nil {
+	if lockErr := conn.QueryRowContext(ctx, "SELECT GET_LOCK(?, ?)", name, m.timeout.Seconds()).Scan(&res); lockErr != nil {
 		_ = conn.Close()
-		return fmt.Errorf("failed to get lock: %w", err)
+		return fmt.Errorf("failed to get lock: %w", lockErr)
 	}
 	if !res.Valid || res.Int64 != 1 {
 		_ = conn.Close()
@@ -70,7 +71,7 @@ func (m *mySQLLocker) ReleaseLock(ctx context.Context, key string) error {
 	delete(m.conns, key)
 	m.mu.Unlock()
 	if conn == nil {
-		return fmt.Errorf("no held connection for key %q", key)
+		return fmt.Errorf("%w: no held connection for key %q", ErrLockNotAcquired, key)
 	}
 
 	var result sql.NullInt64
@@ -81,7 +82,7 @@ func (m *mySQLLocker) ReleaseLock(ctx context.Context, key string) error {
 		return fmt.Errorf("failed to release lock: %w", err)
 	}
 	if !result.Valid || result.Int64 != 1 {
-		return fmt.Errorf("lock was not held or doesn't exist")
+		return fmt.Errorf("%w: lock was not held or doesn't exist", ErrLockNotAcquired)
 	}
 
 	return nil

pkg/cache/memory.go

@@ -94,11 +94,9 @@ func (m *MemoryCache) Get(_ context.Context, key string, opts ...GetOption) ([]b
 		m.mux.Lock()
 		item, ok := m.items[key]
 
-		if !ok { //nolint:revive,gocritic //simplify code structure
-			// item not found, nothing to do
-		} else if o.delete {
+		if ok && o.delete {
 			delete(m.items, key)
-		} else if !item.isExpired(time.Now()) {
+		} else if ok && !item.isExpired(time.Now()) {
 			switch {
 			case o.validUntil != nil:
 				item.validUntil = *o.validUntil

pkg/cache/memory_concurrency_test.go

@@ -157,12 +157,12 @@ func TestMemoryCache_ConcurrentSetAndGetAndDelete(t *testing.T) {
 	var wg sync.WaitGroup
 
 	// Launch goroutines that perform Set, Get, and Delete operations
-	for i := 0; i < numGoroutines; i++ {
+	for i := range numGoroutines {
 		wg.Add(1)
 		go func(goroutineID int) {
 			defer wg.Done()
 
-			for j := 0; j < numOperations/numGoroutines; j++ {
+			for j := range numOperations / numGoroutines {
 				key := "key-" + strconv.Itoa(goroutineID) + "-" + strconv.Itoa(j)
 				value := "value-" + strconv.Itoa(goroutineID) + "-" + strconv.Itoa(j)
 
@@ -357,7 +357,7 @@ func TestMemoryCache_ConcurrentGetAndDelete(t *testing.T) {
 	var wg sync.WaitGroup
 
 	// Pre-populate cache with items
-	for i := 0; i < numGoroutines*attemptsPerGoroutine; i++ {
+	for i := range numGoroutines * attemptsPerGoroutine {
 		key := "item-" + strconv.Itoa(i)
 		value := "value-" + strconv.Itoa(i)
 
@@ -368,12 +368,12 @@ func TestMemoryCache_ConcurrentGetAndDelete(t *testing.T) {
 	}
 
 	// Launch goroutines that perform GetAndDelete operations
-	for i := 0; i < numGoroutines; i++ {
+	for i := range numGoroutines {
 		wg.Add(1)
 		go func(goroutineID int) {
 			defer wg.Done()
 
-			for j := 0; j < attemptsPerGoroutine; j++ {
+			for j := range attemptsPerGoroutine {
 				key := "item-" + strconv.Itoa(goroutineID*attemptsPerGoroutine+j)
 
 				_, err := c.GetAndDelete(ctx, key)