contentful-import 10.1.1 → 10.2.0

package/dist/index.mjs

@@ -31,13 +31,12 @@ function initClient(opts) {
     ...defaultOpts,
     ...opts
   };
-  return createClient(config, { type: "legacy" });
-}
-function initPlainClient(opts) {
-  return createClient({
-    accessToken: opts.managementToken,
-    host: opts.host,
-    logHandler
+  return createClient(config, {
+    type: "plain",
+    defaults: {
+      spaceId: opts.spaceId,
+      environmentId: opts.environmentId
+    }
   });
 }
 
@@ -92,14 +91,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;
@@ -111,13 +110,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" },
@@ -126,47 +118,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;
-      logEmitter3.emit("info", `Fetched ${totalFetched} of ${response.total} ${entityTypeName}`);
+      logEmitter3.emit("info", `Fetched ${totalFetched} of ${response.total} ${name}`);
       return response.items;
     });
   });
   const responses = await Promise2.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;
-    logEmitter3.emit("info", `Fetched ${totalFetched} of ${response.total} ${entityTypeName}`);
+    logEmitter3.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;
-      logEmitter3.emit("info", `Fetched ${totalFetched} of ${response.total} ${entityTypeName}`);
+      logEmitter3.emit("info", `Fetched ${totalFetched} of ${response.total} ${name}`);
       return response.items;
     });
   });
@@ -203,14 +212,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 } }
@@ -239,7 +248,6 @@ async function cursorPaginatedQueryOrWarn(params) {
 }
 async function getDestinationData({
   client,
-  plainClient,
   spaceId,
   environmentId,
   sourceData,
@@ -249,8 +257,6 @@ async function getDestinationData({
   includeExperienceOrchestration,
   requestQueue
 }) {
-  const space = await client.getSpace(spaceId);
-  const environment = await space.getEnvironment(environmentId);
   const result = {
     contentTypes: [],
     tags: [],
@@ -273,7 +279,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
@@ -283,7 +291,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
         });
@@ -291,7 +301,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;
   }
@@ -302,7 +312,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
@@ -310,13 +322,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);
@@ -324,29 +338,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) {
       logEmitter3.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 Promise2.props(result);
@@ -393,9 +407,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;
@@ -418,6 +432,9 @@ async function lastResult(promises) {
 }
 async function processAssets({
   assets: assets2,
+  client,
+  spaceId,
+  environmentId,
   timeout,
   retryLimit,
   requestQueue
@@ -435,7 +452,7 @@ async function processAssets({
       latestAssetVersion = await lastResult(
         locales2.map((locale) => {
           return requestQueue.add(
-            () => processAssetForLocale(locale, asset, processingOptions)
+            () => processAssetForLocale(client, spaceId, environmentId, locale, asset, processingOptions)
           );
         })
       );
@@ -471,7 +488,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) {
@@ -489,7 +506,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);
@@ -505,11 +522,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,
@@ -523,16 +540,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 = 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) {
@@ -542,30 +559,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);
-  assign(destinationEntity, plainData);
-  return destinationEntity.update();
+  const updated = 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 = 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 (get(err, "error.sys.id") === "ValidationFailed") {
@@ -598,51 +663,61 @@ function creationSuccessNotifier(method, createdEntity) {
   return createdEntity;
 }
 function getPlainData(entity) {
-  const data = entity.toPlainObject ? entity.toPlainObject() : entity;
-  return omit(data, "sys");
+  return omit(entity, "sys");
 }
 
 // lib/tasks/push-to-space/publishing.ts
 import getEntityName3 from "contentful-batch-libs/dist/get-entity-name";
 import { logEmitter as logEmitter6 } from "contentful-batch-libs/dist/logging";
-async function publishEntities({ entities, requestQueue }) {
-  const entitiesToPublish = entities.filter((entity2) => {
-    if (!entity2 || !entity2.publish) {
-      logEmitter6.emit("warning", `Unable to publish ${getEntityName3(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) {
     logEmitter6.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";
   logEmitter6.emit("info", `Publishing ${entities.length} ${type}s`);
-  const result = await runQueue(entitiesToPublish, [], requestQueue);
+  const result = await runQueue(entities, [], client, spaceId, environmentId, requestQueue);
   logEmitter6.emit("info", `Successfully published ${result.length} ${type}s`);
   return result;
 }
-async function archiveEntities({ entities, requestQueue }) {
-  const entitiesToArchive = entities.filter((entity2) => {
-    if (!entity2 || !entity2.archive) {
-      logEmitter6.emit("warning", `Unable to archive ${getEntityName3(entity2)}`);
-      return false;
-    }
-    return true;
-  });
-  if (entitiesToArchive.length === 0) {
+async function archiveEntities({ entities, client, spaceId, environmentId, requestQueue }) {
+  if (entities.length === 0) {
     logEmitter6.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";
   logEmitter6.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) {
@@ -658,12 +733,12 @@ async function archiveEntities({ entities, requestQueue }) {
   logEmitter6.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) {
     logEmitter6.emit("info", `Publishing ${entity.sys.type} ${getEntityName3(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) {
@@ -683,7 +758,7 @@ async function runQueue(queue, result = [], requestQueue) {
       const unpublishedEntityNames = unpublishedEntities.map(getEntityName3).join(", ");
       logEmitter6.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;
@@ -851,8 +926,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" }
   });
@@ -882,18 +957,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") {
         logEmitter8.emit("warning", `Could not fetch destination child concept ${destConceptId}: ${err?.message ?? err}`);
@@ -901,8 +976,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] } }
         );
         logEmitter8.emit("info", `Created child folder concept ${destConceptId}`);
@@ -911,16 +987,13 @@ async function createOrPatchChildConcepts(plainClient, organizationId, destinati
       }
     } else {
       const patches = [];
-      if (existing.purpose !== "internal") {
-        patches.push({ op: "add", path: "/purpose", value: "internal" });
-      }
       const spaces = existing.metadata?.spaces ?? [];
       if (!spaces.some((s) => s.sys.id === destinationSpaceId)) {
         patches.push({ op: "add", path: "/metadata/spaces/-", value: spaceLink });
       }
       if (patches.length > 0) {
         try {
-          await plainClient.concept.patch(
+          await client.concept.patch(
             { organizationId, conceptId: destConceptId, version: existing.sys.version },
             patches
           );
@@ -932,14 +1005,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 } } }]
       );
@@ -961,7 +1034,7 @@ function rewriteEntityFolderConcepts(entities, childConceptMap) {
   }
 }
 async function importExoFolders({
-  plainClient,
+  client,
   organizationId,
   destinationSpaceId,
   sourceEntities
@@ -971,7 +1044,7 @@ async function importExoFolders({
     logEmitter8.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) {
     logEmitter8.emit("warn", "One or more Experience Orchestration folder group concept schemes are missing in the destination organization. Please create them before importing.");
     return;
@@ -979,8 +1052,8 @@ async function importExoFolders({
   const childConceptMap = deriveChildConceptMap(sourceEntities, destinationSpaceId);
   if (childConceptMap.size === 0) return;
   logEmitter8.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 ?? [],
@@ -1022,7 +1095,6 @@ function pushToSpace({
   sourceData,
   destinationData = {},
   client,
-  plainClient,
   spaceId,
   environmentId,
   includeExperienceOrchestration,
@@ -1059,15 +1131,6 @@ function pushToSpace({
     destinationDataById[entityType] = entitiesById;
   }
   return new Listr([
-    {
-      title: "Connecting to space",
-      task: 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: wrapTask(async (ctx) => {
@@ -1075,7 +1138,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
@@ -1091,7 +1154,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,
@@ -1107,6 +1170,9 @@ function pushToSpace({
         const publishedContentTypes = await publishEntities2({
           entities: ctx.data.contentTypes,
           sourceEntities: sourceData.contentTypes,
+          client,
+          spaceId,
+          environmentId,
           requestQueue
         });
         ctx.data.contentTypes = publishedContentTypes;
@@ -1118,7 +1184,7 @@ function pushToSpace({
       task: 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,
@@ -1145,14 +1211,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 })
+            );
             logEmitter9.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;
@@ -1176,10 +1252,10 @@ function pushToSpace({
               try {
                 logEmitter9.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: {
@@ -1207,7 +1283,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,
@@ -1215,6 +1291,9 @@ function pushToSpace({
         });
         const processedAssets = await processAssets({
           assets: assetsToProcess,
+          client,
+          spaceId,
+          environmentId,
           timeout,
           retryLimit,
           requestQueue
@@ -1229,6 +1308,9 @@ function pushToSpace({
         const publishedAssets = await publishEntities2({
           entities: ctx.data.assets,
           sourceEntities: sourceData.assets,
+          client,
+          spaceId,
+          environmentId,
           requestQueue
         });
         ctx.data.publishedAssets = publishedAssets;
@@ -1241,6 +1323,9 @@ function pushToSpace({
         const archivedAssets = await archiveEntities2({
           entities: ctx.data.assets,
           sourceEntities: sourceData.assets,
+          client,
+          spaceId,
+          environmentId,
           requestQueue
         });
         ctx.data.archivedAssets = archivedAssets;
@@ -1251,7 +1336,7 @@ function pushToSpace({
       title: "Importing Content Entries",
       task: 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,
@@ -1267,6 +1352,9 @@ function pushToSpace({
         const publishedEntries = await publishEntities2({
           entities: ctx.data.entries,
           sourceEntities: sourceData.entries,
+          client,
+          spaceId,
+          environmentId,
           requestQueue
         });
         ctx.data.publishedEntries = publishedEntries;
@@ -1279,6 +1367,9 @@ function pushToSpace({
         const archivedEntries = await archiveEntities2({
           entities: ctx.data.entries,
           sourceEntities: sourceData.entries,
+          client,
+          spaceId,
+          environmentId,
           requestQueue
         });
         ctx.data.archivedEntries = archivedEntries;
@@ -1292,7 +1383,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
@@ -1303,19 +1394,24 @@ function pushToSpace({
     },
     {
       title: "Create ExO Folders",
-      task: 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: 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) {
+          logEmitter9.emit("warning", `Unable to create Experience Orchestration (ExO) folders, error: ${error}`);
+        }
       }),
       skip: () => !includeExperienceOrchestration
     },
@@ -1328,14 +1424,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
               ));
               logEmitter9.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
               ));
@@ -1357,7 +1453,7 @@ function pushToSpace({
       task: 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 }
           ))
         ));
@@ -1373,12 +1469,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);
               logEmitter9.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);
               logEmitter9.emit("info", `CREATE DesignToken ${entity.sys.id}`);
               return result;
             }
@@ -1402,12 +1498,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);
               logEmitter9.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);
               logEmitter9.emit("info", `CREATE Component ${entity.sys.id}`);
               results.push(result);
             }
@@ -1427,7 +1523,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);
@@ -1444,12 +1540,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);
               logEmitter9.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);
               logEmitter9.emit("info", `CREATE ExperienceTemplate ${entity.sys.id}`);
               return result;
             }
@@ -1468,7 +1564,7 @@ function pushToSpace({
       task: 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 }
           ))
         ));
@@ -1486,12 +1582,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);
               logEmitter9.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);
               logEmitter9.emit("info", `CREATE ExperienceFragment ${entity.sys.id}`);
               results.push(result);
             }
@@ -1511,7 +1607,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);
@@ -1528,12 +1624,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);
               logEmitter9.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);
               logEmitter9.emit("info", `CREATE Experience ${entity.sys.id}`);
               return result;
             }
@@ -1552,7 +1648,7 @@ function pushToSpace({
       task: 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 }
           ))
         ));
@@ -1568,7 +1664,7 @@ function pushToSpace({
       task: 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 }
           ))
         ));
@@ -1581,7 +1677,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 }
           ));
         }
@@ -1593,7 +1689,7 @@ function pushToSpace({
       task: 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 }
           ))
         ));
@@ -1606,7 +1702,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 }
           ));
         }
@@ -1618,7 +1714,7 @@ function pushToSpace({
       task: 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 }
           ))
         ));
@@ -1631,15 +1727,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
@@ -2162,7 +2258,8 @@ async function parseOptions(params) {
     rawProxy: false,
     uploadAssets: false,
     rateLimit: 7,
-    includeExperienceOrchestration: true
+    includeExperienceOrchestration: true,
+    host: "api.contentful.com"
   };
   const configFile = params.config ? __require(resolve(process.cwd(), params.config)) : {};
   const options = {
@@ -2274,8 +2371,7 @@ async function runContentfulImport(params) {
     {
       title: "Initialize client",
       task: wrapTask2(async (ctx) => {
-        ctx.client = initClient({ ...options, content: void 0 });
-        ctx.plainClient = initPlainClient({ ...options, content: void 0 });
+        ctx.client = initClient({ ...options });
       })
     },
     {
@@ -2283,7 +2379,6 @@ async function runContentfulImport(params) {
       task: wrapTask2(async (ctx) => {
         const destinationData = await getDestinationData({
           client: ctx.client,
-          plainClient: ctx.plainClient,
           spaceId: options.spaceId,
           environmentId: options.environmentId,
           sourceData: options.content,
@@ -2311,7 +2406,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,