loopback-jsonapi-model-serializer/dist/serializer.js

JSONAPI Model serializer for loopback

'use strict';

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

var lib = require('./util');
var _ = require('lodash');

module.exports = function () {
  var options = arguments.length <= 0 || arguments[0] === undefined ? { baseUrl: '/' } : arguments[0];

  function serialize(data, model) {
    var serializedData = [];
    var serializedIncluded = new Map();
    if (Array.isArray(data)) {
      var _iteratorNormalCompletion = true;
      var _didIteratorError = false;
      var _iteratorError = undefined;

      try {
        for (var _iterator = data[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
          var dataPoint = _step.value;

          serializedData.push(resource(dataPoint, model));
          included(dataPoint, model).forEach(function (item) {
            serializedIncluded.set(item.type + '-' + item.id, item);
          });
        }
      } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion && _iterator.return) {
            _iterator.return();
          }
        } finally {
          if (_didIteratorError) {
            throw _iteratorError;
          }
        }
      }
    } else {
      serializedData = resource(data, model);
      serializedIncluded = included(data, model);
    }
    var serialized = { data: serializedData };
    if (serializedIncluded.size > 0) serialized.included = [].concat(_toConsumableArray(serializedIncluded.values()));

    return serialized;
  }

  function resource(data, model) {
    var resource = {
      id: id(data, model),
      type: type(data, model),
      links: links(data, model)
    };
    var attrs = attributes(data, model);
    if (!_.isEmpty(attrs)) resource['attributes'] = attrs;

    var rels = relationships(data, model);
    if (!_.isEmpty(rels)) resource['relationships'] = rels;

    return resource;
  }

  function id(data, model) {
    return data[lib().primaryKeyForModel(model)];
  }

  function type(data, model) {
    return lib().pluralForModel(model);
  }

  function attributes(data, model) {
    var opts = _.assign({ primaryKey: false, foreignKeys: false }, options);
    return lib().buildAttributes(data, model, opts);
  }

  function links(data, model) {
    return lib(options).buildResourceLinks(data, model);
  }

  function relationships(data, model) {
    return lib(options).buildRelationships(data, model);
  }

  function included(data, model) {
    var incl = new Map();
    var relations = model.relations;
    var _iteratorNormalCompletion2 = true;
    var _didIteratorError2 = false;
    var _iteratorError2 = undefined;

    try {
      for (var _iterator2 = Object.keys(relations)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
        var name = _step2.value;

        var relation = relations[name];
        if (relation.polymorphic) continue;
        var _model = lib().relatedModelFromRelation(relation);
        var relatedData = data[name] || [];
        if (!_model) return incl;
        if (!Array.isArray(relatedData)) relatedData = [relatedData];
        var _iteratorNormalCompletion3 = true;
        var _didIteratorError3 = false;
        var _iteratorError3 = undefined;

        try {
          for (var _iterator3 = relatedData[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
            var relatedDataPoint = _step3.value;

            var item = resource(relatedDataPoint, _model);
            incl.set(item.type + '-' + item.id, item);
            included(relatedDataPoint, _model).forEach(function (item) {
              incl.set(item.type + '-' + item.id, item);
            });
          }
        } catch (err) {
          _didIteratorError3 = true;
          _iteratorError3 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion3 && _iterator3.return) {
              _iterator3.return();
            }
          } finally {
            if (_didIteratorError3) {
              throw _iteratorError3;
            }
          }
        }
      }
    } catch (err) {
      _didIteratorError2 = true;
      _iteratorError2 = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion2 && _iterator2.return) {
          _iterator2.return();
        }
      } finally {
        if (_didIteratorError2) {
          throw _iteratorError2;
        }
      }
    }

    return incl;
  }

  return {
    serialize: serialize,
    resource: resource,
    id: id,
    type: type,
    attributes: attributes,
    links: links,
    relationships: relationships,
    included: included
  };
};