feat(yacache): update MGet response signature

Author: brizzinck

yacache/memory.go

@@ -344,32 +344,43 @@ func (m *Memory) Get(
 	return value.Value, nil
 }
 
-// MGet fetches several keys at once and returns a map[key]value.
-// If any requested key is absent, the call fails with ErrFailedToMGetValues.
+// MGet fetches the values for the specified keys from the in-memory cache.
+//
+// It returns a map where each found key is mapped to its corresponding string value.
+// Keys that are not found are silently skipped — no error is returned.
+// As a result, the returned map may contain fewer entries than requested.
 //
 // Example:
 //
-//	values, _ := memory.MGet(ctx, "k1", "k2", "k3")
+//	ctx := context.Background()
+//	values, err := memory.MGet(ctx, "k1", "k2", "k3")
+//	if err != nil {
+//	    log.Fatalf("memory MGet failed: %v", err)
+//	}
+//	for k, v := range values {
+//	    fmt.Printf("%s = %s\n", k, v)
+//	}
+//
+// Returns:
+//   - map[string]string: found keys mapped to their values (missing keys are excluded)
+//   - yaerrors.Error: always nil in this implementation
 func (m *Memory) MGet(
 	_ context.Context,
 	keys ...string,
-) (map[string]*string, yaerrors.Error) {
+) (map[string]string, yaerrors.Error) {
 	m.mutex.RLock()
 
 	defer m.mutex.RUnlock()
 
-	result := make(map[string]*string)
+	result := make(map[string]string)
 
 	for _, key := range keys {
 		value, ok := m.inner.Map[key]
 		if !ok {
-			result[key] = nil
-
 			continue
 		}
 
-		v := value.Value
-		result[key] = &v
+		result[key] = value.Value
 	}
 
 	return result, nil

yacache/memory_test.go

@@ -220,10 +220,9 @@ func TestMemory_FetchWorkflow_Works(t *testing.T) {
 	})
 
 	t.Run("[MGET] - get items works", func(t *testing.T) {
-		expected := make(map[string]*string)
+		expected := make(map[string]string)
 
-		yavaluePtr := yavalue
-		expected[yachildKey] = &yavaluePtr
+		expected[yachildKey] = yavalue
 
 		var keys []string
 
@@ -240,8 +239,7 @@ func TestMemory_FetchWorkflow_Works(t *testing.T) {
 				panic(err)
 			}
 
-			yavaluePtr := fmt.Sprintf("%s:%d", yavalue, i)
-			expected[keys[len(keys)-1]] = &yavaluePtr
+			expected[keys[len(keys)-1]] = fmt.Sprintf("%s:%d", yavalue, i)
 		}
 
 		result, _ := memory.MGet(ctx, keys...)

yacache/redis.go

@@ -331,13 +331,12 @@ func (r *Redis) Get(
 
 // MGet performs a batch GET operation for the given keys using Redis.
 //
-// It expects the number of returned values to exactly match the number
-// of requested keys. If the underlying Redis call fails, or the response
-// is incomplete or invalid, the method returns ErrFailedToMGetValues.
+// It returns a map where each successfully fetched key is mapped to its
+// corresponding string value. Keys that are missing in Redis or whose
+// values cannot be cast to strings are silently skipped.
 //
-// The returned map contains each requested key mapped to its corresponding
-// value. If a key does not exist or the value cannot be cast to string,
-// it will be mapped to nil.
+// Unlike atomic variants, this method does not fail if some keys are missing;
+// the resulting map may contain fewer entries than requested.
 //
 // Example:
 //
@@ -347,20 +346,16 @@ func (r *Redis) Get(
 //	    log.Fatalf("failed to fetch keys: %v", err)
 //	}
 //	for k, v := range values {
-//	    if v != nil {
-//	        fmt.Printf("%s = %s\n", k, *v)
-//	    } else {
-//	        fmt.Printf("%s = <nil>\n", k)
-//	    }
+//	    fmt.Printf("%s = %s\n", k, v)
 //	}
 //
 // Returns:
-//   - map[string]*string: keys mapped to their corresponding string values (or nil)
-//   - yaerrors.Error: wrapped error if Redis call fails or result is inconsistent
+//   - map[string]string: found keys mapped to their string values
+//   - yaerrors.Error: wrapped Redis error if the MGET command fails
 func (r *Redis) MGet(
 	ctx context.Context,
 	keys ...string,
-) (map[string]*string, yaerrors.Error) {
+) (map[string]string, yaerrors.Error) {
 	values, err := r.client.MGet(ctx, keys...).Result()
 	if err != nil {
 		return nil, yaerrors.FromError(
@@ -370,24 +365,19 @@ func (r *Redis) MGet(
 		)
 	}
 
-	result := make(map[string]*string)
+	result := make(map[string]string)
 
 	for i, key := range keys {
 		if values[i] == nil {
-			result[key] = nil
-
 			continue
 		}
 
 		value, ok := values[i].(string)
 		if !ok {
-			result[key] = nil
-
 			continue
 		}
 
-		v := value
-		result[key] = &v
+		result[key] = value
 	}
 
 	return result, nil

yacache/redis_test.go

@@ -54,28 +54,27 @@ func TestRedisCacheService(t *testing.T) {
 	})
 
 	t.Run("[MGet] - multi get values works", func(t *testing.T) {
-		expected := make(map[string]*string)
+		expected := make(map[string]string)
 
-		yavaluePtr := yavalue2
-		expected[yachildKey2] = &yavaluePtr
+		expected[yachildKey2] = yavalue2
 
 		var keys []string
 
 		for i := range 10 {
 			keys = append(keys, fmt.Sprintf("%s:%d", yamainKey2, i))
+			value := fmt.Sprintf("%s:%d", yavalue2, i)
 
 			err := redis.Set(
 				ctx,
-				keys[len(keys)-1],
-				fmt.Sprintf("%s:%d", yavalue2, i),
+				keys[i],
+				value,
 				yattl,
 			)
 			if err != nil {
 				panic(err)
 			}
 
-			yavaluePtr := fmt.Sprintf("%s:%d", yavalue2, i)
-			expected[keys[len(keys)-1]] = &yavaluePtr
+			expected[keys[i]] = value
 		}
 
 		keys = append(keys, "key_which_doesnt_contains___))")

yacache/yacache.go

@@ -204,10 +204,10 @@ type Cache[T Container] interface {
 
 	// MGet fetches the values for the specified keys from the cache.
 	//
-	// It returns a map where each key is mapped to its corresponding value.
-	// If any of the keys are missing or the operation fails,
-	// it returns an error of type ErrFailedToMGetValues, allowing callers to
-	// rely on the atomicity of the operation — it's all or nothing.
+	// It returns a map where each key is mapped to its corresponding string value.
+	// If any key is missing or the number of returned values does not match
+	// the number of requested keys, the method fails with ErrFailedToMGetValues,
+	// ensuring atomicity — either all values are returned or none.
 	//
 	// Example:
 	//
@@ -217,20 +217,16 @@ type Cache[T Container] interface {
 	//	    log.Fatalf("failed to fetch keys: %v", err)
 	//	}
 	//	for k, v := range values {
-	//	    if v != nil {
-	//	        fmt.Printf("%s = %s\n", k, *v)
-	//	    } else {
-	//	        fmt.Printf("%s = <nil>\n", k)
-	//	    }
+	//	    fmt.Printf("%s = %s\n", k, v)
 	//	}
 	//
 	// Returns:
-	//   - map[string]*string: a map of keys to their string values (or nil if not found)
-	//   - yaerrors.Error: a wrapped error indicating failure
+	//   - map[string]string: all requested keys mapped to their string values
+	//   - yaerrors.Error: a wrapped error if the operation fails or is incomplete
 	MGet(
 		ctx context.Context,
 		keys ...string,
-	) (map[string]*string, yaerrors.Error)
+	) (map[string]string, yaerrors.Error)
 
 	// GetDel atomically reads **and then deletes** key.
 	// Useful for one-shot tokens or queue semantics.