fix(postgrest): throw a PostgrestException for a non-JSON 2xx body

packages/Postgrest/Postgrest.Tests/Requests/NonJsonResponseTests.cs

@@ -0,0 +1,66 @@
+using System.Threading.Tasks;
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Supabase.Postgrest;
+using Supabase.Postgrest.Attributes;
+using Supabase.Postgrest.Exceptions;
+using Supabase.Postgrest.Models;
+using WireMock.RequestBuilders;
+using WireMock.ResponseBuilders;
+using WireMock.Server;
+
+namespace Postgrest.Tests.Requests;
+
+/// <summary>
+///     A 2xx body that isn't JSON throws a <see cref="PostgrestException" /> carrying the body and status.
+/// </summary>
+[TestClass]
+[TestCategory("Contract")]
+public class NonJsonResponseTests
+{
+    private const string ProxyErrorPage = "<html><body>502 Bad Gateway</body></html>";
+
+    private WireMockServer server = null!;
+    private Client client = null!;
+
+    [Table("todos")]
+    private class Todo : BaseModel
+    {
+        [PrimaryKey("id")] public int Id { get; set; }
+        [Column("name")] public string? Name { get; set; }
+    }
+
+    [TestInitialize]
+    public void SetUp()
+    {
+        this.server = WireMockServer.Start();
+        this.client = new Client(this.server.Url!, new ClientOptions());
+    }
+
+    [TestCleanup]
+    public void TearDown() => this.server.Stop();
+
+    [TestMethod]
+    public async Task Get_ShouldThrowPostgrestException_GivenNonJsonBody()
+    {
+        this.MockProxyErrorPage("/todos");
+        var act = () => this.client.Table<Todo>().Get();
+        await act.Should().ThrowAsync<PostgrestException>()
+            .Where(exception => exception.Content == ProxyErrorPage && exception.StatusCode == 200,
+                "postgrest-js returns a non-JSON 2xx body as the error (#260)");
+    }
+
+    [TestMethod]
+    public async Task Rpc_ShouldThrowPostgrestException_GivenNonJsonBody()
+    {
+        this.MockProxyErrorPage("/rpc/echo");
+        var act = () => this.client.Rpc<int>("echo");
+        await act.Should().ThrowAsync<PostgrestException>()
+            .Where(exception => exception.Content == ProxyErrorPage && exception.StatusCode == 200,
+                "postgrest-js handles rpc responses the same way (#260)");
+    }
+
+    private void MockProxyErrorPage(string path) =>
+        this.server.Given(Request.Create().WithPath(path))
+            .RespondWith(Response.Create().WithStatusCode(200).WithBody(ProxyErrorPage));
+}

packages/Postgrest/Postgrest/Client.cs

@@ -108,7 +108,7 @@ public T Attach<T>(T model) where T : BaseModel
     {
         var response = await this.Rpc(procedureName, parameters);
 
-        return string.IsNullOrEmpty(response.Content) ? default : JsonSerializer.Deserialize<TModeledResponse>(response.Content!, SerializerSettings(this.Options));
+        return string.IsNullOrEmpty(response.Content) ? default : Helpers.DeserializeBody<TModeledResponse>(response, SerializerSettings(this.Options));
     }
 
     /// <inheritdoc />

packages/Postgrest/Postgrest/Helpers.cs

@@ -175,6 +175,26 @@ HttpRequestMessage CreateRequest()
         }
     }
 
+    /// <summary>
+    /// Deserializes a 2xx body and throws a PostgrestException when it can't be read, e.g. a proxy's HTML page.
+    /// </summary>
+    internal static T? DeserializeBody<T>(BaseResponse response, JsonSerializerOptions options)
+    {
+        try
+        {
+            return JsonSerializer.Deserialize<T>(response.Content!, options);
+        }
+        catch (JsonException e)
+        {
+            throw new PostgrestException(response.Content, e)
+            {
+                Content = response.Content,
+                Response = response.ResponseMessage,
+                StatusCode = (int) (response.ResponseMessage?.StatusCode ?? 0)
+            };
+        }
+    }
+
     /// <summary>
     /// Prepares the request with appropriate HTTP headers expected by Postgrest.
     /// </summary>

packages/Postgrest/Postgrest/Responses/ModeledResponse.cs

@@ -38,7 +38,7 @@ public ModeledResponse(BaseResponse baseResponse, JsonSerializerOptions serializ
 
         if (!shouldParse || string.IsNullOrEmpty(this.Content)) return;
 
-        var token = JsonNode.Parse(this.Content!);
+        var token = Helpers.DeserializeBody<JsonNode>(this, serializerSettings);
 
         switch (token)
         {