DynamicSerializerMixin Class
Ember Data Serializer for Apache Solr Dynamic Fields.
Item Index
Methods
- applyTransforms
- dynamicKeyForAttribute
- extract
- extractArray
- extractCreateRecord
- extractDeleteRecord
- extractFind
- extractFindAll
- extractFindBelongsTo
- extractFindHasMany
- extractFindMany
- extractFindQuery
- extractMeta
- extractSave
- extractSingle
- extractUpdateRecord
- keyForAttribute
- keyForRelationship
- normalize
- serialize
- serializeAttribute
- serializeBelongsTo
- serializeHasMany
- serializePolymorphicType
- transformFor
Methods
applyTransforms
-
type
-
data
Given a subclass of DS.Model
and a JSON object this method will
iterate through each attribute of the DS.Model
and invoke the
DS.Transform#deserialize
method on the matching property of the
JSON object. This method is typically called after the
serializer's normalize
method.
Parameters:
-
type
subclass of DS.Model -
data
Object<p><p>The data to transform</p></p>
Returns:
<p><p>data The transformed data object</p></p>
dynamicKeyForAttribute
-
attr
Uses
dynamicFieldPrefixes
and
dynamicFieldSuffixes
to produce a dynamic field key. For a string attribute like related_articles
this method would return related_articles_s
.
Parameters:
-
attr
String
Returns:
key
extract
-
store
-
type
-
payload
-
id
-
requestType
The extract
method is used to deserialize payload data from the
server. By default the JSONSerializer
does not push the records
into the store. However records that subclass JSONSerializer
such as the RESTSerializer
may push records into the store as
part of the extract call.
This method delegates to a more specific extract method based on
the requestType
.
Example
var get = Ember.get;
socket.on('message', function(message) {
var modelName = message.model;
var data = message.data;
var type = store.modelFor(modelName);
var serializer = store.serializerFor(type.typeKey);
var record = serializer.extract(store, type, data, get(data, 'id'), 'single');
store.push(modelName, record);
});
Parameters:
Returns:
<p><p>json The deserialized payload</p></p>
extractArray
-
store
-
type
-
payload
extractArray
is used to deserialize an array of records
returned from the adapter.
Example
App.PostSerializer = DS.JSONSerializer.extend({
extractArray: function(store, type, payload) {
return payload.map(function(json) {
return this.extractSingle(json);
}, this);
}
});
Parameters:
-
store
DS.Store -
type
subclass of DS.Model -
payload
Object
Returns:
<p><p>array An array of deserialized objects</p></p>
extractCreateRecord
-
store
-
type
-
payload
extractCreateRecord
is a hook into the extract method used when a
call is made to DS.Store#createRecord
. By default this method is
alias for extractSave.
Parameters:
-
store
DS.Store -
type
subclass of DS.Model -
payload
Object
Returns:
<p><p>json The deserialized payload</p></p>
extractDeleteRecord
-
store
-
type
-
payload
extractDeleteRecord
is a hook into the extract method used when
a call is made to DS.Store#deleteRecord
. By default this method is
alias for extractSave.
Parameters:
-
store
DS.Store -
type
subclass of DS.Model -
payload
Object
Returns:
<p><p>json The deserialized payload</p></p>
extractFind
-
store
-
type
-
payload
extractFind
is a hook into the extract method used when
a call is made to DS.Store#find
. By default this method is
alias for extractSingle.
Parameters:
-
store
DS.Store -
type
subclass of DS.Model -
payload
Object
Returns:
<p><p>json The deserialized payload</p></p>
extractFindAll
-
store
-
type
-
payload
extractFindAll
is a hook into the extract method used when a
call is made to DS.Store#findAll
. By default this method is an
alias for extractArray.
Parameters:
-
store
DS.Store -
type
subclass of DS.Model -
payload
Object
Returns:
<p><p>array An array of deserialized objects</p></p>
extractFindBelongsTo
-
store
-
type
-
payload
extractFindBelongsTo
is a hook into the extract method used when
a call is made to DS.Store#findBelongsTo
. By default this method is
alias for extractSingle.
Parameters:
-
store
DS.Store -
type
subclass of DS.Model -
payload
Object
Returns:
<p><p>json The deserialized payload</p></p>
extractFindHasMany
-
store
-
type
-
payload
extractFindHasMany
is a hook into the extract method used when a
call is made to DS.Store#findHasMany
. By default this method is
alias for extractArray.
Parameters:
-
store
DS.Store -
type
subclass of DS.Model -
payload
Object
Returns:
<p><p>array An array of deserialized objects</p></p>
extractFindMany
-
store
-
type
-
payload
extractFindMany
is a hook into the extract method used when a
call is made to DS.Store#findMany
. By default this method is
alias for extractArray.
Parameters:
-
store
DS.Store -
type
subclass of DS.Model -
payload
Object
Returns:
<p><p>array An array of deserialized objects</p></p>
extractFindQuery
-
store
-
type
-
payload
extractFindQuery
is a hook into the extract method used when a
call is made to DS.Store#findQuery
. By default this method is an
alias for extractArray.
Parameters:
-
store
DS.Store -
type
subclass of DS.Model -
payload
Object
Returns:
<p><p>array An array of deserialized objects</p></p>
extractMeta
-
store
-
type
-
payload
extractMeta
is used to deserialize any meta information in the
adapter payload. By default Ember Data expects meta information to
be located on the meta
property of the payload object.
Example
App.PostSerializer = DS.JSONSerializer.extend({
extractMeta: function(store, type, payload) {
if (payload && payload._pagination) {
store.metaForType(type, payload._pagination);
delete payload._pagination;
}
}
});
Parameters:
-
store
DS.Store -
type
subclass of DS.Model -
payload
Object
extractSave
-
store
-
type
-
payload
extractSave
is a hook into the extract method used when a call
is made to DS.Model#save
. By default this method is alias
for extractSingle.
Parameters:
-
store
DS.Store -
type
subclass of DS.Model -
payload
Object
Returns:
<p><p>json The deserialized payload</p></p>
extractSingle
-
store
-
type
-
payload
extractSingle
is used to deserialize a single record returned
from the adapter.
Example
App.PostSerializer = DS.JSONSerializer.extend({
extractSingle: function(store, type, payload) {
payload.comments = payload._embedded.comment;
delete payload._embedded;
return this._super(store, type, payload);
},
});
Parameters:
-
store
DS.Store -
type
subclass of DS.Model -
payload
Object
Returns:
<p><p>json The deserialized payload</p></p>
extractUpdateRecord
-
store
-
type
-
payload
extractUpdateRecord
is a hook into the extract method used when
a call is made to DS.Store#update
. By default this method is alias
for extractSave.
Parameters:
-
store
DS.Store -
type
subclass of DS.Model -
payload
Object
Returns:
<p><p>json The deserialized payload</p></p>
keyForAttribute
-
attr
Converts attributes to underscore and uses
dynamicKeyForAttribute.
to produce a dynamic field key. For a string attribute like relatedArticles
this method would return related_articles_s
.
Parameters:
-
attr
String
Returns:
key
keyForRelationship
-
key
-
relationship
keyForRelationship
can be used to define a custom key when
serializing relationship properties. By default JSONSerializer
does not provide an implementation of this method.
Example
App.PostSerializer = DS.JSONSerializer.extend({
keyForRelationship: function(key, relationship) {
return 'rel_' + Ember.String.underscore(key);
}
});
Returns:
<p><p>normalized key</p></p>
normalize
-
type
-
hash
Normalizes a part of the JSON payload returned by the server. You should override this method, munge the hash and call super if you have generic normalization to do.
It takes the type of the record that is being normalized (as a DS.Model class), the property where the hash was originally found, and the hash to normalize.
You can use this method, for example, to normalize underscored keys to camelized or other general-purpose normalizations.
Example
App.ApplicationSerializer = DS.JSONSerializer.extend({
normalize: function(type, hash) {
var fields = Ember.get(type, 'fields');
fields.forEach(function(field) {
var payloadField = Ember.String.underscore(field);
if (field === payloadField) { return; }
hash[field] = hash[payloadField];
delete hash[payloadField];
});
return this._super.apply(this, arguments);
}
});
Parameters:
-
type
subclass of DS.Model -
hash
Object
Returns:
serialize
-
record
-
options
Called when a record is saved in order to convert the record into JSON.
By default, it creates a JSON object with a key for each attribute and belongsTo relationship.
For example, consider this model:
App.Comment = DS.Model.extend({
title: DS.attr(),
body: DS.attr(),
author: DS.belongsTo('user')
});
The default serialization would create a JSON object like:
{
"title": "Rails is unagi",
"body": "Rails? Omakase? O_O",
"author": 12
}
By default, attributes are passed through as-is, unless
you specified an attribute type (DS.attr('date')
). If
you specify a transform, the JavaScript value will be
serialized when inserted into the JSON hash.
By default, belongs-to relationships are converted into IDs when inserted into the JSON hash.
IDs
serialize
takes an options hash with a single option:
includeId
. If this option is true
, serialize
will,
by default include the ID in the JSON object it builds.
The adapter passes in includeId: true
when serializing
a record for createRecord
, but not for updateRecord
.
Customization
Your server may expect a different JSON format than the built-in serialization format.
In that case, you can implement serialize
yourself and
return a JSON hash of your choosing.
App.PostSerializer = DS.JSONSerializer.extend({
serialize: function(post, options) {
var json = {
POST_TTL: post.get('title'),
POST_BDY: post.get('body'),
POST_CMS: post.get('comments').mapProperty('id')
}
if (options.includeId) {
json.POST_ID_ = post.get('id');
}
return json;
}
});
Customizing an App-Wide Serializer
If you want to define a serializer for your entire
application, you'll probably want to use eachAttribute
and eachRelationship
on the record.
App.ApplicationSerializer = DS.JSONSerializer.extend({
serialize: function(record, options) {
var json = {};
record.eachAttribute(function(name) {
json[serverAttributeName(name)] = record.get(name);
})
record.eachRelationship(function(name, relationship) {
if (relationship.kind === 'hasMany') {
json[serverHasManyName(name)] = record.get(name).mapBy('id');
}
});
if (options.includeId) {
json.ID_ = record.get('id');
}
return json;
}
});
function serverAttributeName(attribute) {
return attribute.underscore().toUpperCase();
}
function serverHasManyName(name) {
return serverAttributeName(name.singularize()) + "_IDS";
}
This serializer will generate JSON that looks like this:
{
"TITLE": "Rails is omakase",
"BODY": "Yep. Omakase.",
"COMMENT_IDS": [ 1, 2, 3 ]
}
Tweaking the Default JSON
If you just want to do some small tweaks on the default JSON, you can call super first and make the tweaks on the returned JSON.
App.PostSerializer = DS.JSONSerializer.extend({
serialize: function(record, options) {
var json = this._super.apply(this, arguments);
json.subject = json.title;
delete json.title;
return json;
}
});
Parameters:
-
record
subclass of DS.Model -
options
Object
Returns:
<p><p>json</p></p>
serializeAttribute
-
record
-
json
-
key
-
attribute
serializeAttribute
can be used to customize how DS.attr
properties are serialized
For example if you wanted to ensure all you attributes were always
serialized as properties on an attributes
object you could
write:
App.ApplicationSerializer = DS.JSONSerializer.extend({
serializeAttribute: function(record, json, key, attributes) {
json.attributes = json.attributes || {};
this._super(record, json.attributes, key, attributes);
}
});
serializeBelongsTo
-
record
-
json
-
relationship
serializeBelongsTo
can be used to customize how DS.belongsTo
properties are serialized.
Example
App.PostSerializer = DS.JSONSerializer.extend({
serializeBelongsTo: function(record, json, relationship) {
var key = relationship.key;
var belongsTo = get(record, key);
key = this.keyForRelationship ? this.keyForRelationship(key, "belongsTo") : key;
json[key] = Ember.isNone(belongsTo) ? belongsTo : belongsTo.toJSON();
}
});
Parameters:
-
record
DS.Model -
json
Object -
relationship
Object
serializeHasMany
-
record
-
json
-
relationship
serializeHasMany
can be used to customize how DS.hasMany
properties are serialized.
Example
App.PostSerializer = DS.JSONSerializer.extend({
serializeHasMany: function(record, json, relationship) {
var key = relationship.key;
if (key === 'comments') {
return;
} else {
this._super.apply(this, arguments);
}
}
});
Parameters:
-
record
DS.Model -
json
Object -
relationship
Object
serializePolymorphicType
-
record
-
json
-
relationship
You can use this method to customize how polymorphic objects are
serialized. Objects are considered to be polymorphic if
{polymorphic: true}
is pass as the second argument to the
DS.belongsTo
function.
Example
App.CommentSerializer = DS.JSONSerializer.extend({
serializePolymorphicType: function(record, json, relationship) {
var key = relationship.key,
belongsTo = get(record, key);
key = this.keyForAttribute ? this.keyForAttribute(key) : key;
json[key + "_type"] = belongsTo.constructor.typeKey;
}
});
Parameters:
-
record
DS.Model -
json
Object -
relationship
Object
transformFor
-
attributeType
-
skipAssertion
Parameters:
-
attributeType
String -
skipAssertion
Boolean
Returns:
<p><p>transform</p></p>
Properties
dynamicFieldPrefixes
Object
Provides a mapping of types to dynamic field prefixes.
The following example would cause all attributes of type number
to be mapped by prepending int_
to the attribute name:
App.ApplicationSerializer = SolrDynamicSerializer.extend({
dynamicFieldPrefixes: {
'number': 'int_'
}
});
This property is left null to follow the conventions in the Solr Schemaless example configuration.
Default: null
dynamicFieldSuffixes
Object
Provides a mapping of types to dynamic field prefixes.
The following example would cause all attributes of type date
to be mapped by appending _date
to the attribute name:
App.ApplicationSerializer = SolrdynamicSerializer.extend({
dynamicFieldSuffixes: {
'date': '_date'
}
});
See source code for default mappings that follow conventions in the Solr Dynamic example configuration.
Default: null
primaryKey
String
The primaryKey is used when serializing and deserializing
data. Ember Data always uses the id
property to store the id of
the record. The external source may not always follow this
convention. In these cases it is useful to override the
primaryKey property to match the primaryKey of your external
store.
Example
App.ApplicationSerializer = DS.JSONSerializer.extend({
primaryKey: '_id'
});
Default: 'id'
versionFieldName
String
Field name to use for Solr Optimistic Concurrency. See Updating Parts of Documents.
Default: '_version_'