Dynamic or Computed Filters

[jaredcnance]

A dynamic/computed filter can be defined based on a provided value:

?filter[was-active-on]=2017-10-24

[DynamicFilter("was-active-on")]
public bool WasActiveOn(DateTime date)
{
  // ... 
}

Requirements:

• must return a boolean value
• ...

Design/Random Thoughts:

• limit reflection to startup if possible
• can we get away from any runtime reflection if we require the method to be static (possibly extension method or one that accepts a paramter of type TResource)?

• how to communicate the negative impact on application performance? i.e. EF will probably have to load all resources into memory and then apply the filter

[jaredcnance]

Creating a naive implementation that supports the following:

public class FooEvent : Identifiable {  
  [DynamicFilter("was-active-on")]
  public bool WasActiveOn(DateTime date) => (date > StartedAt && date < EndedAt)
}

Seems simple but it may be properly translated by EF. However, this opens up the possibility for much more complex queries (i.e. anything can go in the WasActiveOn body) and could have unexpected issues.

Perhaps it would make more sense to offer some access to the IQueryable to be filtered. Filtering (and sorting for that matter) could be pulled out of the repository into something like:

interface IEntityFilter<TEntity> {
  IQueryable<TEntity> Filter(IQueryable<TEntity> entities, FilterQuery filterQuery);
}

This would allow more obvious implementations (less hiding of the fact that this is being passed to EF), through DI:

public class DefaultEntityFilter<TEntity> : IEntityFilter<TEntity> { /* ... */ }

public class FooFilter : DefaultEntityFilter<Foo>  { 
  public IQueryable<Foo> Filter(IQueryable<Foo> foos, FilterQuery filterQuery) {
     if(string.Equals(filterQuery.Attribute, "was-active-on", StringComparison.OrdinalIgnoreCase))
       return FilterWasActiveOn(foos, filterQuery);

     return base.Filter(foos, filterQuery);
  }
  // ...
}

[jaredcnance]

This should be resolved by ResourceDefinition.GetQueryFilters

JsonApiDotNetCore/src/JsonApiDotNetCore/Models/ResourceDefinition.cs

Lines 123 to 156 in 2221d57

	/// <summary>
	/// Define a set of custom query expressions that can be applied
	/// instead of the default query behavior. A common use-case for this
	/// is including related resources and filtering on them.
	/// </summary>
	/// <returns>
	/// A set of custom queries that will be applied instead of the default
	/// queries for the given key. Null will be returned if default behavior
	/// is desired.
	/// </returns>
	/// <example>
	/// <code>
	/// protected override QueryFilters GetQueryFilters() => {
	/// { "facility", (t, value) => t.Include(t => t.Tenant)
	/// .Where(t => t.Facility == value) }
	/// }
	/// </code>
	///
	/// If the logic is simply too complex for an in-line expression, you can
	/// delegate to a private method:
	/// <code>
	/// protected override QueryFilters GetQueryFilters()
	/// => new QueryFilters {
	/// { "is-active", FilterIsActive }
	/// };
	///
	/// private IQueryable&lt;Model&gt; FilterIsActive(IQueryable&lt;Model&gt; query, string value)
	/// {
	/// // some complex logic goes here...
	/// return query.Where(x => x.IsActive == computedValue);
	/// }
	/// </code>
	/// </example>
	public virtual QueryFilters GetQueryFilters() => null;