fix: add remove from cache after complete

Author: diegofesanto

Storage/Extensions/HttpClientProgress.cs

@@ -201,8 +201,8 @@ public static Task<HttpResponseMessage> UploadOrContinueFileAsync(
             this HttpClient client,
             Uri uri,
             string filePath,
+            MetadataCollection metadata,
             Dictionary<string, string>? headers = null,
-            MetadataCollection? metadata = null,
             Progress<float>? progress = null,
             CancellationToken cancellationToken = default
         )
@@ -212,8 +212,8 @@ public static Task<HttpResponseMessage> UploadOrContinueFileAsync(
                 client,
                 uri,
                 fileStream,
-                headers,
                 metadata,
+                headers,
                 progress,
                 cancellationToken
             );
@@ -223,8 +223,8 @@ public static Task<HttpResponseMessage> UploadOrContinueByteAsync(
             this HttpClient client,
             Uri uri,
             byte[] data,
+            MetadataCollection metadata,
             Dictionary<string, string>? headers = null,
-            MetadataCollection? metadata = null,
             Progress<float>? progress = null,
             CancellationToken cancellationToken = default
         )
@@ -234,8 +234,8 @@ public static Task<HttpResponseMessage> UploadOrContinueByteAsync(
                 client,
                 uri,
                 stream,
-                headers,
                 metadata,
+                headers,
                 progress,
                 cancellationToken
             );
@@ -245,8 +245,8 @@ private static async Task<HttpResponseMessage> ResumableUploadAsync(
             this HttpClient client,
             Uri uri,
             Stream fileStream,
+            MetadataCollection metadata,
             Dictionary<string, string>? headers = null,
-            MetadataCollection? metadata = null,
             IProgress<float>? progress = null,
             CancellationToken cancellationToken = default
         )
@@ -268,10 +268,8 @@ private static async Task<HttpResponseMessage> ResumableUploadAsync(
                 }
             }
 
-            string? cacheKey = null;
-            if (metadata != null)
-                cacheKey =
-                    $"{metadata["bucketName"]}/{metadata["objectName"]}/{metadata["contentType"]}";
+            var cacheKey =
+                $"{metadata["bucketName"]}/{metadata["objectName"]}/{metadata["contentType"]}";
 
             UploadMemoryCache.TryGet(cacheKey, out var upload);
             Uri? fileLocation = null;
@@ -284,13 +282,15 @@ private static async Task<HttpResponseMessage> ResumableUploadAsync(
                     UploadLength = fileStream.Length,
                 };
 
-                TusCreateResponse responseCreate;
                 try
                 {
-                    responseCreate = await client.TusCreateAsync(createOption, cancellationToken);
-                    
+                    var responseCreate = await client.TusCreateAsync(
+                        createOption,
+                        cancellationToken
+                    );
+
                     fileLocation = responseCreate.FileLocation;
-                    UploadMemoryCache.Set(cacheKey, fileLocation.ToString()); 
+                    UploadMemoryCache.Set(cacheKey, fileLocation.ToString());
                 }
                 catch (TusException error)
                 {
@@ -308,7 +308,11 @@ private static async Task<HttpResponseMessage> ResumableUploadAsync(
                 UploadBufferSize = 6 * 1024 * 1024,
                 UploadType = UploadType.Chunk,
                 OnProgressAsync = x => ReportProgressAsync(progress, x),
-                OnCompletedAsync = _ => Task.CompletedTask,
+                OnCompletedAsync = _ =>
+                {
+                    UploadMemoryCache.Remove(cacheKey);
+                    return Task.CompletedTask;
+                },
                 OnFailedAsync = _ => Task.CompletedTask,
             };
 

Storage/StorageFileApi.cs

@@ -744,8 +744,8 @@ private async Task UploadOrContinue(
             await Helpers.HttpUploadClient!.UploadOrContinueFileAsync(
                 uri,
                 localPath,
-                headers,
                 metadata,
+                headers,
                 progress,
                 cancellationToken
             );
@@ -792,8 +792,8 @@ private async Task UploadOrContinue(
             await Helpers.HttpUploadClient!.UploadOrContinueByteAsync(
                 uri,
                 data,
-                headers,
                 metadata,
+                headers,
                 progress,
                 cancellationToken
             );

Storage/UploadMemoryCache.cs

@@ -4,13 +4,13 @@
 
 namespace Supabase.Storage;
 
+/// <summary>
+/// Provides thread-safe in-memory caching for resumable upload URLs with sliding expiration.
+/// </summary>
 public class UploadMemoryCache
 {
-    // Thread-safe in-memory cache for resumable upload URLs keyed by an identifier (e.g., file path or upload id).
-    // Uses simple sliding expiration.
     private static readonly ConcurrentDictionary<string, CacheEntry> _cache = new();
 
-    // Default sliding expiration for cached URLs.
     private static TimeSpan _defaultTtl = TimeSpan.FromMinutes(60);
 
     private static long _version; // helps with testing/observability if needed
@@ -36,13 +36,23 @@ public void Touch()
         public bool IsExpired() => DateTimeOffset.UtcNow >= Expiration;
     }
 
-    // Sets the default time-to-live for future cache entries.
+    /// <summary>
+    /// Sets the default time-to-live duration for future cache entries.
+    /// </summary>
+    /// <param name="ttl">The time-to-live duration. If less than or equal to zero, defaults to 5 minutes.</param>
     public static void SetDefaultTtl(TimeSpan ttl)
     {
         _defaultTtl = ttl <= TimeSpan.Zero ? TimeSpan.FromMinutes(5) : ttl;
     }
 
-    // Store or update the resumable upload URL for the provided key.
+    // Store or upate the resumable upload URL for the provided key.
+    /// <summary>
+    /// Stores or updates a resumable upload URL in the cache for the specified key.
+    /// </summary>
+    /// <param name="key">The unique identifier for the cached URL.</param>
+    /// <param name="url">The resumable upload URL to cache.</param>
+    /// <param name="ttl">Optional time-to-live duration. If not specified, uses the default TTL.</param>
+    /// <exception cref="ArgumentException">Thrown when key or url is null, empty, or whitespace.</exception>
     public static void Set(string key, string url, TimeSpan? ttl = null)
     {
         if (string.IsNullOrWhiteSpace(key))
@@ -61,32 +71,36 @@ public static void Set(string key, string url, TimeSpan? ttl = null)
         CleanupIfNeeded();
     }
 
-    // Try to get a cached URL. Refreshes sliding expiration on successful hit.
+    /// <summary>
+    /// Attempts to retrieve a cached URL by its key. Updates the sliding expiration on successful retrieval.
+    /// </summary>
+    /// <param name="key">The unique identifier for the cached URL.</param>
+    /// <param name="url">When this method returns, contains the cached URL if found; otherwise, null.</param>
+    /// <returns>True if the URL was found in the cache; otherwise, false.</returns>
     public static bool TryGet(string key, out string? url)
     {
         url = null;
         if (string.IsNullOrWhiteSpace(key))
             return false;
 
-        if (_cache.TryGetValue(key, out var entry))
+        if (!_cache.TryGetValue(key, out var entry)) return false;
+        if (entry.IsExpired())
         {
-            if (entry.IsExpired())
-            {
-                // Evict expired entry
-                _cache.TryRemove(key, out _);
-                return false;
-            }
-
-            // Sliding expiration
-            entry.Touch();
-            url = entry.Url;
-            return true;
+            _cache.TryRemove(key, out _);
+            return false;
         }
 
-        return false;
+        entry.Touch();
+        url = entry.Url;
+        return true;
+
     }
 
-    // Remove a cached URL.
+    /// <summary>
+    /// Removes a cached URL by its key.
+    /// </summary>
+    /// <param name="key">The unique identifier for the cached URL to remove.</param>
+    /// <returns>True if the URL was successfully removed; otherwise, false.</returns>
     public static bool Remove(string key)
     {
         if (string.IsNullOrWhiteSpace(key))
@@ -98,20 +112,22 @@ public static bool Remove(string key)
         return removed;
     }
 
-    // Clear all cached URLs.
+    /// <summary>
+    /// Removes all cached URLs from the cache.
+    /// </summary>
     public static void Clear()
     {
         _cache.Clear();
         Interlocked.Increment(ref _version);
     }
 
-    // Optionally expose count for diagnostics.
+    /// <summary>
+    /// Gets the current number of entries in the cache.
+    /// </summary>
     public static int Count => _cache.Count;
 
-    // Simple opportunistic cleanup to remove expired entries.
     private static void CleanupIfNeeded()
     {
-        // Cheap scan for expired entries. No need for strict guarantees.
         foreach (var kvp in _cache)
         {
             if (kvp.Value.IsExpired())