contentful-import 9.0.21 → 9.1.0

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

@@ -1,227 +1,178 @@
 "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 }; }
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEntries = exports.createLocales = exports.createEntities = void 0;
+const collection_1 = require("lodash/collection");
+const object_1 = require("lodash/object");
+const get_entity_name_1 = __importDefault(require("contentful-batch-libs/dist/get-entity-name"));
+const logging_1 = require("contentful-batch-libs/dist/logging");
 /**
  * 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
-  });
+function createEntities({ context, entities, destinationEntitiesById, requestQueue }) {
+    return createEntitiesWithConcurrency({ context, entities, destinationEntitiesById, requestQueue });
 }
-
+exports.createEntities = createEntities;
 // TODO
 // Locales need to be created in series
-function createLocales({
-  context,
-  entities,
-  destinationEntitiesById,
-  requestQueue
-}) {
-  return createEntitiesInSequence({
-    context,
-    entities,
-    destinationEntitiesById,
-    requestQueue
-  });
+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);
-      }
+exports.createLocales = createLocales;
+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);
+    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);
-      }
+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;
+    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 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
-      });
+exports.createEntries = createEntries;
+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_1.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_1.logEmitter.emit('error', err);
+        // No need to pass this entry down to publishing if it wasn't created
+        return null;
     }
-    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();
+    const plainData = getPlainData(sourceEntity);
+    (0, object_1.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);
+    const { type, target } = context;
+    if (type === 'Tag') {
+        // tags are created with a different signature
+        return createTagInDestination(context, sourceEntity);
+    }
+    const id = (0, object_1.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);
+    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);
+    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;
+    // Handle the case where a locale already exists and skip it
+    if ((0, object_1.get)(err, 'error.sys.id') === 'ValidationFailed') {
+        const errors = (0, object_1.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;
+    err.entity = entity.original;
+    logging_1.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;
+    return (0, object_1.omitBy)(fields, (field, fieldId) => {
+        return (0, collection_1.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;
+    return destinationEntitiesById.get((0, object_1.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;
+    const verb = method[0].toUpperCase() + method.substr(1, method.length) + 'd';
+    logging_1.logEmitter.emit('info', `${verb} ${createdEntity.sys.type} ${(0, get_entity_name_1.default)(createdEntity)}`);
+    return createdEntity;
 }
 function getPlainData(entity) {
-  const data = entity.toPlainObject ? entity.toPlainObject() : entity;
-  return (0, _object.omit)(data, 'sys');
-}
+    const data = entity.toPlainObject ? entity.toPlainObject() : entity;
+    return (0, object_1.omit)(data, 'sys');
+}

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

@@ -1,100 +1,100 @@
 "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 }; }
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.archiveEntities = exports.publishEntities = void 0;
+const get_entity_name_1 = __importDefault(require("contentful-batch-libs/dist/get-entity-name"));
+const logging_1 = require("contentful-batch-libs/dist/logging");
 /**
  * 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;
+async function publishEntities({ entities, requestQueue }) {
+    const entitiesToPublish = entities.filter((entity) => {
+        if (!entity || !entity.publish) {
+            logging_1.logEmitter.emit('warning', `Unable to publish ${(0, get_entity_name_1.default)(entity)}`);
+            return false;
+        }
+        return true;
+    });
+    if (entitiesToPublish.length === 0) {
+        logging_1.logEmitter.emit('info', 'Skipping publishing since zero valid entities passed');
+        return [];
     }
-    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;
+    const entity = entities[0].original || entities[0];
+    const type = entity.sys.type || 'unknown type';
+    logging_1.logEmitter.emit('info', `Publishing ${entities.length} ${type}s`);
+    const result = await runQueue(entitiesToPublish, [], requestQueue);
+    logging_1.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;
+exports.publishEntities = publishEntities;
+async function archiveEntities({ entities, requestQueue }) {
+    const entitiesToArchive = entities.filter((entity) => {
+        if (!entity || !entity.archive) {
+            logging_1.logEmitter.emit('warning', `Unable to archive ${(0, get_entity_name_1.default)(entity)}`);
+            return false;
+        }
+        return true;
+    });
+    if (entitiesToArchive.length === 0) {
+        logging_1.logEmitter.emit('info', 'Skipping archiving since zero valid entities passed');
+        return [];
     }
-    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 entity = entities[0].original || entities[0];
+    const type = entity.sys.type || 'unknown type';
+    logging_1.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_1.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;
+    const allPossiblyArchivedEntities = await Promise.all(pendingArchivedEntities);
+    const allArchivedEntities = allPossiblyArchivedEntities.filter((entity) => entity);
+    logging_1.logEmitter.emit('info', `Successfully archived ${allArchivedEntities.length} ${type}s`);
+    return allArchivedEntities;
 }
+exports.archiveEntities = archiveEntities;
 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);
+    const publishedEntities = [];
+    for (const entity of queue) {
+        logging_1.logEmitter.emit('info', `Publishing ${entity.sys.type} ${(0, get_entity_name_1.default)(entity)}`);
+        try {
+            const publishedEntity = await requestQueue.add(() => entity.publish());
+            publishedEntities.push(publishedEntity);
+        }
+        catch (err) {
+            err.entity = entity;
+            logging_1.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);
+    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(get_entity_name_1.default).join(', ');
+            logging_1.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;
-}
+    // Return only published entities + last result
+    return result;
+}