contentful-import 10.0.18 → 10.1.0-exo.10

package/dist/index.d.mts

@@ -19,6 +19,7 @@ type RunContentfulImportParams = {
     headers?: object;
     errorLogFile?: string;
     useVerboseRenderer?: boolean;
+    includeExperienceOrchestration?: boolean;
     timeout?: number;
     retryLimit?: number;
     config?: string;

package/dist/index.d.ts

@@ -19,6 +19,7 @@ type RunContentfulImportParams = {
     headers?: object;
     errorLogFile?: string;
     useVerboseRenderer?: boolean;
+    includeExperienceOrchestration?: boolean;
     timeout?: number;
     retryLimit?: number;
     config?: string;

package/dist/index.js

@@ -60,22 +60,37 @@ function initClient(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
+  });
+}
 
 // lib/tasks/get-destination-data.ts
 var import_bluebird = __toESM(require("bluebird"));
 var import_logging2 = require("contentful-batch-libs/dist/logging");
 var BATCH_CHAR_LIMIT = 1990;
 var BATCH_SIZE_LIMIT = 100;
-var METHODS = {
+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" },
+  componentTypes: { name: "component types", namespace: "componentType" },
+  templates: { name: "templates", namespace: "template" },
+  fragments: { name: "fragments", namespace: "fragment" },
+  dataAssemblies: { name: "data assemblies", namespace: "dataAssembly" },
+  experiences: { name: "experiences", namespace: "experience" }
+};
 async function batchedIdQuery({ environment, type, ids, requestQueue }) {
-  const method = METHODS[type].method;
-  const entityTypeName = METHODS[type].name;
+  const method = OFFSET_QUERY_METHODS[type].method;
+  const entityTypeName = OFFSET_QUERY_METHODS[type].name;
   const batches = getIdBatches(ids);
   let totalFetched = 0;
   const allPendingResponses = batches.map((idBatch) => {
@@ -93,8 +108,8 @@ async function batchedIdQuery({ environment, type, ids, requestQueue }) {
   return responses.flat();
 }
 async function batchedPageQuery({ environment, type, requestQueue }) {
-  const method = METHODS[type].method;
-  const entityTypeName = METHODS[type].name;
+  const method = OFFSET_QUERY_METHODS[type].method;
+  const entityTypeName = OFFSET_QUERY_METHODS[type].name;
   let totalFetched = 0;
   const { items, total } = await requestQueue.add(async () => {
     const response = await environment[method]({
@@ -150,14 +165,37 @@ function getPagedBatches(totalFetched, total) {
   }
   return batches;
 }
+async function cursorPaginatedQuery({ plainClient, 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({
+        spaceId,
+        environmentId,
+        query: { limit: BATCH_SIZE_LIMIT, ...pageNext && { pageNext } }
+      });
+      totalFetched += response.items.length;
+      import_logging2.logEmitter.emit("info", `Fetched ${totalFetched} ${entityTypeName}`);
+      pageNext = response.pages?.next;
+      return response.items;
+    });
+    allItems.push(...items);
+  } while (pageNext);
+  return allItems;
+}
 async function getDestinationData({
   client,
+  plainClient,
   spaceId,
   environmentId,
   sourceData,
   contentModelOnly,
   skipLocales,
   skipContentModel,
+  includeExperienceOrchestration,
   requestQueue
 }) {
   const space = await client.getSpace(spaceId);
@@ -167,7 +205,14 @@ async function getDestinationData({
     tags: [],
     locales: [],
     entries: [],
-    assets: []
+    assets: [],
+    experiences: [],
+    templates: [],
+    componentTypes: [],
+    fragments: [],
+    dataAssemblies: [],
+    designTokens: [],
+    webhooks: []
   };
   sourceData = {
     ...result,
@@ -204,7 +249,7 @@ async function getDestinationData({
   }
   const entryIds = sourceData.entries?.map((e) => e.sys.id);
   const assetIds = sourceData.assets?.map((e) => e.sys.id);
-  if (entryIds) {
+  if (entryIds && entryIds.length) {
     result.entries = batchedIdQuery({
       environment,
       type: "entries",
@@ -212,7 +257,7 @@ async function getDestinationData({
       requestQueue
     });
   }
-  if (assetIds) {
+  if (assetIds && assetIds.length) {
     result.assets = batchedIdQuery({
       environment,
       type: "assets",
@@ -220,7 +265,14 @@ async function getDestinationData({
       requestQueue
     });
   }
-  result.webhooks = [];
+  if (includeExperienceOrchestration && plainClient) {
+    result.designTokens = cursorPaginatedQuery({ plainClient, spaceId, environmentId, type: "designTokens", requestQueue });
+    result.componentTypes = cursorPaginatedQuery({ plainClient, spaceId, environmentId, type: "componentTypes", requestQueue });
+    result.templates = cursorPaginatedQuery({ plainClient, spaceId, environmentId, type: "templates", requestQueue });
+    result.fragments = cursorPaginatedQuery({ plainClient, spaceId, environmentId, type: "fragments", requestQueue });
+    result.dataAssemblies = cursorPaginatedQuery({ plainClient, spaceId, environmentId, type: "dataAssemblies", requestQueue });
+    result.experiences = cursorPaginatedQuery({ plainClient, spaceId, environmentId, type: "experiences", requestQueue });
+  }
   return import_bluebird.default.props(result);
 }
 
@@ -556,7 +608,138 @@ async function runQueue(queue, result = [], requestQueue) {
   return result;
 }
 
+// lib/utils/graphql-schema-backoff.ts
+var GRAPHQL_SCHEMA_STALE_DELAYS_MS = [500, 1500, 6e3];
+function isGraphQLSchemaStaleError(err) {
+  if (!(err instanceof Error)) {
+    return false;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(err.message);
+  } catch {
+    return false;
+  }
+  const errors = parsed?.details?.errors;
+  if (!Array.isArray(errors)) {
+    return false;
+  }
+  const matched = errors.some(
+    (e) => typeof e.message === "string" && (e.message.includes("GraphQL validation error") || e.message.includes("Unknown content type") || e.message.includes("Pointer path does not exist for"))
+  );
+  return matched;
+}
+
+// lib/utils/sort-component-types.ts
+function sortComponentTypes(componentTypes) {
+  const idToIndex = /* @__PURE__ */ new Map();
+  componentTypes.forEach((ct, i) => idToIndex.set(ct.sys.id, i));
+  const URN_PATTERN = /componentTypes\/([^"\\]+)/g;
+  function getDeps(ct) {
+    const ids = /* @__PURE__ */ new Set();
+    const tree = JSON.stringify(ct.componentTree || []);
+    let match;
+    while ((match = URN_PATTERN.exec(tree)) !== null) {
+      const dep = match[1];
+      if (dep !== ct.sys.id && idToIndex.has(dep)) {
+        ids.add(dep);
+      }
+    }
+    return [...ids];
+  }
+  const dependents = /* @__PURE__ */ new Map();
+  const inDegree = /* @__PURE__ */ new Map();
+  componentTypes.forEach((ct) => {
+    inDegree.set(ct.sys.id, 0);
+    dependents.set(ct.sys.id, []);
+  });
+  componentTypes.forEach((ct) => {
+    for (const dep of getDeps(ct)) {
+      dependents.get(dep).push(ct.sys.id);
+      inDegree.set(ct.sys.id, (inDegree.get(ct.sys.id) ?? 0) + 1);
+    }
+  });
+  const queue = componentTypes.filter((ct) => inDegree.get(ct.sys.id) === 0).map((ct) => ct.sys.id);
+  const sorted = [];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    sorted.push(componentTypes[idToIndex.get(id)]);
+    for (const dependent of dependents.get(id) ?? []) {
+      const deg = (inDegree.get(dependent) ?? 1) - 1;
+      inDegree.set(dependent, deg);
+      if (deg === 0) queue.push(dependent);
+    }
+  }
+  componentTypes.forEach((ct) => {
+    if (!sorted.includes(ct)) sorted.push(ct);
+  });
+  return sorted;
+}
+
+// lib/utils/sort-fragments.ts
+function sortFragments(fragments) {
+  const idToIndex = /* @__PURE__ */ new Map();
+  fragments.forEach((f, i) => idToIndex.set(f.sys.id, i));
+  const FRAGMENT_URN_PATTERN = /fragments\/([^"\\]+)/g;
+  function getDeps(fragment) {
+    const ids = /* @__PURE__ */ new Set();
+    const json = JSON.stringify({ slots: fragment.slots || [], componentTree: fragment.componentTree || [] });
+    let match;
+    while ((match = FRAGMENT_URN_PATTERN.exec(json)) !== null) {
+      const dep = match[1];
+      if (dep !== fragment.sys.id && idToIndex.has(dep)) {
+        ids.add(dep);
+      }
+    }
+    return [...ids];
+  }
+  const dependents = /* @__PURE__ */ new Map();
+  const inDegree = /* @__PURE__ */ new Map();
+  fragments.forEach((f) => {
+    inDegree.set(f.sys.id, 0);
+    dependents.set(f.sys.id, []);
+  });
+  fragments.forEach((f) => {
+    for (const dep of getDeps(f)) {
+      dependents.get(dep).push(f.sys.id);
+      inDegree.set(f.sys.id, (inDegree.get(f.sys.id) ?? 0) + 1);
+    }
+  });
+  const queue = fragments.filter((f) => inDegree.get(f.sys.id) === 0).map((f) => f.sys.id);
+  const sorted = [];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    sorted.push(fragments[idToIndex.get(id)]);
+    for (const dependent of dependents.get(id) ?? []) {
+      const deg = (inDegree.get(dependent) ?? 1) - 1;
+      inDegree.set(dependent, deg);
+      if (deg === 0) queue.push(dependent);
+    }
+  }
+  fragments.forEach((f) => {
+    if (!sorted.includes(f)) sorted.push(f);
+  });
+  return sorted;
+}
+
 // lib/tasks/push-to-space/push-to-space.ts
+async function withGraphQLSchemaBackoff(fn) {
+  let lastErr;
+  for (let attempt = 0; attempt <= GRAPHQL_SCHEMA_STALE_DELAYS_MS.length; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      if (!isGraphQLSchemaStaleError(err) || attempt === GRAPHQL_SCHEMA_STALE_DELAYS_MS.length) {
+        throw err;
+      }
+      const delay = GRAPHQL_SCHEMA_STALE_DELAYS_MS[attempt];
+      import_logging6.logEmitter.emit("warning", `DataAssembly GraphQL schema not yet current, retrying in ${delay}ms (attempt ${attempt + 1}/${GRAPHQL_SCHEMA_STALE_DELAYS_MS.length})`);
+      await new Promise((resolve2) => setTimeout(resolve2, delay));
+      lastErr = err;
+    }
+  }
+  throw lastErr;
+}
 var DEFAULT_CONTENT_STRUCTURE = {
   entries: [],
   assets: [],
@@ -570,8 +753,10 @@ function pushToSpace({
   sourceData,
   destinationData = {},
   client,
+  plainClient,
   spaceId,
   environmentId,
+  includeExperienceOrchestration,
   contentModelOnly,
   skipContentModel,
   skipContentUpdates,
@@ -847,9 +1032,177 @@ function pushToSpace({
         ctx.data.webhooks = webhooks2;
       }),
       skip: () => contentModelOnly || environmentId !== "master" && "Webhooks can only be imported in master environment"
+    },
+    {
+      title: "Importing Data Assemblies",
+      task: (0, import_listr2.wrapTask)(async (ctx) => {
+        const results = await Promise.all((sourceData.dataAssemblies || []).map(async (entity) => {
+          try {
+            const existing = destinationDataById.dataAssemblies?.get(entity.sys.id);
+            let result;
+            if (existing) {
+              const payload = { ...entity, sys: { ...entity.sys, version: existing.sys.version } };
+              result = await withGraphQLSchemaBackoff(() => plainClient.dataAssembly.update(
+                { spaceId, environmentId, dataAssemblyId: entity.sys.id },
+                payload
+              ));
+              import_logging6.logEmitter.emit("info", `UPDATE DataAssembly ${entity.sys.id}`);
+            } else {
+              const payload = { ...omitSys(entity), sys: { id: entity.sys.id, type: "DataAssembly", dataType: entity.sys.dataType, ...entity.sys.variant ? { variant: entity.sys.variant } : {}, version: 0 } };
+              result = await withGraphQLSchemaBackoff(() => plainClient.dataAssembly.update(
+                { spaceId, environmentId, dataAssemblyId: entity.sys.id },
+                payload
+              ));
+              import_logging6.logEmitter.emit("info", `CREATE DataAssembly ${entity.sys.id}`);
+            }
+            return result;
+          } catch (err) {
+            import_logging6.logEmitter.emit("error", err);
+            return null;
+          }
+        }));
+        ctx.data.dataAssemblies = results.filter(Boolean);
+      }),
+      skip: () => !includeExperienceOrchestration || !(sourceData.dataAssemblies || []).length
+    },
+    {
+      title: "Importing Design Tokens",
+      task: (0, import_listr2.wrapTask)(async (ctx) => {
+        const results = await Promise.all((sourceData.designTokens || []).map(async (entity) => {
+          try {
+            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);
+              import_logging6.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);
+              import_logging6.logEmitter.emit("info", `CREATE DesignToken ${entity.sys.id}`);
+              return result;
+            }
+          } catch (err) {
+            import_logging6.logEmitter.emit("error", err);
+            return null;
+          }
+        }));
+        ctx.data.designTokens = results.filter(Boolean);
+      }),
+      skip: () => !includeExperienceOrchestration || !(sourceData.designTokens || []).length
+    },
+    {
+      title: "Importing Component Types",
+      task: (0, import_listr2.wrapTask)(async (ctx) => {
+        const sorted = sortComponentTypes(sourceData.componentTypes || []);
+        const results = [];
+        for (const entity of sorted) {
+          try {
+            const existing = destinationDataById.componentTypes?.get(entity.sys.id);
+            if (existing) {
+              const payload = { ...entity, sys: { id: entity.sys.id, type: "ComponentType", version: existing.sys.version } };
+              const result = await plainClient.componentType.upsert({ spaceId, environmentId, componentTypeId: entity.sys.id }, payload);
+              import_logging6.logEmitter.emit("info", `UPDATE ComponentType ${entity.sys.id}`);
+              results.push(result);
+            } else {
+              const payload = { ...omitSys(entity), sys: { id: entity.sys.id, type: "ComponentType" } };
+              const result = await plainClient.componentType.upsert({ spaceId, environmentId, componentTypeId: entity.sys.id }, payload);
+              import_logging6.logEmitter.emit("info", `CREATE ComponentType ${entity.sys.id}`);
+              results.push(result);
+            }
+          } catch (err) {
+            import_logging6.logEmitter.emit("error", err);
+          }
+        }
+        ctx.data.componentTypes = results;
+      }),
+      skip: () => !includeExperienceOrchestration || !(sourceData.componentTypes || []).length
+    },
+    {
+      title: "Importing Templates",
+      task: (0, import_listr2.wrapTask)(async (ctx) => {
+        const results = await Promise.all((sourceData.templates || []).map(async (entity) => {
+          try {
+            const existing = destinationDataById.templates?.get(entity.sys.id);
+            if (existing) {
+              const payload = { ...entity, sys: { id: entity.sys.id, type: "Template", version: existing.sys.version } };
+              const result = await plainClient.template.upsert({ spaceId, environmentId, templateId: entity.sys.id }, payload);
+              import_logging6.logEmitter.emit("info", `UPDATE Template ${entity.sys.id}`);
+              return result;
+            } else {
+              const payload = { ...omitSys(entity), sys: { id: entity.sys.id, type: "Template" } };
+              const result = await plainClient.template.upsert({ spaceId, environmentId, templateId: entity.sys.id }, payload);
+              import_logging6.logEmitter.emit("info", `CREATE Template ${entity.sys.id}`);
+              return result;
+            }
+          } catch (err) {
+            import_logging6.logEmitter.emit("error", err);
+            return null;
+          }
+        }));
+        ctx.data.templates = results.filter(Boolean);
+      }),
+      skip: () => !includeExperienceOrchestration || !(sourceData.templates || []).length
+    },
+    {
+      title: "Importing Fragments",
+      task: (0, import_listr2.wrapTask)(async (ctx) => {
+        const sorted = sortFragments(sourceData.fragments || []);
+        const results = [];
+        for (const entity of sorted) {
+          try {
+            const existing = destinationDataById.fragments?.get(entity.sys.id);
+            if (existing) {
+              const payload = { ...entity, componentType: entity.sys.componentType, sys: { id: entity.sys.id, type: "Fragment", version: existing.sys.version } };
+              const result = await plainClient.fragment.upsert({ spaceId, environmentId, fragmentId: entity.sys.id }, payload);
+              import_logging6.logEmitter.emit("info", `UPDATE Fragment ${entity.sys.id}`);
+              results.push(result);
+            } else {
+              const payload = { ...omitSys(entity), componentType: entity.sys.componentType, sys: { id: entity.sys.id, type: "Fragment" } };
+              const result = await plainClient.fragment.upsert({ spaceId, environmentId, fragmentId: entity.sys.id }, payload);
+              import_logging6.logEmitter.emit("info", `CREATE Fragment ${entity.sys.id}`);
+              results.push(result);
+            }
+          } catch (err) {
+            import_logging6.logEmitter.emit("error", err);
+          }
+        }
+        ctx.data.fragments = results;
+      }),
+      skip: () => !includeExperienceOrchestration || !(sourceData.fragments || []).length
+    },
+    {
+      title: "Importing Experiences",
+      task: (0, import_listr2.wrapTask)(async (ctx) => {
+        const results = await Promise.all((sourceData.experiences || []).map(async (entity) => {
+          try {
+            const existing = destinationDataById.experiences?.get(entity.sys.id);
+            if (existing) {
+              const payload = { ...entity, template: entity.sys.template, sys: { id: entity.sys.id, type: "Experience", version: existing.sys.version } };
+              const result = await plainClient.experience.upsert({ spaceId, environmentId, experienceId: entity.sys.id }, payload);
+              import_logging6.logEmitter.emit("info", `UPDATE Experience ${entity.sys.id}`);
+              return result;
+            } else {
+              const payload = { ...omitSys(entity), template: entity.sys.template, sys: { id: entity.sys.id, type: "Experience" } };
+              const result = await plainClient.experience.upsert({ spaceId, environmentId, experienceId: entity.sys.id }, payload);
+              import_logging6.logEmitter.emit("info", `CREATE Experience ${entity.sys.id}`);
+              return result;
+            }
+          } catch (err) {
+            import_logging6.logEmitter.emit("error", err);
+            return null;
+          }
+        }));
+        ctx.data.experiences = results.filter(Boolean);
+      }),
+      skip: () => !includeExperienceOrchestration || !(sourceData.experiences || []).length
     }
   ], listrOptions);
 }
+function omitSys(entity) {
+  const { sys: _sys, ...rest } = entity;
+  return rest;
+}
 function archiveEntities2({ entities, sourceEntities, 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);
@@ -1218,7 +1571,13 @@ var SUPPORTED_ENTITY_TYPES = [
   "assets",
   "locales",
   "webhooks",
-  "editorInterfaces"
+  "editorInterfaces",
+  "designTokens",
+  "componentTypes",
+  "templates",
+  "dataAssemblies",
+  "fragments",
+  "experiences"
 ];
 async function parseOptions(params) {
   const defaultOptions = {
@@ -1231,7 +1590,8 @@ async function parseOptions(params) {
     environmentId: "master",
     rawProxy: false,
     uploadAssets: false,
-    rateLimit: 7
+    rateLimit: 7,
+    includeExperienceOrchestration: false
   };
   const configFile = params.config ? require((0, import_path2.resolve)(process.cwd(), params.config)) : {};
   const options = {
@@ -1344,6 +1704,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 });
       })
     },
     {
@@ -1351,11 +1712,13 @@ 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,
           skipLocales: options.skipLocales,
           skipContentModel: options.skipContentModel,
+          includeExperienceOrchestration: options.includeExperienceOrchestration,
           requestQueue
         });
         ctx.sourceDataUntransformed = options.content;
@@ -1377,7 +1740,9 @@ 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,
           contentModelOnly: options.contentModelOnly,
           skipLocales: options.skipLocales,

package/dist/index.mjs

@@ -33,22 +33,37 @@ function initClient(opts) {
   };
   return createClient(config, { type: "legacy" });
 }
+function initPlainClient(opts) {
+  return createClient({
+    accessToken: opts.managementToken,
+    host: opts.host,
+    logHandler
+  });
+}
 
 // lib/tasks/get-destination-data.ts
 import Promise2 from "bluebird";
 import { logEmitter as logEmitter2 } from "contentful-batch-libs/dist/logging";
 var BATCH_CHAR_LIMIT = 1990;
 var BATCH_SIZE_LIMIT = 100;
-var METHODS = {
+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" },
+  componentTypes: { name: "component types", namespace: "componentType" },
+  templates: { name: "templates", namespace: "template" },
+  fragments: { name: "fragments", namespace: "fragment" },
+  dataAssemblies: { name: "data assemblies", namespace: "dataAssembly" },
+  experiences: { name: "experiences", namespace: "experience" }
+};
 async function batchedIdQuery({ environment, type, ids, requestQueue }) {
-  const method = METHODS[type].method;
-  const entityTypeName = METHODS[type].name;
+  const method = OFFSET_QUERY_METHODS[type].method;
+  const entityTypeName = OFFSET_QUERY_METHODS[type].name;
   const batches = getIdBatches(ids);
   let totalFetched = 0;
   const allPendingResponses = batches.map((idBatch) => {
@@ -66,8 +81,8 @@ async function batchedIdQuery({ environment, type, ids, requestQueue }) {
   return responses.flat();
 }
 async function batchedPageQuery({ environment, type, requestQueue }) {
-  const method = METHODS[type].method;
-  const entityTypeName = METHODS[type].name;
+  const method = OFFSET_QUERY_METHODS[type].method;
+  const entityTypeName = OFFSET_QUERY_METHODS[type].name;
   let totalFetched = 0;
   const { items, total } = await requestQueue.add(async () => {
     const response = await environment[method]({
@@ -123,14 +138,37 @@ function getPagedBatches(totalFetched, total) {
   }
   return batches;
 }
+async function cursorPaginatedQuery({ plainClient, 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({
+        spaceId,
+        environmentId,
+        query: { limit: BATCH_SIZE_LIMIT, ...pageNext && { pageNext } }
+      });
+      totalFetched += response.items.length;
+      logEmitter2.emit("info", `Fetched ${totalFetched} ${entityTypeName}`);
+      pageNext = response.pages?.next;
+      return response.items;
+    });
+    allItems.push(...items);
+  } while (pageNext);
+  return allItems;
+}
 async function getDestinationData({
   client,
+  plainClient,
   spaceId,
   environmentId,
   sourceData,
   contentModelOnly,
   skipLocales,
   skipContentModel,
+  includeExperienceOrchestration,
   requestQueue
 }) {
   const space = await client.getSpace(spaceId);
@@ -140,7 +178,14 @@ async function getDestinationData({
     tags: [],
     locales: [],
     entries: [],
-    assets: []
+    assets: [],
+    experiences: [],
+    templates: [],
+    componentTypes: [],
+    fragments: [],
+    dataAssemblies: [],
+    designTokens: [],
+    webhooks: []
   };
   sourceData = {
     ...result,
@@ -177,7 +222,7 @@ async function getDestinationData({
   }
   const entryIds = sourceData.entries?.map((e) => e.sys.id);
   const assetIds = sourceData.assets?.map((e) => e.sys.id);
-  if (entryIds) {
+  if (entryIds && entryIds.length) {
     result.entries = batchedIdQuery({
       environment,
       type: "entries",
@@ -185,7 +230,7 @@ async function getDestinationData({
       requestQueue
     });
   }
-  if (assetIds) {
+  if (assetIds && assetIds.length) {
     result.assets = batchedIdQuery({
       environment,
       type: "assets",
@@ -193,7 +238,14 @@ async function getDestinationData({
       requestQueue
     });
   }
-  result.webhooks = [];
+  if (includeExperienceOrchestration && plainClient) {
+    result.designTokens = cursorPaginatedQuery({ plainClient, spaceId, environmentId, type: "designTokens", requestQueue });
+    result.componentTypes = cursorPaginatedQuery({ plainClient, spaceId, environmentId, type: "componentTypes", requestQueue });
+    result.templates = cursorPaginatedQuery({ plainClient, spaceId, environmentId, type: "templates", requestQueue });
+    result.fragments = cursorPaginatedQuery({ plainClient, spaceId, environmentId, type: "fragments", requestQueue });
+    result.dataAssemblies = cursorPaginatedQuery({ plainClient, spaceId, environmentId, type: "dataAssemblies", requestQueue });
+    result.experiences = cursorPaginatedQuery({ plainClient, spaceId, environmentId, type: "experiences", requestQueue });
+  }
   return Promise2.props(result);
 }
 
@@ -529,7 +581,138 @@ async function runQueue(queue, result = [], requestQueue) {
   return result;
 }
 
+// lib/utils/graphql-schema-backoff.ts
+var GRAPHQL_SCHEMA_STALE_DELAYS_MS = [500, 1500, 6e3];
+function isGraphQLSchemaStaleError(err) {
+  if (!(err instanceof Error)) {
+    return false;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(err.message);
+  } catch {
+    return false;
+  }
+  const errors = parsed?.details?.errors;
+  if (!Array.isArray(errors)) {
+    return false;
+  }
+  const matched = errors.some(
+    (e) => typeof e.message === "string" && (e.message.includes("GraphQL validation error") || e.message.includes("Unknown content type") || e.message.includes("Pointer path does not exist for"))
+  );
+  return matched;
+}
+
+// lib/utils/sort-component-types.ts
+function sortComponentTypes(componentTypes) {
+  const idToIndex = /* @__PURE__ */ new Map();
+  componentTypes.forEach((ct, i) => idToIndex.set(ct.sys.id, i));
+  const URN_PATTERN = /componentTypes\/([^"\\]+)/g;
+  function getDeps(ct) {
+    const ids = /* @__PURE__ */ new Set();
+    const tree = JSON.stringify(ct.componentTree || []);
+    let match;
+    while ((match = URN_PATTERN.exec(tree)) !== null) {
+      const dep = match[1];
+      if (dep !== ct.sys.id && idToIndex.has(dep)) {
+        ids.add(dep);
+      }
+    }
+    return [...ids];
+  }
+  const dependents = /* @__PURE__ */ new Map();
+  const inDegree = /* @__PURE__ */ new Map();
+  componentTypes.forEach((ct) => {
+    inDegree.set(ct.sys.id, 0);
+    dependents.set(ct.sys.id, []);
+  });
+  componentTypes.forEach((ct) => {
+    for (const dep of getDeps(ct)) {
+      dependents.get(dep).push(ct.sys.id);
+      inDegree.set(ct.sys.id, (inDegree.get(ct.sys.id) ?? 0) + 1);
+    }
+  });
+  const queue = componentTypes.filter((ct) => inDegree.get(ct.sys.id) === 0).map((ct) => ct.sys.id);
+  const sorted = [];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    sorted.push(componentTypes[idToIndex.get(id)]);
+    for (const dependent of dependents.get(id) ?? []) {
+      const deg = (inDegree.get(dependent) ?? 1) - 1;
+      inDegree.set(dependent, deg);
+      if (deg === 0) queue.push(dependent);
+    }
+  }
+  componentTypes.forEach((ct) => {
+    if (!sorted.includes(ct)) sorted.push(ct);
+  });
+  return sorted;
+}
+
+// lib/utils/sort-fragments.ts
+function sortFragments(fragments) {
+  const idToIndex = /* @__PURE__ */ new Map();
+  fragments.forEach((f, i) => idToIndex.set(f.sys.id, i));
+  const FRAGMENT_URN_PATTERN = /fragments\/([^"\\]+)/g;
+  function getDeps(fragment) {
+    const ids = /* @__PURE__ */ new Set();
+    const json = JSON.stringify({ slots: fragment.slots || [], componentTree: fragment.componentTree || [] });
+    let match;
+    while ((match = FRAGMENT_URN_PATTERN.exec(json)) !== null) {
+      const dep = match[1];
+      if (dep !== fragment.sys.id && idToIndex.has(dep)) {
+        ids.add(dep);
+      }
+    }
+    return [...ids];
+  }
+  const dependents = /* @__PURE__ */ new Map();
+  const inDegree = /* @__PURE__ */ new Map();
+  fragments.forEach((f) => {
+    inDegree.set(f.sys.id, 0);
+    dependents.set(f.sys.id, []);
+  });
+  fragments.forEach((f) => {
+    for (const dep of getDeps(f)) {
+      dependents.get(dep).push(f.sys.id);
+      inDegree.set(f.sys.id, (inDegree.get(f.sys.id) ?? 0) + 1);
+    }
+  });
+  const queue = fragments.filter((f) => inDegree.get(f.sys.id) === 0).map((f) => f.sys.id);
+  const sorted = [];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    sorted.push(fragments[idToIndex.get(id)]);
+    for (const dependent of dependents.get(id) ?? []) {
+      const deg = (inDegree.get(dependent) ?? 1) - 1;
+      inDegree.set(dependent, deg);
+      if (deg === 0) queue.push(dependent);
+    }
+  }
+  fragments.forEach((f) => {
+    if (!sorted.includes(f)) sorted.push(f);
+  });
+  return sorted;
+}
+
 // lib/tasks/push-to-space/push-to-space.ts
+async function withGraphQLSchemaBackoff(fn) {
+  let lastErr;
+  for (let attempt = 0; attempt <= GRAPHQL_SCHEMA_STALE_DELAYS_MS.length; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      if (!isGraphQLSchemaStaleError(err) || attempt === GRAPHQL_SCHEMA_STALE_DELAYS_MS.length) {
+        throw err;
+      }
+      const delay = GRAPHQL_SCHEMA_STALE_DELAYS_MS[attempt];
+      logEmitter6.emit("warning", `DataAssembly GraphQL schema not yet current, retrying in ${delay}ms (attempt ${attempt + 1}/${GRAPHQL_SCHEMA_STALE_DELAYS_MS.length})`);
+      await new Promise((resolve2) => setTimeout(resolve2, delay));
+      lastErr = err;
+    }
+  }
+  throw lastErr;
+}
 var DEFAULT_CONTENT_STRUCTURE = {
   entries: [],
   assets: [],
@@ -543,8 +726,10 @@ function pushToSpace({
   sourceData,
   destinationData = {},
   client,
+  plainClient,
   spaceId,
   environmentId,
+  includeExperienceOrchestration,
   contentModelOnly,
   skipContentModel,
   skipContentUpdates,
@@ -820,9 +1005,177 @@ function pushToSpace({
         ctx.data.webhooks = webhooks2;
       }),
       skip: () => contentModelOnly || environmentId !== "master" && "Webhooks can only be imported in master environment"
+    },
+    {
+      title: "Importing Data Assemblies",
+      task: wrapTask(async (ctx) => {
+        const results = await Promise.all((sourceData.dataAssemblies || []).map(async (entity) => {
+          try {
+            const existing = destinationDataById.dataAssemblies?.get(entity.sys.id);
+            let result;
+            if (existing) {
+              const payload = { ...entity, sys: { ...entity.sys, version: existing.sys.version } };
+              result = await withGraphQLSchemaBackoff(() => plainClient.dataAssembly.update(
+                { spaceId, environmentId, dataAssemblyId: entity.sys.id },
+                payload
+              ));
+              logEmitter6.emit("info", `UPDATE DataAssembly ${entity.sys.id}`);
+            } else {
+              const payload = { ...omitSys(entity), sys: { id: entity.sys.id, type: "DataAssembly", dataType: entity.sys.dataType, ...entity.sys.variant ? { variant: entity.sys.variant } : {}, version: 0 } };
+              result = await withGraphQLSchemaBackoff(() => plainClient.dataAssembly.update(
+                { spaceId, environmentId, dataAssemblyId: entity.sys.id },
+                payload
+              ));
+              logEmitter6.emit("info", `CREATE DataAssembly ${entity.sys.id}`);
+            }
+            return result;
+          } catch (err) {
+            logEmitter6.emit("error", err);
+            return null;
+          }
+        }));
+        ctx.data.dataAssemblies = results.filter(Boolean);
+      }),
+      skip: () => !includeExperienceOrchestration || !(sourceData.dataAssemblies || []).length
+    },
+    {
+      title: "Importing Design Tokens",
+      task: wrapTask(async (ctx) => {
+        const results = await Promise.all((sourceData.designTokens || []).map(async (entity) => {
+          try {
+            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);
+              logEmitter6.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);
+              logEmitter6.emit("info", `CREATE DesignToken ${entity.sys.id}`);
+              return result;
+            }
+          } catch (err) {
+            logEmitter6.emit("error", err);
+            return null;
+          }
+        }));
+        ctx.data.designTokens = results.filter(Boolean);
+      }),
+      skip: () => !includeExperienceOrchestration || !(sourceData.designTokens || []).length
+    },
+    {
+      title: "Importing Component Types",
+      task: wrapTask(async (ctx) => {
+        const sorted = sortComponentTypes(sourceData.componentTypes || []);
+        const results = [];
+        for (const entity of sorted) {
+          try {
+            const existing = destinationDataById.componentTypes?.get(entity.sys.id);
+            if (existing) {
+              const payload = { ...entity, sys: { id: entity.sys.id, type: "ComponentType", version: existing.sys.version } };
+              const result = await plainClient.componentType.upsert({ spaceId, environmentId, componentTypeId: entity.sys.id }, payload);
+              logEmitter6.emit("info", `UPDATE ComponentType ${entity.sys.id}`);
+              results.push(result);
+            } else {
+              const payload = { ...omitSys(entity), sys: { id: entity.sys.id, type: "ComponentType" } };
+              const result = await plainClient.componentType.upsert({ spaceId, environmentId, componentTypeId: entity.sys.id }, payload);
+              logEmitter6.emit("info", `CREATE ComponentType ${entity.sys.id}`);
+              results.push(result);
+            }
+          } catch (err) {
+            logEmitter6.emit("error", err);
+          }
+        }
+        ctx.data.componentTypes = results;
+      }),
+      skip: () => !includeExperienceOrchestration || !(sourceData.componentTypes || []).length
+    },
+    {
+      title: "Importing Templates",
+      task: wrapTask(async (ctx) => {
+        const results = await Promise.all((sourceData.templates || []).map(async (entity) => {
+          try {
+            const existing = destinationDataById.templates?.get(entity.sys.id);
+            if (existing) {
+              const payload = { ...entity, sys: { id: entity.sys.id, type: "Template", version: existing.sys.version } };
+              const result = await plainClient.template.upsert({ spaceId, environmentId, templateId: entity.sys.id }, payload);
+              logEmitter6.emit("info", `UPDATE Template ${entity.sys.id}`);
+              return result;
+            } else {
+              const payload = { ...omitSys(entity), sys: { id: entity.sys.id, type: "Template" } };
+              const result = await plainClient.template.upsert({ spaceId, environmentId, templateId: entity.sys.id }, payload);
+              logEmitter6.emit("info", `CREATE Template ${entity.sys.id}`);
+              return result;
+            }
+          } catch (err) {
+            logEmitter6.emit("error", err);
+            return null;
+          }
+        }));
+        ctx.data.templates = results.filter(Boolean);
+      }),
+      skip: () => !includeExperienceOrchestration || !(sourceData.templates || []).length
+    },
+    {
+      title: "Importing Fragments",
+      task: wrapTask(async (ctx) => {
+        const sorted = sortFragments(sourceData.fragments || []);
+        const results = [];
+        for (const entity of sorted) {
+          try {
+            const existing = destinationDataById.fragments?.get(entity.sys.id);
+            if (existing) {
+              const payload = { ...entity, componentType: entity.sys.componentType, sys: { id: entity.sys.id, type: "Fragment", version: existing.sys.version } };
+              const result = await plainClient.fragment.upsert({ spaceId, environmentId, fragmentId: entity.sys.id }, payload);
+              logEmitter6.emit("info", `UPDATE Fragment ${entity.sys.id}`);
+              results.push(result);
+            } else {
+              const payload = { ...omitSys(entity), componentType: entity.sys.componentType, sys: { id: entity.sys.id, type: "Fragment" } };
+              const result = await plainClient.fragment.upsert({ spaceId, environmentId, fragmentId: entity.sys.id }, payload);
+              logEmitter6.emit("info", `CREATE Fragment ${entity.sys.id}`);
+              results.push(result);
+            }
+          } catch (err) {
+            logEmitter6.emit("error", err);
+          }
+        }
+        ctx.data.fragments = results;
+      }),
+      skip: () => !includeExperienceOrchestration || !(sourceData.fragments || []).length
+    },
+    {
+      title: "Importing Experiences",
+      task: wrapTask(async (ctx) => {
+        const results = await Promise.all((sourceData.experiences || []).map(async (entity) => {
+          try {
+            const existing = destinationDataById.experiences?.get(entity.sys.id);
+            if (existing) {
+              const payload = { ...entity, template: entity.sys.template, sys: { id: entity.sys.id, type: "Experience", version: existing.sys.version } };
+              const result = await plainClient.experience.upsert({ spaceId, environmentId, experienceId: entity.sys.id }, payload);
+              logEmitter6.emit("info", `UPDATE Experience ${entity.sys.id}`);
+              return result;
+            } else {
+              const payload = { ...omitSys(entity), template: entity.sys.template, sys: { id: entity.sys.id, type: "Experience" } };
+              const result = await plainClient.experience.upsert({ spaceId, environmentId, experienceId: entity.sys.id }, payload);
+              logEmitter6.emit("info", `CREATE Experience ${entity.sys.id}`);
+              return result;
+            }
+          } catch (err) {
+            logEmitter6.emit("error", err);
+            return null;
+          }
+        }));
+        ctx.data.experiences = results.filter(Boolean);
+      }),
+      skip: () => !includeExperienceOrchestration || !(sourceData.experiences || []).length
     }
   ], listrOptions);
 }
+function omitSys(entity) {
+  const { sys: _sys, ...rest } = entity;
+  return rest;
+}
 function archiveEntities2({ entities, sourceEntities, 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);
@@ -1188,7 +1541,13 @@ var SUPPORTED_ENTITY_TYPES = [
   "assets",
   "locales",
   "webhooks",
-  "editorInterfaces"
+  "editorInterfaces",
+  "designTokens",
+  "componentTypes",
+  "templates",
+  "dataAssemblies",
+  "fragments",
+  "experiences"
 ];
 async function parseOptions(params) {
   const defaultOptions = {
@@ -1201,7 +1560,8 @@ async function parseOptions(params) {
     environmentId: "master",
     rawProxy: false,
     uploadAssets: false,
-    rateLimit: 7
+    rateLimit: 7,
+    includeExperienceOrchestration: false
   };
   const configFile = params.config ? __require(resolve(process.cwd(), params.config)) : {};
   const options = {
@@ -1314,6 +1674,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 });
       })
     },
     {
@@ -1321,11 +1682,13 @@ 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,
           skipLocales: options.skipLocales,
           skipContentModel: options.skipContentModel,
+          includeExperienceOrchestration: options.includeExperienceOrchestration,
           requestQueue
         });
         ctx.sourceDataUntransformed = options.content;
@@ -1347,7 +1710,9 @@ 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,
           contentModelOnly: options.contentModelOnly,
           skipLocales: options.skipLocales,

package/dist/usageParams.d.mts

@@ -29,6 +29,8 @@ declare const _default: {
     "rate-limit": number;
     rateLimit: number;
     header: string | undefined;
+    "include-experience-orchestration": boolean;
+    includeExperienceOrchestration: boolean;
     _: (string | number)[];
     $0: string;
 } | Promise<{
@@ -62,6 +64,8 @@ declare const _default: {
     "rate-limit": number;
     rateLimit: number;
     header: string | undefined;
+    "include-experience-orchestration": boolean;
+    includeExperienceOrchestration: boolean;
     _: (string | number)[];
     $0: string;
 }>;

package/dist/usageParams.d.ts

@@ -29,6 +29,8 @@ declare const _default: {
     "rate-limit": number;
     rateLimit: number;
     header: string | undefined;
+    "include-experience-orchestration": boolean;
+    includeExperienceOrchestration: boolean;
     _: (string | number)[];
     $0: string;
 } | Promise<{
@@ -62,6 +64,8 @@ declare const _default: {
     "rate-limit": number;
     rateLimit: number;
     header: string | undefined;
+    "include-experience-orchestration": boolean;
+    includeExperienceOrchestration: boolean;
     _: (string | number)[];
     $0: string;
 }>;

package/dist/usageParams.js

@@ -99,4 +99,8 @@ var usageParams_default = import_yargs.default.version(version || "Version only
   alias: "H",
   type: "string",
   describe: "Pass an additional HTTP Header"
+}).option("include-experience-orchestration", {
+  describe: "Import Experience Orchestration entities (designTokens, componentTypes, templates, fragments, dataAssemblies, experiences). Requires a space with ExO enabled.",
+  type: "boolean",
+  default: true
 }).config("config", "An optional configuration JSON file containing all the options for a single run").argv;

package/dist/usageParams.mjs

@@ -65,6 +65,10 @@ var usageParams_default = yargs.version(version || "Version only available on in
   alias: "H",
   type: "string",
   describe: "Pass an additional HTTP Header"
+}).option("include-experience-orchestration", {
+  describe: "Import Experience Orchestration entities (designTokens, componentTypes, templates, fragments, dataAssemblies, experiences). Requires a space with ExO enabled.",
+  type: "boolean",
+  default: true
 }).config("config", "An optional configuration JSON file containing all the options for a single run").argv;
 export {
   usageParams_default as default

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "contentful-import",
-  "version": "10.0.18",
+  "version": "10.1.0-exo.10",
   "description": "this tool allows you to import JSON dump exported by contentful-export",
   "main": "dist/index.mjs",
   "typings": "dist/index.d.ts",
@@ -64,7 +64,7 @@
     "bluebird": "^3.7.2",
     "cli-table3": "^0.6.5",
     "contentful-batch-libs": "^9.7.0",
-    "contentful-management": "^12.8.0",
+    "contentful-management": "^12.12.0",
     "date-fns": "^2.30.0",
     "joi": "^18.2.3",
     "listr": "^0.14.3",
@@ -145,6 +145,6 @@
     ]
   },
   "overrides": {
-    "undici": "^8.0.0"
+    "undici": "^6.27.0"
   }
 }