Serializing unloaded relationships - ember.js

Question

I've written my owner adapter and serializer for my Ember.js application. I follow the JSON API standard (the ID format), so most of my JSON looks something like this:
{
"id": "2364",
"name": "Test",
"links": {
"single": "2834",
"multiple": ["2292", "9584", "8475"]
}
}
However, all of my relationships are loaded lazily (I defined the async attribute as true). This is required, because some of the records can become quite large. The problem is when I try to serialize the model. If the relationship isn't loaded yet, I won't get the ID for the related model. So let's say I edit the name of the model above and try to save it. I'll get this JSON:
{
"id": "2364",
"name": "This has been edited",
"links": {
"single": null,
"multiple": []
}
}
Because the relationships aren't loaded yet, it gives me empty values. However, because the relationships haven't been edited, they should be exactly the same as when they came in. To get that data back, I can use model.get('data') and get an object that contains the IDs that were originally returned from the server. So if I know a relationship is unloaded, I can call model.get('data.relationshipName') and get those original IDs back.
Now the real problem: if the relationship is loaded fully, I want to serialize it as it exists, in case it was edited. However, if it is not loaded fully, I don't want to attempt to load it. In that case, I can just get the IDs from the data property. So, how can I determine if a relationship is loaded or not, without loading it?

Answer 1

As usual, I did quite a bit of legwork and trickery, but I figured it out. Here's what you do:
Have all of your models inherit from a single base class. In that base class, you want to do three things. First, in the init method, created a hash (object) on the instance (leave it empty). Next, override the get method, and if the user tries to access one of the relationships, update the hash you created to reflect that. Finally add a method like wasRelationshipAccessed(name) to the class to read from the hash. This will tell you exactly which relationships where accessed, and by process of elimination, which ones weren't.
Also in that base class, have the init method create another hash. This one is going to store the original values of the relationships from the server. I called mine originalLinks.
Override DS.Store and assign it to App.Store. In that class, override the push method. In the override, call this._super.apply(this, arguments) and save the return value. That return value is the record. Now that you have both the data from the server and the record, insert the relationships from the server into the originalLinks hash you made above.
Finally, in your serializer, use your wasRelationshipAccessed function. If the relationship was accessed, it was loaded. If it wasn't accessed, get the data from the originalLinks hash.
And that's all there is to it. If you're going to do this, I highly suggest writing unit tests for your serializer, adapter and that part of the store. That will ensure that you'll catch any changes to the internals of Ember-Data.