strapi-plugin-bulk-updater 1.1.0 → 1.2.3

package/dist/server/index.mjs

@@ -169,6 +169,78 @@ const routes = {
     ]
   }
 };
+const auditLog = {
+  collectionName: "bulk_updater_audit_logs",
+  info: {
+    singularName: "audit-log",
+    pluralName: "audit-logs",
+    displayName: "Bulk Updater Audit Log",
+    description: "Internal audit trail for bulk attribute and relation updates"
+  },
+  options: {
+    draftAndPublish: false
+  },
+  pluginOptions: {
+    "content-manager": {
+      visible: true
+    },
+    "content-type-builder": {
+      visible: false
+    }
+  },
+  attributes: {
+    batchId: {
+      type: "string",
+      required: true
+    },
+    attribute: {
+      type: "string",
+      required: true
+    },
+    value: {
+      type: "text"
+    },
+    userEmail: {
+      type: "string"
+    },
+    userName: {
+      type: "string"
+    },
+    updatedCount: {
+      type: "integer",
+      default: 0
+    },
+    skippedCount: {
+      type: "integer",
+      default: 0
+    },
+    totalTargets: {
+      type: "integer",
+      default: 0
+    },
+    diffs: {
+      type: "json"
+    },
+    isRolledBack: {
+      type: "boolean",
+      default: false
+    },
+    rolledBackAt: {
+      type: "datetime"
+    },
+    rolledBackBy: {
+      type: "string"
+    },
+    executedAt: {
+      type: "datetime"
+    }
+  }
+};
+const contentTypes = {
+  "audit-log": {
+    schema: auditLog
+  }
+};
 const bulkUpdaterController = ({ strapi: strapi2 }) => ({
   async getModels(ctx) {
     try {
@@ -211,7 +283,7 @@ const bulkUpdaterController = ({ strapi: strapi2 }) => ({
           return;
         }
       }
-      ctx.body = data;
+      ctx.body = { success: true, ...data };
     } catch (err) {
       ctx.status = 500;
       ctx.body = { success: false, error: err.message };
@@ -660,9 +732,69 @@ async function executeBatchInternal(strapi2, {
       try {
         const currentEntry = await getDocumentDeduplicated(target.uid, target.documentId);
         const entryLabel = currentEntry?.name || currentEntry?.title || currentEntry?.email || `Entry #${target.documentId}`;
+        const isNested = attribute.includes(".");
+        let isComponentNested = false;
+        let parentKey = "";
+        let childKey = "";
+        if (isNested) {
+          const parts = attribute.split(".");
+          parentKey = parts[0];
+          childKey = parts[1];
+          const parentAttrDef = contentType?.attributes?.[parentKey];
+          if (parentAttrDef?.type === "component" && !parentAttrDef.repeatable && parentAttrDef.component) {
+            const compSchema = strapi2.components[parentAttrDef.component];
+            if (compSchema?.attributes?.[childKey]) {
+              isComponentNested = true;
+            }
+          }
+        }
         const attrDef = contentType?.attributes?.[attribute];
-        const hasAttribute = Boolean(attrDef);
+        const hasAttribute = Boolean(attrDef) || isComponentNested;
         if (hasAttribute) {
+          if (isComponentNested) {
+            const currentEntryWithPopulate = await strapi2.documents(target.uid).findOne({
+              documentId: target.documentId,
+              populate: [parentKey]
+            });
+            const existingParent = currentEntryWithPopulate?.[parentKey] || {};
+            const currentVal2 = existingParent?.[childKey];
+            let newValue2 = value;
+            if (regexObj && typeof currentVal2 === "string") {
+              newValue2 = currentVal2.replace(regexObj, value);
+            }
+            const updatedParent = {
+              ...existingParent,
+              [childKey]: newValue2
+            };
+            await strapi2.documents(target.uid).update({
+              documentId: target.documentId,
+              data: {
+                [parentKey]: updatedParent
+              }
+            });
+            const isDraftAndPublishComp = Boolean(contentType?.options?.draftAndPublish);
+            if (publishOnApproval && isDraftAndPublishComp) {
+              try {
+                await strapi2.documents(target.uid).publish({
+                  documentId: target.documentId
+                });
+              } catch (publishErr) {
+                strapi2.log.warn(`[bulk-updater] Failed to auto-publish ${target.uid}/${target.documentId}:`, publishErr);
+              }
+            }
+            invalidateCollectionCache(target.uid);
+            return {
+              uid: target.uid,
+              collectionName: displayName,
+              documentId: target.documentId,
+              label: entryLabel,
+              attribute,
+              oldValue: currentVal2 ?? null,
+              newValue: newValue2,
+              status: "updated",
+              message: `Successfully updated nested field ${attribute}`
+            };
+          }
           if (attrDef.type === "relation") {
             const isMulti = attrDef.relation === "oneToMany" || attrDef.relation === "manyToMany";
             const currentEntryWithPopulate = await strapi2.documents(target.uid).findOne({
@@ -904,9 +1036,24 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
           const isSingleType = contentType.kind === "singleType";
           const rawAttrs = contentType.attributes || {};
           const relationsByAttr = {};
+          const nestedComponentAttrs = [];
           const validAttrs = Object.keys(rawAttrs).filter((attrKey) => {
             if (systemFields.includes(attrKey)) return false;
-            if (rawAttrs[attrKey].type === "component" || rawAttrs[attrKey].type === "dynamiczone") return false;
+            if (rawAttrs[attrKey].type === "dynamiczone") return false;
+            if (rawAttrs[attrKey].type === "component") {
+              const compDef = rawAttrs[attrKey];
+              if (!compDef.repeatable && compDef.component) {
+                const componentSchema = strapi2.components[compDef.component];
+                if (componentSchema && componentSchema.attributes) {
+                  for (const [subKey, subAttr] of Object.entries(componentSchema.attributes)) {
+                    if (systemFields.includes(subKey)) continue;
+                    if (["component", "dynamiczone", "relation"].includes(subAttr.type)) continue;
+                    nestedComponentAttrs.push(`${attrKey}.${subKey}`);
+                  }
+                }
+              }
+              return false;
+            }
             if (rawAttrs[attrKey].type === "relation") {
               const rel = rawAttrs[attrKey];
               const targetUid = rel.target;
@@ -926,7 +1073,8 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
             }
             return true;
           });
-          validAttrs.forEach((attr) => allAttributesSet.add(attr));
+          const allColAttrs = [...validAttrs, ...nestedComponentAttrs];
+          allColAttrs.forEach((attr) => allAttributesSet.add(attr));
           metaByUid[uid] = {
             uid,
             kind: contentType.kind,
@@ -934,7 +1082,7 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
             singularName: contentType.info?.singularName || uid,
             pluralName: contentType.info?.pluralName || uid,
             displayName: contentType.info?.displayName || uid,
-            attributes: validAttrs,
+            attributes: allColAttrs,
             relations: relationsByAttr
           };
         }
@@ -963,8 +1111,17 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
           let entries = [];
           let totalCount = 0;
           try {
+            const ctAttrs = allContentTypes[uid]?.attributes || {};
             const relKeys = Object.keys(meta.relations || {});
-            const populateOption = relKeys.length > 0 ? relKeys.reduce((acc, k) => ({ ...acc, [k]: true }), {}) : void 0;
+            const compKeys = Object.keys(ctAttrs).filter((k) => ctAttrs[k].type === "component");
+            const populateOptionObj = {};
+            relKeys.forEach((k) => {
+              populateOptionObj[k] = true;
+            });
+            compKeys.forEach((k) => {
+              populateOptionObj[k] = true;
+            });
+            const populateOption = Object.keys(populateOptionObj).length > 0 ? populateOptionObj : void 0;
             if (meta.isSingleType) {
               const singleDoc = await strapi2.documents(uid).findFirst({
                 populate: populateOption
@@ -1042,7 +1199,7 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
       if (!contentType) {
         throw new Error(`Collection with UID "${uid}" does not exist.`);
       }
-      const limit = Math.min(Math.max(Number(pageSize) || 10, 1), 100);
+      const limit = Math.min(Math.max(Number(pageSize) || 10, 1), 500);
       const currentPage = Math.max(Number(page) || 1, 1);
       const start = (currentPage - 1) * limit;
       const isSingleType = contentType.kind === "singleType";
@@ -1058,8 +1215,118 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
         };
       }
       let result;
+      const filters2 = {};
+      const attrs = contentType.attributes || {};
+      let colHasAttribute = false;
+      let isNestedAttr = false;
+      let parentKey = "";
+      let childKey = "";
+      if (attribute) {
+        if (attribute.includes(".")) {
+          [parentKey, childKey] = attribute.split(".");
+          if (attrs[parentKey]?.type === "component" && !attrs[parentKey].repeatable && attrs[parentKey].component) {
+            const compSchema = strapi2.components[attrs[parentKey].component];
+            if (compSchema?.attributes?.[childKey]) {
+              colHasAttribute = true;
+              isNestedAttr = true;
+            }
+          }
+        } else if (attrs[attribute]) {
+          colHasAttribute = true;
+        }
+      }
+      const normOp = (filterOperator || "").toLowerCase().replace(/_/g, "");
+      if (normOp && normOp !== "none") {
+        if (!colHasAttribute) {
+          result = {
+            uid,
+            displayName: contentType.info?.displayName || uid,
+            isSingleType,
+            entries: [],
+            pagination: {
+              page: 1,
+              pageSize: limit,
+              total: 0,
+              pageCount: 0
+            }
+          };
+          queryCache.set(cacheKey, { signature, data: result, timestamp: Date.now() });
+          return { ...result, cached: false, etag };
+        }
+        let condition = void 0;
+        const q = (filterQuery || "").trim();
+        if (normOp === "empty") {
+          condition = { $or: [{ $null: true }, { $eq: "" }] };
+        } else if (normOp === "notempty") {
+          condition = { $and: [{ $notNull: true }, { $ne: "" }] };
+        } else if (q !== "") {
+          switch (normOp) {
+            case "equals":
+              condition = { $containsi: q };
+              break;
+            case "notequals":
+              condition = { $notContainsi: q };
+              break;
+            case "contains":
+              condition = { $containsi: q };
+              break;
+            case "notcontains":
+              condition = { $notContainsi: q };
+              break;
+            case "startswith":
+              condition = { $startsWith: q };
+              break;
+            case "endswith":
+              condition = { $endsWith: q };
+              break;
+          }
+        }
+        if (condition !== void 0) {
+          if (isNestedAttr) {
+            filters2[parentKey] = {
+              [childKey]: condition
+            };
+          } else {
+            if (normOp === "empty") {
+              filters2.$or = [
+                { [attribute]: { $null: true } },
+                { [attribute]: { $eq: "" } }
+              ];
+            } else if (normOp === "notempty") {
+              filters2[attribute] = { $notNull: true, $ne: "" };
+            } else {
+              filters2[attribute] = condition;
+            }
+          }
+        }
+      }
+      if (search && search.trim() !== "") {
+        const q = search.trim();
+        const searchableAttrs = Object.keys(attrs).filter(
+          (k) => ["string", "text", "email", "uid"].includes(attrs[k]?.type)
+        );
+        if (searchableAttrs.length > 0) {
+          const orList = searchableAttrs.slice(0, 6).map((k) => ({
+            [k]: { $containsi: q }
+          }));
+          if (Object.keys(filters2).length > 0) {
+            const existingFilters = { ...filters2 };
+            Object.keys(filters2).forEach((k) => delete filters2[k]);
+            filters2.$and = [existingFilters, { $or: orList }];
+          } else {
+            filters2.$or = orList;
+          }
+        }
+      }
       if (isSingleType) {
-        const singleDoc = await strapi2.documents(uid).findFirst();
+        let singleDoc = null;
+        try {
+          singleDoc = await strapi2.documents(uid).findFirst({
+            filters: Object.keys(filters2).length > 0 ? filters2 : void 0
+          });
+        } catch {
+          singleDoc = null;
+        }
         result = {
           uid,
           displayName: contentType.info?.displayName || uid,
@@ -1073,55 +1340,23 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
           }
         };
       } else {
-        const filters2 = {};
-        if (attribute && filterOperator && filterQuery !== void 0 && filterQuery !== "") {
-          switch (filterOperator) {
-            case "equals":
-              filters2[attribute] = { $eq: filterQuery };
-              break;
-            case "notEquals":
-              filters2[attribute] = { $ne: filterQuery };
-              break;
-            case "contains":
-              filters2[attribute] = { $containsi: filterQuery };
-              break;
-            case "notContains":
-              filters2[attribute] = { $notContainsi: filterQuery };
-              break;
-            case "startsWith":
-              filters2[attribute] = { $startsWith: filterQuery };
-              break;
-            case "endsWith":
-              filters2[attribute] = { $endsWith: filterQuery };
-              break;
-            case "empty":
-              filters2[attribute] = { $null: true };
-              break;
-            case "notEmpty":
-              filters2[attribute] = { $notNull: true };
-              break;
-          }
-        }
-        if (search && search.trim() !== "") {
-          const stringAttrs = Object.keys(contentType.attributes || {}).filter(
-            (k) => contentType.attributes[k].type === "string" || contentType.attributes[k].type === "text" || contentType.attributes[k].type === "email"
-          );
-          if (stringAttrs.length > 0) {
-            filters2.$or = stringAttrs.slice(0, 5).map((attr) => ({
-              [attr]: { $containsi: search.trim() }
-            }));
-          }
-        }
         const sortClause = {};
-        if (sortField && contentType.attributes?.[sortField]) {
+        if (sortField && sortField.includes(".")) {
+          const [parent, child] = sortField.split(".");
+          if (contentType.attributes?.[parent]?.type === "component") {
+            sortClause[parent] = { [child]: sortOrder };
+          } else {
+            sortClause["createdAt"] = "desc";
+          }
+        } else if (sortField && contentType.attributes?.[sortField]) {
           sortClause[sortField] = sortOrder;
         } else {
           sortClause["createdAt"] = "desc";
         }
-        const relationAttrs = Object.keys(contentType.attributes || {}).filter(
-          (k) => contentType.attributes[k].type === "relation"
+        const populateAttrs = Object.keys(contentType.attributes || {}).filter(
+          (k) => contentType.attributes[k].type === "relation" || contentType.attributes[k].type === "component"
         );
-        const populateOption = relationAttrs.length > 0 ? relationAttrs.reduce((acc, k) => ({ ...acc, [k]: true }), {}) : void 0;
+        const populateOption = populateAttrs.length > 0 ? populateAttrs.reduce((acc, k) => ({ ...acc, [k]: true }), {}) : void 0;
         const [entries, totalEntries] = await Promise.all([
           strapi2.documents(uid).findMany({
             start,
@@ -1460,6 +1695,9 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
         modelsCache.clear();
         staticSchemaCache = null;
       }
+    },
+    invalidateCollectionCache(uid) {
+      invalidateCollectionCache(uid);
     }
   };
 };
@@ -1479,6 +1717,7 @@ const DEFAULT_FIELDS = {
   executedAt: "executedAt"
 };
 const DEFAULT_CANDIDATE_TYPES = [
+  "plugin::bulk-updater.audit-log",
   "api::audit-log.audit-log",
   "api::audit.audit",
   "api::bulk-audit-log.bulk-audit-log"
@@ -1500,6 +1739,7 @@ const auditService = ({ strapi: strapi2 }) => ({
    * 1. Explicit consumer custom schema (full declarative control)
    * 2. Zero-config convention auto-detection (api::audit-log.audit-log)
    * 3. Strapi Enterprise native audit log bridge
+   * 4. Zero-config plugin core store (works out of the box in 100% of Strapi installations)
    */
   getAuditConfig() {
     const rawConfig = strapi2.config.get("plugin::bulk-updater.audit");
@@ -1553,10 +1793,9 @@ const auditService = ({ strapi: strapi2 }) => ({
       };
     }
     return {
-      enabled: false,
-      mode: "disabled",
-      isEnterpriseNativeAvailable: false,
-      error: "No audit collection configured or detected. To enable rollback, provide a collection or use Strapi Enterprise."
+      enabled: true,
+      mode: "store",
+      isEnterpriseNativeAvailable: false
     };
   },
   /**
@@ -1601,7 +1840,40 @@ const auditService = ({ strapi: strapi2 }) => ({
       },
       user
     );
-    if (!config.enabled || !config.contentType || !config.fields) {
+    if (!config.enabled) {
+      return null;
+    }
+    if (config.mode === "store") {
+      try {
+        const store = strapi2.store({ type: "plugin", name: "bulk-updater", key: "audit-history" });
+        const stored = await store.get({}) || { history: [] };
+        const history = Array.isArray(stored.history) ? stored.history : [];
+        const newRecord = {
+          id: batchSummary.batchId,
+          documentId: batchSummary.batchId,
+          batchId: batchSummary.batchId,
+          attribute: batchSummary.attribute,
+          value: batchSummary.value,
+          userEmail: user?.email || "admin@strapi.io",
+          userName: user?.firstname ? `${user.firstname} ${user.lastname || ""}`.trim() : user?.email || "Admin",
+          updatedCount: batchSummary.updatedCount,
+          skippedCount: batchSummary.skippedCount,
+          totalTargets: batchSummary.totalTargets,
+          diffs: results,
+          isRolledBack: false,
+          rolledBackAt: null,
+          rolledBackBy: null,
+          executedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        const updatedHistory = [newRecord, ...history].slice(0, 200);
+        await store.set({ value: { history: updatedHistory } });
+        return newRecord;
+      } catch (err) {
+        strapi2.log.error(`[bulk-updater] Failed to record audit log in core store: ${err.message}`);
+        return null;
+      }
+    }
+    if (!config.contentType || !config.fields) {
       return null;
     }
     const f = config.fields;
@@ -1642,6 +1914,25 @@ const auditService = ({ strapi: strapi2 }) => ({
         history: []
       };
     }
+    if (config.mode === "store") {
+      try {
+        const store = strapi2.store({ type: "plugin", name: "bulk-updater", key: "audit-history" });
+        const stored = await store.get({}) || { history: [] };
+        const history = Array.isArray(stored.history) ? stored.history : [];
+        return {
+          enabled: true,
+          mode: "store",
+          isEnterpriseNativeAvailable: config.isEnterpriseNativeAvailable,
+          history
+        };
+      } catch (err) {
+        return {
+          enabled: false,
+          message: `Failed to read audit history from core store: ${err.message}`,
+          history: []
+        };
+      }
+    }
     if (!config.enabled || !config.contentType || !config.fields) {
       return {
         enabled: false,
@@ -1687,27 +1978,9 @@ const auditService = ({ strapi: strapi2 }) => ({
     }
   },
   /**
-   * Performs deterministic rollback of a batch
+   * Helper to revert diff items back to original values
    */
-  async rollbackBatch(batchId, currentUser) {
-    const config = this.getAuditConfig();
-    if (!config.enabled || !config.contentType || !config.fields) {
-      throw new Error("Audit trail is not configured or disabled.");
-    }
-    const f = config.fields;
-    const records = await strapi2.documents(config.contentType).findMany({
-      filters: {
-        [f.batchId]: { $eq: batchId }
-      }
-    });
-    const record = records?.[0];
-    if (!record) {
-      throw new Error(`Batch record with ID "${batchId}" was not found in audit trail.`);
-    }
-    if (record[f.isRolledBack]) {
-      throw new Error(`Batch "${batchId}" has already been rolled back.`);
-    }
-    const diffs = typeof record[f.diffs] === "string" ? JSON.parse(record[f.diffs]) : record[f.diffs] || [];
+  async revertDiffItems(diffs) {
     let revertedCount = 0;
     const rollbackDetails = [];
     for (const item of diffs) {
@@ -1721,12 +1994,41 @@ const auditService = ({ strapi: strapi2 }) => ({
           } else {
             rollbackPayload = item.oldValue;
           }
-          await strapi2.documents(item.uid).update({
-            documentId: item.documentId,
-            data: {
-              [item.attribute]: rollbackPayload
+          if (item.attribute.includes(".")) {
+            const [parentKey, childKey] = item.attribute.split(".");
+            const ct2 = strapi2.contentTypes[item.uid];
+            if (ct2?.attributes?.[parentKey]?.type === "component") {
+              const currentDoc = await strapi2.documents(item.uid).findOne({
+                documentId: item.documentId,
+                populate: [parentKey]
+              });
+              const currentParent = currentDoc?.[parentKey] || {};
+              const restoredParent = {
+                ...currentParent,
+                [childKey]: rollbackPayload
+              };
+              await strapi2.documents(item.uid).update({
+                documentId: item.documentId,
+                data: {
+                  [parentKey]: restoredParent
+                }
+              });
+            } else {
+              await strapi2.documents(item.uid).update({
+                documentId: item.documentId,
+                data: {
+                  [item.attribute]: rollbackPayload
+                }
+              });
             }
-          });
+          } else {
+            await strapi2.documents(item.uid).update({
+              documentId: item.documentId,
+              data: {
+                [item.attribute]: rollbackPayload
+              }
+            });
+          }
           const ct = strapi2.contentTypes[item.uid];
           if (ct?.options?.draftAndPublish) {
             try {
@@ -1737,7 +2039,10 @@ const auditService = ({ strapi: strapi2 }) => ({
             }
           }
           try {
-            strapi2.plugin("bulk-updater").service("bulkUpdater").invalidateCollectionCache(item.uid);
+            const bulkService = strapi2.plugin("bulk-updater").service("bulkUpdater");
+            if (bulkService?.invalidateCache) {
+              bulkService.invalidateCache(item.uid);
+            }
           } catch {
           }
           revertedCount++;
@@ -1760,6 +2065,78 @@ const auditService = ({ strapi: strapi2 }) => ({
         }
       }
     }
+    return { revertedCount, rollbackDetails };
+  },
+  /**
+   * Performs deterministic rollback of a batch
+   */
+  async rollbackBatch(batchId, currentUser) {
+    const config = this.getAuditConfig();
+    if (!config.enabled) {
+      throw new Error("Audit trail is not configured or disabled.");
+    }
+    if (config.mode === "store") {
+      const store = strapi2.store({ type: "plugin", name: "bulk-updater", key: "audit-history" });
+      const stored = await store.get({}) || { history: [] };
+      const history = Array.isArray(stored.history) ? stored.history : [];
+      const recordIndex = history.findIndex((r) => r.batchId === batchId);
+      if (recordIndex === -1) {
+        throw new Error(`Batch record with ID "${batchId}" was not found in audit trail.`);
+      }
+      const record2 = history[recordIndex];
+      if (record2.isRolledBack) {
+        throw new Error(`Batch "${batchId}" has already been rolled back.`);
+      }
+      const diffs2 = Array.isArray(record2.diffs) ? record2.diffs : [];
+      const { revertedCount: revertedCount2, rollbackDetails: rollbackDetails2 } = await this.revertDiffItems(diffs2);
+      record2.isRolledBack = true;
+      record2.rolledBackAt = (/* @__PURE__ */ new Date()).toISOString();
+      record2.rolledBackBy = currentUser?.email || "Admin";
+      history[recordIndex] = record2;
+      await store.set({ value: { history } });
+      try {
+        const affectedUids = new Set(rollbackDetails2.map((d) => d.uid));
+        const bulkService = strapi2.plugin("bulk-updater").service("bulkUpdater");
+        affectedUids.forEach((uid) => {
+          if (uid && bulkService?.invalidateCache) {
+            bulkService.invalidateCache(uid);
+          }
+        });
+      } catch {
+      }
+      await this.recordToEnterpriseNative(
+        "bulk-updater.rollback",
+        {
+          batchId,
+          revertedCount: revertedCount2
+        },
+        currentUser
+      );
+      return {
+        success: true,
+        batchId,
+        revertedCount: revertedCount2,
+        details: rollbackDetails2
+      };
+    }
+    if (!config.contentType || !config.fields) {
+      throw new Error("Audit trail is not configured or disabled.");
+    }
+    const f = config.fields;
+    const records = await strapi2.documents(config.contentType).findMany({
+      filters: {
+        [f.batchId]: { $eq: batchId }
+      }
+    });
+    const record = records?.[0];
+    if (!record) {
+      throw new Error(`Batch record with ID "${batchId}" was not found in audit trail.`);
+    }
+    if (record[f.isRolledBack]) {
+      throw new Error(`Batch "${batchId}" has already been rolled back.`);
+    }
+    const diffs = typeof record[f.diffs] === "string" ? JSON.parse(record[f.diffs]) : record[f.diffs] || [];
+    const { revertedCount, rollbackDetails } = await this.revertDiffItems(diffs);
     const updateData = {};
     if (f.isRolledBack) updateData[f.isRolledBack] = true;
     if (f.rolledBackAt) updateData[f.rolledBackAt] = (/* @__PURE__ */ new Date()).toISOString();
@@ -2117,10 +2494,24 @@ ${sampleRow.map(escapeCsvValue).join(",")}
     const attrs = ct.attributes || {};
     const excluded = ["createdBy", "updatedBy", "localizations"];
     const exportFields = ["documentId"];
+    const compFieldsToPopulate = [];
     for (const [attrName, attrDef] of Object.entries(attrs)) {
       if (excluded.includes(attrName)) continue;
-      if (["component", "dynamiczone", "media"].includes(attrDef.type)) continue;
-      if (attrDef.type === "relation") continue;
+      if (["dynamiczone", "media", "relation"].includes(attrDef.type)) continue;
+      if (attrDef.type === "component") {
+        if (!attrDef.repeatable && attrDef.component) {
+          const comp = strapi2.components[attrDef.component];
+          if (comp?.attributes) {
+            compFieldsToPopulate.push(attrName);
+            for (const [subKey, subDef] of Object.entries(comp.attributes)) {
+              if (excluded.includes(subKey)) continue;
+              if (["component", "dynamiczone", "media", "relation"].includes(subDef.type)) continue;
+              exportFields.push(`${attrName}.${subKey}`);
+            }
+          }
+        }
+        continue;
+      }
       exportFields.push(attrName);
     }
     const filters2 = {};
@@ -2164,16 +2555,25 @@ ${sampleRow.map(escapeCsvValue).join(",")}
         }
       }
     }
+    const populateOption = compFieldsToPopulate.length > 0 ? compFieldsToPopulate.reduce((acc, k) => ({ ...acc, [k]: true }), {}) : void 0;
     const entries = await strapi2.documents(uid).findMany({
       filters: Object.keys(filters2).length > 0 ? filters2 : void 0,
       limit: options.limit || 5e3,
-      sort: { createdAt: "desc" }
+      sort: { createdAt: "desc" },
+      populate: populateOption
     });
     const lines = [];
     lines.push(exportFields.map(escapeCsvValue).join(","));
     for (const entry of entries || []) {
       const rowValues = exportFields.map((field) => {
-        return escapeCsvValue(entry[field]);
+        let val;
+        if (field.includes(".")) {
+          const [parent, child] = field.split(".");
+          val = entry[parent]?.[child];
+        } else {
+          val = entry[field];
+        }
+        return escapeCsvValue(val);
       });
       lines.push(rowValues.join(","));
     }
@@ -2259,6 +2659,29 @@ ${sampleRow.map(escapeCsvValue).join(",")}
       const payload = {};
       for (const [key, rawVal] of Object.entries(row)) {
         if (key === "documentId" || key === "id") continue;
+        if (key.includes(".")) {
+          const [parent, child] = key.split(".");
+          const parentDef = attrs[parent];
+          if (parentDef?.type === "component" && !parentDef.repeatable && parentDef.component) {
+            const comp = strapi2.components[parentDef.component];
+            const childDef = comp?.attributes?.[child];
+            if (childDef) {
+              if (!payload[parent]) payload[parent] = {};
+              let val = rawVal;
+              if (rawVal === "" || rawVal === null || rawVal === void 0) {
+                val = null;
+              } else if (childDef.type === "integer" || childDef.type === "biginteger") {
+                val = parseInt(rawVal, 10);
+              } else if (childDef.type === "float" || childDef.type === "decimal") {
+                val = parseFloat(rawVal);
+              } else if (childDef.type === "boolean") {
+                val = rawVal.toLowerCase() === "true" || rawVal === "1";
+              }
+              payload[parent][child] = val;
+            }
+          }
+          continue;
+        }
         const attrDef = attrs[key];
         if (!attrDef) continue;
         if (rawVal === "" || rawVal === null || rawVal === void 0) {
@@ -2310,9 +2733,15 @@ ${sampleRow.map(escapeCsvValue).join(",")}
             });
             continue;
           }
+          const mergedPayload = { ...payload };
+          for (const key of Object.keys(payload)) {
+            if (attrs[key]?.type === "component" && typeof payload[key] === "object" && payload[key] !== null) {
+              mergedPayload[key] = { ...existing[key] || {}, ...payload[key] };
+            }
+          }
           await strapi2.documents(uid).update({
             documentId: docId,
-            data: payload
+            data: mergedPayload
           });
           if (publish && ct.options?.draftAndPublish) {
             try {
@@ -2339,9 +2768,15 @@ ${sampleRow.map(escapeCsvValue).join(",")}
               documentId: docId
             });
             if (existing) {
+              const mergedPayload = { ...payload };
+              for (const key of Object.keys(payload)) {
+                if (attrs[key]?.type === "component" && typeof payload[key] === "object" && payload[key] !== null) {
+                  mergedPayload[key] = { ...existing[key] || {}, ...payload[key] };
+                }
+              }
               await strapi2.documents(uid).update({
                 documentId: docId,
-                data: payload
+                data: mergedPayload
               });
               if (publish && ct.options?.draftAndPublish) {
                 try {
@@ -31944,6 +32379,7 @@ const index = {
     });
   },
   routes,
+  contentTypes,
   controllers: {
     bulkUpdater: bulkUpdaterController,
     audit: auditController,