contentful-export 8.2.2 → 8.4.0

package/README.md

@@ -389,6 +389,23 @@ If the source space has no ExO entities, or lacks the `exoM1` entitlement, each
 
 Requires the `exoM1` entitlement on the source space's organization. [contentful-cli](https://github.com/contentful/contentful-cli)'s `space export` command doesn't expose this option at all yet, so ExO export isn't reachable through that separate CLI regardless of default.
 
+### Optimization Variants
+
+Experiences and Experience Fragments each support **Optimization Variants** — alternate versions used for personalization. Variants are a separate opt-in on top of `includeExperienceOrchestration`, defaulting to `false`:
+
+```javascript
+const options = {
+  spaceId: '<space_id>',
+  managementToken: '<content_management_api_key>',
+  includeExperienceOrchestration: true,
+  includeExoVariants: true
+}
+
+await contentfulExport(options)
+```
+
+Unlike the six entity types above, variants are **not** exported as a seventh top-level array — they're nested onto their parent as `experience.optimizationVariants` / `experienceFragment.optimizationVariants`, because a variant has no globally-unique `sys.id` of its own (the API's variant response reuses the parent's `sys.id`; the variant is identified by `sys.variant`/`sys.variantType`/`sys.variantDimension` instead). When `includeExoVariants` is omitted or `false`, the `optimizationVariants` field is absent entirely — not an empty array — so default export output is unaffected. See [`docs/exo-export.md`](./docs/exo-export.md#optimization-variants) for the full shape, the ADR behind the nested-storage decision, and the corresponding `contentful-import` behavior.
+
 ### Round-tripping into `contentful-import`
 
 The ExO entities exported here are designed to be fed directly into [`contentful-import`](https://github.com/contentful/contentful-import), which preserves source IDs, applies dependency ordering (a topological sort for Components and Experience Fragments, since either can reference others of the same type), and upgrades entities from older, pre-rename export files automatically. See `contentful-import`'s README "Experience Orchestration (ExO) entities" section for the import-side details.

package/dist/index.js

@@ -18,9 +18,8 @@ var _formatDistance = require("date-fns/formatDistance");
 var _contentfulBatchLibs = require("contentful-batch-libs");
 var _downloadAssets = _interopRequireDefault(require("./tasks/download-assets"));
 var _getSpaceData = _interopRequireDefault(require("./tasks/get-space-data"));
-var _initClient = _interopRequireWildcard(require("./tasks/init-client"));
+var _initClient = _interopRequireDefault(require("./tasks/init-client"));
 var _parseOptions = _interopRequireDefault(require("./parseOptions"));
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const accessP = _bluebird.default.promisify(_fs.access);
 const tableOptions = {
@@ -54,7 +53,6 @@ function runContentfulExport(params) {
       try {
         // CMA client
         ctx.client = (0, _initClient.default)(options);
-        ctx.plainClient = (0, _initClient.initPlainClient)(options);
         if (options.deliveryToken && !options.includeDrafts) {
           // CDA client for fetching only public entries
           ctx.cdaClient = (0, _initClient.default)(options, true);
@@ -69,7 +67,6 @@ function runContentfulExport(params) {
     task: ctx => {
       return (0, _getSpaceData.default)({
         client: ctx.client,
-        plainClient: ctx.plainClient,
         cdaClient: ctx.cdaClient,
         spaceId: options.spaceId,
         environmentId: options.environmentId,
@@ -85,6 +82,7 @@ function runContentfulExport(params) {
         skipTags: options.skipTags,
         stripTags: options.stripTags,
         includeExperienceOrchestration: options.includeExperienceOrchestration,
+        includeExoVariants: options.includeExoVariants,
         listrOptions,
         queryEntries: options.queryEntries,
         queryAssets: options.queryAssets
@@ -134,6 +132,7 @@ function runContentfulExport(params) {
   }).then(ctx => {
     const resultTypes = Object.keys(ctx.data);
     if (resultTypes.length) {
+      var _ctx$data$experiences, _ctx$optimizationVari, _ctx$data$experienceF, _ctx$optimizationVari2;
       const resultTable = new _cliTable.default(tableOptions);
       resultTable.push([{
         colSpan: 2,
@@ -142,6 +141,33 @@ function runContentfulExport(params) {
       resultTypes.forEach(type => {
         resultTable.push([(0, _lodash.default)(type), ctx.data[type].length]);
       });
+
+      // Optimization Variants are nested onto their parent Experience/Experience
+      // Fragment rather than exported as their own top-level field, so their count
+      // isn't free from resultTypes above and is computed here instead. A per-parent
+      // fetch failure falls back to an empty optimizationVariants array, which is
+      // indistinguishable from a parent that genuinely has none -- so failures are
+      // surfaced as their own row rather than folded silently into the count.
+      if ((_ctx$data$experiences = ctx.data.experiences) !== null && _ctx$data$experiences !== void 0 && _ctx$data$experiences.some(experience => experience.optimizationVariants)) {
+        const count = ctx.data.experiences.reduce((sum, experience) => {
+          var _experience$optimizat, _experience$optimizat2;
+          return sum + ((_experience$optimizat = (_experience$optimizat2 = experience.optimizationVariants) === null || _experience$optimizat2 === void 0 ? void 0 : _experience$optimizat2.length) !== null && _experience$optimizat !== void 0 ? _experience$optimizat : 0);
+        }, 0);
+        resultTable.push(['Experience Optimization Variants', count]);
+      }
+      if ((_ctx$optimizationVari = ctx.optimizationVariantFailures) !== null && _ctx$optimizationVari !== void 0 && _ctx$optimizationVari.experiences) {
+        resultTable.push(['Experience Optimization Variant Fetch Failures', ctx.optimizationVariantFailures.experiences]);
+      }
+      if ((_ctx$data$experienceF = ctx.data.experienceFragments) !== null && _ctx$data$experienceF !== void 0 && _ctx$data$experienceF.some(experienceFragment => experienceFragment.optimizationVariants)) {
+        const count = ctx.data.experienceFragments.reduce((sum, experienceFragment) => {
+          var _experienceFragment$o, _experienceFragment$o2;
+          return sum + ((_experienceFragment$o = (_experienceFragment$o2 = experienceFragment.optimizationVariants) === null || _experienceFragment$o2 === void 0 ? void 0 : _experienceFragment$o2.length) !== null && _experienceFragment$o !== void 0 ? _experienceFragment$o : 0);
+        }, 0);
+        resultTable.push(['Experience Fragment Optimization Variants', count]);
+      }
+      if ((_ctx$optimizationVari2 = ctx.optimizationVariantFailures) !== null && _ctx$optimizationVari2 !== void 0 && _ctx$optimizationVari2.experienceFragments) {
+        resultTable.push(['Experience Fragment Optimization Variant Fetch Failures', ctx.optimizationVariantFailures.experienceFragments]);
+      }
       console.log(resultTable.toString());
     } else {
       console.log('No data was exported');

package/dist/parseOptions.js

@@ -32,6 +32,7 @@ function parseOptions(params) {
     stripTags: false,
     maxAllowedLimit: 1000,
     includeExperienceOrchestration: true,
+    includeExoVariants: false,
     saveFile: true,
     useVerboseRenderer: false,
     rawProxy: false

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

@@ -9,6 +9,11 @@ var _contentfulBatchLibs = require("contentful-batch-libs");
 var _listr = _interopRequireDefault(require("listr"));
 var _listrVerboseRenderer = _interopRequireDefault(require("listr-verbose-renderer"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 const MAX_ALLOWED_LIMIT = 1000;
 let pageLimit = MAX_ALLOWED_LIMIT;
 
@@ -18,7 +23,6 @@ let pageLimit = MAX_ALLOWED_LIMIT;
  */
 function getFullSourceSpace({
   client,
-  plainClient,
   cdaClient,
   spaceId,
   environmentId = 'master',
@@ -34,6 +38,7 @@ function getFullSourceSpace({
   includeArchived,
   maxAllowedLimit,
   includeExperienceOrchestration,
+  includeExoVariants,
   listrOptions,
   queryEntries,
   queryAssets
@@ -43,22 +48,32 @@ function getFullSourceSpace({
     renderer: _listrVerboseRenderer.default
   };
   return new _listr.default([{
-    title: 'Connecting to space',
-    task: (0, _contentfulBatchLibs.wrapTask)(ctx => {
-      return client.getSpace(spaceId).then(space => {
-        ctx.space = space;
-        return space.getEnvironment(environmentId);
-      }).then(environment => {
-        ctx.environment = environment;
-      });
+    title: 'Connecting to space/environment',
+    task: (0, _contentfulBatchLibs.wrapTask)(async () => {
+      try {
+        await client.space.get({
+          spaceId
+        });
+      } catch (err) {
+        throw new Error(`Unable to retrieve space ${spaceId}, please ensure the space exists and the token is valid. (${err.message})`);
+      }
+      try {
+        await client.environment.get({
+          spaceId,
+          environmentId
+        });
+      } catch (err) {
+        throw new Error(`Unable to retrieve environment ${environmentId}, please ensure the environment exists and the token is valid. (${err.message})`);
+      }
     })
   }, {
     title: 'Fetching content types data',
     task: (0, _contentfulBatchLibs.wrapTask)(ctx => {
-      return pagedGet({
-        source: ctx.environment,
-        method: 'getContentTypes'
-      }).then(extractItems).then(items => {
+      return pagedGet(query => client.contentType.getMany({
+        spaceId,
+        environmentId,
+        query
+      })).then(extractItems).then(items => {
         ctx.data.contentTypes = items;
       });
     }),
@@ -66,10 +81,11 @@ function getFullSourceSpace({
   }, {
     title: 'Fetching tags data',
     task: (0, _contentfulBatchLibs.wrapTask)(ctx => {
-      return pagedGet({
-        source: ctx.environment,
-        method: 'getTags'
-      }).then(extractItems).then(items => {
+      return pagedGet(query => client.tag.getMany({
+        spaceId,
+        environmentId,
+        query
+      })).then(extractItems).then(items => {
         ctx.data.tags = items;
       }).catch(err => {
         _contentfulBatchLibs.logEmitter.emit('error', new Error(`Fetching tags failed: ${err.message}`, {
@@ -82,7 +98,7 @@ function getFullSourceSpace({
   }, {
     title: 'Fetching editor interfaces data',
     task: (0, _contentfulBatchLibs.wrapTask)(ctx => {
-      return getEditorInterfaces(ctx.data.contentTypes).then(editorInterfaces => {
+      return getEditorInterfaces(client, spaceId, environmentId, ctx.data.contentTypes).then(editorInterfaces => {
         ctx.data.editorInterfaces = editorInterfaces.filter(editorInterface => {
           return editorInterface !== null;
         });
@@ -92,17 +108,17 @@ function getFullSourceSpace({
   }, {
     title: 'Fetching content entries data',
     task: (0, _contentfulBatchLibs.wrapTask)(ctx => {
-      const source = (cdaClient === null || cdaClient === void 0 ? void 0 : cdaClient.withAllLocales) || ctx.environment;
       if (cdaClient) {
         // let's not fetch children when using Content Delivery API
         queryEntries = queryEntries || {};
         queryEntries.include = 0;
       }
-      return pagedGet({
-        source,
-        method: 'getEntries',
-        query: queryEntries
-      }).then(extractItems).then(items => filterDrafts(items, includeDrafts, cdaClient)).then(items => filterArchived(items, includeArchived)).then(items => removeTags(items, stripTags)).then(items => {
+      const fetchFn = cdaClient ? query => cdaClient.withAllLocales.getEntries(query) : query => client.entry.getMany({
+        spaceId,
+        environmentId,
+        query
+      });
+      return pagedGet(fetchFn, queryEntries).then(extractItems).then(items => filterDrafts(items, includeDrafts, cdaClient)).then(items => filterArchived(items, includeArchived)).then(items => removeTags(items, stripTags)).then(items => {
         ctx.data.entries = items;
       });
     }),
@@ -110,13 +126,13 @@ function getFullSourceSpace({
   }, {
     title: 'Fetching assets data',
     task: (0, _contentfulBatchLibs.wrapTask)(ctx => {
-      const source = (cdaClient === null || cdaClient === void 0 ? void 0 : cdaClient.withAllLocales) || ctx.environment;
       queryAssets = queryAssets || {};
-      return pagedGet({
-        source,
-        method: 'getAssets',
-        query: queryAssets
-      }).then(extractItems).then(items => filterDrafts(items, includeDrafts, cdaClient)).then(items => filterArchived(items, includeArchived)).then(items => removeTags(items, stripTags)).then(items => {
+      const fetchFn = cdaClient ? query => cdaClient.withAllLocales.getAssets(query) : query => client.asset.getMany({
+        spaceId,
+        environmentId,
+        query
+      });
+      return pagedGet(fetchFn, queryAssets).then(extractItems).then(items => filterDrafts(items, includeDrafts, cdaClient)).then(items => filterArchived(items, includeArchived)).then(items => removeTags(items, stripTags)).then(items => {
         ctx.data.assets = items;
       });
     }),
@@ -124,33 +140,34 @@ function getFullSourceSpace({
   }, {
     title: 'Fetching locales data',
     task: (0, _contentfulBatchLibs.wrapTask)(ctx => {
-      return pagedGet({
-        source: ctx.environment,
-        method: 'getLocales'
-      }).then(extractItems).then(items => {
+      return pagedGet(query => client.locale.getMany({
+        spaceId,
+        environmentId,
+        query
+      })).then(extractItems).then(items => {
         ctx.data.locales = items;
       });
     }),
     skip: () => skipContentModel
   }, {
     title: 'Fetching webhooks data',
-    task: (0, _contentfulBatchLibs.wrapTask)(ctx => {
-      return pagedGet({
-        source: ctx.space,
-        method: 'getWebhooks'
-      }).then(extractItems).then(items => {
-        ctx.data.webhooks = items;
+    task: (0, _contentfulBatchLibs.wrapTask)(async ctx => {
+      const webhooksResponse = await client.webhook.getMany({
+        query: {
+          // webhooks are capped to 100 per space
+          limit: 100
+        },
+        spaceId
       });
+      ctx.data.webhooks = webhooksResponse.items;
     }),
     skip: () => skipWebhooks || environmentId !== 'master' && 'Webhooks can only be exported from master environment'
   }, {
     title: 'Fetching roles data',
-    task: (0, _contentfulBatchLibs.wrapTask)(ctx => {
-      return pagedGet({
-        source: ctx.space,
-        method: 'getRoles'
-      }).then(extractItems).then(items => {
-        ctx.data.roles = items;
+    task: (0, _contentfulBatchLibs.wrapTask)(async ctx => {
+      ctx.data.roles = await pagedRolesGet({
+        client,
+        spaceId
       });
     }),
     skip: () => skipRoles || environmentId !== 'master' && 'Roles can only be exported from master environment'
@@ -158,12 +175,11 @@ function getFullSourceSpace({
     title: 'Fetching Design Tokens data',
     task: (0, _contentfulBatchLibs.wrapTask)(async ctx => {
       try {
-        ctx.data.designTokens = await cursorPagedGet({
-          client: plainClient,
+        ctx.data.designTokens = await cursorPagedGet(query => client.designToken.getMany({
           spaceId,
           environmentId,
-          method: 'designToken.getMany'
-        });
+          query
+        }), 'designToken');
       } catch (err) {
         _contentfulBatchLibs.logEmitter.emit('warning', `Skipping Design Tokens export: ${err.message}`);
         ctx.data.designTokens = [];
@@ -174,12 +190,11 @@ function getFullSourceSpace({
     title: 'Fetching Components data',
     task: (0, _contentfulBatchLibs.wrapTask)(async ctx => {
       try {
-        ctx.data.components = await cursorPagedGet({
-          client: plainClient,
+        ctx.data.components = await cursorPagedGet(query => client.component.getMany({
           spaceId,
           environmentId,
-          method: 'component.getMany'
-        });
+          query
+        }), 'component');
       } catch (err) {
         _contentfulBatchLibs.logEmitter.emit('warning', `Skipping Components export: ${err.message}`);
         ctx.data.components = [];
@@ -190,12 +205,11 @@ function getFullSourceSpace({
     title: 'Fetching Experience Templates data',
     task: (0, _contentfulBatchLibs.wrapTask)(async ctx => {
       try {
-        ctx.data.experienceTemplates = await cursorPagedGet({
-          client: plainClient,
+        ctx.data.experienceTemplates = await cursorPagedGet(query => client.experienceTemplate.getMany({
           spaceId,
           environmentId,
-          method: 'experienceTemplate.getMany'
-        });
+          query
+        }), 'experienceTemplate');
       } catch (err) {
         _contentfulBatchLibs.logEmitter.emit('warning', `Skipping Experience Templates export: ${err.message}`);
         ctx.data.experienceTemplates = [];
@@ -206,12 +220,11 @@ function getFullSourceSpace({
     title: 'Fetching Data Assemblies data',
     task: (0, _contentfulBatchLibs.wrapTask)(async ctx => {
       try {
-        ctx.data.dataAssemblies = await cursorPagedGet({
-          client: plainClient,
+        ctx.data.dataAssemblies = await cursorPagedGet(query => client.dataAssembly.getMany({
           spaceId,
           environmentId,
-          method: 'dataAssembly.getMany'
-        });
+          query
+        }), 'dataAssembly');
       } catch (err) {
         _contentfulBatchLibs.logEmitter.emit('warning', `Skipping Data Assemblies export: ${err.message}`);
         ctx.data.dataAssemblies = [];
@@ -222,12 +235,11 @@ function getFullSourceSpace({
     title: 'Fetching Experience Fragments data',
     task: (0, _contentfulBatchLibs.wrapTask)(async ctx => {
       try {
-        ctx.data.experienceFragments = await cursorPagedGet({
-          client: plainClient,
+        ctx.data.experienceFragments = await cursorPagedGet(query => client.experienceFragment.getMany({
           spaceId,
           environmentId,
-          method: 'experienceFragment.getMany'
-        });
+          query
+        }), 'experienceFragment');
       } catch (err) {
         _contentfulBatchLibs.logEmitter.emit('warning', `Skipping Experience Fragments export: ${err.message}`);
         ctx.data.experienceFragments = [];
@@ -238,23 +250,60 @@ function getFullSourceSpace({
     title: 'Fetching Experiences data',
     task: (0, _contentfulBatchLibs.wrapTask)(async ctx => {
       try {
-        ctx.data.experiences = await cursorPagedGet({
-          client: plainClient,
+        ctx.data.experiences = await cursorPagedGet(query => client.experience.getMany({
           spaceId,
           environmentId,
-          method: 'experience.getMany'
-        });
+          query
+        }), 'experience');
       } catch (err) {
         _contentfulBatchLibs.logEmitter.emit('warning', `Skipping Experiences export: ${err.message}`);
         ctx.data.experiences = [];
       }
     }),
     skip: () => !includeExperienceOrchestration
+  }, {
+    title: 'Fetching Experience Optimization Variants data',
+    task: (0, _contentfulBatchLibs.wrapTask)(async ctx => {
+      const experienceFailureCount = await attachOptimizationVariants({
+        parents: ctx.data.experiences,
+        fetchFn: (parentId, query) => client.experienceVariant.getMany({
+          spaceId,
+          environmentId,
+          experienceId: parentId,
+          query
+        }),
+        entityLabel: 'Experience Optimization Variants'
+      });
+      ctx.optimizationVariantFailures = ctx.optimizationVariantFailures || {};
+      ctx.optimizationVariantFailures.experiences = experienceFailureCount;
+    }),
+    skip: () => !includeExperienceOrchestration || !includeExoVariants
+  }, {
+    title: 'Fetching Experience Fragment Optimization Variants data',
+    task: (0, _contentfulBatchLibs.wrapTask)(async ctx => {
+      const experienceFragmentFailureCount = await attachOptimizationVariants({
+        parents: ctx.data.experienceFragments,
+        fetchFn: (parentId, query) => client.experienceFragmentVariant.getMany({
+          spaceId,
+          environmentId,
+          experienceFragmentId: parentId,
+          query
+        }),
+        entityLabel: 'Experience Fragment Optimization Variants'
+      });
+      ctx.optimizationVariantFailures = ctx.optimizationVariantFailures || {};
+      ctx.optimizationVariantFailures.experienceFragments = experienceFragmentFailureCount;
+    }),
+    skip: () => !includeExperienceOrchestration || !includeExoVariants
   }], listrOptions);
 }
-function getEditorInterfaces(contentTypes) {
+function getEditorInterfaces(client, spaceId, environmentId, contentTypes) {
   return _bluebird.default.map(contentTypes, contentType => {
-    return contentType.getEditorInterface().then(editorInterface => {
+    return client.editorInterface.get({
+      spaceId,
+      environmentId,
+      contentTypeId: contentType.sys.id
+    }).then(editorInterface => {
       _contentfulBatchLibs.logEmitter.emit('info', `Fetched editor interface for ${contentType.name}`);
       return editorInterface;
     }).catch(() => {
@@ -272,55 +321,154 @@ function getEditorInterfaces(contentTypes) {
  * Gets all ExO entities using cursor-based pagination (pageNext/pagePrev tokens).
  * ExO list endpoints do not support skip-based pagination or the order param.
  */
-async function cursorPagedGet({
-  client,
-  spaceId,
-  environmentId,
-  method
-}) {
-  const [entity, operation] = method.split('.');
+async function cursorPagedGet(fetchFn, entityLabel) {
   const allItems = [];
   let pageNext = null;
   do {
     var _response$pages$next, _response$pages;
     const query = {
-      spaceId,
-      environmentId,
       limit: pageLimit
     };
     if (pageNext) {
       query.pageNext = pageNext;
     }
-    const response = await client[entity][operation](query);
+    const response = await fetchFn(query);
     allItems.push(...response.items);
-    _contentfulBatchLibs.logEmitter.emit('info', `Fetched ${allItems.length} ${entity} items`);
+    _contentfulBatchLibs.logEmitter.emit('info', `Fetched ${allItems.length} ${entityLabel} items`);
     pageNext = (_response$pages$next = (_response$pages = response.pages) === null || _response$pages === void 0 ? void 0 : _response$pages.next) !== null && _response$pages$next !== void 0 ? _response$pages$next : null;
   } while (pageNext);
   return allItems;
 }
 
 /**
+ * Fetches and attaches Optimization Variants onto each of a parent entity type's
+ * items (Experience or ExperienceFragment), mutating them in place as
+ * `parent.optimizationVariants`. Variants are nested onto their parent rather than
+ * exported as their own top-level field because a variant's `sys.id` is borrowed
+ * from its parent (not unique to the variant), so a flat array would collide the
+ * way none of the other ExO entity types do.
+ *
+ * Unlike the top-level ExO entities, the optimization_variants list endpoint is NOT
+ * cursor-paginated — it takes no limit/pageNext query params and its response has no
+ * total/pages fields, just { sys: { type: 'Array' }, items }. So this is a single
+ * request per parent, not a paging loop.
+ *
+ * The API always leads the list with a `sys.variantType: 'default'` item representing
+ * the parent's own base view (either a real record, or the baseline Experience/Fragment
+ * itself if none exists) — not a real personalization variant. That entity is already
+ * exported as its own top-level Experience/ExperienceFragment, so it's filtered out here
+ * to avoid double-counting it as a variant.
+ *
+ * Runs with bounded concurrency (mirrors getEditorInterfaces' pattern) since this
+ * issues one request per parent entity (N+1).
+ *
+ * Returns the count of parents whose variant fetch failed, so callers can
+ * surface that distinctly from a parent that genuinely has zero variants
+ * (both look identical as an empty `optimizationVariants` array otherwise).
+ */
+async function attachOptimizationVariants({
+  parents,
+  fetchFn,
+  entityLabel
+}) {
+  if (!(parents !== null && parents !== void 0 && parents.length)) {
+    return 0;
+  }
+  let totalFetched = 0;
+  let failureCount = 0;
+  await _bluebird.default.map(parents, async parent => {
+    try {
+      const response = await fetchFn(parent.sys.id, {});
+      parent.optimizationVariants = response.items.filter(item => item.sys.variantType !== 'default');
+      totalFetched += parent.optimizationVariants.length;
+      _contentfulBatchLibs.logEmitter.emit('info', `Fetched ${totalFetched} ${entityLabel} items`);
+    } catch (err) {
+      _contentfulBatchLibs.logEmitter.emit('warning', `Skipping ${entityLabel} export for ${parent.sys.id}: ${err.message}`);
+      parent.optimizationVariants = [];
+      failureCount++;
+    }
+  }, {
+    concurrency: 6
+  });
+  return failureCount;
+}
+
+/**
+ * Gets all roles. Roles are scheduled to switch from skip/limit to
+ * cursor-based (pages.next/pagePrev) pagination on Feb 15, 2027:
+ * https://www.contentful.com/developers/api-changes/space-roles-collection-endpoints-update/
+ * Handles both shapes so this keeps working across that migration.
+ */
+async function pagedRolesGet({
+  client,
+  spaceId
+}) {
+  const allItems = [];
+  const order = 'sys.createdAt,sys.id';
+  let response = await client.role.getMany({
+    spaceId,
+    query: {
+      limit: pageLimit,
+      order
+    }
+  });
+  allItems.push(...response.items);
+  _contentfulBatchLibs.logEmitter.emit('info', `Fetched ${allItems.length} roles`);
+  if (response.pages !== undefined) {
+    var _response$pages$next2, _response$pages2;
+    let pageNext = (_response$pages$next2 = (_response$pages2 = response.pages) === null || _response$pages2 === void 0 ? void 0 : _response$pages2.next) !== null && _response$pages$next2 !== void 0 ? _response$pages$next2 : null;
+    while (pageNext) {
+      var _response$pages$next3, _response$pages3;
+      response = await client.role.getMany({
+        spaceId,
+        query: {
+          limit: pageLimit,
+          order,
+          pageNext
+        }
+      });
+      allItems.push(...response.items);
+      _contentfulBatchLibs.logEmitter.emit('info', `Fetched ${allItems.length} roles`);
+      pageNext = (_response$pages$next3 = (_response$pages3 = response.pages) === null || _response$pages3 === void 0 ? void 0 : _response$pages3.next) !== null && _response$pages$next3 !== void 0 ? _response$pages$next3 : null;
+    }
+  } else {
+    let skip = allItems.length;
+    while (allItems.length < response.total && response.items.length > 0) {
+      response = await client.role.getMany({
+        spaceId,
+        query: {
+          limit: pageLimit,
+          order,
+          skip
+        }
+      });
+      allItems.push(...response.items);
+      _contentfulBatchLibs.logEmitter.emit('info', `Fetched ${allItems.length} roles`);
+      skip += response.items.length;
+    }
+  }
+  return allItems;
+}
+
+/**
+ * Recursively fetches all pages of a offset-based paginated CMA collection and returns
+ * them merged into a single response shaped like `{ items: [...], total, ... }`
+ *
  * Gets all the existing entities based on pagination parameters.
  * The first call will have no aggregated response. Subsequent calls will
  * concatenate the new responses to the original one.
  */
-function pagedGet({
-  source,
-  method,
-  skip = 0,
-  aggregatedResponse = null,
-  query = null
-}) {
-  const userQueryLimit = query && query.limit;
+function pagedGet(fetchFn, userQuery = null, skip = 0, aggregatedResponse = null) {
+  const userQueryLimit = userQuery && userQuery.limit;
   const fetchedTotal = aggregatedResponse && aggregatedResponse.items.length;
   const limit = userQueryLimit ? Math.min(pageLimit, userQueryLimit - fetchedTotal) : pageLimit;
-  const requestQuery = Object.assign({}, {
+  const query = _objectSpread(_objectSpread({
     skip,
     order: 'sys.createdAt,sys.id'
-  }, query, {
+  }, userQuery), {}, {
     limit
   });
-  return source[method](requestQuery).then(response => {
+  return fetchFn(query).then(response => {
     if (!aggregatedResponse) {
       aggregatedResponse = response;
     } else {
@@ -328,20 +476,14 @@ function pagedGet({
     }
     const totalItemsLength = aggregatedResponse.items.length;
     const total = response.total;
-    logPagingStatus(response, requestQuery, userQueryLimit);
+    logPagingStatus(response, query, userQueryLimit);
     const gotAllQueryLimitedItems = userQueryLimit && totalItemsLength >= userQueryLimit;
     const gotAllItems = totalItemsLength >= total;
     const gotNoItems = totalItemsLength <= 0;
     if (gotAllQueryLimitedItems || gotAllItems || gotNoItems) {
       return aggregatedResponse;
     }
-    return pagedGet({
-      source,
-      method,
-      skip: skip + response.items.length,
-      aggregatedResponse,
-      query
-    });
+    return pagedGet(fetchFn, userQuery, skip + response.items.length, aggregatedResponse);
   });
 }
 function logPagingStatus(response, requestQuery, userLimit) {

package/dist/tasks/init-client.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = initClient;
-exports.initPlainClient = initPlainClient;
 var _contentful = require("contentful");
 var _contentfulBatchLibs = require("contentful-batch-libs");
 var _contentfulManagement = require("contentful-management");
@@ -32,13 +31,10 @@ function initClient(opts, useCda = false) {
     return (0, _contentful.createClient)(cdaConfig).withoutLinkResolution;
   }
   return (0, _contentfulManagement.createClient)(config, {
-    type: 'legacy'
+    defaults: {
+      spaceId: config.spaceId,
+      environmentId: config.environmentId
+    }
   });
 }
-function initPlainClient(opts) {
-  return (0, _contentfulManagement.createClient)({
-    accessToken: opts.managementToken,
-    host: opts.host,
-    logHandler
-  });
-}
+module.exports = exports.default;

package/dist/usageParams.js

@@ -111,6 +111,10 @@ var _default = exports.default = _yargs.default.version(_package.default.version
   describe: 'Include Experience Orchestration entities (Components, Experience Templates, Data Assemblies, Experience Fragments, Experiences, Design Tokens). Requires exo_m1 entitlement on the source space.',
   type: 'boolean',
   default: true
+}).option('include-exo-variants', {
+  describe: 'Include Optimization Variants, nested onto their parent Experience/Experience Fragment as `optimizationVariants`. Requires include-experience-orchestration. Only has an effect if the Contentful Personalization app is installed on the source space.',
+  type: 'boolean',
+  default: false
 }).option('header', {
   alias: 'H',
   type: 'string',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "contentful-export",
-  "version": "8.2.2",
+  "version": "8.4.0",
   "description": "this tool allows you to export a space to a JSON dump",
   "main": "dist/index.js",
   "types": "types.d.ts",
@@ -52,7 +52,7 @@
     "cli-table3": "^0.6.0",
     "contentful": "^11.5.10",
     "contentful-batch-libs": "^12.0.0",
-    "contentful-management": "^12.14.0",
+    "contentful-management": "^12.17.0",
     "date-fns": "^4.1.0",
     "figures": "^3.2.0",
     "jsonwebtoken": "^9.0.0",