Ember Data Filter Objects

[bmac]

Rendered

[knownasilya]

Very interesting idea. I like it a lot, even if it doesn't fix the memory leak.

[trabus]

I really like this idea as well, especially if it will help protect against memory leaks. It looks like it could definitely simplify the way we're using store.filter to control when our users load data. We don't use the query param with filter to load any data, but rather we filter already loaded and cached data, only loading data when necessary.

We use store.filter pretty extensively in our app at the model level. We often need to use more than one filter method, and so we built some convenience methods to streamline the process. Our implementation essentially takes an array of objects/functions and converts them into an array of assertions. If all assertions pass, the data makes it through the filter:

// app/utils/data-filter.js
export default function dataFilter(filterData) {
    var filters = filterData.map(function(data) {
        if(typeof data === 'function') {
            return data;
        }
        return assertions[data.type](data.property, data.value);
    });
    return function(obj) {
        var results = filters.map(function(f) {
            return f(obj);
        });
        return results.indexOf(false) === -1;
    };
}

export var assertions = {
    isEqual: isEqual,
    notEqual: notEqual
    ...
// assertion methods 
function isEqual(property, value) {
    return function(obj) {
        return obj.get(property) === value;
    };
}
...

We then have a mixin for the routes that initially loads from a store.find, but uses store.filter on subsequent requests. This lets us control the data into our app better:

// app/mixins/filtered-route.js
export default Ember.Mixin.create({
    isModelLoaded: false,
    modelQuery: null,
    modelFilter: null,

    model: function() {
        return this.setupModel(
            this.get('modelName'), 
            this.get('modelQuery'), 
            this.get('modelFilter')
        );
    },

    setupModel: function(name, query, filters) {
        var filterData = dataFilter(filters);
        var self = this;
        if(!this.get('isModelLoaded') || !this.get('modelFilter')){
            return this.store.find(name, query)
            .then(function(data) {
                self.set('isModelLoaded',true);
                return data;
            });
        } else {
            return this.store.filter(name, filterData);
        }
    }
});

This is a simple, contrived version of our implementation, and doesn't take into account our cached data management or pagination, but I think it gets the point across.

// app/routes/inbox.js
import Ember from 'ember';
import FilteredRoute from 'app/mixins/filtered-route';

export default Ember.Route.extend(FilteredRoute,{
    modelName: 'message',
    modelQuery: { type: 'inbox'},
    modelFilter: function() {
        return [
            {
                type: 'isEqual',
                property:'type',
                value: 'all'
            }
        ];
    }.property()
});

// app/routes/sent.js
import Ember from 'ember';

export default Ember.Route.extend(FilteredRoute,{
    modelName: 'message',
    modelQuery: { type: 'sent'},
    modelFilter: function() {
        return [
            {
                type: 'isEqual',
                property:'type',
                value: 'sent'
            }
        ];
    }.property()
});

I can see filter being a blueprint in Ember-cli. Generating a filter module like you would for an adapter or serializer would be great for separating out your filter logic, and would work well in pods as well. Anyhow, really looking forward to see how this develops.

[stefanpenner]

@ef4 this actually related to some of our relational language discussions lately.