contentful-import/dist/tasks/push-to-space/creation.js

this tool allows you to import JSON dump exported by contentful-export

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

exports.createEntities = createEntities;
exports.createLocales = createLocales;
exports.createEntries = createEntries;

var _bluebird = require('bluebird');

var _bluebird2 = _interopRequireDefault(_bluebird);

var _function = require('lodash/function');

var _collection = require('lodash/collection');

var _object = require('lodash/object');

var _getEntityName = require('contentful-batch-libs/dist/get-entity-name');

var _getEntityName2 = _interopRequireDefault(_getEntityName);

var _logging = require('contentful-batch-libs/dist/logging');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Creates a list of entities
 * Applies to all entities except Entries, as the CMA API for those is slightly different
 * See handleCreationErrors for details on what errors reject the promise or not.
 */
function createEntities(context, entities, destinationEntities, concurrency = 6) {
  return createEntitiesWithConcurrency(context, entities, destinationEntities, concurrency, _bluebird2.default.map);
}

function createLocales(context, entities, destinationEntities) {
  return createEntitiesWithConcurrency(context, entities, destinationEntities, 1, _bluebird2.default.mapSeries);
}

function createEntitiesWithConcurrency(context, entities, destinationEntities, concurrency, mapper) {
  return mapper(entities, entity => {
    const destinationEntity = getDestinationEntityForSourceEntity(destinationEntities, entity.transformed);
    const operation = destinationEntity ? 'update' : 'create';
    const promise = destinationEntity ? updateDestinationWithSourceData(destinationEntity, entity.transformed) : createInDestination(context, entity.transformed);
    return promise.then((0, _function.partial)(creationSuccessNotifier, operation)).catch((0, _function.partial)(handleCreationErrors, entity));
  }, { concurrency });
}

/**
 * Creates a list of entries
 */
function createEntries(context, entries, destinationEntries) {
  return _bluebird2.default.map(entries, entry => createEntry(entry, context.target, context.skipContentModel, destinationEntries), { concurrency: 6 });
}

function createEntry(entry, target, skipContentModel, destinationEntries) {
  const contentTypeId = entry.original.sys.contentType.sys.id;
  const destinationEntry = getDestinationEntityForSourceEntity(destinationEntries, entry.transformed);
  const operation = destinationEntry ? 'update' : 'create';
  const promise = destinationEntry ? updateDestinationWithSourceData(destinationEntry, entry.transformed) : createEntryInDestination(target, contentTypeId, entry.transformed);
  return promise.then((0, _function.partial)(creationSuccessNotifier, operation)).catch((0, _function.partial)(handleEntryCreationErrors, entry, target, skipContentModel, destinationEntries));
}

function updateDestinationWithSourceData(destinationEntity, sourceEntity) {
  const plainData = getPlainData(sourceEntity);
  (0, _object.assign)(destinationEntity, plainData);
  return destinationEntity.update();
}

function createInDestination(context, sourceEntity) {
  const type = context.type,
        target = context.target;

  if (type === 'Tag') {
    // tags are created with a different signature
    return createTagInDestination(context, sourceEntity);
  }

  const id = (0, _object.get)(sourceEntity, 'sys.id');
  const plainData = getPlainData(sourceEntity);
  return id ? target[`create${type}WithId`](id, plainData) : target[`create${type}`](plainData);
}

function createEntryInDestination(space, contentTypeId, sourceEntity) {
  const id = sourceEntity.sys.id;
  const plainData = getPlainData(sourceEntity);
  return id ? space.createEntryWithId(contentTypeId, id, plainData) : space.createEntry(contentTypeId, plainData);
}

function createTagInDestination(context, sourceEntity) {
  const id = sourceEntity.sys.id;
  const name = sourceEntity.name;
  return context.target['createTag'](id, name);
}

/**
 * Handles entity creation errors.
 * If the error is a VersionMismatch the error is thrown and a message is returned
 * instructing the user on what this situation probably means.
 */
function handleCreationErrors(entity, err) {
  // Handle the case where a locale already exists and skip it
  if ((0, _object.get)(err, 'error.sys.id') === 'ValidationFailed') {
    const errors = (0, _object.get)(err, 'error.details.errors');
    if (errors && errors.length > 0 && errors[0].name === 'taken') {
      return entity;
    }
  }
  err.entity = entity.original;
  _logging.logEmitter.emit('error', err);

  // No need to pass this entity down to publishing if it wasn't created
  return null;
}

/**
 * Handles entry creation errors.
 * If a field doesn't exist, it means it has been removed from the content types
 * In that case, the field is removed from the entry, and creation is attempted again.
 */
function handleEntryCreationErrors(entry, space, skipContentModel, destinationEntries, err) {
  if (skipContentModel && err.name === 'UnknownField') {
    const errors = (0, _object.get)(JSON.parse(err.message), 'details.errors');
    entry.transformed.fields = cleanupUnknownFields(entry.transformed.fields, errors);
    return createEntry(entry, space, skipContentModel, destinationEntries);
  }
  err.entity = entry;
  _logging.logEmitter.emit('error', err);

  // No need to pass this entry down to publishing if it wasn't created
  return null;
}

function cleanupUnknownFields(fields, errors) {
  return (0, _object.omitBy)(fields, (field, fieldId) => {
    return (0, _collection.find)(errors, error => {
      var _error$path = _slicedToArray(error.path, 2);

      const errorFieldId = _error$path[1];

      return error.name === 'unknown' && errorFieldId === fieldId;
    });
  });
}

function getDestinationEntityForSourceEntity(destinationEntities, sourceEntity) {
  return (0, _collection.find)(destinationEntities, {
    sys: { id: (0, _object.get)(sourceEntity, 'sys.id', null) }
  });
}

function creationSuccessNotifier(method, createdEntity) {
  const verb = method[0].toUpperCase() + method.substr(1, method.length) + 'd';
  _logging.logEmitter.emit('info', `${verb} ${createdEntity.sys.type} ${(0, _getEntityName2.default)(createdEntity)}`);
  return createdEntity;
}

function getPlainData(entity) {
  const data = entity.toPlainObject ? entity.toPlainObject() : entity;
  return (0, _object.omit)(data, 'sys');
}