contentful-import 9.0.21 → 9.2.0

package/dist/tasks/push-to-space/creation.js

@@ -1,227 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createEntities = createEntities;
-exports.createEntries = createEntries;
-exports.createLocales = createLocales;
-var _collection = require("lodash/collection");
-var _object = require("lodash/object");
-var _getEntityName = _interopRequireDefault(require("contentful-batch-libs/dist/get-entity-name"));
-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,
-  destinationEntitiesById,
-  requestQueue
-}) {
-  return createEntitiesWithConcurrency({
-    context,
-    entities,
-    destinationEntitiesById,
-    requestQueue
-  });
-}
-
-// TODO
-// Locales need to be created in series
-function createLocales({
-  context,
-  entities,
-  destinationEntitiesById,
-  requestQueue
-}) {
-  return createEntitiesInSequence({
-    context,
-    entities,
-    destinationEntitiesById,
-    requestQueue
-  });
-}
-async function createEntitiesWithConcurrency({
-  context,
-  entities,
-  destinationEntitiesById,
-  requestQueue
-}) {
-  const pendingCreatedEntities = entities.map(entity => {
-    const destinationEntity = getDestinationEntityForSourceEntity(destinationEntitiesById, entity.transformed);
-    const operation = destinationEntity ? 'update' : 'create';
-    return requestQueue.add(async () => {
-      try {
-        const createdEntity = await (destinationEntity ? updateDestinationWithSourceData(destinationEntity, entity.transformed) : createInDestination(context, entity.transformed));
-        creationSuccessNotifier(operation, createdEntity);
-        return createdEntity;
-      } catch (err) {
-        return handleCreationErrors(entity, err);
-      }
-    });
-  });
-  const createdEntities = await Promise.all(pendingCreatedEntities);
-
-  // Filter null values in case of errors
-  return createdEntities.filter(entity => entity);
-}
-async function createEntitiesInSequence({
-  context,
-  entities,
-  destinationEntitiesById,
-  requestQueue
-}) {
-  const createdEntities = [];
-  for (const entity of entities) {
-    const destinationEntity = getDestinationEntityForSourceEntity(destinationEntitiesById, entity.transformed);
-    const operation = destinationEntity ? 'update' : 'create';
-    try {
-      // Even though we run things in sequence here,
-      // we still want to go through the normal rate limiting queue
-      const createdEntity = await requestQueue.add(async () => {
-        const createdOrUpdatedEntity = await (destinationEntity ? updateDestinationWithSourceData(destinationEntity, entity.transformed) : createInDestination(context, entity.transformed));
-        return createdOrUpdatedEntity;
-      });
-      creationSuccessNotifier(operation, createdEntity);
-      createdEntities.push(createdEntity);
-    } catch (err) {
-      const maybeSubstituteEntity = handleCreationErrors(entity, err);
-      if (maybeSubstituteEntity) {
-        createdEntities.push(maybeSubstituteEntity);
-      }
-    }
-  }
-  return createdEntities;
-}
-
-/**
- * Creates a list of entries
- */
-async function createEntries({
-  context,
-  entities,
-  destinationEntitiesById,
-  requestQueue
-}) {
-  const createdEntries = await Promise.all(entities.map(entry => {
-    return createEntry({
-      entry,
-      target: context.target,
-      skipContentModel: context.skipContentModel,
-      destinationEntitiesById,
-      requestQueue
-    });
-  }));
-  return createdEntries.filter(entry => entry);
-}
-async function createEntry({
-  entry,
-  target,
-  skipContentModel,
-  destinationEntitiesById,
-  requestQueue
-}) {
-  const contentTypeId = entry.original.sys.contentType.sys.id;
-  const destinationEntry = getDestinationEntityForSourceEntity(destinationEntitiesById, entry.transformed);
-  const operation = destinationEntry ? 'update' : 'create';
-  try {
-    const createdOrUpdatedEntry = await requestQueue.add(() => {
-      return destinationEntry ? updateDestinationWithSourceData(destinationEntry, entry.transformed) : createEntryInDestination(target, contentTypeId, entry.transformed);
-    });
-    creationSuccessNotifier(operation, createdOrUpdatedEntry);
-    return createdOrUpdatedEntry;
-  } catch (err) {
-    /* 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.
-    */
-    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,
-        target,
-        skipContentModel,
-        destinationEntitiesById,
-        requestQueue
-      });
-    }
-    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 updateDestinationWithSourceData(destinationEntity, sourceEntity) {
-  const plainData = getPlainData(sourceEntity);
-  (0, _object.assign)(destinationEntity, plainData);
-  return destinationEntity.update();
-}
-function createInDestination(context, sourceEntity) {
-  const {
-    type,
-    target
-  } = context;
-  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 visibility = sourceEntity.sys.visibility || 'private';
-  const name = sourceEntity.name;
-  return context.target.createTag(id, name, visibility);
-}
-
-/**
- * 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;
-}
-function cleanupUnknownFields(fields, errors) {
-  return (0, _object.omitBy)(fields, (field, fieldId) => {
-    return (0, _collection.find)(errors, error => {
-      const [, errorFieldId] = error.path;
-      return error.name === 'unknown' && errorFieldId === fieldId;
-    });
-  });
-}
-function getDestinationEntityForSourceEntity(destinationEntitiesById, sourceEntity) {
-  return destinationEntitiesById.get((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, _getEntityName.default)(createdEntity)}`);
-  return createdEntity;
-}
-function getPlainData(entity) {
-  const data = entity.toPlainObject ? entity.toPlainObject() : entity;
-  return (0, _object.omit)(data, 'sys');
-}

package/dist/tasks/push-to-space/publishing.js

@@ -1,100 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.archiveEntities = archiveEntities;
-exports.publishEntities = publishEntities;
-var _getEntityName = _interopRequireDefault(require("contentful-batch-libs/dist/get-entity-name"));
-var _logging = require("contentful-batch-libs/dist/logging");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-/**
- * Publish a list of entities.
- * Does not return a rejected promise in the case of an error, pushing it
- * to an error buffer instead.
- */
-async function publishEntities({
-  entities,
-  requestQueue
-}) {
-  const entitiesToPublish = entities.filter(entity => {
-    if (!entity || !entity.publish) {
-      _logging.logEmitter.emit('warning', `Unable to publish ${(0, _getEntityName.default)(entity)}`);
-      return false;
-    }
-    return true;
-  });
-  if (entitiesToPublish.length === 0) {
-    _logging.logEmitter.emit('info', 'Skipping publishing since zero valid entities passed');
-    return [];
-  }
-  const entity = entities[0].original || entities[0];
-  const type = entity.sys.type || 'unknown type';
-  _logging.logEmitter.emit('info', `Publishing ${entities.length} ${type}s`);
-  const result = await runQueue(entitiesToPublish, [], requestQueue);
-  _logging.logEmitter.emit('info', `Successfully published ${result.length} ${type}s`);
-  return result;
-}
-async function archiveEntities({
-  entities,
-  requestQueue
-}) {
-  const entitiesToArchive = entities.filter(entity => {
-    if (!entity || !entity.archive) {
-      _logging.logEmitter.emit('warning', `Unable to archive ${(0, _getEntityName.default)(entity)}`);
-      return false;
-    }
-    return true;
-  });
-  if (entitiesToArchive.length === 0) {
-    _logging.logEmitter.emit('info', 'Skipping archiving since zero valid entities passed');
-    return [];
-  }
-  const entity = entities[0].original || entities[0];
-  const type = entity.sys.type || 'unknown type';
-  _logging.logEmitter.emit('info', `Archiving ${entities.length} ${type}s`);
-  const pendingArchivedEntities = entitiesToArchive.map(entity => {
-    return requestQueue.add(async () => {
-      try {
-        const archivedEntity = await entity.archive();
-        return archivedEntity;
-      } catch (err) {
-        err.entity = entity;
-        _logging.logEmitter.emit('error', err);
-        return null;
-      }
-    });
-  });
-  const allPossiblyArchivedEntities = await Promise.all(pendingArchivedEntities);
-  const allArchivedEntities = allPossiblyArchivedEntities.filter(entity => entity);
-  _logging.logEmitter.emit('info', `Successfully archived ${allArchivedEntities.length} ${type}s`);
-  return allArchivedEntities;
-}
-async function runQueue(queue, result = [], requestQueue) {
-  const publishedEntities = [];
-  for (const entity of queue) {
-    _logging.logEmitter.emit('info', `Publishing ${entity.sys.type} ${(0, _getEntityName.default)(entity)}`);
-    try {
-      const publishedEntity = await requestQueue.add(() => entity.publish());
-      publishedEntities.push(publishedEntity);
-    } catch (err) {
-      err.entity = entity;
-      _logging.logEmitter.emit('error', err);
-    }
-  }
-  result = [...result, ...publishedEntities];
-  const publishedEntityIds = new Set(publishedEntities.map(entity => entity.sys.id));
-  const unpublishedEntities = queue.filter(entity => !publishedEntityIds.has(entity.sys.id));
-  if (unpublishedEntities.length > 0) {
-    if (queue.length === unpublishedEntities.length) {
-      // Fail when queue could not publish at least one item
-      const unpublishedEntityNames = unpublishedEntities.map(_getEntityName.default).join(', ');
-      _logging.logEmitter.emit('error', `Could not publish the following entities: ${unpublishedEntityNames}`);
-    } else {
-      // Rerun queue with unpublished entities
-      return runQueue(unpublishedEntities, result, requestQueue);
-    }
-  }
-  // Return only published entities + last result
-  return result;
-}

package/dist/tasks/push-to-space/push-to-space.js

@@ -1,346 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = pushToSpace;
-var _listr = _interopRequireDefault(require("listr"));
-var _listrVerboseRenderer = _interopRequireDefault(require("listr-verbose-renderer"));
-var _logging = require("contentful-batch-libs/dist/logging");
-var _listr2 = require("contentful-batch-libs/dist/listr");
-var assets = _interopRequireWildcard(require("./assets"));
-var creation = _interopRequireWildcard(require("./creation"));
-var publishing = _interopRequireWildcard(require("./publishing"));
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-const DEFAULT_CONTENT_STRUCTURE = {
-  entries: [],
-  assets: [],
-  contentTypes: [],
-  tags: [],
-  locales: [],
-  webhooks: [],
-  editorInterfaces: []
-};
-
-/**
- * Pushes all changes to a given space. Handles (un)publishing
- * as well as delays after creation and before publishing.
- *
- * Creates everything in the right order so that a content type for a given entry
- * is there when entry creation for that content type is attempted.
- *
- * Allows only content model or only content pushing.
- *
- * Options:
- * - sourceData: see DEFAULT_CONTENT_STRUCTURE
- * - destinationData: see DEFAULT_CONTENT_STRUCTURE
- * - client: preconfigured management API client
- * - spaceId: ID of space content is being copied to
- * - contentModelOnly: synchronizes only content types and locales
- * - skipLocales: skips locales when synchronizing the content model
- * - skipContentModel: synchronizes only entries and assets
- * - skipContentPublishing: create content but don't publish it
- * - uploadAssets: upload exported files instead of pointing to an existing URL
- * - assetsDirectory: path to exported asset files to be uploaded instead of pointing to an existing URL
- */
-
-function pushToSpace({
-  sourceData,
-  destinationData = {},
-  client,
-  spaceId,
-  environmentId,
-  contentModelOnly,
-  skipContentModel,
-  skipLocales,
-  skipContentPublishing,
-  timeout,
-  retryLimit,
-  listrOptions,
-  uploadAssets,
-  assetsDirectory,
-  requestQueue
-}) {
-  sourceData = _objectSpread(_objectSpread({}, DEFAULT_CONTENT_STRUCTURE), sourceData);
-  destinationData = _objectSpread(_objectSpread({}, DEFAULT_CONTENT_STRUCTURE), destinationData);
-  listrOptions = listrOptions || {
-    renderer: _listrVerboseRenderer.default
-  };
-  const destinationDataById = {};
-  for (const [entityType, entities] of Object.entries(destinationData)) {
-    const entitiesById = new Map();
-    for (const entity of entities) {
-      entitiesById.set(entity.sys.id, entity);
-    }
-    destinationDataById[entityType] = entitiesById;
-  }
-  return new _listr.default([{
-    title: 'Connecting to space',
-    task: (0, _listr2.wrapTask)(async (ctx, task) => {
-      const space = await client.getSpace(spaceId);
-      const environment = await space.getEnvironment(environmentId);
-      ctx.space = space;
-      ctx.environment = environment;
-    })
-  }, {
-    title: 'Importing Locales',
-    task: (0, _listr2.wrapTask)(async (ctx, task) => {
-      const locales = await creation.createLocales({
-        context: {
-          target: ctx.environment,
-          type: 'Locale'
-        },
-        entities: sourceData.locales,
-        destinationEntitiesById: destinationDataById.locales,
-        requestQueue
-      });
-      ctx.data.locales = locales;
-    }),
-    skip: () => skipContentModel || skipLocales
-  }, {
-    title: 'Importing Content Types',
-    task: (0, _listr2.wrapTask)(async (ctx, task) => {
-      const contentTypes = await creation.createEntities({
-        context: {
-          target: ctx.environment,
-          type: 'ContentType'
-        },
-        entities: sourceData.contentTypes,
-        destinationEntitiesById: destinationDataById.contentTypes,
-        requestQueue
-      });
-      ctx.data.contentTypes = contentTypes;
-    }),
-    skip: () => skipContentModel
-  }, {
-    title: 'Publishing Content Types',
-    task: (0, _listr2.wrapTask)(async (ctx, task) => {
-      const publishedContentTypes = await publishEntities({
-        entities: ctx.data.contentTypes,
-        sourceEntities: sourceData.contentTypes,
-        requestQueue
-      });
-      ctx.data.contentTypes = publishedContentTypes;
-    }),
-    skip: ctx => skipContentModel
-  }, {
-    title: 'Importing Tags',
-    task: (0, _listr2.wrapTask)(async (ctx, task) => {
-      const tags = await creation.createEntities({
-        context: {
-          target: ctx.environment,
-          type: 'Tag'
-        },
-        entities: sourceData.tags,
-        destinationEntitiesById: destinationDataById.tags,
-        requestQueue
-      });
-      ctx.data.tags = tags;
-    }),
-    // we remove `tags` from destination data if an error was thrown trying to access them
-    // this means the user doesn't have access to this feature, skip importing tags
-    skip: () => !destinationDataById.tags
-  }, {
-    title: 'Importing Editor Interfaces',
-    task: (0, _listr2.wrapTask)(async (ctx, task) => {
-      const allEditorInterfacesBeingFetched = ctx.data.contentTypes.map(async contentType => {
-        const editorInterface = sourceData.editorInterfaces.find(editorInterface => {
-          return editorInterface.sys.contentType.sys.id === contentType.sys.id;
-        });
-        if (!editorInterface) {
-          return;
-        }
-        try {
-          const ctEditorInterface = await requestQueue.add(() => ctx.environment.getEditorInterfaceForContentType(contentType.sys.id));
-          _logging.logEmitter.emit('info', `Fetched editor interface for ${contentType.name}`);
-          ctEditorInterface.controls = editorInterface.controls;
-          ctEditorInterface.groupControls = editorInterface.groupControls;
-          ctEditorInterface.editorLayout = editorInterface.editorLayout;
-          const updatedEditorInterface = await requestQueue.add(() => ctEditorInterface.update());
-          return updatedEditorInterface;
-        } catch (err) {
-          err.entity = editorInterface;
-          throw err;
-        }
-      });
-      const allEditorInterfaces = await Promise.all(allEditorInterfacesBeingFetched);
-      const editorInterfaces = allEditorInterfaces.filter(editorInterface => editorInterface);
-      ctx.data.editorInterfaces = editorInterfaces;
-    }),
-    skip: ctx => skipContentModel || ctx.data.contentTypes.length === 0
-  }, {
-    title: 'Uploading Assets',
-    task: (0, _listr2.wrapTask)(async (ctx, task) => {
-      const allPendingUploads = [];
-      for (const asset of sourceData.assets) {
-        for (const file of Object.values(asset.transformed.fields.file)) {
-          allPendingUploads.push(requestQueue.add(async () => {
-            try {
-              _logging.logEmitter.emit('info', `Uploading Asset file ${file.upload}`);
-              const assetStream = await assets.getAssetStreamForURL(file.upload, assetsDirectory);
-              const upload = await ctx.environment.createUpload({
-                fileName: asset.transformed.sys.id,
-                file: assetStream
-              });
-              delete file.upload;
-              file.uploadFrom = {
-                sys: {
-                  type: 'Link',
-                  linkType: 'Upload',
-                  id: upload.sys.id
-                }
-              };
-              return upload;
-            } catch (err) {
-              _logging.logEmitter.emit('error', err);
-            }
-          }));
-        }
-      }
-
-      // We call the pending uploads for the side effects
-      // so we can just await all pending ones that are queued
-      const uploads = await Promise.all(allPendingUploads);
-      ctx.data.uploadedAssetFiles = uploads;
-    }),
-    skip: ctx => !uploadAssets || !sourceData.assets.length
-  }, {
-    title: 'Importing Assets',
-    task: (0, _listr2.wrapTask)(async (ctx, task) => {
-      const assetsToProcess = await creation.createEntities({
-        context: {
-          target: ctx.environment,
-          type: 'Asset'
-        },
-        entities: sourceData.assets,
-        destinationEntitiesById: destinationDataById.assets,
-        requestQueue
-      });
-      const processedAssets = await assets.processAssets({
-        assets: assetsToProcess,
-        timeout,
-        retryLimit,
-        requestQueue
-      });
-      ctx.data.assets = processedAssets;
-    }),
-    skip: ctx => contentModelOnly
-  }, {
-    title: 'Publishing Assets',
-    task: (0, _listr2.wrapTask)(async (ctx, task) => {
-      const publishedAssets = await publishEntities({
-        entities: ctx.data.assets,
-        sourceEntities: sourceData.assets,
-        requestQueue
-      });
-      ctx.data.publishedAssets = publishedAssets;
-    }),
-    skip: ctx => contentModelOnly || skipContentPublishing
-  }, {
-    title: 'Archiving Assets',
-    task: (0, _listr2.wrapTask)(async (ctx, task) => {
-      const archivedAssets = await archiveEntities({
-        entities: ctx.data.assets,
-        sourceEntities: sourceData.assets,
-        requestQueue
-      });
-      ctx.data.archivedAssets = archivedAssets;
-    }),
-    skip: ctx => contentModelOnly || skipContentPublishing
-  }, {
-    title: 'Importing Content Entries',
-    task: (0, _listr2.wrapTask)(async (ctx, task) => {
-      const entries = await creation.createEntries({
-        context: {
-          target: ctx.environment,
-          skipContentModel
-        },
-        entities: sourceData.entries,
-        destinationEntitiesById: destinationDataById.entries,
-        requestQueue
-      });
-      ctx.data.entries = entries;
-    }),
-    skip: ctx => contentModelOnly
-  }, {
-    title: 'Publishing Content Entries',
-    task: (0, _listr2.wrapTask)(async (ctx, task) => {
-      const publishedEntries = await publishEntities({
-        entities: ctx.data.entries,
-        sourceEntities: sourceData.entries,
-        requestQueue
-      });
-      ctx.data.publishedEntries = publishedEntries;
-    }),
-    skip: ctx => contentModelOnly || skipContentPublishing
-  }, {
-    title: 'Archiving Entries',
-    task: (0, _listr2.wrapTask)(async (ctx, task) => {
-      const archivedEntries = await archiveEntities({
-        entities: ctx.data.entries,
-        sourceEntities: sourceData.entries,
-        requestQueue
-      });
-      ctx.data.archivedEntries = archivedEntries;
-    }),
-    skip: ctx => contentModelOnly || skipContentPublishing
-  }, {
-    title: 'Creating Web Hooks',
-    task: (0, _listr2.wrapTask)(async (ctx, task) => {
-      const webhooks = await creation.createEntities({
-        context: {
-          target: ctx.space,
-          type: 'Webhook'
-        },
-        entities: sourceData.webhooks,
-        destinationEntitiesById: destinationDataById.webhooks,
-        requestQueue
-      });
-      ctx.data.webhooks = webhooks;
-    }),
-    skip: ctx => contentModelOnly || environmentId !== 'master' && 'Webhooks can only be imported in master environment'
-  }], listrOptions);
-}
-function archiveEntities({
-  entities,
-  sourceEntities,
-  requestQueue
-}) {
-  const entityIdsToArchive = sourceEntities.filter(({
-    original
-  }) => original.sys.archivedVersion).map(({
-    original
-  }) => original.sys.id);
-  const entitiesToArchive = entities.filter(entity => entityIdsToArchive.indexOf(entity.sys.id) !== -1);
-  return publishing.archiveEntities({
-    entities: entitiesToArchive,
-    requestQueue
-  });
-}
-function publishEntities({
-  entities,
-  sourceEntities,
-  requestQueue
-}) {
-  // Find all entities in source content which are published
-  const entityIdsToPublish = sourceEntities.filter(({
-    original
-  }) => original.sys.publishedVersion).map(({
-    original
-  }) => original.sys.id);
-
-  // Filter imported entities and publish only these who got published in the source
-  const entitiesToPublish = entities.filter(entity => entityIdsToPublish.indexOf(entity.sys.id) !== -1);
-  return publishing.publishEntities({
-    entities: entitiesToPublish,
-    requestQueue
-  });
-}
-module.exports = exports.default;