strapi-plugin-bulk-updater 1.3.11 → 1.4.3

package/dist/server/index.mjs

@@ -908,9 +908,72 @@ function discoverComponentAttributes(strapi, compUid, prefix, currentDepth, maxD
   }
   return Array.from(new Set(discoveredAttrs));
 }
+function parseDynamicZonePath(path) {
+  if (!path) return { cleanPath: "", rootKey: "", subPath: "" };
+  const bracketMatch = path.match(/^([^.[]+)\[([^\]]+)\]\.(.+)$/);
+  if (bracketMatch) {
+    const rootKey = bracketMatch[1];
+    const selector = bracketMatch[2];
+    const subPath = bracketMatch[3];
+    const cleanPath = `${rootKey}.${subPath}`;
+    if (/^\d+$/.test(selector)) {
+      return { cleanPath, rootKey, subPath, targetIndex: parseInt(selector, 10) };
+    }
+    return { cleanPath, rootKey, subPath, targetComponentUid: selector };
+  }
+  const parts = path.split(".");
+  return {
+    cleanPath: path,
+    rootKey: parts[0] || "",
+    subPath: parts.slice(1).join(".")
+  };
+}
+function formatComponentName(compUid) {
+  if (!compUid) return "Component";
+  const name = compUid.includes(".") ? compUid.split(".")[1] : compUid;
+  return name.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function getAllNestedValues(obj, path) {
+  if (!obj || !path) return [];
+  const parsed = parseDynamicZonePath(path);
+  const parts = parsed.cleanPath.split(".");
+  const [head, ...tail] = parts;
+  const rootTarget = obj[head];
+  if (Array.isArray(rootTarget)) {
+    const results = [];
+    rootTarget.forEach((item, idx) => {
+      if (!item || typeof item !== "object") return;
+      if (parsed.targetIndex !== void 0 && idx !== parsed.targetIndex) return;
+      if (parsed.targetComponentUid && item.__component !== parsed.targetComponentUid) return;
+      const subVal = tail.length > 0 ? getDeepProperty(item, tail.join(".")) : item;
+      if (subVal !== void 0) {
+        results.push({
+          index: idx,
+          componentUid: item.__component,
+          componentName: formatComponentName(item.__component),
+          value: subVal,
+          path: `${head}[#${idx}${item.__component ? ` ${formatComponentName(item.__component)}` : ""}].${tail.join(".")}`
+        });
+      }
+    });
+    return results;
+  }
+  const singleVal = getDeepProperty(obj, parsed.cleanPath);
+  if (singleVal !== void 0) {
+    return [
+      {
+        index: 0,
+        value: singleVal,
+        path: parsed.cleanPath
+      }
+    ];
+  }
+  return [];
+}
 function isDeepComponentField(contentType, allComponents, attribute) {
-  if (!attribute || !attribute.includes(".")) return false;
-  const parts = attribute.split(".");
+  if (!attribute || !attribute.includes(".") && !attribute.includes("[")) return false;
+  const parsed = parseDynamicZonePath(attribute);
+  const parts = parsed.cleanPath.split(".");
   function checkPath(currentSchema, pathParts) {
     if (pathParts.length === 0) return true;
     if (!currentSchema || !currentSchema.attributes) return false;
@@ -926,6 +989,10 @@ function isDeepComponentField(contentType, allComponents, attribute) {
     }
     if (attrDef.type === "dynamiczone") {
       const compUids = Array.isArray(attrDef.components) ? attrDef.components : [];
+      if (parsed.targetComponentUid) {
+        const comp = allComponents[parsed.targetComponentUid];
+        return comp ? checkPath(comp, tail) : false;
+      }
       return compUids.some((compUid) => {
         const comp = allComponents[compUid];
         return checkPath(comp, tail);
@@ -937,8 +1004,9 @@ function isDeepComponentField(contentType, allComponents, attribute) {
 }
 function getLeafAttributeSchema(contentType, allComponents, attribute) {
   if (!attribute) return null;
-  if (!attribute.includes(".")) return contentType?.attributes?.[attribute] || null;
-  const parts = attribute.split(".");
+  const parsed = parseDynamicZonePath(attribute);
+  if (!parsed.cleanPath.includes(".")) return contentType?.attributes?.[parsed.cleanPath] || null;
+  const parts = parsed.cleanPath.split(".");
   function resolveLeaf(currentSchema, pathParts) {
     if (!currentSchema || !currentSchema.attributes) return null;
     const [head, ...tail] = pathParts;
@@ -952,6 +1020,9 @@ function getLeafAttributeSchema(contentType, allComponents, attribute) {
     }
     if (attrDef.type === "dynamiczone") {
       const compUids = Array.isArray(attrDef.components) ? attrDef.components : [];
+      if (parsed.targetComponentUid) {
+        return resolveLeaf(allComponents[parsed.targetComponentUid], tail);
+      }
       for (const compUid of compUids) {
         const found = resolveLeaf(allComponents[compUid], tail);
         if (found) return found;
@@ -961,22 +1032,28 @@ function getLeafAttributeSchema(contentType, allComponents, attribute) {
   }
   return resolveLeaf(contentType, parts);
 }
-function setDeepProperty(obj, pathParts, value) {
+function setDeepProperty(obj, pathParts, value, options) {
   if (pathParts.length === 0) return value;
   const [head, ...tail] = pathParts;
   if (Array.isArray(obj)) {
     if (/^\d+$/.test(head)) {
       const idx = parseInt(head, 10);
       const copy = [...obj];
-      copy[idx] = setDeepProperty(copy[idx] || {}, tail, value);
+      copy[idx] = setDeepProperty(copy[idx] || {}, tail, value, options);
       return copy;
     }
-    return obj.map((item) => {
+    return obj.map((item, idx) => {
       if (!item || typeof item !== "object") return item;
+      if (options?.targetIndexes && options.targetIndexes.length > 0) {
+        if (!options.targetIndexes.includes(idx)) return item;
+      }
+      if (options?.targetComponentUid) {
+        if (item.__component !== options.targetComponentUid) return item;
+      }
       if (head in item || tail.length > 0 && typeof item[head] === "object") {
         return {
           ...item,
-          [head]: setDeepProperty(item[head], tail, value)
+          [head]: setDeepProperty(item[head], tail, value, options)
         };
       }
       return item;
@@ -988,16 +1065,17 @@ function setDeepProperty(obj, pathParts, value) {
   } else {
     const subTarget = current[head];
     if (Array.isArray(subTarget)) {
-      current[head] = setDeepProperty(subTarget, tail, value);
+      current[head] = setDeepProperty(subTarget, tail, value, options);
     } else {
-      current[head] = setDeepProperty(subTarget || {}, tail, value);
+      current[head] = setDeepProperty(subTarget || {}, tail, value, options);
     }
   }
   return current;
 }
 function getDeepProperty(obj, path) {
   if (!obj || !path) return void 0;
-  const parts = path.split(".");
+  const parsed = parseDynamicZonePath(path);
+  const parts = parsed.cleanPath.split(".");
   function extract(current, remainingParts) {
     if (current === void 0 || current === null) return void 0;
     if (remainingParts.length === 0) return current;
@@ -1006,7 +1084,10 @@ function getDeepProperty(obj, path) {
       if (/^\d+$/.test(head)) {
         return extract(current[parseInt(head, 10)], tail);
       }
-      for (const item of current) {
+      for (let idx = 0; idx < current.length; idx++) {
+        const item = current[idx];
+        if (parsed.targetIndex !== void 0 && idx !== parsed.targetIndex) continue;
+        if (parsed.targetComponentUid && item?.__component !== parsed.targetComponentUid) continue;
         const found = extract(item?.[head], tail);
         if (found !== void 0 && found !== null) return found;
       }
@@ -1171,7 +1252,12 @@ async function executeBatchInternal(strapi, {
   for (const item of selectedEntries) {
     if (!item.uid || !item.documentId) continue;
     const key = `${item.uid}@@@${item.documentId}`;
-    targetsMap.set(key, { uid: item.uid, documentId: item.documentId });
+    targetsMap.set(key, {
+      uid: item.uid,
+      documentId: item.documentId,
+      dynamicZoneIndexes: item.dynamicZoneIndexes,
+      targetComponentUid: item.targetComponentUid
+    });
   }
   if (targetsMap.size === 0) {
     throw new Error("No collections or entries were selected for update.");
@@ -1230,10 +1316,13 @@ async function executeBatchInternal(strapi, {
       try {
         const currentEntry = await getDocumentDeduplicated(target.uid, target.documentId);
         const entryLabel = currentEntry?.name || currentEntry?.title || currentEntry?.email || `Entry #${target.documentId}`;
-        const isNested = attribute.includes(".");
+        const parsed = parseDynamicZonePath(attribute);
+        const isNested = attribute.includes(".") || attribute.includes("[");
         const isComponentNested = isNested && isDeepComponentField(contentType, strapi.components, attribute);
-        const parts = isNested ? attribute.split(".") : [];
-        const rootKey = isNested ? parts[0] : "";
+        const parts = isNested ? parsed.cleanPath.split(".") : [];
+        const rootKey = parsed.rootKey;
+        const targetComponentUid = target.targetComponentUid || parsed.targetComponentUid;
+        const targetIndexes = target.dynamicZoneIndexes;
         const attrDef = contentType?.attributes?.[attribute];
         const hasAttribute = Boolean(attrDef) || isComponentNested;
         if (hasAttribute) {
@@ -1246,12 +1335,25 @@ async function executeBatchInternal(strapi, {
             const currentEntryWithPopulate = await strapi.documents(target.uid).findOne(findOneArgs);
             const isRootDz = contentType?.attributes?.[rootKey]?.type === "dynamiczone";
             const existingRoot = currentEntryWithPopulate?.[rootKey] || (isRootDz ? [] : {});
-            const currentVal2 = getDeepProperty(existingRoot, parts.slice(1).join("."));
+            let affectedMatches = [];
+            if (isRootDz && Array.isArray(existingRoot)) {
+              affectedMatches = getAllNestedValues({ [rootKey]: existingRoot }, attribute);
+              if (targetIndexes && targetIndexes.length > 0) {
+                affectedMatches = affectedMatches.filter((m) => targetIndexes.includes(m.index));
+              }
+              if (targetComponentUid) {
+                affectedMatches = affectedMatches.filter((m) => m.componentUid === targetComponentUid);
+              }
+            }
+            const currentVal2 = isRootDz ? affectedMatches.length > 0 ? affectedMatches.map((m) => m.value).join(", ") : getDeepProperty(existingRoot, parts.slice(1).join(".")) : getDeepProperty(existingRoot, parts.slice(1).join("."));
             let newValue2 = value;
             if (regexObj && typeof currentVal2 === "string") {
               newValue2 = currentVal2.replace(regexObj, value);
             }
-            const updatedRoot = setDeepProperty(existingRoot, parts.slice(1), newValue2);
+            const updatedRoot = setDeepProperty(existingRoot, parts.slice(1), newValue2, {
+              targetIndexes,
+              targetComponentUid
+            });
             await strapi.documents(target.uid).update({
               documentId: target.documentId,
               data: {
@@ -1275,6 +1377,14 @@ async function executeBatchInternal(strapi, {
               userId: currentUser?.id,
               statusOverride: publishOnApproval && isDraftAndPublishComp ? "published" : void 0
             });
+            const dzDiffs = isRootDz && affectedMatches.length > 0 ? affectedMatches.map((m) => ({
+              index: m.index,
+              componentUid: m.componentUid,
+              componentName: m.componentName,
+              attribute: `${rootKey}[#${m.index} ${m.componentName}].${parts.slice(1).join(".")}`,
+              oldValue: m.value,
+              newValue: regexObj && typeof m.value === "string" ? m.value.replace(regexObj, value) : value
+            })) : [];
             return {
               uid: target.uid,
               collectionName: displayName,
@@ -1284,7 +1394,8 @@ async function executeBatchInternal(strapi, {
               oldValue: currentVal2 ?? null,
               newValue: newValue2,
               status: "updated",
-              message: `Successfully updated nested field ${attribute}`
+              message: isRootDz ? `Successfully updated ${affectedMatches.length} dynamic zone item(s) in ${attribute}` : `Successfully updated nested field ${attribute}`,
+              dynamicZoneDiffs: dzDiffs
             };
           }
           if (attrDef.type === "relation") {
@@ -1313,13 +1424,13 @@ async function executeBatchInternal(strapi, {
               newDisplay = "(cleared / unlinked)";
             } else {
               try {
-                const parsed = JSON.parse(value);
-                if (parsed && typeof parsed === "object" && parsed.mode) {
-                  mode = parsed.mode;
-                  targetDocIds = Array.isArray(parsed.documentIds) ? parsed.documentIds : parsed.documentId ? [parsed.documentId] : [];
-                  newDisplay = parsed.label || targetDocIds.join(", ") || `[${mode}]`;
-                } else if (Array.isArray(parsed)) {
-                  targetDocIds = parsed;
+                const parsed2 = JSON.parse(value);
+                if (parsed2 && typeof parsed2 === "object" && parsed2.mode) {
+                  mode = parsed2.mode;
+                  targetDocIds = Array.isArray(parsed2.documentIds) ? parsed2.documentIds : parsed2.documentId ? [parsed2.documentId] : [];
+                  newDisplay = parsed2.label || targetDocIds.join(", ") || `[${mode}]`;
+                } else if (Array.isArray(parsed2)) {
+                  targetDocIds = parsed2;
                   newDisplay = targetDocIds.join(", ");
                 } else {
                   targetDocIds = [value];
@@ -1463,6 +1574,26 @@ async function executeBatchInternal(strapi, {
     ...r,
     isLive: r.status === "updated"
   }));
+  const flattenedDiffs = [];
+  for (const r of results) {
+    if (r.dynamicZoneDiffs && r.dynamicZoneDiffs.length > 0) {
+      for (const dz of r.dynamicZoneDiffs) {
+        flattenedDiffs.push({
+          uid: r.uid,
+          collectionName: r.collectionName,
+          documentId: r.documentId,
+          label: `${r.label} [Block #${dz.index} (${dz.componentName})]`,
+          attribute: dz.attribute,
+          oldValue: dz.oldValue,
+          newValue: dz.newValue,
+          status: "updated",
+          message: `Updated ${dz.attribute}`
+        });
+      }
+    } else {
+      flattenedDiffs.push(r);
+    }
+  }
   const batchSummary = {
     batchId,
     attribute,
@@ -1474,7 +1605,7 @@ async function executeBatchInternal(strapi, {
   };
   await strapi.plugin("bulk-updater").service("audit").recordBatch(
     batchSummary,
-    results,
+    flattenedDiffs,
     currentUser
   );
   return {
@@ -1742,6 +1873,19 @@ const bulkUpdaterService = ({ strapi }) => {
                   colAttributesMeta
                 );
                 nestedComponentAttrs.push(...compAttrs);
+                const scopedAttrs = discoverComponentAttributes(
+                  strapi,
+                  compUid,
+                  `${attrKey}[${compUid}]`,
+                  1,
+                  5,
+                  systemFields,
+                  allContentTypes,
+                  relationsByAttr,
+                  allRelationsMeta,
+                  colAttributesMeta
+                );
+                nestedComponentAttrs.push(...scopedAttrs);
               }
               return false;
             }
@@ -1956,13 +2100,20 @@ const bulkUpdaterService = ({ strapi }) => {
       const attrs = contentType.attributes || {};
       let colHasAttribute = false;
       let isNestedAttr = false;
+      let isRootDz = false;
       let parts = [];
       if (targetFilterAttr) {
-        if (targetFilterAttr.includes(".")) {
+        const parsed = parseDynamicZonePath(targetFilterAttr);
+        if (parsed.rootKey && contentType.attributes?.[parsed.rootKey]?.type === "dynamiczone") {
+          isRootDz = true;
+          colHasAttribute = true;
+          isNestedAttr = true;
+          parts = parsed.cleanPath.split(".");
+        } else if (targetFilterAttr.includes(".") || targetFilterAttr.includes("[")) {
           isNestedAttr = isDeepComponentField(contentType, strapi.components, targetFilterAttr);
           if (isNestedAttr) {
             colHasAttribute = true;
-            parts = targetFilterAttr.split(".");
+            parts = parsed.cleanPath.split(".");
           }
         } else if (attrs[targetFilterAttr]) {
           colHasAttribute = true;
@@ -2019,8 +2170,11 @@ const bulkUpdaterService = ({ strapi }) => {
         }
         if (condition !== void 0) {
           if (isNestedAttr) {
-            const deepFilter = buildDeepFilter(parts, condition);
-            Object.assign(filters, deepFilter);
+            if (isRootDz) ;
+            else {
+              const deepFilter = buildDeepFilter(parts, condition);
+              Object.assign(filters, deepFilter);
+            }
           } else {
             if (normOp === "empty" && isStringLike) {
               filters.$or = [
@@ -2094,39 +2248,100 @@ const bulkUpdaterService = ({ strapi }) => {
         } else {
           sortClause["createdAt"] = "desc";
         }
-        const findManyArgs = {
-          start,
-          limit,
-          filters: Object.keys(filters).length > 0 ? filters : void 0,
-          sort: sortClause
-        };
-        if (populateOption) {
-          findManyArgs.populate = populateOption;
-        }
-        const [entries, totalEntries] = await Promise.all([
-          strapi.documents(uid).findMany(findManyArgs),
-          strapi.documents(uid).count({
-            filters: Object.keys(filters).length > 0 ? filters : void 0
-          })
-        ]);
-        const totalPages = Math.ceil(totalEntries / limit);
-        result = {
-          uid,
-          displayName: contentType.info?.displayName || uid,
-          isSingleType: false,
-          draftAndPublish: Boolean(contentType.options?.draftAndPublish),
-          entries: (entries || []).map((entry) => ({
-            id: entry.id,
-            documentId: entry.documentId,
-            ...entry
-          })),
-          pagination: {
-            page: currentPage,
-            pageSize: limit,
-            total: totalEntries,
-            pageCount: totalPages
+        if (isRootDz && normOp && normOp !== "none") {
+          const findManyArgs = {
+            limit: 500,
+            filters: Object.keys(filters).length > 0 ? filters : void 0,
+            sort: sortClause
+          };
+          if (populateOption) {
+            findManyArgs.populate = populateOption;
           }
-        };
+          const rawEntries = await strapi.documents(uid).findMany(findManyArgs);
+          const qVal = (filterQuery || "").trim().toLowerCase();
+          const passesDzFilter = (entry) => {
+            const matches = getAllNestedValues(entry, targetFilterAttr);
+            if (normOp === "empty") {
+              return matches.length === 0 || matches.every((m) => m.value === void 0 || m.value === null || String(m.value).trim() === "");
+            }
+            if (normOp === "notempty") {
+              return matches.some((m) => m.value !== void 0 && m.value !== null && String(m.value).trim() !== "");
+            }
+            return matches.some((m) => {
+              if (m.value === void 0 || m.value === null) return false;
+              const valStr = String(m.value).toLowerCase();
+              switch (normOp) {
+                case "equals":
+                  return valStr === qVal;
+                case "notequals":
+                  return valStr !== qVal;
+                case "contains":
+                  return valStr.includes(qVal);
+                case "notcontains":
+                  return !valStr.includes(qVal);
+                case "startswith":
+                  return valStr.startsWith(qVal);
+                case "endswith":
+                  return valStr.endsWith(qVal);
+                default:
+                  return true;
+              }
+            });
+          };
+          const matchedEntries = (rawEntries || []).filter(passesDzFilter);
+          const totalEntries = matchedEntries.length;
+          const paginatedEntries = matchedEntries.slice(start, start + limit);
+          result = {
+            uid,
+            displayName: contentType.info?.displayName || uid,
+            isSingleType: false,
+            draftAndPublish: Boolean(contentType.options?.draftAndPublish),
+            entries: paginatedEntries.map((entry) => ({
+              id: entry.id,
+              documentId: entry.documentId,
+              ...entry
+            })),
+            pagination: {
+              page: currentPage,
+              pageSize: limit,
+              total: totalEntries,
+              pageCount: Math.ceil(totalEntries / limit) || 1
+            }
+          };
+        } else {
+          const findManyArgs = {
+            start,
+            limit,
+            filters: Object.keys(filters).length > 0 ? filters : void 0,
+            sort: sortClause
+          };
+          if (populateOption) {
+            findManyArgs.populate = populateOption;
+          }
+          const [entries, totalEntries] = await Promise.all([
+            strapi.documents(uid).findMany(findManyArgs),
+            strapi.documents(uid).count({
+              filters: Object.keys(filters).length > 0 ? filters : void 0
+            })
+          ]);
+          result = {
+            uid,
+            displayName: contentType.info?.displayName || uid,
+            isSingleType: false,
+            draftAndPublish: Boolean(contentType.options?.draftAndPublish),
+            entries: (entries || []).map((entry) => ({
+              id: entry.id,
+              documentId: entry.documentId,
+              ...entry
+            })),
+            pagination: {
+              page: currentPage,
+              pageSize: limit,
+              total: totalEntries,
+              pageCount: Math.ceil(totalEntries / limit) || 1
+            }
+          };
+        }
       }
       if (queryCache.size >= MAX_QUERY_CACHE_SIZE) {
         const toDelete = Array.from(queryCache.keys()).slice(0, 100);
@@ -4157,6 +4372,99 @@ function parseCsv(csvText) {
   }
   return records;
 }
+const LIFECYCLE_STATUS_WORDS = /* @__PURE__ */ new Set([
+  "pending review",
+  "pending_review",
+  "pending approval",
+  "pending_approval",
+  "approved",
+  "rejected",
+  "draft",
+  "published",
+  "modified",
+  "supported",
+  "ignored"
+]);
+function isValidDocId(val) {
+  if (!val || typeof val !== "string") return false;
+  const trimmed = val.trim();
+  if (!trimmed) return false;
+  if (LIFECYCLE_STATUS_WORDS.has(trimmed.toLowerCase())) return false;
+  if (/\s/.test(trimmed)) return false;
+  return /^[a-zA-Z0-9_-]+$/.test(trimmed);
+}
+function extractDocId(row) {
+  if (!row || typeof row !== "object") return "";
+  const candidates = [
+    row.documentId,
+    row.document_id,
+    row["Document ID"],
+    row["Document Id"],
+    row["document_id"],
+    row.docId,
+    row["docId"],
+    row.id,
+    row.ID,
+    row.Id
+  ];
+  for (const c of candidates) {
+    if (c !== void 0 && c !== null) {
+      const str = String(c).trim();
+      if (isValidDocId(str)) {
+        return str;
+      }
+    }
+  }
+  return "";
+}
+function extractLocale(row) {
+  if (!row || typeof row !== "object") return void 0;
+  const candidates = [row.locale, row.Locale, row["locale"], row["Locale"]];
+  for (const c of candidates) {
+    if (c !== void 0 && c !== null) {
+      const str = String(c).trim();
+      if (str && str.toLowerCase() !== "null" && str.toLowerCase() !== "undefined") {
+        return str;
+      }
+    }
+  }
+  return void 0;
+}
+function extractDetailedErrorMessage(err) {
+  if (!err) return "Error processing row";
+  const detailsErrors = err.details?.errors || err.error?.details?.errors;
+  if (Array.isArray(detailsErrors) && detailsErrors.length > 0) {
+    const messages = detailsErrors.map((e) => {
+      if (!e) return "";
+      const path = Array.isArray(e.path) ? e.path.join(".") : e.path;
+      const msg = e.message || (typeof e === "string" ? e : JSON.stringify(e));
+      return path ? `${path}: ${msg}` : msg;
+    }).filter(Boolean);
+    if (messages.length > 0) return messages.join("; ");
+  }
+  if (Array.isArray(err.inner) && err.inner.length > 0) {
+    const messages = err.inner.map((e) => {
+      if (!e) return "";
+      const path = e.path;
+      const msg = e.message || (typeof e === "string" ? e : JSON.stringify(e));
+      return path ? `${path}: ${msg}` : msg;
+    }).filter(Boolean);
+    if (messages.length > 0) return messages.join("; ");
+  }
+  if (Array.isArray(err.errors) && err.errors.length > 0) {
+    return err.errors.join("; ");
+  }
+  if (typeof err.details === "string" && err.details.trim()) {
+    return err.details;
+  }
+  if (err.details?.message) {
+    return err.details.message;
+  }
+  if (err.message && err.message !== "[object Object]") {
+    return err.message;
+  }
+  return "Error processing row";
+}
 function discoverExportFields(ct, allComponents, maxDepth = 4) {
   const fields = [{ key: "documentId", label: "documentId", type: "string" }];
   const excluded = ["createdBy", "updatedBy", "localizations"];
@@ -4552,13 +4860,63 @@ const csvService = ({ strapi }) => ({
     const batchId = `csv_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
     const userEmail = user?.email || "admin@strapi.io";
     const userName = user ? `${user.firstname || ""} ${user.lastname || ""}`.trim() : "CSV Importer";
+    const findExistingDocument = async (targetDocId, docLocale) => {
+      if (!targetDocId) return null;
+      try {
+        const queryArgs = { documentId: targetDocId };
+        if (docLocale) queryArgs.locale = docLocale;
+        const found = await strapi.documents(uid).findOne(queryArgs);
+        if (found) return found;
+      } catch {
+      }
+      if (/^\d+$/.test(targetDocId)) {
+        try {
+          const queryArgs = {
+            filters: { id: parseInt(targetDocId, 10) },
+            limit: 1
+          };
+          if (docLocale) queryArgs.locale = docLocale;
+          const list = await strapi.documents(uid).findMany(queryArgs);
+          if (list && list.length > 0) return list[0];
+        } catch {
+        }
+      }
+      return null;
+    };
+    const SYSTEM_FIELD_KEYS = /* @__PURE__ */ new Set([
+      "documentid",
+      "document_id",
+      "docid",
+      "id",
+      "createdat",
+      "updatedat",
+      "publishedat",
+      "createdby",
+      "updatedby",
+      "localizations",
+      "locale",
+      "status"
+    ]);
     for (let i = 0; i < parsedRows.length; i++) {
       const rowNumber = i + 2;
       const row = parsedRows[i];
-      const docId = (row.documentId || row.id || "").trim();
+      let docId = extractDocId(row);
+      const rowLocale = extractLocale(row);
+      if (ct.kind === "singleType" && !docId) {
+        try {
+          const findSingleArgs = {};
+          if (rowLocale) findSingleArgs.locale = rowLocale;
+          const singleDoc = await strapi.documents(uid).findFirst(findSingleArgs);
+          if (singleDoc?.documentId) {
+            docId = singleDoc.documentId;
+          }
+        } catch {
+        }
+      }
       const payload = {};
       for (const [key, rawVal] of Object.entries(row)) {
-        if (key === "documentId" || key === "id") continue;
+        const normalizedKey = key.toLowerCase().replace(/[\s_-]/g, "");
+        if (SYSTEM_FIELD_KEYS.has(normalizedKey)) continue;
         if (key.includes(".")) {
           const [parent, child] = key.split(".");
           const parentDef = attrs[parent];
@@ -4571,32 +4929,54 @@ const csvService = ({ strapi }) => ({
               if (rawVal === "" || rawVal === null || rawVal === void 0) {
                 val = null;
               } else if (childDef.type === "integer" || childDef.type === "biginteger") {
-                val = parseInt(rawVal, 10);
+                const parsedInt = parseInt(rawVal, 10);
+                val = isNaN(parsedInt) ? null : parsedInt;
               } else if (childDef.type === "float" || childDef.type === "decimal") {
-                val = parseFloat(rawVal);
+                const parsedFloat = parseFloat(rawVal);
+                val = isNaN(parsedFloat) ? null : parsedFloat;
               } else if (childDef.type === "boolean") {
                 val = rawVal.toLowerCase() === "true" || rawVal === "1";
+              } else if (childDef.type === "json") {
+                try {
+                  val = JSON.parse(rawVal);
+                } catch {
+                  val = rawVal;
+                }
               }
               payload[parent][child] = val;
             }
           }
           continue;
         }
-        const attrDef = attrs[key];
+        let attrDef = attrs[key];
+        if (!attrDef) {
+          const matchKey = Object.keys(attrs).find(
+            (k) => k.toLowerCase() === key.toLowerCase() || k.toLowerCase() === key.toLowerCase().replace(/\s+/g, "")
+          );
+          if (matchKey) {
+            attrDef = attrs[matchKey];
+          }
+        }
         if (!attrDef) continue;
         if (rawVal === "" || rawVal === null || rawVal === void 0) {
-          payload[key] = null;
+          if (attrDef.type !== "dynamiczone" && !(attrDef.type === "component" && attrDef.repeatable)) {
+            payload[key] = null;
+          }
           continue;
         }
         switch (attrDef.type) {
           case "integer":
-          case "biginteger":
-            payload[key] = parseInt(rawVal, 10);
+          case "biginteger": {
+            const parsedInt = parseInt(rawVal, 10);
+            payload[key] = isNaN(parsedInt) ? null : parsedInt;
             break;
+          }
           case "float":
-          case "decimal":
-            payload[key] = parseFloat(rawVal);
+          case "decimal": {
+            const parsedFloat = parseFloat(rawVal);
+            payload[key] = isNaN(parsedFloat) ? null : parsedFloat;
             break;
+          }
           case "boolean":
             payload[key] = rawVal.toLowerCase() === "true" || rawVal === "1";
             break;
@@ -4607,6 +4987,69 @@ const csvService = ({ strapi }) => ({
               payload[key] = rawVal;
             }
             break;
+          case "dynamiczone": {
+            try {
+              const parsed = JSON.parse(rawVal);
+              if (Array.isArray(parsed) && parsed.every((item) => item && typeof item === "object" && typeof item.__component === "string")) {
+                payload[key] = parsed;
+              }
+            } catch {
+            }
+            break;
+          }
+          case "component": {
+            if (attrDef.repeatable) {
+              try {
+                const parsed = JSON.parse(rawVal);
+                if (Array.isArray(parsed) && parsed.every((item) => item && typeof item === "object")) {
+                  payload[key] = parsed;
+                }
+              } catch {
+              }
+            } else {
+              try {
+                const parsed = JSON.parse(rawVal);
+                if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+                  payload[key] = parsed;
+                }
+              } catch {
+              }
+            }
+            break;
+          }
+          case "relation": {
+            try {
+              const parsed = JSON.parse(rawVal);
+              if (Array.isArray(parsed) || typeof parsed === "object" && parsed !== null) {
+                payload[key] = parsed;
+                break;
+              }
+            } catch {
+            }
+            if (isValidDocId(rawVal)) {
+              payload[key] = rawVal;
+            } else if (rawVal.includes(";") || rawVal.includes(",")) {
+              const parts = rawVal.split(/[;,]/).map((s) => s.trim()).filter(Boolean);
+              if (parts.length > 0 && parts.every((p) => isValidDocId(p))) {
+                payload[key] = parts;
+              }
+            }
+            break;
+          }
+          case "media": {
+            if (/^\d+$/.test(rawVal.trim())) {
+              payload[key] = parseInt(rawVal.trim(), 10);
+            } else {
+              try {
+                const parsed = JSON.parse(rawVal);
+                if (typeof parsed === "number" || typeof parsed === "object") {
+                  payload[key] = parsed;
+                }
+              } catch {
+              }
+            }
+            break;
+          }
           default:
             payload[key] = rawVal;
         }
@@ -4617,114 +5060,146 @@ const csvService = ({ strapi }) => ({
             stats.skipped++;
             stats.errors.push({
               row: rowNumber,
-              error: "Missing documentId for Update mode. (Tip: Use Smart Auto-Detect mode to auto-add entries without document IDs)."
+              error: "Missing or invalid documentId for Update mode. (Tip: Use Smart Auto-Detect mode to auto-add entries without document IDs)."
             });
             continue;
           }
-          const existing = await strapi.documents(uid).findOne({
-            documentId: docId
-          });
+          const existing = await findExistingDocument(docId, rowLocale);
           if (!existing) {
             stats.skipped++;
             stats.errors.push({
               row: rowNumber,
               documentId: docId,
-              error: `Document with documentId "${docId}" not found.`
+              error: `Document with ID "${docId}" not found in database.`
             });
             continue;
           }
+          const resolvedDocId = existing.documentId || docId;
           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 strapi.documents(uid).update({
-            documentId: docId,
+          if (Object.keys(mergedPayload).length === 0) {
+            stats.skipped++;
+            stats.diffs.push({
+              uid,
+              collectionName: ct.info?.displayName || uid,
+              documentId: resolvedDocId,
+              label: existing.title || existing.name || `Entry #${resolvedDocId}`,
+              attribute: "",
+              oldValue: existing,
+              newValue: {},
+              status: "skipped",
+              message: `Skipped (no editable attributes in row ${rowNumber})`
+            });
+            continue;
+          }
+          const updateArgs = {
+            documentId: resolvedDocId,
             data: mergedPayload
-          });
+          };
+          if (rowLocale) updateArgs.locale = rowLocale;
+          await strapi.documents(uid).update(updateArgs);
           if (publish && ct.options?.draftAndPublish) {
             try {
-              await strapi.documents(uid).publish({ documentId: docId });
+              const pubArgs = { documentId: resolvedDocId };
+              if (rowLocale) pubArgs.locale = rowLocale;
+              await strapi.documents(uid).publish(pubArgs);
             } catch (pubErr) {
-              strapi.log.warn(`[bulk-updater] Auto-publish failed for ${docId}:`, pubErr);
+              strapi.log.warn(`[bulk-updater] Auto-publish failed for ${resolvedDocId}:`, pubErr);
             }
           }
           try {
             await recordContentHistoryVersion(strapi, {
               uid,
-              documentId: docId,
+              documentId: resolvedDocId,
               userId: user?.id,
               statusOverride: publish && ct.options?.draftAndPublish ? "published" : void 0
             });
           } catch {
           }
           stats.updated++;
-          stats.diffs.push({
-            uid,
-            collectionName: ct.info?.displayName || uid,
-            documentId: docId,
-            label: existing.title || existing.name || `Entry #${docId}`,
-            attribute: Object.keys(payload).join(", "),
-            oldValue: existing,
-            newValue: payload,
-            status: "updated",
-            message: `Updated via CSV import (row ${rowNumber})`
-          });
+          for (const attrKey of Object.keys(payload)) {
+            const oldVal = existing?.[attrKey] ?? null;
+            const newVal = payload[attrKey];
+            stats.diffs.push({
+              uid,
+              collectionName: ct.info?.displayName || uid,
+              documentId: resolvedDocId,
+              label: existing.title || existing.name || `Entry #${resolvedDocId}`,
+              attribute: attrKey,
+              oldValue: oldVal,
+              newValue: newVal,
+              status: "updated",
+              message: `Updated "${attrKey}" via CSV import (row ${rowNumber})`
+            });
+          }
         } else if (mode === "create_or_override") {
+          let existing = null;
           if (docId) {
-            const existing = await strapi.documents(uid).findOne({
-              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 strapi.documents(uid).update({
-                documentId: docId,
-                data: mergedPayload
-              });
-              if (publish && ct.options?.draftAndPublish) {
-                try {
-                  await strapi.documents(uid).publish({ documentId: docId });
-                } catch (pubErr) {
-                  strapi.log.warn(`[bulk-updater] Auto-publish failed for ${docId}:`, pubErr);
-                }
+            existing = await findExistingDocument(docId, rowLocale);
+          }
+          if (existing) {
+            const resolvedDocId = existing.documentId || docId;
+            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] };
               }
+            }
+            const updateArgs = {
+              documentId: resolvedDocId,
+              data: mergedPayload
+            };
+            if (rowLocale) updateArgs.locale = rowLocale;
+            await strapi.documents(uid).update(updateArgs);
+            if (publish && ct.options?.draftAndPublish) {
               try {
-                await recordContentHistoryVersion(strapi, {
-                  uid,
-                  documentId: docId,
-                  userId: user?.id,
-                  statusOverride: publish && ct.options?.draftAndPublish ? "published" : void 0
-                });
-              } catch {
+                const pubArgs = { documentId: resolvedDocId };
+                if (rowLocale) pubArgs.locale = rowLocale;
+                await strapi.documents(uid).publish(pubArgs);
+              } catch (pubErr) {
+                strapi.log.warn(`[bulk-updater] Auto-publish failed for ${resolvedDocId}:`, pubErr);
               }
-              stats.updated++;
+            }
+            try {
+              await recordContentHistoryVersion(strapi, {
+                uid,
+                documentId: resolvedDocId,
+                userId: user?.id,
+                statusOverride: publish && ct.options?.draftAndPublish ? "published" : void 0
+              });
+            } catch {
+            }
+            stats.updated++;
+            for (const attrKey of Object.keys(payload)) {
+              const oldVal = existing?.[attrKey] ?? null;
+              const newVal = payload[attrKey];
               stats.diffs.push({
                 uid,
                 collectionName: ct.info?.displayName || uid,
-                documentId: docId,
-                label: existing.title || existing.name || `Entry #${docId}`,
-                attribute: Object.keys(payload).join(", "),
-                oldValue: existing,
-                newValue: payload,
+                documentId: resolvedDocId,
+                label: existing.title || existing.name || `Entry #${resolvedDocId}`,
+                attribute: attrKey,
+                oldValue: oldVal,
+                newValue: newVal,
                 status: "updated",
-                message: `Overridden via CSV import (row ${rowNumber})`
+                message: `Overridden "${attrKey}" via CSV import (row ${rowNumber})`
               });
-              continue;
             }
+            continue;
           }
-          const created = await strapi.documents(uid).create({
-            data: payload
-          });
+          const createArgs = { data: payload };
+          if (rowLocale) createArgs.locale = rowLocale;
+          const created = await strapi.documents(uid).create(createArgs);
           const newDocId = created?.documentId || docId;
           if (publish && ct.options?.draftAndPublish && newDocId) {
             try {
-              await strapi.documents(uid).publish({ documentId: newDocId });
+              const pubArgs = { documentId: newDocId };
+              if (rowLocale) pubArgs.locale = rowLocale;
+              await strapi.documents(uid).publish(pubArgs);
             } catch (pubErr) {
               strapi.log.warn(`[bulk-updater] Auto-publish failed for ${newDocId}:`, pubErr);
             }
@@ -4742,71 +5217,83 @@ const csvService = ({ strapi }) => ({
           if (!docId) {
             stats.newWithoutDocId++;
           }
-          stats.diffs.push({
-            uid,
-            collectionName: ct.info?.displayName || uid,
-            documentId: newDocId,
-            label: created?.title || created?.name || `New Entry #${newDocId}`,
-            attribute: Object.keys(payload).join(", "),
-            oldValue: null,
-            newValue: payload,
-            status: "updated",
-            message: docId ? `Created via CSV import (row ${rowNumber})` : `Created as new entry (no documentId provided in CSV - row ${rowNumber})`
-          });
+          for (const attrKey of Object.keys(payload)) {
+            stats.diffs.push({
+              uid,
+              collectionName: ct.info?.displayName || uid,
+              documentId: newDocId,
+              label: created?.title || created?.name || `New Entry #${newDocId}`,
+              attribute: attrKey,
+              oldValue: null,
+              newValue: payload[attrKey],
+              status: "created",
+              message: docId ? `Created "${attrKey}" via CSV import (row ${rowNumber})` : `Created "${attrKey}" as new entry (row ${rowNumber})`
+            });
+          }
         } else {
+          let existing = null;
           if (docId) {
-            const existing = await strapi.documents(uid).findOne({
-              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 strapi.documents(uid).update({
-                documentId: docId,
-                data: mergedPayload
-              });
-              if (publish && ct.options?.draftAndPublish) {
-                try {
-                  await strapi.documents(uid).publish({ documentId: docId });
-                } catch (pubErr) {
-                  strapi.log.warn(`[bulk-updater] Auto-publish failed for ${docId}:`, pubErr);
-                }
+            existing = await findExistingDocument(docId, rowLocale);
+          }
+          if (existing) {
+            const resolvedDocId = existing.documentId || docId;
+            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] };
               }
+            }
+            const updateArgs = {
+              documentId: resolvedDocId,
+              data: mergedPayload
+            };
+            if (rowLocale) updateArgs.locale = rowLocale;
+            await strapi.documents(uid).update(updateArgs);
+            if (publish && ct.options?.draftAndPublish) {
               try {
-                await recordContentHistoryVersion(strapi, {
-                  uid,
-                  documentId: docId,
-                  userId: user?.id,
-                  statusOverride: publish && ct.options?.draftAndPublish ? "published" : void 0
-                });
-              } catch {
+                const pubArgs = { documentId: resolvedDocId };
+                if (rowLocale) pubArgs.locale = rowLocale;
+                await strapi.documents(uid).publish(pubArgs);
+              } catch (pubErr) {
+                strapi.log.warn(`[bulk-updater] Auto-publish failed for ${resolvedDocId}:`, pubErr);
               }
-              stats.updated++;
+            }
+            try {
+              await recordContentHistoryVersion(strapi, {
+                uid,
+                documentId: resolvedDocId,
+                userId: user?.id,
+                statusOverride: publish && ct.options?.draftAndPublish ? "published" : void 0
+              });
+            } catch {
+            }
+            stats.updated++;
+            for (const attrKey of Object.keys(payload)) {
+              const oldVal = existing?.[attrKey] ?? null;
+              const newVal = payload[attrKey];
               stats.diffs.push({
                 uid,
                 collectionName: ct.info?.displayName || uid,
-                documentId: docId,
-                label: existing.title || existing.name || `Entry #${docId}`,
-                attribute: Object.keys(payload).join(", "),
-                oldValue: existing,
-                newValue: payload,
+                documentId: resolvedDocId,
+                label: existing.title || existing.name || `Entry #${resolvedDocId}`,
+                attribute: attrKey,
+                oldValue: oldVal,
+                newValue: newVal,
                 status: "updated",
-                message: `Updated existing entry via smart match (row ${rowNumber})`
+                message: `Updated "${attrKey}" via CSV import (row ${rowNumber})`
               });
-              continue;
             }
+            continue;
           }
-          const created = await strapi.documents(uid).create({
-            data: payload
-          });
+          const createArgs = { data: payload };
+          if (rowLocale) createArgs.locale = rowLocale;
+          const created = await strapi.documents(uid).create(createArgs);
           const newDocId = created?.documentId || docId;
           if (publish && ct.options?.draftAndPublish && newDocId) {
             try {
-              await strapi.documents(uid).publish({ documentId: newDocId });
+              const pubArgs = { documentId: newDocId };
+              if (rowLocale) pubArgs.locale = rowLocale;
+              await strapi.documents(uid).publish(pubArgs);
             } catch (pubErr) {
               strapi.log.warn(`[bulk-updater] Auto-publish failed for ${newDocId}:`, pubErr);
             }
@@ -4824,23 +5311,25 @@ const csvService = ({ strapi }) => ({
           if (!docId) {
             stats.newWithoutDocId++;
           }
-          stats.diffs.push({
-            uid,
-            collectionName: ct.info?.displayName || uid,
-            documentId: newDocId,
-            label: created?.title || created?.name || `New Entry #${newDocId}`,
-            attribute: Object.keys(payload).join(", "),
-            oldValue: null,
-            newValue: payload,
-            status: "updated",
-            message: docId ? `Created as new entry (documentId "${docId}" not found in database - row ${rowNumber})` : `Created as new entry (no documentId provided in CSV - row ${rowNumber})`
-          });
+          for (const attrKey of Object.keys(payload)) {
+            stats.diffs.push({
+              uid,
+              collectionName: ct.info?.displayName || uid,
+              documentId: newDocId,
+              label: created?.title || created?.name || `New Entry #${newDocId}`,
+              attribute: attrKey,
+              oldValue: null,
+              newValue: payload[attrKey],
+              status: "created",
+              message: docId ? `Created "${attrKey}" as new entry (documentId "${docId}" not found in database - row ${rowNumber})` : `Created "${attrKey}" as new entry (no documentId provided in CSV - row ${rowNumber})`
+            });
+          }
         }
       } catch (err) {
         stats.errors.push({
           row: rowNumber,
           documentId: docId || void 0,
-          error: err.message || "Error processing row"
+          error: extractDetailedErrorMessage(err)
         });
       }
     }
@@ -4857,10 +5346,32 @@ const csvService = ({ strapi }) => ({
         if (auditService2) {
           const isEnabled = typeof auditService2.isAuditEnabled === "function" ? auditService2.isAuditEnabled() : Boolean(auditService2.getAuditConfig?.().enabled ?? true);
           if (isEnabled) {
+            const collectionDisplayName = ct.info?.displayName || uid;
+            const updatedDiffs = stats.diffs.filter(
+              (d) => d.status === "updated" || d.status === "created"
+            );
+            const uniqueAttributes = Array.from(
+              new Set(updatedDiffs.map((d) => d.attribute))
+            ).filter(Boolean);
+            const attrListStr = uniqueAttributes.length > 0 ? uniqueAttributes.join(", ") : "fields";
+            const batchAttribute = `CSV [${collectionDisplayName}]: ${attrListStr}`;
+            let batchValue = "";
+            if (updatedDiffs.length === 1) {
+              const d = updatedDiffs[0];
+              const newStr = d.newValue !== null && d.newValue !== void 0 ? String(d.newValue) : "(empty)";
+              batchValue = `"${d.label}": ${d.attribute} → "${newStr}"`;
+            } else if (updatedDiffs.length > 1 && stats.updated === 1 && stats.created === 0) {
+              const d = updatedDiffs[0];
+              const changes = updatedDiffs.map((ud) => `${ud.attribute}: "${ud.newValue ?? ""}"`).join(", ");
+              batchValue = `"${d.label}": ${changes}`;
+            } else {
+              const sampleVal = updatedDiffs[0] ? ` (e.g. ${updatedDiffs[0].attribute}: "${updatedDiffs[0].newValue ?? ""}")` : "";
+              batchValue = `${stats.updated} updated, ${stats.created} created in ${collectionDisplayName}${sampleVal}`;
+            }
             const batchSummary = {
               batchId,
-              attribute: "CSV_IMPORT",
-              value: `Mode: ${mode} (${stats.created} created, ${stats.updated} updated)`,
+              attribute: batchAttribute,
+              value: batchValue,
               updatedCount: stats.updated + stats.created,
               skippedCount: stats.skipped,
               totalTargets: stats.total