contentful-import/dist/index.js

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

'use strict';

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

var _cliTable = require('cli-table3');

var _cliTable2 = _interopRequireDefault(_cliTable);

var _listr = require('listr');

var _listr2 = _interopRequireDefault(_listr);

var _listrUpdateRenderer = require('listr-update-renderer');

var _listrUpdateRenderer2 = _interopRequireDefault(_listrUpdateRenderer);

var _listrVerboseRenderer = require('listr-verbose-renderer');

var _listrVerboseRenderer2 = _interopRequireDefault(_listrVerboseRenderer);

var _lodash = require('lodash');

var _moment = require('moment');

var _moment2 = _interopRequireDefault(_moment);

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

var _listr3 = require('contentful-batch-libs/dist/listr');

var _initClient = require('./tasks/init-client');

var _initClient2 = _interopRequireDefault(_initClient);

var _getDestinationData = require('./tasks/get-destination-data');

var _getDestinationData2 = _interopRequireDefault(_getDestinationData);

var _pushToSpace = require('./tasks/push-to-space/push-to-space');

var _pushToSpace2 = _interopRequireDefault(_pushToSpace);

var _transformSpace = require('./transform/transform-space');

var _transformSpace2 = _interopRequireDefault(_transformSpace);

var _validations = require('./utils/validations');

var _parseOptions = require('./parseOptions');

var _parseOptions2 = _interopRequireDefault(_parseOptions);

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

function createListrOptions(options) {
  if (options.useVerboseRenderer) {
    return {
      renderer: _listrVerboseRenderer2.default
    };
  }
  return {
    renderer: _listrUpdateRenderer2.default,
    collapse: false
  };
}

function runContentfulImport(params) {
  const log = [];
  const options = (0, _parseOptions2.default)(params);
  const listrOptions = createListrOptions(options);

  // Setup custom log listener to store log messages for later
  (0, _logging.setupLogging)(log);

  const infoTable = new _cliTable2.default();

  infoTable.push([{ colSpan: 2, content: 'The following entities are going to be imported:' }]);

  Object.keys(options.content).forEach(type => {
    if (options.skipLocales && type === 'locales') {
      return;
    }

    if (options.skipContentModel && ['contentTypes', 'editorInterfaces'].indexOf(type) >= 0) {
      return;
    }

    if (options.contentModelOnly && !(['contentTypes', 'editorInterfaces', 'locales'].indexOf(type) >= 0)) {
      return;
    }

    infoTable.push([(0, _lodash.startCase)(type), options.content[type].length]);
  });

  console.log(infoTable.toString());

  const tasks = new _listr2.default([{
    title: 'Validating content-file',
    task: ctx => {
      (0, _validations.assertPayload)(options.content);
    }
  }, {
    title: 'Initialize client',
    task: (0, _listr3.wrapTask)(ctx => {
      try {
        ctx.client = (0, _initClient2.default)(options);
        return Promise.resolve();
      } catch (err) {
        return Promise.reject(err);
      }
    })
  }, {
    title: 'Checking if destination space already has any content and retrieving it',
    task: (0, _listr3.wrapTask)((ctx, task) => {
      return (0, _getDestinationData2.default)({
        client: ctx.client,
        spaceId: options.spaceId,
        environmentId: options.environmentId,
        sourceData: options.content,
        skipLocales: options.skipLocales,
        skipContentModel: options.skipContentModel
      }).then(destinationData => {
        ctx.sourceDataUntransformed = options.content;
        ctx.destinationData = destinationData;
        (0, _validations.assertDefaultLocale)(ctx.sourceDataUntransformed, ctx.destinationData);
      });
    })
  }, {
    title: 'Apply transformations to source data',
    task: (0, _listr3.wrapTask)(ctx => {
      try {
        const transformedSourceData = (0, _transformSpace2.default)(ctx.sourceDataUntransformed, ctx.destinationData);
        ctx.sourceData = transformedSourceData;
        return Promise.resolve();
      } catch (err) {
        return Promise.reject(err);
      }
    })
  }, {
    title: 'Push content to destination space',
    task: (ctx, _task) => {
      return (0, _pushToSpace2.default)({
        sourceData: ctx.sourceData,
        destinationData: ctx.destinationData,
        client: ctx.client,
        spaceId: options.spaceId,
        environmentId: options.environmentId,
        contentModelOnly: options.contentModelOnly,
        skipLocales: options.skipLocales,
        skipContentModel: options.skipContentModel,
        skipContentPublishing: options.skipContentPublishing,
        prePublishDelay: options.prePublishDelay,
        timeout: options.timeout,
        retryLimit: options.retryLimit,
        listrOptions
      });
    }
  }], listrOptions);

  return tasks.run({
    data: {}
  }).then(ctx => {
    console.log('Finished importing all data');

    const resultTypes = Object.keys(ctx.data);
    if (resultTypes.length) {
      const resultTable = new _cliTable2.default();

      resultTable.push([{ colSpan: 2, content: 'Imported entities' }]);

      resultTypes.forEach(type => {
        resultTable.push([(0, _lodash.startCase)(type), ctx.data[type].length]);
      });

      console.log(resultTable.toString());
    } else {
      console.log('No data was imported');
    }

    const durationHuman = options.startTime.fromNow(true);
    const durationSeconds = (0, _moment2.default)().diff(options.startTime, 'seconds');

    console.log(`The import took ${durationHuman} (${durationSeconds}s)`);

    return ctx.data;
  }).catch(err => {
    log.push({
      ts: new Date().toJSON(),
      level: 'error',
      error: err
    });
  }).then(data => {
    const errorLog = log.filter(logMessage => logMessage.level !== 'info' && logMessage.level !== 'warning');
    const displayLog = log.filter(logMessage => logMessage.level !== 'info');
    (0, _logging.displayErrorLog)(displayLog);

    if (errorLog.length) {
      return (0, _logging.writeErrorLogFile)(options.errorLogFile, errorLog).then(() => {
        const multiError = new Error('Errors occurred');
        multiError.name = 'ContentfulMultiError';
        multiError.errors = errorLog;
        throw multiError;
      });
    }

    console.log('The import was successful.');

    return data;
  });
}
module.exports = exports.default;