Re: #92 Changes IPostgrestTable<> contract to return the interface rather than a concrete type.

Author: acupofjose

Postgrest/Interfaces/IPostgrestTable.cs

@@ -35,7 +35,7 @@ namespace Supabase.Postgrest.Interfaces
         /// </summary>
         /// <param name="filters"></param>
         /// <returns></returns>
-        Table<TModel> And(List<IPostgrestQueryFilter> filters);
+        IPostgrestTable<TModel> And(List<IPostgrestQueryFilter> filters);
 
         /// <summary>
         /// Clears currently defined query values.
@@ -52,7 +52,7 @@ namespace Supabase.Postgrest.Interfaces
         /// </summary>
         /// <param name="columns"></param>
         /// <returns></returns>
-        Table<TModel> Columns(string[] columns);
+        IPostgrestTable<TModel> Columns(string[] columns);
 
         /// <summary>
         /// By using the columns query parameter it’s possible to specify the payload keys that will be inserted and ignore the rest of the payload.
@@ -64,7 +64,7 @@ namespace Supabase.Postgrest.Interfaces
         /// </summary>
         /// <param name="predicate"></param>
         /// <returns></returns>
-        Table<TModel> Columns(Expression<Func<TModel, object[]>> predicate);
+        IPostgrestTable<TModel> Columns(Expression<Func<TModel, object[]>> predicate);
 
         /// <summary>
         /// Returns ONLY a count from the specified query.
@@ -99,7 +99,7 @@ Task<ModeledResponse<TModel>> Delete(TModel model, QueryOptions? options = null,
         /// <param name="op">Operation to perform.</param>
         /// <param name="criterion">Value to filter with, must be a `string`, `List&lt;object&gt;`, `Dictionary&lt;string, object&gt;`, `FullTextSearchConfig`, or `Range`</param>
         /// <returns></returns>
-        Table<TModel> Filter<TCriterion>(string columnName, Constants.Operator op, TCriterion? criterion);
+        IPostgrestTable<TModel> Filter<TCriterion>(string columnName, Constants.Operator op, TCriterion? criterion);
 
         /// <summary>
         /// Add a filter to a query request using a predicate to select column.
@@ -109,7 +109,7 @@ Task<ModeledResponse<TModel>> Delete(TModel model, QueryOptions? options = null,
         /// <param name="criterion">Value to filter with, must be a `string`, `List&lt;object&gt;`, `Dictionary&lt;string, object&gt;`, `FullTextSearchConfig`, or `Range`</param>
         /// <returns></returns>
         /// <exception cref="ArgumentException"></exception>
-        Table<TModel> Filter<TCriterion>(Expression<Func<TModel, object>> predicate, Constants.Operator op,
+        IPostgrestTable<TModel> Filter<TCriterion>(Expression<Func<TModel, object>> predicate, Constants.Operator op,
             TCriterion? criterion);
 
         /// <summary>
@@ -145,28 +145,28 @@ Task<ModeledResponse<TModel>> Insert(TModel model, QueryOptions? options = null,
         /// <param name="limit"></param>
         /// <param name="foreignTableName"></param>
         /// <returns></returns>
-        Table<TModel> Limit(int limit, string? foreignTableName = null);
+        IPostgrestTable<TModel> Limit(int limit, string? foreignTableName = null);
 
         /// <summary>
         /// Finds all rows whose columns match the specified `query` object.
         /// </summary>
         /// <param name="query">The object to filter with, with column names as keys mapped to their filter values.</param>
         /// <returns></returns>
-        Table<TModel> Match(Dictionary<string, string> query);
+        IPostgrestTable<TModel> Match(Dictionary<string, string> query);
 
         /// <summary>
         /// Fills in query parameters based on a given model's primary key(s).
         /// </summary>
         /// <param name="model">A model with a primary key column</param>
         /// <returns></returns>
-        Table<TModel> Match(TModel model);
+        IPostgrestTable<TModel> Match(TModel model);
 
         /// <summary>
         /// Adds a NOT filter to the current query args.
         /// </summary>
         /// <param name="filter"></param>
         /// <returns></returns>
-        Table<TModel> Not(IPostgrestQueryFilter filter);
+        IPostgrestTable<TModel> Not(IPostgrestQueryFilter filter);
 
         /// <summary>
         /// Adds a NOT filter to the current query args.
@@ -175,7 +175,7 @@ Task<ModeledResponse<TModel>> Insert(TModel model, QueryOptions? options = null,
         /// <param name="op"></param>
         /// <param name="criteria"></param>
         /// <returns></returns>
-        Table<TModel> Not(string columnName, Constants.Operator op, Dictionary<string, object> criteria);
+        IPostgrestTable<TModel> Not(string columnName, Constants.Operator op, Dictionary<string, object> criteria);
 
         /// <summary>
         /// Adds a NOT filter to the current query args.
@@ -184,7 +184,7 @@ Task<ModeledResponse<TModel>> Insert(TModel model, QueryOptions? options = null,
         /// <param name="op"></param>
         /// <param name="criteria"></param>
         /// <returns></returns>
-        Table<TModel> Not(Expression<Func<TModel, object>> predicate, Constants.Operator op, Dictionary<string, object> criteria);
+        IPostgrestTable<TModel> Not(Expression<Func<TModel, object>> predicate, Constants.Operator op, Dictionary<string, object> criteria);
 
         /// <summary>
         /// Adds a NOT filter to the current query args.
@@ -197,7 +197,7 @@ Task<ModeledResponse<TModel>> Insert(TModel model, QueryOptions? options = null,
         /// <param name="op"></param>
         /// <param name="criteria"></param>
         /// <returns></returns>
-        Table<TModel> Not<TCriterion>(string columnName, Constants.Operator op, List<TCriterion> criteria);
+        IPostgrestTable<TModel> Not<TCriterion>(string columnName, Constants.Operator op, List<TCriterion> criteria);
 
         /// <summary>
         /// Adds a NOT filter to the current query args.
@@ -210,7 +210,7 @@ Task<ModeledResponse<TModel>> Insert(TModel model, QueryOptions? options = null,
         /// <param name="op"></param>
         /// <param name="criteria"></param>
         /// <returns></returns>
-        Table<TModel> Not<TCriterion>(Expression<Func<TModel, object>> predicate, Constants.Operator op,
+        IPostgrestTable<TModel> Not<TCriterion>(Expression<Func<TModel, object>> predicate, Constants.Operator op,
             List<TCriterion> criteria);
 
         /// <summary>
@@ -225,7 +225,7 @@ Table<TModel> Not<TCriterion>(Expression<Func<TModel, object>> predicate, Consta
         /// <param name="op"></param>
         /// <param name="criterion"></param>
         /// <returns></returns>
-        Table<TModel> Not<TCriterion>(string columnName, Constants.Operator op, TCriterion? criterion);
+        IPostgrestTable<TModel> Not<TCriterion>(string columnName, Constants.Operator op, TCriterion? criterion);
 
 
         /// <summary>
@@ -240,7 +240,7 @@ Table<TModel> Not<TCriterion>(Expression<Func<TModel, object>> predicate, Consta
         /// <param name="op"></param>
         /// <param name="criterion"></param>
         /// <returns></returns>
-        Table<TModel> Not<TCriterion>(Expression<Func<TModel, object>> predicate, Constants.Operator op,
+        IPostgrestTable<TModel> Not<TCriterion>(Expression<Func<TModel, object>> predicate, Constants.Operator op,
             TCriterion? criterion);
 
         /// <summary>
@@ -249,28 +249,28 @@ Table<TModel> Not<TCriterion>(Expression<Func<TModel, object>> predicate, Consta
         /// <param name="offset"></param>
         /// <param name="foreignTableName"></param>
         /// <returns></returns>
-        Table<TModel> Offset(int offset, string? foreignTableName = null);
+        IPostgrestTable<TModel> Offset(int offset, string? foreignTableName = null);
 
         /// <summary>
         /// By specifying the onConflict query parameter, you can make UPSERT work on a column(s) that has a UNIQUE constraint.
         /// </summary>
         /// <param name="columnName"></param>
         /// <returns></returns>
-        Table<TModel> OnConflict(string columnName);
+        IPostgrestTable<TModel> OnConflict(string columnName);
 
         /// <summary>
         /// Set an onConflict query parameter for UPSERTing on a column that has a UNIQUE constraint using a linq predicate.
         /// </summary>
         /// <param name="predicate">Expects a column from the model to be returned.</param>
         /// <returns></returns>
-        Table<TModel> OnConflict(Expression<Func<TModel, object>> predicate);
+        IPostgrestTable<TModel> OnConflict(Expression<Func<TModel, object>> predicate);
 
         /// <summary>
         /// Adds a OR Filter to the current query args.
         /// </summary>
         /// <param name="filters"></param>
         /// <returns></returns>
-        Table<TModel> Or(List<IPostgrestQueryFilter> filters);
+        IPostgrestTable<TModel> Or(List<IPostgrestQueryFilter> filters);
 
         /// <summary>
         /// Adds an ordering to the current query args.
@@ -284,7 +284,7 @@ Table<TModel> Not<TCriterion>(Expression<Func<TModel, object>> predicate, Consta
         /// <param name="ordering"></param>
         /// <param name="nullPosition"></param>
         /// <returns></returns>
-        Table<TModel> Order(string column, Constants.Ordering ordering,
+        IPostgrestTable<TModel> Order(string column, Constants.Ordering ordering,
             Constants.NullPosition nullPosition = Constants.NullPosition.First);
 
         /// <summary>
@@ -299,7 +299,7 @@ Table<TModel> Order(string column, Constants.Ordering ordering,
         /// <param name="ordering">>Expects a columns from the Model to be returned</param>
         /// <param name="nullPosition"></param>
         /// <returns></returns>
-        Table<TModel> Order(Expression<Func<TModel, object>> predicate, Constants.Ordering ordering,
+        IPostgrestTable<TModel> Order(Expression<Func<TModel, object>> predicate, Constants.Ordering ordering,
             Constants.NullPosition nullPosition = Constants.NullPosition.First);
 
         /// <summary>
@@ -315,30 +315,30 @@ Table<TModel> Order(Expression<Func<TModel, object>> predicate, Constants.Orderi
         /// <param name="ordering"></param>
         /// <param name="nullPosition"></param>
         /// <returns></returns>
-        Table<TModel> Order(string foreignTable, string column, Constants.Ordering ordering,
+        IPostgrestTable<TModel> Order(string foreignTable, string column, Constants.Ordering ordering,
             Constants.NullPosition nullPosition = Constants.NullPosition.First);
 
         /// <summary>
         /// Sets a FROM range, similar to a `StartAt` query.
         /// </summary>
         /// <param name="from"></param>
         /// <returns></returns>
-        Table<TModel> Range(int from);
+        IPostgrestTable<TModel> Range(int from);
 
         /// <summary>
         /// Sets a bounded range to the current query.
         /// </summary>
         /// <param name="from"></param>
         /// <param name="to"></param>
         /// <returns></returns>
-        Table<TModel> Range(int from, int to);
+        IPostgrestTable<TModel> Range(int from, int to);
 
         /// <summary>
         /// Select columns for query. 
         /// </summary>
         /// <param name="columnQuery"></param>
         /// <returns></returns>
-        Table<TModel> Select(string columnQuery);
+        IPostgrestTable<TModel> Select(string columnQuery);
 
         /// <summary>
         /// Select columns using a predicate function.
@@ -348,7 +348,7 @@ Table<TModel> Order(string foreignTable, string column, Constants.Ordering order
         /// </summary>
         /// <param name="predicate">Expects an array of columns from the Model to be returned.</param>
         /// <returns></returns>
-        Table<TModel> Select(Expression<Func<TModel, object[]>> predicate);
+        IPostgrestTable<TModel> Select(Expression<Func<TModel, object[]>> predicate);
 
         /// <summary>
         /// Filter a query based on a predicate function. 
@@ -365,7 +365,7 @@ Table<TModel> Order(string foreignTable, string column, Constants.Ordering order
         /// </summary>
         /// <param name="predicate"></param>
         /// <returns></returns>
-        Table<TModel> Where(Expression<Func<TModel, bool>> predicate);
+        IPostgrestTable<TModel> Where(Expression<Func<TModel, bool>> predicate);
 
         /// <summary>
         /// Executes a query that expects to have a single object returned, rather than returning list of models
@@ -383,7 +383,7 @@ Table<TModel> Order(string foreignTable, string column, Constants.Ordering order
         /// <param name="keySelector"></param>
         /// <param name="value"></param>
         /// <returns></returns>
-        Table<TModel> Set(Expression<Func<TModel, object>> keySelector, object? value);
+        IPostgrestTable<TModel> Set(Expression<Func<TModel, object>> keySelector, object? value);
 
         /// <summary>
         /// Specifies a KeyValuePair to be updated. Should be combined with filters/where clauses.
@@ -393,7 +393,7 @@ Table<TModel> Order(string foreignTable, string column, Constants.Ordering order
         /// <param name="keyValuePairExpression"></param>
         /// <returns></returns>
         /// <exception cref="ArgumentException"></exception>
-        Table<TModel> Set(Expression<Func<TModel, KeyValuePair<object, object?>>> keyValuePairExpression);
+        IPostgrestTable<TModel> Set(Expression<Func<TModel, KeyValuePair<object, object?>>> keyValuePairExpression);
 
         /// <summary>
         /// Calls an Update function after `Set` has been called.

Postgrest/Linq/WhereExpressionVisitor.cs

@@ -123,9 +123,9 @@ protected override Expression VisitMethodCall(MethodCallExpression node)
                 case nameof(String.Contains):
 
                     if (typeof(ICollection).IsAssignableFrom(node.Method.DeclaringType))
-                        Filter = new QueryFilter(column, Constants.Operator.Contains, GetArgumentValues(node));
+                        Filter = new QueryFilter(column, Operator.Contains, GetArgumentValues(node));
                     else
-                        Filter = new QueryFilter(column, Constants.Operator.Like, "*" + GetArgumentValues(node).First() + "*");
+                        Filter = new QueryFilter(column, Operator.Like, "*" + GetArgumentValues(node).First() + "*");
 
                     break;
                 default:
@@ -141,7 +141,7 @@ protected override Expression VisitMethodCall(MethodCallExpression node)
         /// <param name="column"></param>
         /// <param name="op"></param>
         /// <param name="constantExpression"></param>
-        private void HandleConstantExpression(string column, Constants.Operator op, ConstantExpression constantExpression)
+        private void HandleConstantExpression(string column, Operator op, ConstantExpression constantExpression)
         {
             if (constantExpression.Type.IsEnum)
             {
@@ -160,7 +160,7 @@ private void HandleConstantExpression(string column, Constants.Operator op, Cons
         /// <param name="column"></param>
         /// <param name="op"></param>
         /// <param name="memberExpression"></param>
-        private void HandleMemberExpression(string column, Constants.Operator op, MemberExpression memberExpression)
+        private void HandleMemberExpression(string column, Operator op, MemberExpression memberExpression)
         {
             Filter = new QueryFilter(column, op, GetMemberExpressionValue(memberExpression));
         }
@@ -171,7 +171,7 @@ private void HandleMemberExpression(string column, Constants.Operator op, Member
         /// <param name="column"></param>
         /// <param name="op"></param>
         /// <param name="unaryExpression"></param>
-        private void HandleUnaryExpression(string column, Constants.Operator op, UnaryExpression unaryExpression)
+        private void HandleUnaryExpression(string column, Operator op, UnaryExpression unaryExpression)
         {
             if (unaryExpression.Operand is ConstantExpression constantExpression)
             {
@@ -193,7 +193,7 @@ private void HandleUnaryExpression(string column, Constants.Operator op, UnaryEx
         /// <param name="column"></param>
         /// <param name="op"></param>
         /// <param name="newExpression"></param>
-        private void HandleNewExpression(string column, Constants.Operator op, NewExpression newExpression)
+        private void HandleNewExpression(string column, Operator op, NewExpression newExpression)
         {
             var argumentValues = new List<object>();
             foreach (var argument in newExpression.Arguments)
@@ -279,22 +279,22 @@ private object GetMemberExpressionValue(MemberExpression member)
         /// </summary>
         /// <param name="node"></param>
         /// <returns></returns>
-        private Constants.Operator GetMappedOperator(Expression node)
+        private Operator GetMappedOperator(Expression node)
         {
             return node.NodeType switch
             {
-                ExpressionType.Not => Constants.Operator.Not,
-                ExpressionType.And => Constants.Operator.And,
-                ExpressionType.AndAlso => Constants.Operator.And,
-                ExpressionType.OrElse => Constants.Operator.Or,
-                ExpressionType.Or => Constants.Operator.Or,
-                ExpressionType.Equal => Constants.Operator.Equals,
-                ExpressionType.NotEqual => Constants.Operator.NotEqual,
-                ExpressionType.LessThan => Constants.Operator.LessThan,
-                ExpressionType.GreaterThan => Constants.Operator.GreaterThan,
-                ExpressionType.LessThanOrEqual => Constants.Operator.LessThanOrEqual,
-                ExpressionType.GreaterThanOrEqual => Constants.Operator.GreaterThanOrEqual,
-                _ => Constants.Operator.Equals
+                ExpressionType.Not => Operator.Not,
+                ExpressionType.And => Operator.And,
+                ExpressionType.AndAlso => Operator.And,
+                ExpressionType.OrElse => Operator.Or,
+                ExpressionType.Or => Operator.Or,
+                ExpressionType.Equal => Operator.Equals,
+                ExpressionType.NotEqual => Operator.NotEqual,
+                ExpressionType.LessThan => Operator.LessThan,
+                ExpressionType.GreaterThan => Operator.GreaterThan,
+                ExpressionType.LessThanOrEqual => Operator.LessThanOrEqual,
+                ExpressionType.GreaterThanOrEqual => Operator.GreaterThanOrEqual,
+                _ => Operator.Equals
             };
         }