strapi-plugin-bulk-updater 1.4.2 → 1.4.3

package/dist/admin/index.js

@@ -68,7 +68,7 @@ const index = {
         id: `${PLUGIN_ID}.plugin.name`,
         defaultMessage: "Bulk Attribute Updater"
       },
-      Component: () => Promise.resolve().then(() => require("../_chunks/BulkUpdater-L2FdlJfh.js")),
+      Component: () => Promise.resolve().then(() => require("../_chunks/BulkUpdater-mSvmiLwc.js")),
       permissions: [],
       position: 3
     });

package/dist/admin/index.mjs

@@ -65,7 +65,7 @@ const index = {
         id: `${PLUGIN_ID}.plugin.name`,
         defaultMessage: "Bulk Attribute Updater"
       },
-      Component: () => import("../_chunks/BulkUpdater-D4v5fP-1.mjs"),
+      Component: () => import("../_chunks/BulkUpdater-CbQk_OQG.mjs"),
       permissions: [],
       position: 3
     });

package/dist/server/index.js

@@ -911,9 +911,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;
@@ -929,6 +992,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);
@@ -940,8 +1007,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;
@@ -955,6 +1023,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;
@@ -964,22 +1035,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;
@@ -991,16 +1068,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;
@@ -1009,7 +1087,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;
       }
@@ -1174,7 +1255,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.");
@@ -1233,10 +1319,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) {
@@ -1249,12 +1338,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: {
@@ -1278,6 +1380,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,
@@ -1287,7 +1397,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") {
@@ -1316,13 +1427,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];
@@ -1466,6 +1577,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,
@@ -1477,7 +1608,7 @@ async function executeBatchInternal(strapi, {
   };
   await strapi.plugin("bulk-updater").service("audit").recordBatch(
     batchSummary,
-    results,
+    flattenedDiffs,
     currentUser
   );
   return {
@@ -1745,6 +1876,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;
             }
@@ -1959,13 +2103,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;
@@ -2022,8 +2173,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 = [
@@ -2097,39 +2251,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);