fix(): rollback enconding file

Author: diegofesanto

Storage/Bucket.cs

@@ -1,47 +1,48 @@
 using System;
 using System.Collections.Generic;
-using Newtonsoft.Json;
+using System.Text.Json.Serialization;
 
 namespace Supabase.Storage
 {
     public class Bucket
     {
-        [JsonProperty("id")]
+        [JsonPropertyName("id")]
         public string? Id { get; set; }
 
-        [JsonProperty("name")]
+        [JsonPropertyName("name")]
         public string? Name { get; set; }
 
-        [JsonProperty("owner")]
+        [JsonPropertyName("owner")]
         public string? Owner { get; set; }
 
-        [JsonProperty("created_at")]
+        [JsonPropertyName("created_at")]
         public DateTime? CreatedAt { get; set; }
 
-        [JsonProperty("updated_at")]
+        [JsonPropertyName("updated_at")]
         public DateTime? UpdatedAt { get; set; }
 
         /// <summary>
         /// The visibility of the bucket. Public buckets don't require an authorization token to download objects,
 		/// but still require a valid token for all other operations. By default, buckets are private.
         /// </summary>
-        [JsonProperty("public")]
+        [JsonPropertyName("public")]
         public bool Public { get; set; }
 
         /// <summary>
         /// Specifies the file size limit that this bucket can accept during upload.
         ///
         /// Expects a string value following a format like: '1kb', '50mb', '150kb', etc.
         /// </summary>
-        [JsonProperty("file_size_limit", NullValueHandling = NullValueHandling.Include)]
+        [JsonPropertyName("file_size_limit")]
         public string? FileSizeLimit { get; set; }
 
         /// <summary>
         /// Specifies the allowed mime types that this bucket can accept during upload.
 		///
 		/// Expects a List of values such as: ['image/jpeg', 'image/png', etc]
         /// </summary>
-        [JsonProperty("allowed_mime_types", NullValueHandling = NullValueHandling.Ignore)]
+        [JsonPropertyName("allowed_mime_types")]
+        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public List<string>? AllowedMimes { get; set; }
     }
 }

Storage/BucketUpsertOptions.cs

@@ -1,5 +1,5 @@
 using System.Collections.Generic;
-using Newtonsoft.Json;
+using System.Text.Json.Serialization;
 
 namespace Supabase.Storage
 {
@@ -9,23 +9,24 @@ public class BucketUpsertOptions
         /// The visibility of the bucket. Public buckets don't require an authorization token to download objects,
 		/// but still require a valid token for all other operations. By default, buckets are private.
         /// </summary>
-        [JsonProperty("public")]
+        [JsonPropertyName("public")]
         public bool Public { get; set; } = false;
 
         /// <summary>
         /// Specifies the file size limit that this bucket can accept during upload.
         ///
         /// Expects a string value following a format like: '1kb', '50mb', '150kb', etc.
         /// </summary>
-        [JsonProperty("file_size_limit", NullValueHandling = NullValueHandling.Include)]
+        [JsonPropertyName("file_size_limit")]
         public string? FileSizeLimit { get; set; }
 
         /// <summary>
         /// Specifies the allowed mime types that this bucket can accept during upload.
 		///
 		/// Expects a List of values such as: ['image/jpeg', 'image/png', etc]
         /// </summary>
-        [JsonProperty("allowed_mime_types", NullValueHandling = NullValueHandling.Ignore)]
+        [JsonPropertyName("allowed_mime_types")]
+        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
         public List<string>? AllowedMimes { get; set; }
     }
 }

Storage/CreateSignedUrlResponse.cs

@@ -1,16 +1,34 @@
-using Newtonsoft.Json;
+using System.Text.Json.Serialization;
 
 namespace Supabase.Storage
 {
+    /// <summary>
+    /// Represents the response received when creating a signed URL for file access through Supabase Storage.
+    /// </summary>
     public class CreateSignedUrlResponse
     {
-        [JsonProperty("signedURL")]
+        /// <summary>
+        /// Represents the signed URL returned as part of a response when requesting access to a file
+        /// stored in Supabase Storage. This URL can be used to access the file directly with
+        /// the defined expiration and optional transformations or download options applied.
+        /// </summary>
+        [JsonPropertyName("signedURL")]
         public string? SignedUrl { get; set; }
     }
 
+    /// <summary>
+    /// Represents the extended response received when creating multiple signed URLs
+    /// for file access through Supabase Storage. In addition to the signed URL, it includes
+    /// the associated file path.
+    /// </summary>
     public class CreateSignedUrlsResponse: CreateSignedUrlResponse
     {
-        [JsonProperty("path")]
+        /// <summary>
+        /// Represents the file path associated with a signed URL in the response.
+        /// This property indicates the specific file path for which the signed URL
+        /// was generated, allowing identification of the file within the storage bucket.
+        /// </summary>
+        [JsonPropertyName("path")]
         public string? Path { get; set; }
     }
 }

Storage/DownloadOptions.cs

@@ -1,7 +1,8 @@
-using Newtonsoft.Json;
-
 namespace Supabase.Storage
 {
+    /// <summary>
+    /// Represents options used when downloading files from storage.
+    /// </summary>
     public class DownloadOptions
     {
         /// <summary>

Storage/Extensions/HttpClientProgress.cs

@@ -2,11 +2,13 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Net.Http;
+using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
 using BirdMessenger;
 using BirdMessenger.Collections;
-using Newtonsoft.Json;
+using BirdMessenger.Delegates;
+using BirdMessenger.Infrastructure;
 using Supabase.Storage.Exceptions;
 
 namespace Supabase.Storage.Extensions
@@ -45,7 +47,10 @@ public static async Task<MemoryStream> DownloadDataAsync(
                 if (!response.IsSuccessStatusCode)
                 {
                     var content = await response.Content.ReadAsStringAsync();
-                    var errorResponse = JsonConvert.DeserializeObject<ErrorResponse>(content);
+                    var errorResponse = JsonSerializer.Deserialize<ErrorResponse>(
+                        content,
+                        Helpers.JsonOptions
+                    );
                     var e = new SupabaseStorageException(errorResponse?.Message ?? content)
                     {
                         Content = content,
@@ -175,12 +180,15 @@ public static async Task<HttpResponseMessage> UploadAsync(
                 }
             }
 
-			var response = await client.PostAsync(uri, content, cancellationToken);
+            var response = await client.PostAsync(uri, content, cancellationToken);
 
             if (!response.IsSuccessStatusCode)
             {
                 var httpContent = await response.Content.ReadAsStringAsync();
-                var errorResponse = JsonConvert.DeserializeObject<ErrorResponse>(httpContent);
+                var errorResponse = JsonSerializer.Deserialize<ErrorResponse>(
+                    httpContent,
+                    Helpers.JsonOptions
+                );
                 var e = new SupabaseStorageException(errorResponse?.Message ?? httpContent)
                 {
                     Content = httpContent,
@@ -273,24 +281,26 @@ private static async Task<HttpResponseMessage> ResumableUploadAsync(
                 UploadLength = fileStream.Length,
             };
 
-            var responseCreate = await client.TusCreateAsync(createOption, cancellationToken);
+            TusCreateResponse? responseCreate;
+            try
+            {
+                responseCreate = await client.TusCreateAsync(createOption, cancellationToken);
+            }
+            catch (Exception exception)
+            {
+                if (exception is not TusException response)
+                    throw;
+
+                throw await HandleResponseError(response);
+            }
 
             var patchOption = new TusPatchRequestOption
             {
                 FileLocation = responseCreate.FileLocation,
                 Stream = fileStream,
                 UploadBufferSize = 6 * 1024 * 1024,
                 UploadType = UploadType.Chunk,
-                OnProgressAsync = x =>
-                {
-                    if (progress == null)
-                        return Task.CompletedTask;
-
-                    var uploadedProgress = (float)x.UploadedSize / x.TotalSize * 100f;
-                    progress.Report(uploadedProgress);
-
-                    return Task.CompletedTask;
-                },
+                OnProgressAsync = x => ReportProgressAsync(progress, x),
                 OnCompletedAsync = _ => Task.CompletedTask,
                 OnFailedAsync = _ => Task.CompletedTask,
             };
@@ -300,19 +310,57 @@ private static async Task<HttpResponseMessage> ResumableUploadAsync(
             if (responsePatch.OriginResponseMessage.IsSuccessStatusCode)
                 return responsePatch.OriginResponseMessage;
 
-            var httpContent = await responsePatch.OriginResponseMessage.Content.ReadAsStringAsync();
-            var errorResponse = JsonConvert.DeserializeObject<ErrorResponse>(httpContent);
-            var e = new SupabaseStorageException(errorResponse?.Message ?? httpContent)
+            throw await HandleResponseError(responsePatch.OriginResponseMessage);
+        }
+
+        private static Task ReportProgressAsync(
+            IProgress<float>? progress,
+            UploadProgressEvent progressInfo
+        )
+        {
+            if (progress == null)
+                return Task.CompletedTask;
+
+            var uploadedProgress = (float)progressInfo.UploadedSize / progressInfo.TotalSize * 100f;
+            progress.Report(uploadedProgress);
+
+            return Task.CompletedTask;
+        }
+
+        private static async Task<SupabaseStorageException> HandleResponseError(
+            HttpResponseMessage response
+        )
+        {
+            var httpContent = await response.Content.ReadAsStringAsync();
+            var errorResponse = JsonSerializer.Deserialize<ErrorResponse>(
+                httpContent,
+                Helpers.JsonOptions
+            );
+            var error = new SupabaseStorageException(errorResponse?.Message ?? httpContent)
+            {
+                Content = httpContent,
+                Response = response,
+                StatusCode = errorResponse?.StatusCode ?? (int)response.StatusCode,
+            };
+            error.AddReason();
+
+            return error;
+        }
+
+        private static async Task<SupabaseStorageException> HandleResponseError(
+            TusException response
+        )
+        {
+            var httpContent = await response.OriginHttpResponse.Content.ReadAsStringAsync();
+            var error = new SupabaseStorageException(httpContent)
             {
                 Content = httpContent,
-                Response = responsePatch.OriginResponseMessage,
-                StatusCode =
-                    errorResponse?.StatusCode
-                    ?? (int)responsePatch.OriginResponseMessage.StatusCode,
+                Response = response.OriginHttpResponse,
+                StatusCode = (int)response.OriginHttpResponse.StatusCode,
             };
+            error.AddReason();
 
-            e.AddReason();
-            throw e;
+            return error;
         }
     }
 }

Storage/FileObject.cs

@@ -1,6 +1,6 @@
 using System;
 using System.Collections.Generic;
-using Newtonsoft.Json;
+using System.Text.Json.Serialization;
 
 namespace Supabase.Storage
 {
@@ -10,32 +10,23 @@ public class FileObject
         /// Flag representing if this object is a folder, all properties will be null but the name
         /// </summary>
         public bool IsFolder => !string.IsNullOrEmpty(Name) && Id == null && CreatedAt == null && UpdatedAt == null;
-        
-        [JsonProperty("name")]
-        public string? Name { get; set; }
 
-        [JsonProperty("bucket_id")]
-        public string? BucketId { get; set; }
+        [JsonPropertyName("name")] public string? Name { get; set; }
 
-        [JsonProperty("owner")]
-        public string? Owner { get; set; }
+        [JsonPropertyName("bucket_id")] public string? BucketId { get; set; }
 
-        [JsonProperty("id")]
-        public string? Id { get; set; }
+        [JsonPropertyName("owner")] public string? Owner { get; set; }
 
-        [JsonProperty("updated_at")]
-        public DateTime? UpdatedAt { get; set; }
+        [JsonPropertyName("id")] public string? Id { get; set; }
 
-        [JsonProperty("created_at")]
-        public DateTime? CreatedAt { get; set; }
+        [JsonPropertyName("updated_at")] public DateTime? UpdatedAt { get; set; }
 
-        [JsonProperty("last_accessed_at")]
-        public DateTime? LastAccessedAt { get; set; }
+        [JsonPropertyName("created_at")] public DateTime? CreatedAt { get; set; }
 
-        [JsonProperty("metadata")]
-        public Dictionary<string, object> MetaData = new Dictionary<string, object>();
+        [JsonPropertyName("last_accessed_at")] public DateTime? LastAccessedAt { get; set; }
 
-        [JsonProperty("buckets")]
-        public Bucket? Buckets { get; set; }
+        [JsonPropertyName("metadata")] public Dictionary<string, object> MetaData = new Dictionary<string, object>();
+
+        [JsonPropertyName("buckets")] public Bucket? Buckets { get; set; }
     }
-}
+}