JSONAPI 序列化嵌套的 hasMany 关系

Question

我们正在为这个项目使用JSONAPI，但是由于[原因]我们无法在API中处理它推荐的关系结构，所以我们正在服务并期望它们是嵌套对象，格式如下：

{
  "data":{
    "type":"video",
    "id":"55532284a1f9f909b0d11d73",

    "attributes":{
      "title":"Test",

      "transcriptions":{
        "type": "embedded",

        "data":[
          {
            "type":"transcription",
            "id":"203dee25-4431-42d1-a0ba-b26ea6938e75",

            "attributes":{
              "transcriptText":"Some transcription text here. And another sentence after it.",

              "cuepoints":{
                "type":"embedded",

                "data":[
                  {
                    "type":"cuepoint",
                    "id":"bb6b0434-bdc4-43e4-8010-66bdef5c432a",

                    "attributes":{
                      "text":"Some transcription text here."
                    }
                  },
                  {
                    "type":"cuepoint",
                    "id":"b663ee00-0ebc-4cf4-96fc-04d904bc1baf",

                    "attributes":{
                      "text":"And another sentence after it."
                    }
                  }
                ]
              }
            }
          }
        ]
      }
    }
  }
}

我有以下模型结构：

// models/video
export default DS.Model.extend({
  transcriptions: DS.hasMany('transcription')
)};

// models/transcription
export default DS.Model.extend({
  video: DS.belongsTo('video'),
  cuepoints: DS.hasMany('cuepoint')
});

// models/cuepoint
export default DS.Model.extend({
  transcription: DS.belongsTo('transcription')
);

现在，我们要做的是保存一个 video 记录，并让它序列化它包含的 transcriptions 和 cuepoints。我有以下序列化器，它非常适合将 transcription 嵌入到 video 即。一个级别，但我需要它然后将 cuepoints 也嵌入其中。

export default DS.JSONAPISerializer.extend({
    serializeHasMany: function(record, json, relationship) {
      var hasManyRecords, key;
          key = relationship.key;
          hasManyRecords = Ember.get(record, key);

      if (hasManyRecords) {
        json.attributes[key] = {};

        hasManyRecords.forEach(function(item) {
          json.attributes[key].data = json.attributes[key].data || [];

          json.attributes[key].data.push({
            attributes: item._attributes,
            id: item.get('id'),
            type: item.get('type')
          });
        });
      } else {
        this._super(record, json, relationship);
      }
    }
  });

检查 serializeHasMany 方法中的 record、json 和 relationship 属性，我看不到任何有关嵌套关系的信息，所以我什至不确定我用对了方法。

有什么我在这方面出错的想法吗？

Answer 1

您必须为每个模型添加序列化器，并根据需要在正确的序列化器中调整有效负载。上面的序列化程序生成您在描述中提供的确切有效负载。

app/serializers/cuepoint.js

import DS from 'ember-data';

export default DS.JSONAPISerializer.extend({

    payloadKeyFromModelName (modelName) {
        return modelName;
    },

    serialize (record, options) {
        return this._super(record, options).data;
    },

    serializeBelongsTo () {}

});

app/serializers/transcription.js

import DS from 'ember-data';

export default DS.JSONAPISerializer.extend(DS.EmbeddedRecordsMixin, {

    attrs: {
        cuepoints: {
            serialize: 'records',
            deserialize: 'records'
        }
    },

    keyForAttribute (key, method) {
        return key;
    },

    payloadKeyFromModelName (modelName) {
        return modelName;
    },

    serialize (record, options) {
        let json = this._super(record, options);
        json.data.attributes.cuepoints = {
            type: 'embedded',
            data: json.data.cuepoints
        }
        delete json.data.cuepoints;
        return json.data;
    },

    serializeBelongsTo () {}

});

app/serializers/video.js

import DS from 'ember-data';

export default DS.JSONAPISerializer.extend(DS.EmbeddedRecordsMixin, {

    attrs: {
        transcriptions: {
            serialize: 'records',
            deserialize: 'records'
        }
    },

    payloadKeyFromModelName (modelName) {
        return modelName;
    },

    serialize (record, options) {
        let json = this._super(record, options);
        json.data.attributes.transcriptions = {
            type: 'embedded',
            data: json.data.transcriptions
        }
        delete json.data.transcriptions;
        return json;
    },

    serializeBelongsTo () {}

});

Answer 2

我想我已经明白了。有一些我不知道的用于遍历关系的方法，我需要编写一个自定义 serialize 方法，而不是仅仅覆盖默认的 serializeHasMany 方法。

serialize(record) {
  // Set up the main data structure for the record to be serialized
  var JSON = {
    data: {
      id: record.id,
      type: record.modelName,
      attributes: {}
    }
  };

  // Find relationships in the record and serialize them into the JSON.data.attributes object
  JSON.data.attributes = this.serializeRelationships(JSON.data.attributes, record);

  // Loop through the record's attributes and insert them into the JSON.data.attributes object
  record.eachAttribute((attr) => {
    JSON.data.attributes[attr] = record.attr(attr);
  });

  // Return the fully serialized JSON data
  return JSON;
},

// Take a parent JSON object and an individual record, loops through any relationships in the record, and creates a JSONAPI resource object
serializeRelationships(JSON, record) {
  record.eachRelationship((key, relationship) => {
    if (relationship.kind === 'hasMany') {

      // Set up the relationship data structure
      JSON[relationship.key] = {
        data: []
      };

      // Gran any relationships in the record
      var embeddedRecords = record.hasMany(relationship.key);

      // Loop through the relationship's records and build a resource object
      if (embeddedRecords) {
        embeddedRecords.forEach((embeddedRecord) => {
          var obj = {
            id: embeddedRecord.id,
            type: embeddedRecord.modelName,
            attributes: {}
          }

          // Recursively check for relationships in the record
          obj.attributes = this.serializeRelationships(obj.attributes, embeddedRecord);

          // Loop through the standard attributes and populate the record.data.attributes object
          embeddedRecord.eachAttribute((attr) => {
            obj.attributes[attr] = embeddedRecord.attr(attr);
          });

          JSON[relationship.key].data.push(obj);
        });
      }
    }
  });

  return JSON;
}

JSONAPI 序列化嵌套的 hasMany 关系

JSONAPI serialize nested hasMany relationships

ember.js

ember-data

json-api