Fix issue from supabase-community/supabase-csharp#48 where boolean model properties would not be evaluated in predicate expressions

Author: acupofjose

Postgrest/Interfaces/IPostgrestTable.cs

@@ -47,6 +47,7 @@ public interface IPostgrestTable<T> : IGettableHeaders
 		Table<T> Select(Expression<Func<T, object[]>> predicate);
 		Table<T> Where(Expression<Func<T, bool>> predicate);
 		Task<T?> Single(CancellationToken cancellationToken = default);
+		Table<T> Set(Expression<Func<T, object>> keySelector, object value);
 		Table<T> Set(Expression<Func<T, KeyValuePair<object, object>>> keyValuePairExpression);
 		Task<ModeledResponse<T>> Update(QueryOptions? options = null, CancellationToken cancellationToken = default);
 		Task<ModeledResponse<T>> Update(T model, QueryOptions? options = null, CancellationToken cancellationToken = default);

Postgrest/Linq/SetExpressionVisitor.cs

@@ -30,32 +30,93 @@ internal class SetExpressionVisitor : ExpressionVisitor
 		/// </summary>
 		public object? Value { get; private set; }
 
+		/// <summary>
+		/// A Unary Node, delved into to represent a property on a BaseModel.
+		/// </summary>
+		/// <param name="node"></param>
+		/// <returns></returns>
+		protected override Expression VisitUnary(UnaryExpression node)
+		{
+			if (node.Operand is MemberExpression memberExpression)
+			{
+				var column = GetColumnFromMemberExpression(memberExpression);
+
+				if (column != null)
+				{
+					Column = column;
+					ExpectedType = memberExpression.Type;
+				}
+			}
+
+			return node;
+		}
+
+		/// <summary>
+		/// A Member Node, representing a property on a BaseModel.
+		/// </summary>
+		/// <param name="node"></param>
+		/// <returns></returns>
+		protected override Expression VisitMember(MemberExpression node)
+		{
+			var column = GetColumnFromMemberExpression(node);
+
+			if (column != null)
+			{
+				Column = column;
+				ExpectedType = node.Type;
+			}
+
+			return node;
+		}
+
 		/// <summary>
 		/// Called when visiting a the expected new KeyValuePair().
 		/// </summary>
 		/// <param name="node"></param>
 		/// <returns></returns>
 		/// <exception cref="ArgumentException"></exception>
 		protected override Expression VisitNew(NewExpression node)
+		{
+			if (typeof(KeyValuePair<object, object>).IsAssignableFrom(node.Type))
+			{
+				HandleKeyValuePair(node);
+			}
+
+			return node;
+		}
+
+		private void HandleKeyValuePair(NewExpression node)
 		{
 			if (node.Arguments.Count != 2)
 				throw new ArgumentException("Unknown expression, should be a `KeyValuePair<object, object>`");
 
-			var member = node.Arguments[0] as MemberExpression;
+			var left = node.Arguments[0];
+			var right = node.Arguments[1];
 
-			if (member == null)
+			if (left is NewExpression)
+			{
+				Visit(left);
+			}
+			else if (left is MemberExpression member)
+			{
+				Column = GetColumnFromMemberExpression(member);
+				ExpectedType = member.Type;
+			}
+			else if (left is UnaryExpression unaryExpression && unaryExpression.Operand is MemberExpression unaryMemberExpression)
+			{
+				Column = GetColumnFromMemberExpression(unaryMemberExpression);
+				ExpectedType = unaryMemberExpression.Type;
+			}
+			else
+			{
 				throw new ArgumentException("Key should reference a Model Property.");
+			}
 
-			Column = GetColumnFromMemberExpression(member);
-			ExpectedType = member.Type;
-
-			var valueArgument = Expression.Lambda(node.Arguments[1]).Compile().DynamicInvoke();
+			var valueArgument = Expression.Lambda(right).Compile().DynamicInvoke();
 			Value = valueArgument;
 
-			if (!ExpectedType.IsAssignableFrom(Value.GetType()))
+			if (!ExpectedType!.IsAssignableFrom(Value.GetType()))
 				throw new ArgumentException(string.Format("Expected Value to be of Type: {0}, instead received: {1}.", ExpectedType.Name, Value.GetType().Name));
-
-			return node;
 		}
 
 		/// <summary>

Postgrest/Linq/WhereExpressionVisitor.cs

@@ -75,6 +75,10 @@ protected override Expression VisitBinary(BinaryExpression node)
 			{
 				HandleNewExpression(column, op, newExpression);
 			}
+			else if (right is UnaryExpression unaryExpression)
+			{
+				HandleUnaryExpression(column, op, unaryExpression);
+			}
 
 			return node;
 		}
@@ -138,6 +142,21 @@ private void HandleMemberExpression(string column, Operator op, MemberExpression
 			Filter = new QueryFilter(column, op, GetMemberExpressionValue(memberExpression));
 		}
 
+
+		/// <summary>
+		/// A unary expression parser (i.e. => x.Id == 1 <- where both `1` is considered unary)
+		/// </summary>
+		/// <param name="column"></param>
+		/// <param name="op"></param>
+		/// <param name="memberExpression"></param>
+		private void HandleUnaryExpression(string column, Operator op, UnaryExpression unaryExpression)
+		{
+			if (unaryExpression.Operand is ConstantExpression constantExpression)
+			{
+				HandleConstantExpression(column, op, constantExpression);
+			}
+		}
+
 		/// <summary>
 		/// An instantiated class parser (i.e. x => x.CreatedAt <= new DateTime(2022, 08, 20) <- where `new DateTime(...)` is an instantiated expression.
 		/// </summary>

Postgrest/Table.cs

@@ -9,6 +9,7 @@
 using System.Threading.Tasks;
 using System.Web;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 using Postgrest.Attributes;
 using Postgrest.Extensions;
 using Postgrest.Interfaces;
@@ -583,6 +584,31 @@ public Task<ModeledResponse<T>> Upsert(ICollection<T> model, QueryOptions? optio
 			return PerformInsert(model, options, cancellationToken);
 		}
 
+
+		/// <summary>
+		/// Specifies a key and value to be updated. Should be combined with filters/where clauses.
+		/// 
+		/// Can be called multiple times to set multiple values.
+		/// </summary>
+		/// <param name="keySelector"></param>
+		/// <param name="value"></param>
+		/// <returns></returns>
+		public Table<T> Set(Expression<Func<T, object>> keySelector, object value)
+		{
+			var visitor = new SetExpressionVisitor();
+			visitor.Visit(keySelector);
+
+			if (visitor.Column == null || visitor.ExpectedType == null)
+				throw new ArgumentException("Expression should return a KeyValuePair with a key of a Model Property and a value.");
+
+			if (!visitor.ExpectedType.IsAssignableFrom(value.GetType()))
+				throw new ArgumentException(string.Format("Expected Value to be of Type: {0}, instead received: {1}.", visitor.ExpectedType.Name, value.GetType().Name));
+
+			setData.Add(visitor.Column, value);
+
+			return this;
+		}
+
 		/// <summary>
 		/// Specifies a KeyValuePair to be updated. Should be combined with filters/where clauses.
 		/// 
@@ -596,7 +622,7 @@ public Table<T> Set(Expression<Func<T, KeyValuePair<object, object>>> keyValuePa
 			var visitor = new SetExpressionVisitor();
 			visitor.Visit(keyValuePairExpression);
 
-			if (visitor.Column == null || visitor.Value == null)
+			if (visitor.Column == null || visitor.Value == default)
 				throw new ArgumentException("Expression should return a KeyValuePair with a key of a Model Property and a value.");
 
 			setData.Add(visitor.Column, visitor.Value);

PostgrestTests/Linq.cs

@@ -9,10 +9,10 @@
 
 namespace PostgrestTests
 {
-    [TestClass]
-    public class LinqTests
-    {
-        private static string baseUrl = "http://localhost:3000";
+	[TestClass]
+	public class LinqTests
+	{
+		private static string baseUrl = "http://localhost:3000";
 
 		[TestMethod("Linq: Select")]
 		public async Task TestLinqSelect()
@@ -213,6 +213,63 @@ public async Task TestLinqUpdate()
 			Assert.IsNotNull(exists);
 			Assert.IsTrue(count == 1);
 
+			var originalRecord = await client.Table<KitchenSink>().Where(x => x.Id == 1).Single();
+
+			var newRecord = await client.Table<KitchenSink>()
+				.Set(x => new KeyValuePair<object, object>(x.BooleanValue, !originalRecord.BooleanValue))
+				.Set(x => new KeyValuePair<object, object>(x.IntValue, originalRecord.IntValue + 1))
+				.Set(x => new KeyValuePair<object, object>(x.FloatValue, originalRecord.FloatValue + 1))
+				.Set(x => new KeyValuePair<object, object>(x.DoubleValue, originalRecord.DoubleValue + 1))
+				.Set(x => new KeyValuePair<object, object>(x.DateTimeValue, DateTime.Now))
+				.Set(x => new KeyValuePair<object, object>(x.ListOfStrings, new List<string>(originalRecord.ListOfStrings)
+				{
+					"updated"
+				}))
+				.Where(x => x.Id == originalRecord.Id)
+				.Update(new QueryOptions { Returning = QueryOptions.ReturnType.Representation });
+
+			var testRecord1 = newRecord.Models[0];
+
+			Assert.AreNotEqual(originalRecord.BooleanValue, testRecord1.BooleanValue);
+			Assert.AreNotEqual(originalRecord.IntValue, testRecord1.IntValue);
+			Assert.AreNotEqual(originalRecord.FloatValue, testRecord1.FloatValue);
+			Assert.AreNotEqual(originalRecord.DoubleValue, testRecord1.DoubleValue);
+			Assert.AreNotEqual(originalRecord.DateTimeValue, testRecord1.DateTimeValue);
+			CollectionAssert.AreNotEqual(originalRecord.ListOfStrings, testRecord1.ListOfStrings);
+
+
+			var newRecord2 = await client.Table<KitchenSink>()
+				.Set(x => x.BooleanValue, !testRecord1.BooleanValue)
+				.Set(x => x.IntValue, testRecord1.IntValue + 1)
+				.Set(x => x.FloatValue, testRecord1.FloatValue + 1)
+				.Set(x => x.DoubleValue, testRecord1.DoubleValue + 1)
+				.Set(x => x.DateTimeValue, DateTime.Now.AddSeconds(30))
+				.Set(x => x.ListOfStrings, new List<string>(testRecord1.ListOfStrings)
+				{
+					"updated"
+				})
+				.Where(x => x.Id == testRecord1.Id)
+				.Update(new QueryOptions { Returning = QueryOptions.ReturnType.Representation });
+
+			var testRecord2 = newRecord2.Models[0];
+
+			Assert.AreNotEqual(testRecord1.BooleanValue, testRecord2.BooleanValue);
+			Assert.AreNotEqual(testRecord1.IntValue, testRecord2.IntValue);
+			Assert.AreNotEqual(testRecord1.FloatValue, testRecord2.FloatValue);
+			Assert.AreNotEqual(testRecord1.DoubleValue, testRecord2.DoubleValue);
+			Assert.AreNotEqual(testRecord1.DateTimeValue, testRecord2.DateTimeValue);
+			CollectionAssert.AreNotEqual(testRecord1.ListOfStrings, testRecord2.ListOfStrings);
+
+			Assert.ThrowsException<ArgumentException>(() =>
+			{
+				return client.Table<Movie>().Set(x => x.Name, DateTime.Now).Update();
+			});
+
+			Assert.ThrowsException<ArgumentException>(() =>
+			{
+				return client.Table<Movie>().Set(x => DateTime.Now, newName).Update();
+			});
+
 			Assert.ThrowsException<ArgumentException>(() =>
 			{
 				return client.Table<Movie>().Set(x => new KeyValuePair<object, object>(x.Name, DateTime.Now)).Update();

PostgrestTests/Models/KitchenSink.cs

@@ -12,11 +12,14 @@ namespace PostgrestTests.Models
     public class KitchenSink : BaseModel
     {
         [PrimaryKey("id", false)]
-        public string? Id { get; set; }
+        public int? Id { get; set; }
 
         [Column("string_value")]
         public string? StringValue { get; set; }
 
+        [Column("bool_value")]
+        public bool? BooleanValue { get; set; }
+
         [Column("unique_value")]
         public string? UniqueValue { get; set; }
 

PostgrestTests/db/00-schema.sql

@@ -47,6 +47,7 @@ COMMENT ON COLUMN public.messages.data IS 'For unstructured data and prototyping
 create table "public"."kitchen_sink" (
   "id" serial primary key,
   "string_value" varchar(255) null,
+  "bool_value" BOOL DEFAULT false,
   "unique_value" varchar(255) UNIQUE,
   "int_value" INT null,
   "float_value" FLOAT null,