contentful-import 9.1.0 → 9.2.1

package/package.json

@@ -1,22 +1,30 @@
 {
   "name": "contentful-import",
-  "version": "9.1.0",
+  "version": "9.2.1",
   "description": "this tool allows you to import JSON dump exported by contentful-export",
-  "main": "dist/index.js",
+  "main": "dist/index.mjs",
+  "typings": "dist/index.d.ts",
+  "module": "dist/index.mjs",
   "engines": {
     "node": ">=16"
   },
+  "exports": {
+    "default": "./dist/index.js",
+    "require": "./dist/index.js",
+    "import": "./dist/index.mjs",
+    "node": "./dist/index.js"
+  },
   "bin": {
     "contentful-import": "./bin/contentful-import"
   },
   "scripts": {
-    "build": "npm run clean && tsc",
+    "build": "tsup",
     "build:watch": "babel lib --out-dir dist --watch",
     "clean": "rimraf dist && rimraf coverage",
     "lint": "eslint lib bin/contentful-import test",
     "pretest": "npm run lint && npm run build",
     "test": "npm run test:unit && npm run test:integration",
-    "test:unit": "jest --testPathPattern=test/unit --coverage",
+    "test:unit": "jest --testPathPattern=test/unit --runInBand --coverage",
     "test:unit:debug": "node --inspect-brk ./node_modules/.bin/jest --runInBand --watch --testPathPattern=test/unit",
     "test:unit:watch": "npm run test:unit -- --watch",
     "test:integration": "jest --testPathPattern=test/integration",
@@ -49,12 +57,23 @@
   "bugs": {
     "url": "https://github.com/contentful/contentful-import/issues"
   },
+  "tsup": {
+    "entry": [
+      "lib/index.ts"
+    ],
+    "format": [
+      "cjs",
+      "esm"
+    ],
+    "clean": true,
+    "dts": true
+  },
   "dependencies": {
     "@discoveryjs/json-ext": "^0.5.7",
     "bluebird": "^3.5.1",
     "cli-table3": "^0.6.0",
     "contentful-batch-libs": "^9.5.0",
-    "contentful-management": "^10.46.2",
+    "contentful-management": "^10.46.4",
     "date-fns": "^2.30.0",
     "eslint": "^8.50.0",
     "eslint-config-standard": "^17.1.0",
@@ -73,7 +92,7 @@
     "@babel/preset-env": "^7.22.20",
     "@types/jest": "^29.5.5",
     "@types/node": "^20.6.3",
-    "@typescript-eslint/eslint-plugin": "^6.7.2",
+    "@typescript-eslint/eslint-plugin": "^6.7.3",
     "@typescript-eslint/parser": "^6.7.2",
     "babel-jest": "^29.7.0",
     "babel-plugin-add-module-exports": "^1.0.2",
@@ -89,6 +108,7 @@
     "rimraf": "^5.0.0",
     "semantic-release": "^19.0.5",
     "ts-jest": "^29.1.1",
+    "tsup": "^7.2.0",
     "typescript": "^5.2.2"
   },
   "files": [

package/dist/parseOptions.js

@@ -1,97 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = __importDefault(require("fs"));
-const path_1 = require("path");
-const format_1 = __importDefault(require("date-fns/format"));
-const package_1 = require("../package");
-const headers_1 = require("./utils/headers");
-const proxy_1 = require("contentful-batch-libs/dist/proxy");
-const add_sequence_header_1 = __importDefault(require("contentful-batch-libs/dist/add-sequence-header"));
-const json_ext_1 = require("@discoveryjs/json-ext");
-const SUPPORTED_ENTITY_TYPES = [
-    'contentTypes',
-    'tags',
-    'entries',
-    'assets',
-    'locales',
-    'webhooks',
-    'editorInterfaces'
-];
-async function parseOptions(params) {
-    const defaultOptions = {
-        skipContentModel: false,
-        skipLocales: false,
-        skipContentPublishing: false,
-        useVerboseRenderer: false,
-        environmentId: 'master',
-        rawProxy: false,
-        uploadAssets: false,
-        rateLimit: 7
-    };
-    const configFile = params.config
-        ? require((0, path_1.resolve)(process.cwd(), params.config))
-        : {};
-    const options = {
-        ...defaultOptions,
-        ...configFile,
-        ...params,
-        headers: (0, add_sequence_header_1.default)(params.headers || (0, headers_1.getHeadersConfig)(params.header))
-    };
-    // Validation
-    if (!options.spaceId) {
-        throw new Error('The `spaceId` option is required.');
-    }
-    if (!options.managementToken) {
-        throw new Error('The `managementToken` option is required.');
-    }
-    if (!options.contentFile && !options.content) {
-        throw new Error('Either the `contentFile` or `content` option are required.');
-    }
-    if (options.contentModelOnly && options.skipContentModel) {
-        throw new Error('`contentModelOnly` and `skipContentModel` cannot be used together');
-    }
-    if (options.skipLocales && !options.contentModelOnly) {
-        throw new Error('`skipLocales` can only be used together with `contentModelOnly`');
-    }
-    const proxySimpleExp = /.+:\d+/;
-    const proxyAuthExp = /.+:.+@.+:\d+/;
-    if (typeof options.proxy === 'string' && options.proxy && !(proxySimpleExp.test(options.proxy) || proxyAuthExp.test(options.proxy))) {
-        throw new Error('Please provide the proxy config in the following format:\nhost:port or user:password@host:port');
-    }
-    options.startTime = new Date();
-    if (!options.errorLogFile) {
-        options.errorLogFile = (0, path_1.resolve)(process.cwd(), `contentful-import-error-log-${options.spaceId}-${(0, format_1.default)(options.startTime, "yyyy-MM-dd'T'HH-mm-ss")}.json`);
-    }
-    else {
-        options.errorLogFile = (0, path_1.resolve)(process.cwd(), options.errorLogFile);
-    }
-    options.accessToken = options.managementToken;
-    if (!options.content) {
-        // using a stream parser allows input files > 512 MB
-        const fileStream = fs_1.default.createReadStream(options.contentFile, { encoding: 'utf8' });
-        options.content = await (0, json_ext_1.parseChunked)(fileStream);
-    }
-    // Clean up content to only include supported entity types
-    Object.keys(options.content).forEach((type) => {
-        if (SUPPORTED_ENTITY_TYPES.indexOf(type) === -1) {
-            delete options.content[type];
-        }
-    });
-    SUPPORTED_ENTITY_TYPES.forEach((type) => {
-        options.content[type] = options.content[type] || [];
-    });
-    if (typeof options.proxy === 'string') {
-        options.proxy = (0, proxy_1.proxyStringToObject)(options.proxy);
-    }
-    if (!options.rawProxy && options.proxy) {
-        options.httpsAgent = (0, proxy_1.agentFromProxy)(options.proxy);
-        delete options.proxy;
-    }
-    options.application = options.managementApplication || `contentful.import/${package_1.version}`;
-    options.feature = options.managementFeature || 'library-import';
-    return options;
-}
-exports.default = parseOptions;

package/dist/tasks/get-destination-data.js

@@ -1,122 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const bluebird_1 = __importDefault(require("bluebird"));
-const logging_1 = require("contentful-batch-libs/dist/logging");
-const BATCH_CHAR_LIMIT = 1990;
-const BATCH_SIZE_LIMIT = 100;
-const METHODS = {
-    contentTypes: { name: 'content types', method: 'getContentTypes' },
-    locales: { name: 'locales', method: 'getLocales' },
-    entries: { name: 'entries', method: 'getEntries' },
-    assets: { name: 'assets', method: 'getAssets' }
-};
-async function batchedIdQuery({ environment, type, ids, requestQueue }) {
-    const method = METHODS[type].method;
-    const entityTypeName = METHODS[type].name;
-    const batches = getIdBatches(ids);
-    let totalFetched = 0;
-    const allPendingResponses = batches.map((idBatch) => {
-        // TODO: add batch count to indicate that it's running
-        return requestQueue.add(async () => {
-            const response = await environment[method]({
-                'sys.id[in]': idBatch,
-                limit: idBatch.split(',').length
-            });
-            totalFetched = totalFetched + response.items.length;
-            logging_1.logEmitter.emit('info', `Fetched ${totalFetched} of ${response.total} ${entityTypeName}`);
-            return response.items;
-        });
-    });
-    const responses = await bluebird_1.default.all(allPendingResponses);
-    return responses.flat();
-}
-function getIdBatches(ids) {
-    const batches = [];
-    let currentBatch = '';
-    let currentSize = 0;
-    while (ids.length > 0) {
-        const id = ids.splice(0, 1);
-        currentBatch += id;
-        currentSize = currentSize + 1;
-        if (currentSize === BATCH_SIZE_LIMIT || currentBatch.length > BATCH_CHAR_LIMIT || ids.length === 0) {
-            batches.push(currentBatch);
-            currentBatch = '';
-            currentSize = 0;
-        }
-        else {
-            currentBatch += ',';
-        }
-    }
-    return batches;
-}
-/**
- * Gets content from a space which will have content copied to it, based on a
- * collection of existing content.
- *
- * Only the supplied entry/asset/contentType/locale IDs will be retrieved.
- * All tags will be retrieved.
- *
- */
-async function getDestinationData({ client, spaceId, environmentId, sourceData, contentModelOnly, skipLocales, skipContentModel, requestQueue }) {
-    const space = await client.getSpace(spaceId);
-    const environment = await space.getEnvironment(environmentId);
-    const result = {
-        contentTypes: [],
-        tags: [],
-        locales: [],
-        entries: [],
-        assets: []
-    };
-    // Make sure all required properties are available and at least an empty array
-    sourceData = {
-        ...result,
-        ...sourceData
-    };
-    if (!skipContentModel) {
-        const contentTypeIds = sourceData.contentTypes.map((e) => e.sys.id);
-        result.contentTypes = batchedIdQuery({
-            environment,
-            type: 'contentTypes',
-            ids: contentTypeIds,
-            requestQueue
-        });
-        if (!skipLocales) {
-            const localeIds = sourceData.locales.map((e) => e.sys.id);
-            result.locales = batchedIdQuery({
-                environment,
-                type: 'locales',
-                ids: localeIds,
-                requestQueue
-            });
-        }
-    }
-    // include tags even if contentModelOnly = true
-    result.tags = environment.getTags().then(response => response.items).catch((e) => {
-        // users without access to Tags will get 404
-        // if they dont have access, remove tags array so they're not handled in future steps
-        delete result.tags;
-    });
-    if (contentModelOnly) {
-        return bluebird_1.default.props(result);
-    }
-    const entryIds = sourceData.entries.map((e) => e.sys.id);
-    const assetIds = sourceData.assets.map((e) => e.sys.id);
-    result.entries = batchedIdQuery({
-        environment,
-        type: 'entries',
-        ids: entryIds,
-        requestQueue
-    });
-    result.assets = batchedIdQuery({
-        environment,
-        type: 'assets',
-        ids: assetIds,
-        requestQueue
-    });
-    result.webhooks = [];
-    return bluebird_1.default.props(result);
-}
-exports.default = getDestinationData;

package/dist/tasks/init-client.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const contentful_management_1 = require("contentful-management");
-const logging_1 = require("contentful-batch-libs/dist/logging");
-function logHandler(level, data) {
-    logging_1.logEmitter.emit(level, data);
-}
-function initClient(opts) {
-    const defaultOpts = {
-        timeout: 30000,
-        logHandler
-    };
-    const config = {
-        ...defaultOpts,
-        ...opts
-    };
-    return (0, contentful_management_1.createClient)(config);
-}
-exports.default = initClient;

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

@@ -1,75 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.processAssets = exports.getAssetStreamForURL = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = require("path");
-const util_1 = require("util");
-const get_entity_name_1 = __importDefault(require("contentful-batch-libs/dist/get-entity-name"));
-const logging_1 = require("contentful-batch-libs/dist/logging");
-const stat = (0, util_1.promisify)(fs_1.default.stat);
-async function getAssetStreamForURL(url, assetsDirectory) {
-    const [, assetPath] = url.split('//');
-    const filePath = (0, path_1.join)(assetsDirectory, assetPath);
-    try {
-        await stat(filePath);
-        return fs_1.default.createReadStream(filePath);
-    }
-    catch (err) {
-        const error = new Error('Cannot open asset from filesystem');
-        error.filePath = filePath;
-        throw error;
-    }
-}
-exports.getAssetStreamForURL = getAssetStreamForURL;
-async function processAssetForLocale(locale, asset, processingOptions) {
-    try {
-        return await asset.processForLocale(locale, processingOptions);
-    }
-    catch (err) {
-        err.entity = asset;
-        logging_1.logEmitter.emit('error', err);
-        throw err;
-    }
-}
-// From
-// https://stackoverflow.com/questions/67339630/how-to-get-last-resolved-promise-from-a-list-of-resolved-promises-in-javascript
-async function lastResult(promises) {
-    if (!promises.length)
-        throw new RangeError('No last result from no promises');
-    const results = [];
-    await Promise.all(promises.map((p) => p.then((v) => {
-        results.push(v);
-    })));
-    return results[results.length - 1];
-}
-async function processAssets({ assets, timeout, retryLimit, requestQueue }) {
-    const processingOptions = Object.assign({}, timeout && { processingCheckWait: timeout }, retryLimit && { processingCheckRetry: retryLimit });
-    const pendingProcessingAssets = assets.map(async (asset) => {
-        logging_1.logEmitter.emit('info', `Processing Asset ${(0, get_entity_name_1.default)(asset)}`);
-        // We want to do what processForAllLocale does, but as the rate
-        // limit is only enforced if we have a dedicated requestQueue item
-        // for every processForLocale call, we need to duplicate the logic
-        // here
-        const locales = Object.keys(asset.fields.file || {});
-        let latestAssetVersion = asset;
-        try {
-            // The last resolved promise will return the most up to date asset
-            // version which we need for next import steps (e.g. publishing)
-            latestAssetVersion = await lastResult(locales.map((locale) => {
-                return requestQueue.add(() => processAssetForLocale(locale, asset, processingOptions));
-            }));
-        }
-        catch (err) {
-            // Handle any error that arises during the processing of any locale
-            return null;
-        }
-        return latestAssetVersion;
-    });
-    const potentiallyProcessedAssets = await Promise.all(pendingProcessingAssets);
-    // This filters out all process attempts which failed
-    return potentiallyProcessedAssets.filter((asset) => asset);
-}
-exports.processAssets = processAssets;

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

@@ -1,178 +0,0 @@
-"use strict";
-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 });
-}
-exports.createEntities = createEntities;
-// TODO
-// Locales need to be created in series
-function createLocales({ context, entities, destinationEntitiesById, requestQueue }) {
-    return createEntitiesInSequence({ context, entities, destinationEntitiesById, requestQueue });
-}
-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);
-}
-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);
-}
-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;
-    }
-}
-function updateDestinationWithSourceData(destinationEntity, sourceEntity) {
-    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_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);
-}
-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_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_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_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_1.get)(sourceEntity, 'sys.id')) || null;
-}
-function creationSuccessNotifier(method, 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_1.omit)(data, 'sys');
-}

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

@@ -1,100 +0,0 @@
-"use strict";
-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_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 [];
-    }
-    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;
-}
-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 [];
-    }
-    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_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_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(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;
-}