contentful-import 10.1.2 → 10.2.0

package/dist/index.js

@@ -58,13 +58,12 @@ function initClient(opts) {
     ...defaultOpts,
     ...opts
   };
-  return (0, import_contentful_management.createClient)(config, { type: "legacy" });
-}
-function initPlainClient(opts) {
-  return (0, import_contentful_management.createClient)({
-    accessToken: opts.managementToken,
-    host: opts.host,
-    logHandler
+  return (0, import_contentful_management.createClient)(config, {
+    type: "plain",
+    defaults: {
+      spaceId: opts.spaceId,
+      environmentId: opts.environmentId
+    }
   });
 }
 
@@ -119,14 +118,14 @@ function isExoEntitlementError(err) {
   }
 }
 var EXO_M1_FEATURE = "exoM1";
-async function spaceHasExoM1Entitlement(plainClient, spaceId) {
+async function spaceHasExoM1Entitlement(client, spaceId) {
   try {
-    const space = await plainClient.space.get({ spaceId });
+    const space = await client.space.get({ spaceId });
     const organizationId = space.sys.organization?.sys?.id;
     if (!organizationId) {
       return null;
     }
-    const entitlements = await plainClient.raw.get(
+    const entitlements = await client.raw.get(
       `/organizations/${organizationId}/organization_entitlement_set`
     );
     return entitlements.features?.[EXO_M1_FEATURE]?.value === true;
@@ -138,13 +137,6 @@ async function spaceHasExoM1Entitlement(plainClient, spaceId) {
 // lib/tasks/get-destination-data.ts
 var BATCH_CHAR_LIMIT = 1990;
 var BATCH_SIZE_LIMIT = 100;
-var OFFSET_QUERY_METHODS = {
-  contentTypes: { name: "content types", method: "getContentTypes" },
-  locales: { name: "locales", method: "getLocales" },
-  entries: { name: "entries", method: "getEntries" },
-  assets: { name: "assets", method: "getAssets" },
-  tags: { name: "tags", method: "getTags" }
-};
 var CURSOR_QUERY_METHODS = {
   designTokens: { name: "design tokens", namespace: "designToken" },
   components: { name: "components", namespace: "component" },
@@ -153,47 +145,64 @@ var CURSOR_QUERY_METHODS = {
   dataAssemblies: { name: "data assemblies", namespace: "dataAssembly" },
   experiences: { name: "experiences", namespace: "experience" }
 };
-async function batchedIdQuery({ environment, type, ids, requestQueue }) {
-  const method = OFFSET_QUERY_METHODS[type].method;
-  const entityTypeName = OFFSET_QUERY_METHODS[type].name;
+var ENTITY_METHODS = {
+  contentTypes: { name: "content types", ns: "contentType" },
+  entries: { name: "entries", ns: "entry" },
+  assets: { name: "assets", ns: "asset" },
+  locales: { name: "locales", ns: "locale" },
+  tags: { name: "tags", ns: "tag" }
+};
+async function batchedIdQuery({ client, spaceId, environmentId, type, ids, requestQueue }) {
+  const { name, ns } = ENTITY_METHODS[type];
   const batches = getIdBatches(ids);
   let totalFetched = 0;
   const allPendingResponses = batches.map((idBatch) => {
     return requestQueue.add(async () => {
-      const response = await environment[method]({
-        "sys.id[in]": idBatch,
-        limit: idBatch.split(",").length
+      const response = await client[ns].getMany({
+        spaceId,
+        environmentId,
+        query: {
+          "sys.id[in]": idBatch,
+          limit: idBatch.split(",").length
+        }
       });
       totalFetched = totalFetched + response.items.length;
-      import_logging3.logEmitter.emit("info", `Fetched ${totalFetched} of ${response.total} ${entityTypeName}`);
+      import_logging3.logEmitter.emit("info", `Fetched ${totalFetched} of ${response.total} ${name}`);
       return response.items;
     });
   });
   const responses = await import_bluebird.default.all(allPendingResponses);
   return responses.flat();
 }
-async function batchedPageQuery({ environment, type, requestQueue }) {
-  const method = OFFSET_QUERY_METHODS[type].method;
-  const entityTypeName = OFFSET_QUERY_METHODS[type].name;
+async function batchedPageQuery({ client, spaceId, environmentId, type, requestQueue }) {
+  const { name, ns } = ENTITY_METHODS[type];
   let totalFetched = 0;
   const { items, total } = await requestQueue.add(async () => {
-    const response = await environment[method]({
-      skip: 0,
-      limit: BATCH_SIZE_LIMIT
+    const response = await client[ns].getMany({
+      spaceId,
+      environmentId,
+      query: {
+        skip: 0,
+        limit: BATCH_SIZE_LIMIT
+      }
     });
     totalFetched += response.items.length;
-    import_logging3.logEmitter.emit("info", `Fetched ${totalFetched} of ${response.total} ${entityTypeName}`);
+    import_logging3.logEmitter.emit("info", `Fetched ${totalFetched} of ${response.total} ${name}`);
     return { items: response.items, total: response.total };
   });
   const batches = getPagedBatches(totalFetched, total);
   const remainingTotalResponses = batches.map(({ skip }) => {
     return requestQueue.add(async () => {
-      const response = await environment[method]({
-        skip,
-        limit: BATCH_SIZE_LIMIT
+      const response = await client[ns].getMany({
+        spaceId,
+        environmentId,
+        query: {
+          skip,
+          limit: BATCH_SIZE_LIMIT
+        }
       });
       totalFetched = totalFetched + response.items.length;
-      import_logging3.logEmitter.emit("info", `Fetched ${totalFetched} of ${response.total} ${entityTypeName}`);
+      import_logging3.logEmitter.emit("info", `Fetched ${totalFetched} of ${response.total} ${name}`);
       return response.items;
     });
   });
@@ -230,14 +239,14 @@ function getPagedBatches(totalFetched, total) {
   }
   return batches;
 }
-async function cursorPaginatedQuery({ plainClient, spaceId, environmentId, type, requestQueue }) {
+async function cursorPaginatedQuery({ client, spaceId, environmentId, type, requestQueue }) {
   const { name: entityTypeName, namespace } = CURSOR_QUERY_METHODS[type];
   let totalFetched = 0;
   let pageNext = void 0;
   const allItems = [];
   do {
     const items = await requestQueue.add(async () => {
-      const response = await plainClient[namespace].getMany({
+      const response = await client[namespace].getMany({
         spaceId,
         environmentId,
         query: { limit: BATCH_SIZE_LIMIT, ...pageNext && { pageNext } }
@@ -266,7 +275,6 @@ async function cursorPaginatedQueryOrWarn(params) {
 }
 async function getDestinationData({
   client,
-  plainClient,
   spaceId,
   environmentId,
   sourceData,
@@ -276,8 +284,6 @@ async function getDestinationData({
   includeExperienceOrchestration,
   requestQueue
 }) {
-  const space = await client.getSpace(spaceId);
-  const environment = await space.getEnvironment(environmentId);
   const result = {
     contentTypes: [],
     tags: [],
@@ -300,7 +306,9 @@ async function getDestinationData({
     const contentTypeIds = sourceData.contentTypes?.map((e) => e.sys.id);
     if (contentTypeIds) {
       result.contentTypes = batchedIdQuery({
-        environment,
+        client,
+        spaceId,
+        environmentId,
         type: "contentTypes",
         ids: contentTypeIds,
         requestQueue
@@ -310,7 +318,9 @@ async function getDestinationData({
       const localeIds = sourceData.locales?.map((e) => e.sys.id);
       if (localeIds && localeIds.length) {
         result.locales = batchedPageQuery({
-          environment,
+          client,
+          spaceId,
+          environmentId,
           type: "locales",
           requestQueue
         });
@@ -318,7 +328,7 @@ async function getDestinationData({
     }
   }
   try {
-    result.tags = await batchedPageQuery({ environment, type: "tags", requestQueue });
+    result.tags = await batchedPageQuery({ client, spaceId, environmentId, type: "tags", requestQueue });
   } catch (_) {
     delete result.tags;
   }
@@ -329,7 +339,9 @@ async function getDestinationData({
   const assetIds = sourceData.assets?.map((e) => e.sys.id);
   if (entryIds && entryIds.length) {
     result.entries = batchedIdQuery({
-      environment,
+      client,
+      spaceId,
+      environmentId,
       type: "entries",
       ids: entryIds,
       requestQueue
@@ -337,13 +349,15 @@ async function getDestinationData({
   }
   if (assetIds && assetIds.length) {
     result.assets = batchedIdQuery({
-      environment,
+      client,
+      spaceId,
+      environmentId,
       type: "assets",
       ids: assetIds,
       requestQueue
     });
   }
-  if (includeExperienceOrchestration && plainClient) {
+  if (includeExperienceOrchestration && client) {
     const sourceHasDesignTokens = Boolean(sourceData.designTokens?.length);
     const sourceHasComponents = Boolean(sourceData.components?.length);
     const sourceHasExperienceTemplates = Boolean(sourceData.experienceTemplates?.length);
@@ -351,29 +365,29 @@ async function getDestinationData({
     const sourceHasExperiences = Boolean(sourceData.experiences?.length);
     let entitled = true;
     if (sourceHasDesignTokens || sourceHasComponents || sourceHasExperienceTemplates || sourceHasExperienceFragments || sourceHasExperiences) {
-      entitled = await spaceHasExoM1Entitlement(plainClient, spaceId);
+      entitled = await spaceHasExoM1Entitlement(client, spaceId);
     }
     if (entitled === false) {
       import_logging3.logEmitter.emit("error", new Error("Skipping Experience Orchestration import: Experience Orchestration (ExO) is not enabled for this space"));
     } else {
       if (sourceHasDesignTokens) {
-        result.designTokens = cursorPaginatedQueryOrWarn({ plainClient, spaceId, environmentId, type: "designTokens", requestQueue });
+        result.designTokens = cursorPaginatedQueryOrWarn({ client, spaceId, environmentId, type: "designTokens", requestQueue });
       }
       if (sourceHasComponents) {
-        result.components = cursorPaginatedQueryOrWarn({ plainClient, spaceId, environmentId, type: "components", requestQueue });
+        result.components = cursorPaginatedQueryOrWarn({ client, spaceId, environmentId, type: "components", requestQueue });
       }
       if (sourceHasExperienceTemplates) {
-        result.experienceTemplates = cursorPaginatedQueryOrWarn({ plainClient, spaceId, environmentId, type: "experienceTemplates", requestQueue });
+        result.experienceTemplates = cursorPaginatedQueryOrWarn({ client, spaceId, environmentId, type: "experienceTemplates", requestQueue });
       }
       if (sourceHasExperienceFragments) {
-        result.experienceFragments = cursorPaginatedQueryOrWarn({ plainClient, spaceId, environmentId, type: "experienceFragments", requestQueue });
+        result.experienceFragments = cursorPaginatedQueryOrWarn({ client, spaceId, environmentId, type: "experienceFragments", requestQueue });
       }
       if (sourceHasExperiences) {
-        result.experiences = cursorPaginatedQueryOrWarn({ plainClient, spaceId, environmentId, type: "experiences", requestQueue });
+        result.experiences = cursorPaginatedQueryOrWarn({ client, spaceId, environmentId, type: "experiences", requestQueue });
       }
     }
     if (sourceData.dataAssemblies?.length) {
-      result.dataAssemblies = cursorPaginatedQueryOrWarn({ plainClient, spaceId, environmentId, type: "dataAssemblies", requestQueue });
+      result.dataAssemblies = cursorPaginatedQueryOrWarn({ client, spaceId, environmentId, type: "dataAssemblies", requestQueue });
     }
   }
   return import_bluebird.default.props(result);
@@ -420,9 +434,9 @@ async function getAssetStreamForURL(url, assetsDirectory) {
     throw error;
   }
 }
-async function processAssetForLocale(locale, asset, processingOptions) {
+async function processAssetForLocale(client, spaceId, environmentId, locale, asset, processingOptions) {
   try {
-    return await asset.processForLocale(locale, processingOptions);
+    return await client.asset.processForLocale({ spaceId, environmentId }, asset, locale, processingOptions);
   } catch (err) {
     if (err instanceof ContentfulEntityError) {
       err.entity = asset;
@@ -445,6 +459,9 @@ async function lastResult(promises) {
 }
 async function processAssets({
   assets: assets2,
+  client,
+  spaceId,
+  environmentId,
   timeout,
   retryLimit,
   requestQueue
@@ -462,7 +479,7 @@ async function processAssets({
       latestAssetVersion = await lastResult(
         locales2.map((locale) => {
           return requestQueue.add(
-            () => processAssetForLocale(locale, asset, processingOptions)
+            () => processAssetForLocale(client, spaceId, environmentId, locale, asset, processingOptions)
           );
         })
       );
@@ -498,7 +515,7 @@ async function createEntitiesWithConcurrency({ context, entities, destinationEnt
     }
     return requestQueue.add(async () => {
       try {
-        const createdEntity = await (destinationEntity ? updateDestinationWithSourceData(destinationEntity, entity.transformed) : createInDestination(context, entity.transformed));
+        const createdEntity = await (destinationEntity ? updateDestinationWithSourceData(context, destinationEntity, entity.transformed) : createInDestination(context, entity.transformed));
         creationSuccessNotifier(operation, createdEntity);
         return createdEntity;
       } catch (err) {
@@ -516,7 +533,7 @@ async function createEntitiesInSequence({ context, entities, destinationEntities
     const operation = destinationEntity ? "update" : "create";
     try {
       const createdEntity = await requestQueue.add(async () => {
-        const createdOrUpdatedEntity = await (destinationEntity ? updateDestinationWithSourceData(destinationEntity, entity.transformed) : createInDestination(context, entity.transformed));
+        const createdOrUpdatedEntity = await (destinationEntity ? updateDestinationWithSourceData(context, destinationEntity, entity.transformed) : createInDestination(context, entity.transformed));
         return createdOrUpdatedEntity;
       });
       creationSuccessNotifier(operation, createdEntity);
@@ -532,11 +549,11 @@ async function createEntitiesInSequence({ context, entities, destinationEntities
 }
 async function createEntries({ context, entities, destinationEntitiesById, skipUpdates, requestQueue }) {
   const createdEntries = await Promise.all(entities.map((entry) => {
-    return createEntry({ entry, target: context.target, skipContentModel: context.skipContentModel, destinationEntitiesById, skipUpdates, requestQueue });
+    return createEntry({ entry, context, destinationEntitiesById, skipUpdates, requestQueue });
   }));
   return createdEntries.filter((entry) => entry);
 }
-async function createEntry({ entry, target, skipContentModel, destinationEntitiesById, skipUpdates, requestQueue }) {
+async function createEntry({ entry, context, destinationEntitiesById, skipUpdates, requestQueue }) {
   const contentTypeId = entry.original.sys.contentType.sys.id;
   const destinationEntry = getDestinationEntityForSourceEntity(
     destinationEntitiesById,
@@ -550,16 +567,16 @@ async function createEntry({ entry, target, skipContentModel, destinationEntitie
   }
   try {
     const createdOrUpdatedEntry = await requestQueue.add(() => {
-      return destinationEntry ? updateDestinationWithSourceData(destinationEntry, entry.transformed) : createEntryInDestination(target, contentTypeId, entry.transformed);
+      return destinationEntry ? updateDestinationWithSourceData(context, destinationEntry, entry.transformed) : createEntryInDestination(context, contentTypeId, entry.transformed);
     });
     creationSuccessNotifier(operation, createdOrUpdatedEntry);
     return createdOrUpdatedEntry;
   } catch (err) {
     if (err instanceof Error) {
-      if (skipContentModel && err.name === "UnknownField") {
+      if (context.skipContentModel && err.name === "UnknownField") {
         const errors = (0, import_object.get)(JSON.parse(err.message), "details.errors");
         entry.transformed.fields = cleanupUnknownFields(entry.transformed.fields, errors);
-        return createEntry({ entry, target, skipContentModel, destinationEntitiesById, skipUpdates, requestQueue });
+        return createEntry({ entry, context, destinationEntitiesById, skipUpdates, requestQueue });
       }
     }
     if (err instanceof ContentfulEntityError) {
@@ -569,30 +586,78 @@ async function createEntry({ entry, target, skipContentModel, destinationEntitie
     return null;
   }
 }
-function updateDestinationWithSourceData(destinationEntity, sourceEntity) {
+function updateDestinationWithSourceData(context, destinationEntity, sourceEntity) {
+  const { client, spaceId, environmentId, type } = context;
   const plainData = getPlainData(sourceEntity);
-  (0, import_object.assign)(destinationEntity, plainData);
-  return destinationEntity.update();
+  const updated = (0, import_object.assign)({}, plainData, { sys: destinationEntity.sys });
+  if (type === "Entry") {
+    return client.entry.update(
+      { spaceId, environmentId, entryId: destinationEntity.sys.id },
+      updated
+    );
+  }
+  if (type === "ContentType") {
+    return client.contentType.update(
+      { spaceId, environmentId, contentTypeId: destinationEntity.sys.id },
+      updated
+    );
+  }
+  if (type === "Asset") {
+    return client.asset.update(
+      { spaceId, environmentId, assetId: destinationEntity.sys.id },
+      updated
+    );
+  }
+  if (type === "Locale") {
+    return client.locale.update(
+      { spaceId, environmentId, localeId: destinationEntity.sys.id },
+      updated
+    );
+  }
+  if (type === "Webhook") {
+    return client.webhook.update(
+      { spaceId, webhookDefinitionId: destinationEntity.sys.id },
+      updated
+    );
+  }
+  throw new Error(`updateDestinationWithSourceData: unsupported type "${type}"`);
 }
 function createInDestination(context, sourceEntity) {
-  const { type, target } = context;
+  const { type, client, spaceId, environmentId } = context;
   if (type === "Tag") {
     return createTagInDestination(context, sourceEntity);
   }
   const id = (0, import_object.get)(sourceEntity, "sys.id");
   const plainData = getPlainData(sourceEntity);
-  return id ? target[`create${type}WithId`](id, plainData) : target[`create${type}`](plainData);
+  if (type === "ContentType") {
+    return id ? client.contentType.createWithId({ spaceId, environmentId, contentTypeId: id }, plainData) : client.contentType.create({ spaceId, environmentId }, plainData);
+  }
+  if (type === "Asset") {
+    return id ? client.asset.createWithId({ spaceId, environmentId, assetId: id }, plainData) : client.asset.create({ spaceId, environmentId }, plainData);
+  }
+  if (type === "Locale") {
+    return client.locale.create({ spaceId, environmentId }, plainData);
+  }
+  if (type === "Webhook") {
+    return id ? client.webhook.update({ spaceId, webhookDefinitionId: id }, { ...plainData, sys: { id } }) : client.webhook.create({ spaceId }, plainData);
+  }
+  throw new Error(`createInDestination: unsupported type "${type}"`);
 }
-function createEntryInDestination(space, contentTypeId, sourceEntity) {
+function createEntryInDestination(context, contentTypeId, sourceEntity) {
+  const { client, spaceId, environmentId } = context;
   const id = sourceEntity.sys.id;
   const plainData = getPlainData(sourceEntity);
-  return id ? space.createEntryWithId(contentTypeId, id, plainData) : space.createEntry(contentTypeId, plainData);
+  return id ? client.entry.createWithId({ spaceId, environmentId, contentTypeId, entryId: id }, plainData) : client.entry.create({ spaceId, environmentId, contentTypeId }, plainData);
 }
 function createTagInDestination(context, sourceEntity) {
+  const { client, spaceId, environmentId } = context;
   const id = sourceEntity.sys.id;
   const visibility = sourceEntity.sys.visibility || "private";
   const name = sourceEntity.name;
-  return context.target.createTag(id, name, visibility);
+  return client.tag.createWithId(
+    { spaceId, environmentId, tagId: id },
+    { name, sys: { visibility } }
+  );
 }
 function handleCreationErrors(entity, err) {
   if ((0, import_object.get)(err, "error.sys.id") === "ValidationFailed") {
@@ -625,51 +690,61 @@ function creationSuccessNotifier(method, createdEntity) {
   return createdEntity;
 }
 function getPlainData(entity) {
-  const data = entity.toPlainObject ? entity.toPlainObject() : entity;
-  return (0, import_object.omit)(data, "sys");
+  return (0, import_object.omit)(entity, "sys");
 }
 
 // lib/tasks/push-to-space/publishing.ts
 var import_get_entity_name3 = __toESM(require("contentful-batch-libs/dist/get-entity-name"));
 var import_logging6 = require("contentful-batch-libs/dist/logging");
-async function publishEntities({ entities, requestQueue }) {
-  const entitiesToPublish = entities.filter((entity2) => {
-    if (!entity2 || !entity2.publish) {
-      import_logging6.logEmitter.emit("warning", `Unable to publish ${(0, import_get_entity_name3.default)(entity2)}`);
-      return false;
-    }
-    return true;
-  });
-  if (entitiesToPublish.length === 0) {
+function publishEntity(client, spaceId, environmentId, entity) {
+  const id = entity.sys.id;
+  const type = entity.sys.type;
+  if (type === "Entry") {
+    return client.entry.publish({ spaceId, environmentId, entryId: id }, entity);
+  }
+  if (type === "Asset") {
+    return client.asset.publish({ spaceId, environmentId, assetId: id }, entity);
+  }
+  if (type === "ContentType") {
+    return client.contentType.publish({ spaceId, environmentId, contentTypeId: id }, entity);
+  }
+  throw new Error(`publishEntity: unsupported type "${type}"`);
+}
+function archiveEntity(client, spaceId, environmentId, entity) {
+  const id = entity.sys.id;
+  const type = entity.sys.type;
+  if (type === "Entry") {
+    return client.entry.archive({ spaceId, environmentId, entryId: id });
+  }
+  if (type === "Asset") {
+    return client.asset.archive({ spaceId, environmentId, assetId: id });
+  }
+  throw new Error(`archiveEntity: unsupported type "${type}"`);
+}
+async function publishEntities({ entities, client, spaceId, environmentId, requestQueue }) {
+  if (entities.length === 0) {
     import_logging6.logEmitter.emit("info", "Skipping publishing since zero valid entities passed");
     return [];
   }
-  const entity = entities[0].original || entities[0];
+  const entity = entities[0];
   const type = entity.sys.type || "unknown type";
   import_logging6.logEmitter.emit("info", `Publishing ${entities.length} ${type}s`);
-  const result = await runQueue(entitiesToPublish, [], requestQueue);
+  const result = await runQueue(entities, [], client, spaceId, environmentId, requestQueue);
   import_logging6.logEmitter.emit("info", `Successfully published ${result.length} ${type}s`);
   return result;
 }
-async function archiveEntities({ entities, requestQueue }) {
-  const entitiesToArchive = entities.filter((entity2) => {
-    if (!entity2 || !entity2.archive) {
-      import_logging6.logEmitter.emit("warning", `Unable to archive ${(0, import_get_entity_name3.default)(entity2)}`);
-      return false;
-    }
-    return true;
-  });
-  if (entitiesToArchive.length === 0) {
+async function archiveEntities({ entities, client, spaceId, environmentId, requestQueue }) {
+  if (entities.length === 0) {
     import_logging6.logEmitter.emit("info", "Skipping archiving since zero valid entities passed");
     return [];
   }
-  const entity = entities[0].original || entities[0];
+  const entity = entities[0];
   const type = entity.sys.type || "unknown type";
   import_logging6.logEmitter.emit("info", `Archiving ${entities.length} ${type}s`);
-  const pendingArchivedEntities = entitiesToArchive.map((entity2) => {
+  const pendingArchivedEntities = entities.map((entity2) => {
     return requestQueue.add(async () => {
       try {
-        const archivedEntity = await entity2.archive();
+        const archivedEntity = await archiveEntity(client, spaceId, environmentId, entity2);
         return archivedEntity;
       } catch (err) {
         if (err instanceof ContentfulEntityError) {
@@ -685,12 +760,12 @@ async function archiveEntities({ entities, requestQueue }) {
   import_logging6.logEmitter.emit("info", `Successfully archived ${allArchivedEntities.length} ${type}s`);
   return allArchivedEntities;
 }
-async function runQueue(queue, result = [], requestQueue) {
+async function runQueue(queue, result = [], client, spaceId, environmentId, requestQueue) {
   const publishedEntities = [];
   for (const entity of queue) {
     import_logging6.logEmitter.emit("info", `Publishing ${entity.sys.type} ${(0, import_get_entity_name3.default)(entity)}`);
     try {
-      const publishedEntity = await requestQueue.add(() => entity.publish());
+      const publishedEntity = await requestQueue.add(() => publishEntity(client, spaceId, environmentId, entity));
       publishedEntities.push(publishedEntity);
     } catch (err) {
       if (err instanceof ContentfulEntityError) {
@@ -710,7 +785,7 @@ async function runQueue(queue, result = [], requestQueue) {
       const unpublishedEntityNames = unpublishedEntities.map(import_get_entity_name3.default).join(", ");
       import_logging6.logEmitter.emit("error", `Could not publish the following entities: ${unpublishedEntityNames}`);
     } else {
-      return runQueue(unpublishedEntities, result, requestQueue);
+      return runQueue(unpublishedEntities, result, client, spaceId, environmentId, requestQueue);
     }
   }
   return result;
@@ -878,8 +953,8 @@ function getSourceSpaceId(sourceEntities) {
   }
   return void 0;
 }
-async function ensureParentFolderGroupsExist(plainClient, organizationId) {
-  const { items } = await plainClient.conceptScheme.getMany({
+async function ensureParentFolderGroupsExist(client, organizationId) {
+  const { items } = await client.conceptScheme.getMany({
     organizationId,
     query: { purpose: "internal" }
   });
@@ -909,18 +984,18 @@ function deriveChildConceptMap(sourceEntities, destinationSpaceId) {
   }
   return childConceptMap;
 }
-async function createOrPatchChildConcepts(plainClient, organizationId, destinationSpaceId, childConceptMap) {
+async function createOrPatchChildConcepts(client, organizationId, destinationSpaceId, childConceptMap) {
   const spaceLink = { sys: { type: "Link", linkType: "Space", id: destinationSpaceId } };
   for (const [sourceConceptId, { destConceptId }] of childConceptMap) {
     let prefLabel = { "en-US": destConceptId };
     try {
-      const sourceConcept = await plainClient.concept.get({ organizationId, conceptId: sourceConceptId });
+      const sourceConcept = await client.concept.get({ organizationId, conceptId: sourceConceptId });
       if (sourceConcept?.prefLabel) prefLabel = sourceConcept.prefLabel;
     } catch {
     }
     let existing = null;
     try {
-      existing = await plainClient.concept.get({ organizationId, conceptId: destConceptId });
+      existing = await client.concept.get({ organizationId, conceptId: destConceptId });
     } catch (err) {
       if (err?.name !== "NotFound") {
         import_logging8.logEmitter.emit("warning", `Could not fetch destination child concept ${destConceptId}: ${err?.message ?? err}`);
@@ -928,8 +1003,9 @@ async function createOrPatchChildConcepts(plainClient, organizationId, destinati
     }
     if (!existing) {
       try {
-        await plainClient.concept.createWithId(
+        await client.concept.createWithId(
           { organizationId, conceptId: destConceptId },
+          // @ts-expect-error - CMA.js type needs to be updated to be aware of purpose: 'internal'
           { purpose: "internal", prefLabel, metadata: { spaces: [spaceLink] } }
         );
         import_logging8.logEmitter.emit("info", `Created child folder concept ${destConceptId}`);
@@ -944,7 +1020,7 @@ async function createOrPatchChildConcepts(plainClient, organizationId, destinati
       }
       if (patches.length > 0) {
         try {
-          await plainClient.concept.patch(
+          await client.concept.patch(
             { organizationId, conceptId: destConceptId, version: existing.sys.version },
             patches
           );
@@ -956,14 +1032,14 @@ async function createOrPatchChildConcepts(plainClient, organizationId, destinati
     }
   }
 }
-async function linkChildConceptsToParentGroups(plainClient, organizationId, childConceptMap, parentGroups) {
+async function linkChildConceptsToParentGroups(client, organizationId, childConceptMap, parentGroups) {
   for (const [, { destConceptId, parentGroupId }] of childConceptMap) {
     const parentGroup = parentGroups.get(parentGroupId);
     if (!parentGroup) continue;
     const alreadyLinked = (parentGroup.concepts ?? []).some((c) => c.sys.id === destConceptId);
     if (alreadyLinked) continue;
     try {
-      const updated = await plainClient.conceptScheme.patch(
+      const updated = await client.conceptScheme.patch(
         { organizationId, conceptSchemeId: parentGroupId, version: parentGroup.sys.version },
         [{ op: "add", path: "/concepts/-", value: { sys: { type: "Link", linkType: "TaxonomyConcept", id: destConceptId } } }]
       );
@@ -985,7 +1061,7 @@ function rewriteEntityFolderConcepts(entities, childConceptMap) {
   }
 }
 async function importExoFolders({
-  plainClient,
+  client,
   organizationId,
   destinationSpaceId,
   sourceEntities
@@ -995,7 +1071,7 @@ async function importExoFolders({
     import_logging8.logEmitter.emit("info", "Source and destination space are the same \u2014 skipping ExO folder import");
     return;
   }
-  const parentGroups = await ensureParentFolderGroupsExist(plainClient, organizationId);
+  const parentGroups = await ensureParentFolderGroupsExist(client, organizationId);
   if (parentGroups.size === 0) {
     import_logging8.logEmitter.emit("warn", "One or more Experience Orchestration folder group concept schemes are missing in the destination organization. Please create them before importing.");
     return;
@@ -1003,8 +1079,8 @@ async function importExoFolders({
   const childConceptMap = deriveChildConceptMap(sourceEntities, destinationSpaceId);
   if (childConceptMap.size === 0) return;
   import_logging8.logEmitter.emit("info", `Importing ${childConceptMap.size} ExO folder concept(s) into destination space ${destinationSpaceId}`);
-  await createOrPatchChildConcepts(plainClient, organizationId, destinationSpaceId, childConceptMap);
-  await linkChildConceptsToParentGroups(plainClient, organizationId, childConceptMap, parentGroups);
+  await createOrPatchChildConcepts(client, organizationId, destinationSpaceId, childConceptMap);
+  await linkChildConceptsToParentGroups(client, organizationId, childConceptMap, parentGroups);
   const allEntities = [
     ...sourceEntities.designTokens ?? [],
     ...sourceEntities.components ?? [],
@@ -1046,7 +1122,6 @@ function pushToSpace({
   sourceData,
   destinationData = {},
   client,
-  plainClient,
   spaceId,
   environmentId,
   includeExperienceOrchestration,
@@ -1083,15 +1158,6 @@ function pushToSpace({
     destinationDataById[entityType] = entitiesById;
   }
   return new import_listr.default([
-    {
-      title: "Connecting to space",
-      task: (0, import_listr2.wrapTask)(async (ctx) => {
-        const space = await client.getSpace(spaceId);
-        const environment = await space.getEnvironment(environmentId);
-        ctx.space = space;
-        ctx.environment = environment;
-      })
-    },
     {
       title: "Importing Locales",
       task: (0, import_listr2.wrapTask)(async (ctx) => {
@@ -1099,7 +1165,7 @@ function pushToSpace({
           return;
         }
         const locales2 = await createLocales({
-          context: { target: ctx.environment, type: "Locale" },
+          context: { client, spaceId, environmentId, type: "Locale" },
           entities: sourceData.locales,
           destinationEntitiesById: destinationDataById.locales,
           requestQueue
@@ -1115,7 +1181,7 @@ function pushToSpace({
           return;
         }
         const contentTypes2 = await createEntities({
-          context: { target: ctx.environment, type: "ContentType" },
+          context: { client, spaceId, environmentId, type: "ContentType" },
           entities: sourceData.contentTypes,
           destinationEntitiesById: destinationDataById.contentTypes,
           skipUpdates: false,
@@ -1131,6 +1197,9 @@ function pushToSpace({
         const publishedContentTypes = await publishEntities2({
           entities: ctx.data.contentTypes,
           sourceEntities: sourceData.contentTypes,
+          client,
+          spaceId,
+          environmentId,
           requestQueue
         });
         ctx.data.contentTypes = publishedContentTypes;
@@ -1142,7 +1211,7 @@ function pushToSpace({
       task: (0, import_listr2.wrapTask)(async (ctx) => {
         if (sourceData.tags && destinationDataById.tags) {
           const tags2 = await createEntities({
-            context: { target: ctx.environment, type: "Tag" },
+            context: { client, spaceId, environmentId, type: "Tag" },
             entities: sourceData.tags,
             destinationEntitiesById: destinationDataById.tags,
             skipUpdates: false,
@@ -1169,14 +1238,24 @@ function pushToSpace({
             return;
           }
           try {
-            const ctEditorInterface = await requestQueue.add(() => ctx.environment.getEditorInterfaceForContentType(contentType.sys.id));
+            const ctEditorInterface = await requestQueue.add(
+              () => client.editorInterface.get({ spaceId, environmentId, contentTypeId: contentType.sys.id })
+            );
             import_logging9.logEmitter.emit("info", `Fetched editor interface for ${contentType.name}`);
-            ctEditorInterface.controls = editorInterface.controls;
-            ctEditorInterface.groupControls = editorInterface.groupControls;
-            ctEditorInterface.editorLayout = editorInterface.editorLayout;
-            ctEditorInterface.sidebar = editorInterface.sidebar;
-            ctEditorInterface.editors = editorInterface.editors;
-            const updatedEditorInterface = await requestQueue.add(() => ctEditorInterface.update());
+            const updatedData = {
+              ...ctEditorInterface,
+              controls: editorInterface.controls,
+              groupControls: editorInterface.groupControls,
+              editorLayout: editorInterface.editorLayout,
+              sidebar: editorInterface.sidebar,
+              editors: editorInterface.editors
+            };
+            const updatedEditorInterface = await requestQueue.add(
+              () => client.editorInterface.update(
+                { spaceId, environmentId, contentTypeId: contentType.sys.id },
+                updatedData
+              )
+            );
             return updatedEditorInterface;
           } catch (err) {
             err.entity = editorInterface;
@@ -1200,10 +1279,10 @@ function pushToSpace({
               try {
                 import_logging9.logEmitter.emit("info", `Uploading Asset file ${file.upload}`);
                 const assetStream = await getAssetStreamForURL(file.upload, assetsDirectory);
-                const upload = await ctx.environment.createUpload({
-                  fileName: asset.transformed.sys.id,
-                  file: assetStream
-                });
+                const upload = await client.upload.create(
+                  { spaceId, environmentId },
+                  { file: assetStream }
+                );
                 delete file.upload;
                 file.uploadFrom = {
                   sys: {
@@ -1231,7 +1310,7 @@ function pushToSpace({
           return;
         }
         const assetsToProcess = await createEntities({
-          context: { target: ctx.environment, type: "Asset" },
+          context: { client, spaceId, environmentId, type: "Asset" },
           entities: sourceData.assets,
           destinationEntitiesById: destinationDataById.assets,
           skipUpdates: skipAssetUpdates,
@@ -1239,6 +1318,9 @@ function pushToSpace({
         });
         const processedAssets = await processAssets({
           assets: assetsToProcess,
+          client,
+          spaceId,
+          environmentId,
           timeout,
           retryLimit,
           requestQueue
@@ -1253,6 +1335,9 @@ function pushToSpace({
         const publishedAssets = await publishEntities2({
           entities: ctx.data.assets,
           sourceEntities: sourceData.assets,
+          client,
+          spaceId,
+          environmentId,
           requestQueue
         });
         ctx.data.publishedAssets = publishedAssets;
@@ -1265,6 +1350,9 @@ function pushToSpace({
         const archivedAssets = await archiveEntities2({
           entities: ctx.data.assets,
           sourceEntities: sourceData.assets,
+          client,
+          spaceId,
+          environmentId,
           requestQueue
         });
         ctx.data.archivedAssets = archivedAssets;
@@ -1275,7 +1363,7 @@ function pushToSpace({
       title: "Importing Content Entries",
       task: (0, import_listr2.wrapTask)(async (ctx) => {
         const entries2 = await createEntries({
-          context: { target: ctx.environment, skipContentModel },
+          context: { client, spaceId, environmentId, skipContentModel, type: "Entry" },
           entities: sourceData.entries,
           destinationEntitiesById: destinationDataById.entries,
           skipUpdates: skipContentUpdates,
@@ -1291,6 +1379,9 @@ function pushToSpace({
         const publishedEntries = await publishEntities2({
           entities: ctx.data.entries,
           sourceEntities: sourceData.entries,
+          client,
+          spaceId,
+          environmentId,
           requestQueue
         });
         ctx.data.publishedEntries = publishedEntries;
@@ -1303,6 +1394,9 @@ function pushToSpace({
         const archivedEntries = await archiveEntities2({
           entities: ctx.data.entries,
           sourceEntities: sourceData.entries,
+          client,
+          spaceId,
+          environmentId,
           requestQueue
         });
         ctx.data.archivedEntries = archivedEntries;
@@ -1316,7 +1410,7 @@ function pushToSpace({
           return;
         }
         const webhooks2 = await createEntities({
-          context: { target: ctx.space, type: "Webhook" },
+          context: { client, spaceId, environmentId, type: "Webhook" },
           entities: sourceData.webhooks,
           destinationEntitiesById: destinationDataById.webhooks,
           requestQueue
@@ -1327,19 +1421,24 @@ function pushToSpace({
     },
     {
       title: "Create ExO Folders",
-      task: (0, import_listr2.wrapTask)(async (ctx) => {
-        await importExoFolders({
-          plainClient,
-          organizationId: ctx.space.sys.organization.sys.id,
-          destinationSpaceId: spaceId,
-          sourceEntities: {
-            designTokens: sourceData.designTokens,
-            components: sourceData.components,
-            experienceTemplates: sourceData.experienceTemplates,
-            experienceFragments: sourceData.experienceFragments,
-            experiences: sourceData.experiences
-          }
-        });
+      task: (0, import_listr2.wrapTask)(async () => {
+        try {
+          const space = await client.space.get({ spaceId });
+          await importExoFolders({
+            client,
+            organizationId: space.sys.organization.sys.id,
+            destinationSpaceId: spaceId,
+            sourceEntities: {
+              designTokens: sourceData.designTokens,
+              components: sourceData.components,
+              experienceTemplates: sourceData.experienceTemplates,
+              experienceFragments: sourceData.experienceFragments,
+              experiences: sourceData.experiences
+            }
+          });
+        } catch (error) {
+          import_logging9.logEmitter.emit("warning", `Unable to create Experience Orchestration (ExO) folders, error: ${error}`);
+        }
       }),
       skip: () => !includeExperienceOrchestration
     },
@@ -1352,14 +1451,14 @@ function pushToSpace({
             let result;
             if (existing) {
               const payload = { ...omitSys(entity), sys: buildDataAssemblySys(entity, existing.sys.version) };
-              result = await withGraphQLSchemaBackoff(() => plainClient.dataAssembly.update(
+              result = await withGraphQLSchemaBackoff(() => client.dataAssembly.update(
                 { spaceId, environmentId, dataAssemblyId: entity.sys.id },
                 payload
               ));
               import_logging9.logEmitter.emit("info", `UPDATE DataAssembly ${entity.sys.id}`);
             } else {
               const payload = { ...omitSys(entity), sys: buildDataAssemblySys(entity, 0) };
-              result = await withGraphQLSchemaBackoff(() => plainClient.dataAssembly.update(
+              result = await withGraphQLSchemaBackoff(() => client.dataAssembly.update(
                 { spaceId, environmentId, dataAssemblyId: entity.sys.id },
                 payload
               ));
@@ -1381,7 +1480,7 @@ function pushToSpace({
       task: (0, import_listr2.wrapTask)(async (ctx) => {
         const entitiesToPublish = filterExoEntitiesToPublish(ctx.data.dataAssemblies, sourceData.dataAssemblies || []);
         const results = await Promise.all(entitiesToPublish.map(
-          (entity) => publishExoEntity("DataAssembly", entity, () => plainClient.dataAssembly.publish(
+          (entity) => publishExoEntity("DataAssembly", entity, () => client.dataAssembly.publish(
             { spaceId, environmentId, dataAssemblyId: entity.sys.id, version: entity.sys.version }
           ))
         ));
@@ -1397,12 +1496,12 @@ function pushToSpace({
             const existing = destinationDataById.designTokens?.get(entity.sys.id);
             if (existing) {
               const payload = { ...entity, sys: { id: entity.sys.id, type: "DesignToken", version: existing.sys.version } };
-              const result = await plainClient.designToken.upsert({ spaceId, environmentId, designTokenId: entity.sys.id }, payload);
+              const result = await client.designToken.upsert({ spaceId, environmentId, designTokenId: entity.sys.id }, payload);
               import_logging9.logEmitter.emit("info", `UPDATE DesignToken ${entity.sys.id}`);
               return result;
             } else {
               const payload = { ...omitSys(entity), sys: { id: entity.sys.id, type: "DesignToken" } };
-              const result = await plainClient.designToken.upsert({ spaceId, environmentId, designTokenId: entity.sys.id }, payload);
+              const result = await client.designToken.upsert({ spaceId, environmentId, designTokenId: entity.sys.id }, payload);
               import_logging9.logEmitter.emit("info", `CREATE DesignToken ${entity.sys.id}`);
               return result;
             }
@@ -1426,12 +1525,12 @@ function pushToSpace({
             const existing = destinationDataById.components?.get(entity.sys.id);
             if (existing) {
               const payload = { ...entity, sys: { id: entity.sys.id, type: "Component", version: existing.sys.version } };
-              const result = await plainClient.component.upsert({ spaceId, environmentId, componentId: entity.sys.id }, payload);
+              const result = await client.component.upsert({ spaceId, environmentId, componentId: entity.sys.id }, payload);
               import_logging9.logEmitter.emit("info", `UPDATE Component ${entity.sys.id}`);
               results.push(result);
             } else {
               const payload = { ...omitSys(entity), sys: { id: entity.sys.id, type: "Component" } };
-              const result = await plainClient.component.upsert({ spaceId, environmentId, componentId: entity.sys.id }, payload);
+              const result = await client.component.upsert({ spaceId, environmentId, componentId: entity.sys.id }, payload);
               import_logging9.logEmitter.emit("info", `CREATE Component ${entity.sys.id}`);
               results.push(result);
             }
@@ -1451,7 +1550,7 @@ function pushToSpace({
         const sorted = sortOrReport(() => sortComponents(entitiesToPublish));
         const results = [];
         for (const entity of sorted) {
-          const published = await publishExoEntity("Component", entity, () => plainClient.component.publish(
+          const published = await publishExoEntity("Component", entity, () => client.component.publish(
             { spaceId, environmentId, componentId: entity.sys.id, version: entity.sys.version }
           ));
           if (published) results.push(published);
@@ -1468,12 +1567,12 @@ function pushToSpace({
             const existing = destinationDataById.experienceTemplates?.get(entity.sys.id);
             if (existing) {
               const payload = { ...entity, sys: { id: entity.sys.id, type: "ExperienceTemplate", version: existing.sys.version } };
-              const result = await plainClient.experienceTemplate.upsert({ spaceId, environmentId, experienceTemplateId: entity.sys.id }, payload);
+              const result = await client.experienceTemplate.upsert({ spaceId, environmentId, experienceTemplateId: entity.sys.id }, payload);
               import_logging9.logEmitter.emit("info", `UPDATE ExperienceTemplate ${entity.sys.id}`);
               return result;
             } else {
               const payload = { ...omitSys(entity), sys: { id: entity.sys.id, type: "ExperienceTemplate" } };
-              const result = await plainClient.experienceTemplate.upsert({ spaceId, environmentId, experienceTemplateId: entity.sys.id }, payload);
+              const result = await client.experienceTemplate.upsert({ spaceId, environmentId, experienceTemplateId: entity.sys.id }, payload);
               import_logging9.logEmitter.emit("info", `CREATE ExperienceTemplate ${entity.sys.id}`);
               return result;
             }
@@ -1492,7 +1591,7 @@ function pushToSpace({
       task: (0, import_listr2.wrapTask)(async (ctx) => {
         const entitiesToPublish = filterExoEntitiesToPublish(ctx.data.experienceTemplates, sourceData.experienceTemplates || []);
         const results = await Promise.all(entitiesToPublish.map(
-          (entity) => publishExoEntity("ExperienceTemplate", entity, () => plainClient.experienceTemplate.publish(
+          (entity) => publishExoEntity("ExperienceTemplate", entity, () => client.experienceTemplate.publish(
             { spaceId, environmentId, experienceTemplateId: entity.sys.id, version: entity.sys.version }
           ))
         ));
@@ -1510,12 +1609,12 @@ function pushToSpace({
             const existing = destinationDataById.experienceFragments?.get(entity.sys.id);
             if (existing) {
               const payload = { ...entity, sys: { id: entity.sys.id, type: "ExperienceFragment", version: existing.sys.version } };
-              const result = await plainClient.experienceFragment.upsert({ spaceId, environmentId, experienceFragmentId: entity.sys.id }, payload);
+              const result = await client.experienceFragment.upsert({ spaceId, environmentId, experienceFragmentId: entity.sys.id }, payload);
               import_logging9.logEmitter.emit("info", `UPDATE ExperienceFragment ${entity.sys.id}`);
               results.push(result);
             } else {
               const payload = { ...omitSys(entity), component: entity.sys.component, sys: { id: entity.sys.id, type: "ExperienceFragment" } };
-              const result = await plainClient.experienceFragment.upsert({ spaceId, environmentId, experienceFragmentId: entity.sys.id }, payload);
+              const result = await client.experienceFragment.upsert({ spaceId, environmentId, experienceFragmentId: entity.sys.id }, payload);
               import_logging9.logEmitter.emit("info", `CREATE ExperienceFragment ${entity.sys.id}`);
               results.push(result);
             }
@@ -1535,7 +1634,7 @@ function pushToSpace({
         const sorted = sortOrReport(() => sortExperienceFragments(entitiesToPublish));
         const results = [];
         for (const entity of sorted) {
-          const published = await publishExoEntity("ExperienceFragment", entity, () => plainClient.experienceFragment.publish(
+          const published = await publishExoEntity("ExperienceFragment", entity, () => client.experienceFragment.publish(
             { spaceId, environmentId, experienceFragmentId: entity.sys.id, version: entity.sys.version }
           ));
           if (published) results.push(published);
@@ -1552,12 +1651,12 @@ function pushToSpace({
             const existing = destinationDataById.experiences?.get(entity.sys.id);
             if (existing) {
               const payload = { ...entity, sys: { id: entity.sys.id, type: "Experience", version: existing.sys.version } };
-              const result = await plainClient.experience.upsert({ spaceId, environmentId, experienceId: entity.sys.id }, payload);
+              const result = await client.experience.upsert({ spaceId, environmentId, experienceId: entity.sys.id }, payload);
               import_logging9.logEmitter.emit("info", `UPDATE Experience ${entity.sys.id}`);
               return result;
             } else {
               const payload = { ...omitSys(entity), experienceTemplate: entity.sys.experienceTemplate, sys: { id: entity.sys.id, type: "Experience" } };
-              const result = await plainClient.experience.upsert({ spaceId, environmentId, experienceId: entity.sys.id }, payload);
+              const result = await client.experience.upsert({ spaceId, environmentId, experienceId: entity.sys.id }, payload);
               import_logging9.logEmitter.emit("info", `CREATE Experience ${entity.sys.id}`);
               return result;
             }
@@ -1576,7 +1675,7 @@ function pushToSpace({
       task: (0, import_listr2.wrapTask)(async (ctx) => {
         const entitiesToPublish = filterExoEntitiesToPublish(ctx.data.experiences, sourceData.experiences || []);
         const results = await Promise.all(entitiesToPublish.map(
-          (entity) => publishExoEntity("Experience", entity, () => plainClient.experience.publish(
+          (entity) => publishExoEntity("Experience", entity, () => client.experience.publish(
             { spaceId, environmentId, experienceId: entity.sys.id, version: entity.sys.version }
           ))
         ));
@@ -1592,7 +1691,7 @@ function pushToSpace({
       task: (0, import_listr2.wrapTask)(async (ctx) => {
         const entitiesToUnpublish = filterExoEntitiesToUnpublish(ctx.data.experiences, sourceData.experiences || []);
         await Promise.all(entitiesToUnpublish.map(
-          (entity) => unpublishExoEntity("Experience", entity, () => plainClient.experience.unpublish(
+          (entity) => unpublishExoEntity("Experience", entity, () => client.experience.unpublish(
             { spaceId, environmentId, experienceId: entity.sys.id, version: entity.sys.version }
           ))
         ));
@@ -1605,7 +1704,7 @@ function pushToSpace({
         const entitiesToUnpublish = filterExoEntitiesToUnpublish(ctx.data.experienceFragments, sourceData.experienceFragments || []);
         const sorted = sortExperienceFragments(entitiesToUnpublish).reverse();
         for (const entity of sorted) {
-          await unpublishExoEntity("ExperienceFragment", entity, () => plainClient.experienceFragment.unpublish(
+          await unpublishExoEntity("ExperienceFragment", entity, () => client.experienceFragment.unpublish(
             { spaceId, environmentId, experienceFragmentId: entity.sys.id, version: entity.sys.version }
           ));
         }
@@ -1617,7 +1716,7 @@ function pushToSpace({
       task: (0, import_listr2.wrapTask)(async (ctx) => {
         const entitiesToUnpublish = filterExoEntitiesToUnpublish(ctx.data.experienceTemplates, sourceData.experienceTemplates || []);
         await Promise.all(entitiesToUnpublish.map(
-          (entity) => unpublishExoEntity("ExperienceTemplate", entity, () => plainClient.experienceTemplate.unpublish(
+          (entity) => unpublishExoEntity("ExperienceTemplate", entity, () => client.experienceTemplate.unpublish(
             { spaceId, environmentId, experienceTemplateId: entity.sys.id, version: entity.sys.version }
           ))
         ));
@@ -1630,7 +1729,7 @@ function pushToSpace({
         const entitiesToUnpublish = filterExoEntitiesToUnpublish(ctx.data.components, sourceData.components || []);
         const sorted = sortComponents(entitiesToUnpublish).reverse();
         for (const entity of sorted) {
-          await unpublishExoEntity("Component", entity, () => plainClient.component.unpublish(
+          await unpublishExoEntity("Component", entity, () => client.component.unpublish(
             { spaceId, environmentId, componentId: entity.sys.id, version: entity.sys.version }
           ));
         }
@@ -1642,7 +1741,7 @@ function pushToSpace({
       task: (0, import_listr2.wrapTask)(async (ctx) => {
         const entitiesToUnpublish = filterExoEntitiesToUnpublish(ctx.data.dataAssemblies, sourceData.dataAssemblies || []);
         await Promise.all(entitiesToUnpublish.map(
-          (entity) => unpublishExoEntity("DataAssembly", entity, () => plainClient.dataAssembly.unpublish(
+          (entity) => unpublishExoEntity("DataAssembly", entity, () => client.dataAssembly.unpublish(
             { spaceId, environmentId, dataAssemblyId: entity.sys.id, version: entity.sys.version }
           ))
         ));
@@ -1655,15 +1754,15 @@ function omitSys(entity) {
   const { sys: _sys, ...rest } = entity;
   return rest;
 }
-function archiveEntities2({ entities, sourceEntities, requestQueue }) {
+function archiveEntities2({ entities, sourceEntities, client, spaceId, environmentId, 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 archiveEntities({ entities: entitiesToArchive, requestQueue });
+  return archiveEntities({ entities: entitiesToArchive, client, spaceId, environmentId, requestQueue });
 }
-function publishEntities2({ entities, sourceEntities, requestQueue }) {
+function publishEntities2({ entities, sourceEntities, client, spaceId, environmentId, requestQueue }) {
   const entityIdsToPublish = sourceEntities.filter(({ original }) => original.sys.publishedVersion).map(({ original }) => original.sys.id);
   const entitiesToPublish = entities.filter((entity) => entityIdsToPublish.indexOf(entity.sys.id) !== -1);
-  return publishEntities({ entities: entitiesToPublish, requestQueue });
+  return publishEntities({ entities: entitiesToPublish, client, spaceId, environmentId, requestQueue });
 }
 
 // lib/transform/transform-space.ts
@@ -2189,7 +2288,8 @@ async function parseOptions(params) {
     rawProxy: false,
     uploadAssets: false,
     rateLimit: 7,
-    includeExperienceOrchestration: true
+    includeExperienceOrchestration: true,
+    host: "api.contentful.com"
   };
   const configFile = params.config ? require((0, import_path2.resolve)(process.cwd(), params.config)) : {};
   const options = {
@@ -2301,8 +2401,7 @@ async function runContentfulImport(params) {
     {
       title: "Initialize client",
       task: (0, import_listr4.wrapTask)(async (ctx) => {
-        ctx.client = initClient({ ...options, content: void 0 });
-        ctx.plainClient = initPlainClient({ ...options, content: void 0 });
+        ctx.client = initClient({ ...options });
       })
     },
     {
@@ -2310,7 +2409,6 @@ async function runContentfulImport(params) {
       task: (0, import_listr4.wrapTask)(async (ctx) => {
         const destinationData = await getDestinationData({
           client: ctx.client,
-          plainClient: ctx.plainClient,
           spaceId: options.spaceId,
           environmentId: options.environmentId,
           sourceData: options.content,
@@ -2338,7 +2436,6 @@ async function runContentfulImport(params) {
           sourceData: ctx.sourceData,
           destinationData: ctx.destinationData,
           client: ctx.client,
-          plainClient: ctx.plainClient,
           spaceId: options.spaceId,
           includeExperienceOrchestration: options.includeExperienceOrchestration,
           environmentId: options.environmentId,