Better support for nested models and collections

At the moment the support for nested structures is limited. We’d like to improve this as it’s a common situation and should in theory work as you would expect. This issue is a place to collect all the things we’d like to achieve when we get to improving this support.

• Errors should be set on the child, not with dot notation on the parent. (or both?)
• Determine the difference between parent.saved('child.attr') and parent.child.saved('attr')
• Provide a nice mechanism to convert nested objects to models

[Sarke]

I extended Model like this for a simple relation:

export default class extends Model {

    /**
     * Creates a new instance, called when using 'new'.
     *
     * @param  {Object}     [attributes]  Model attributes
     * @param  {Collection} [collection]  Collection that this model belongs to.
     * @param  {Object}     [options]     Options to set on the model.
     */
    constructor(attributes = {}, collection = null, options = {}) {
        super(attributes, collection, options);
        this._relations = {};
        this.init();
    }

    init() {
        ;
    }

    relation(relationName, findCallback) {
        if (typeof this._relations[relationName] === 'undefined') {
            let storeData = store.get(relationName);
            if (storeData.length === 0) {
                return null;
            }

            this._relations[relationName] = storeData.find(findCallback);
            if (this._relations[relationName] === undefined) {
                this._relations[relationName] = null;
            }
        }

        return this._relations[relationName];
    }
}

The init() is just there so you can more easily add things to the constructor. All I really need to do is add this._relations = {};.

Then, in the model for a particular resource, I can just do this:

    get categoryModel() {
        return this.relation('categories', Category => Category.id === this.categoryId);
    }

Nothing crazy, just a simple way to do it. The relation is cached, and there’s nothing invalidating that cache on update, but other than that it’s works well.

[rtheunissen]

@MichMich There are two stages here: 1) plan it, 2) implement it. I’m not confident that we know what the solution is yet, so while the implementation might be quick, it’s difficult to estimate how long it would take to come up with a solution.

Can you give me an example of one of your model schema’s?

The API for this should be as simple as:

delegates() {
    "a.b": ModelA,
    "x.y.*": ModelB,
}

I think if we can come up with an API that is “acceptable”, we’re good to go. This would only solve 1 of the 3 points laid out in the opening statement. I don’t believe the other two are difficult to solve though:

Errors should be set on the child, not with dot notation on the parent. (or both?)

Should be set on the child, such that parent.errors is empty but parent.child.errors is populated.

Determine the difference between parent.saved(‘child.prop’) and parent.child.saved(‘prop’)

These should both be supported because they are not equivalent. This first uses the saved child’s property, and the second uses the active child’s saved property. This is a bit confusing but it will be very difficult to avoid that, unless we disallow nesting that isn’t delegated (I don’t want to do this though because it could force a lot of boilerplate).