How to properly setup a store that acts as a single pointer across your web app

问题

I have a home grown store that has a simple identityMap. When I return an array of models from this and bind it to a controllers "model" it reflects what you'd expect

the first time you hit a route it reflects this in the template as you'd expect

But later if I get this same store instance (it's a singleton) and push an object into the identityMap it doesn't automatically update the previous template

The store itself is super basic (no relationships/ just push objects and get by id)

function buildRecord(type, data, store) {
    var containerKey = 'model:' + type;
    var factory = store.container.lookupFactory(containerKey);

    var record = factory.create(data);

    var id = data.id;
    identityMapForType(type, store)[id] = record;

    return record;
}

function identityMapForType(type, store) {
    var typeIdentityMap = store.get('identityMap');

    var idIdentityMap = typeIdentityMap[type] || {};
    typeIdentityMap[type] = idIdentityMap;

    return idIdentityMap;
}

var Store = Ember.Object.extend({
    init: function() {
        this.set('identityMap', {});
    },

    push: function(type, data) {
        var record = this.getById(type, data.id);
        if (record) {
            record.setProperties(data);
        } else {
            record = buildRecord(type, data, this);
        }
        return record;
    },

    getById: function(type, id) {
        var identityMap = identityMapForType(type, this);
        return identityMap[id] || null;
    }

    getEverything: function(type) {
        var identityMap = identityMapForType(type, this);
        var keys = Object.keys(identityMap);
        var values = [];
        for (var i = 0; i < keys.length; i++)
        {
            var val = identityMap[keys[i]];
            values.push(val);
        }
        return values;
    }
});

Ember.onLoad('Ember.Application', function(Application) {
    Application.initializer({
        name: "store",
        initialize: function(container, application) {
            application.register('store:main', Store);
            application.inject('controller', 'store', 'store:main');
            application.inject('route', 'store', 'store:main');
        }
    });
});

In my model hook (in the find all route lets say) I simply query for each item and push them into the store

//inside my model find method lets say ...
find: function(store) {
    var url = "/api/foo";
    $.getJSON(url, function(response) {
        response.forEach(function(data) {
            var model = store.push("foo", data);
        }
    }
    return store.getEverything("foo");
}

So I assumed my controllers' model was this bound array (using a single pointer in memory for this array of models)

Yet when I do this inside a controller submit action it won't re-render that prev view (to show the new item that was added to that store's array)

actions: {
    submit: function() {
        var foo = {}; // assume this is a real json response or js object
        var store = this.get("store");
        store.push("foo", foo);
    }
}

Because of this today, I'm forced to get the parent controller and "set" / "push" this new object to it's content/model property :(

Anyone know what I'm doing wrong here?

回答1:

I like homegrown solutions, they generally are easier to work with and meld around what you're working on.

So I'm actually surprised this part is working:

//inside my model find method lets say ...
find: function(store) {
    var url = "/api/foo";
    $.getJSON(url, function(response) {
        response.forEach(function(data) {
            var model = store.push("foo", data);
        }
    }
    return store.getEverything("foo");
}

If I read through it I see you make an ajax call, and then return store.getEverything immediately after (without a guarantee that the ajax call has completed). Then inside of getEverything you create a new array called values then iterate the identity map linking up all of the currently available records and return that. At this point your store is unaware of this array going forward. So any changes to your store wouldn't get pushed out to the array, they might make it into the identity map, but it isn't feeding the getEverything array.

There are a couple of solutions, one would be to keep track of your everything array. That collection would be super cheap to build, more expensive to search, so keeping the identity map as well would be super beneficial. You could follow your same pattern, but one collection would be the map, whereas the other would be an array of everything.

Modified Build Record

function buildRecord(type, data, store) {
    var containerKey = 'model:' + type;
    var factory = store.container.lookupFactory(containerKey);

    var record = factory.create(data);

    var id = data.id;
    identityMapForType(type, store)[id] = record;
    everythingArrayForType(type, this).pushObject(record);
    return record;
}

Copy paste, possibly could be refactored

function everythingArrayForType(type, store) {
    var everythingArrays = store.get('everythingArrays');
    var arr = everythingArrays[type] || [];
    everythingArrays[type] = arr;

    return arr;
}

Slightly modified Store

var Store = Ember.Object.extend({
    init: function() {
        this.set('identityMap', {});
        this.set('everythingArrays', {});
    },
    push: function(type, data) {
        var record = this.getById(type, data.id);
        if (record) {
            record.setProperties(data);
        } else {
            record = buildRecord(type, data, this);
        }
        return record;
    },

    getById: function(type, id) {
        var identityMap = identityMapForType(type, this);
        return identityMap[id] || null;
    }

    getEverything: function(type) {
        return everythingArrayForType(type, this);
    }
});

来源：https://stackoverflow.com/questions/25392921/how-to-properly-setup-a-store-that-acts-as-a-single-pointer-across-your-web-app