Question

My question is this: How can you implement a default server-side “filter” for a navigation property?

In our application we seldom actually delete anything from the database. Instead, we implement “soft deletes” where each table has a Deleted bit column. If this column is true the record has been “deleted”. If it is false, it has not.

This allows us to easily “undelete” records accidentally deleted by the client.

Our current ASP.NET Web API returns only “undeleted” records by default, unless a deleted argument is sent as true from the client. The idea is that the consumer of the service doesn’t have to worry about specifying that they only want undeleted items.

Implementing this same functionality in Breeze is quite simple, at least for base entities. For example, here would be the implementation of the classic Todo’s example, adding a “Deleted” bit field:

    // Note: Will show only undeleted items by default unless you explicitly pass deleted = true.
    [HttpGet]
    public IQueryable<BreezeSampleTodoItem> Todos(bool deleted = false) {
        return _contextProvider.Context.Todos.Where(td => td.Deleted == deleted);
    }

On the client, all we need to do is…

var query = breeze.EntityQuery.from("Todos");

…to get all undeleted Todos, or…

var query = breeze.EntityQuery.from("Todos").withParameters({deleted: true})

…to get all deleted Todos.

But let’s say that a BreezeSampleTodoItem has a child collection for the tools that are needed to complete that Todo. We’ll call this “Tools”. Tools also implements soft deletes. When we perform a query that uses expand to get a Todo with its Tools, it will return all Tools – “deleted” or not.

But how can I filter out these records by default when Todo.Tools is expanded?

It has occurred to me to have separate Web API methods for each item that may need expanded, for example:

[HttpGet]
public IQueryable<Todo> TodoAndTools(bool deletedTodos = false, bool deletedTools = false)
{
    return // ...Code to get filtered Todos with filtered Tools
}

I found some example code of how to do this in another SO post, but it requires hand-coding each property of Todo. The code from the above-mentioned post also returns a List, not an IQueryable. Furthermore this requires methods to be added for every possible expansion which isn’t cool.

Essentially what I’m looking for is some way to define a piece of code that gets called whenever Todos is queried, and another for whenever Tools is queried – preferably being able to pass an argument that defines if it should return Deleted items. This could be anywhere on the server-side stack – be it in the Web API method, itself, or maybe part of Entity Framework (note that filtering Include extensions is not supported in EF.)

Answer 1

Breeze cannot do exactly what you are asking for right now, although we have discussed the idea of allowing the filtering of “expands”, but we really need more feedback as to whether the community would find this useful. Please add this to the breeze User Voice and vote for it. We take these suggestions very seriously.

Moreover, as you point out, EF does not support this.

But… what you can do is use a projection instead of an expand to do something very similar:

public IQueryable<Object> TodoAndTools(bool deleted = false
                                      ,bool deletedTools = false) {
    var baseQuery = _contextProvider.Context.Todos.Where(td => td.Deleted == deleted);
    return baseQuery.Select(t => new {
      Todo: t,
      Tools: t.Tools.Where( tool => tool.Deleted = deletedTools);
    });
 }

Several things to note here:

1) We are returning an IQueryable of Object instead of IQueryable of ToDo

2) Breeze will inspect the returned payload and automatically create breeze entities for any ‘entityTypes’ returned (even within a projection). So the result of this query will be an array of javascript objects each with two properties; ‘ToDo’ and ‘Tools’ where Tools is an array of ‘Tool’ entities. The nice thing is that both ToDo and Tool entities returned within the projection will be ‘full’ breeze entities.

3) You can still pass client side filters based on the projected property names. i.e.

var query = EntityQuery.from("TodoAndTools")
        .where("Todo.Description", "startsWith", "A")
        .using(em);

4) EF does support this.