strapi-plugin-bulk-updater 1.3.8 → 1.3.10

package/dist/server/index.mjs

@@ -842,7 +842,9 @@ function buildDeepPopulate$1(attributes, allComponents, depth2 = 0) {
         populate2[key] = true;
       }
     } else if (def.type === "dynamiczone") {
-      populate2[key] = true;
+      populate2[key] = {
+        populate: "*"
+      };
     } else if (def.type === "relation" || def.type === "media") {
       populate2[key] = true;
     }
@@ -856,10 +858,28 @@ function discoverComponentAttributes(strapi2, compUid, prefix, currentDepth, max
   const discoveredAttrs = [];
   for (const [subKey, subAttr] of Object.entries(compSchema.attributes)) {
     if (systemFields.includes(subKey)) continue;
-    if (subAttr.type === "dynamiczone") continue;
     const fullPath = prefix ? `${prefix}.${subKey}` : subKey;
+    if (subAttr.type === "dynamiczone") {
+      const dzComps = Array.isArray(subAttr.components) ? subAttr.components : [];
+      for (const dzCompUid of dzComps) {
+        const deeper = discoverComponentAttributes(
+          strapi2,
+          dzCompUid,
+          fullPath,
+          currentDepth + 1,
+          maxDepth,
+          systemFields,
+          allContentTypes,
+          relationsByAttr,
+          allRelationsMeta,
+          attributesMeta
+        );
+        discoveredAttrs.push(...deeper);
+      }
+      continue;
+    }
     if (subAttr.type === "component") {
-      if (!subAttr.repeatable && subAttr.component) {
+      if (subAttr.component) {
         const deeper = discoverComponentAttributes(
           strapi2,
           subAttr.component,
@@ -901,46 +921,110 @@ function discoverComponentAttributes(strapi2, compUid, prefix, currentDepth, max
 function isDeepComponentField(contentType, allComponents, attribute) {
   if (!attribute || !attribute.includes(".")) return false;
   const parts = attribute.split(".");
-  let currentSchema = contentType;
-  for (let i = 0; i < parts.length - 1; i++) {
-    const part = parts[i];
-    const attrDef = currentSchema?.attributes?.[part];
-    if (!attrDef || attrDef.type !== "component" || !attrDef.component) return false;
-    currentSchema = allComponents[attrDef.component];
-    if (!currentSchema) return false;
+  function checkPath(currentSchema, pathParts) {
+    if (pathParts.length === 0) return true;
+    if (!currentSchema || !currentSchema.attributes) return false;
+    const [head, ...tail] = pathParts;
+    const attrDef = currentSchema.attributes[head];
+    if (!attrDef) return false;
+    if (tail.length === 0) {
+      return true;
+    }
+    if (attrDef.type === "component" && attrDef.component) {
+      const comp = allComponents[attrDef.component];
+      return checkPath(comp, tail);
+    }
+    if (attrDef.type === "dynamiczone") {
+      const compUids = Array.isArray(attrDef.components) ? attrDef.components : [];
+      return compUids.some((compUid) => {
+        const comp = allComponents[compUid];
+        return checkPath(comp, tail);
+      });
+    }
+    return false;
   }
-  const leafField = parts[parts.length - 1];
-  return Boolean(currentSchema?.attributes?.[leafField]);
+  return checkPath(contentType, parts);
 }
 function getLeafAttributeSchema(contentType, allComponents, attribute) {
   if (!attribute) return null;
   if (!attribute.includes(".")) return contentType?.attributes?.[attribute] || null;
   const parts = attribute.split(".");
-  let currentSchema = contentType;
-  for (let i = 0; i < parts.length - 1; i++) {
-    const part = parts[i];
-    const attrDef = currentSchema?.attributes?.[part];
-    if (!attrDef || attrDef.type !== "component" || !attrDef.component) return null;
-    currentSchema = allComponents[attrDef.component];
-    if (!currentSchema) return null;
+  function resolveLeaf(currentSchema, pathParts) {
+    if (!currentSchema || !currentSchema.attributes) return null;
+    const [head, ...tail] = pathParts;
+    const attrDef = currentSchema.attributes[head];
+    if (!attrDef) return null;
+    if (tail.length === 0) {
+      return attrDef;
+    }
+    if (attrDef.type === "component" && attrDef.component) {
+      return resolveLeaf(allComponents[attrDef.component], tail);
+    }
+    if (attrDef.type === "dynamiczone") {
+      const compUids = Array.isArray(attrDef.components) ? attrDef.components : [];
+      for (const compUid of compUids) {
+        const found = resolveLeaf(allComponents[compUid], tail);
+        if (found) return found;
+      }
+    }
+    return null;
   }
-  return currentSchema?.attributes?.[parts[parts.length - 1]] || null;
+  return resolveLeaf(contentType, parts);
 }
 function setDeepProperty(obj, pathParts, value) {
   if (pathParts.length === 0) return value;
-  const current = { ...obj || {} };
   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);
+      return copy;
+    }
+    return obj.map((item) => {
+      if (!item || typeof item !== "object") return item;
+      if (head in item || tail.length > 0 && typeof item[head] === "object") {
+        return {
+          ...item,
+          [head]: setDeepProperty(item[head], tail, value)
+        };
+      }
+      return item;
+    });
+  }
+  const current = { ...obj || {} };
   if (tail.length === 0) {
     current[head] = value;
   } else {
-    current[head] = setDeepProperty(current[head] || {}, tail, value);
+    const subTarget = current[head];
+    if (Array.isArray(subTarget)) {
+      current[head] = setDeepProperty(subTarget, tail, value);
+    } else {
+      current[head] = setDeepProperty(subTarget || {}, tail, value);
+    }
   }
   return current;
 }
 function getDeepProperty(obj, path2) {
   if (!obj || !path2) return void 0;
-  if (!path2.includes(".")) return obj[path2];
-  return path2.split(".").reduce((acc, part) => acc && typeof acc === "object" ? acc[part] : void 0, obj);
+  const parts = path2.split(".");
+  function extract(current, remainingParts) {
+    if (current === void 0 || current === null) return void 0;
+    if (remainingParts.length === 0) return current;
+    const [head, ...tail] = remainingParts;
+    if (Array.isArray(current)) {
+      if (/^\d+$/.test(head)) {
+        return extract(current[parseInt(head, 10)], tail);
+      }
+      for (const item of current) {
+        const found = extract(item?.[head], tail);
+        if (found !== void 0 && found !== null) return found;
+      }
+      return void 0;
+    }
+    return extract(current[head], tail);
+  }
+  return extract(obj, parts);
 }
 function buildDeepFilter(pathParts, condition) {
   if (pathParts.length === 0) return condition;
@@ -1170,7 +1254,8 @@ async function executeBatchInternal(strapi2, {
               findOneArgs.populate = populateOption;
             }
             const currentEntryWithPopulate = await strapi2.documents(target.uid).findOne(findOneArgs);
-            const existingRoot = currentEntryWithPopulate?.[rootKey] || {};
+            const isRootDz = contentType?.attributes?.[rootKey]?.type === "dynamiczone";
+            const existingRoot = currentEntryWithPopulate?.[rootKey] || (isRootDz ? [] : {});
             const currentVal2 = getDeepProperty(existingRoot, parts.slice(1).join("."));
             let newValue2 = value;
             if (regexObj && typeof currentVal2 === "string") {
@@ -1650,10 +1735,29 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
           const nestedComponentAttrs = [];
           const validAttrs = Object.keys(rawAttrs).filter((attrKey) => {
             if (systemFields.includes(attrKey)) return false;
-            if (rawAttrs[attrKey].type === "dynamiczone") return false;
+            if (rawAttrs[attrKey].type === "dynamiczone") {
+              const dzDef = rawAttrs[attrKey];
+              const dzComponents = Array.isArray(dzDef.components) ? dzDef.components : [];
+              for (const compUid of dzComponents) {
+                const compAttrs = discoverComponentAttributes(
+                  strapi2,
+                  compUid,
+                  attrKey,
+                  1,
+                  5,
+                  systemFields,
+                  allContentTypes,
+                  relationsByAttr,
+                  allRelationsMeta,
+                  colAttributesMeta
+                );
+                nestedComponentAttrs.push(...compAttrs);
+              }
+              return false;
+            }
             if (rawAttrs[attrKey].type === "component") {
               const compDef = rawAttrs[attrKey];
-              if (!compDef.repeatable && compDef.component) {
+              if (compDef.component) {
                 const compAttrs = discoverComponentAttributes(
                   strapi2,
                   compDef.component,
@@ -3617,15 +3721,70 @@ function extractHeadingsFromRichText(content) {
   }
   return counts;
 }
+function cleanKey(str2) {
+  return (str2 || "").replace(/[-_]/g, "").toLowerCase().trim();
+}
 function matchesPath(normalizedPath, leafKey, targetField) {
   if (!targetField) return false;
-  const pLower = (normalizedPath || "").toLowerCase().trim();
-  const kLower = (leafKey || "").toLowerCase().trim();
-  const tLower = targetField.toLowerCase().trim();
-  if (!tLower.includes(".")) {
-    return kLower === tLower || pLower === tLower || pLower.endsWith(`.${tLower}`);
+  const pClean = cleanKey(normalizedPath);
+  const kClean = cleanKey(leafKey);
+  const tClean = cleanKey(targetField);
+  if (kClean === tClean || pClean === tClean) return true;
+  const targetSegments = targetField.replace(/^api::/i, "").split(".").map(cleanKey).filter(Boolean);
+  const pathSegments = normalizedPath.split(".").map(cleanKey).filter(Boolean);
+  if (targetSegments.length === 0 || pathSegments.length === 0) return false;
+  if (targetSegments.length === 1) {
+    const single = targetSegments[0];
+    return kClean === single || pathSegments[pathSegments.length - 1] === single;
+  }
+  let isSuffix = true;
+  for (let i = 0; i < targetSegments.length; i++) {
+    const tSeg = targetSegments[targetSegments.length - 1 - i];
+    const pSeg = pathSegments[pathSegments.length - 1 - i];
+    if (tSeg !== "*" && tSeg !== pSeg) {
+      isSuffix = false;
+      break;
+    }
   }
-  return pLower === tLower || pLower.endsWith(`.${tLower}`) || pLower.endsWith(tLower);
+  if (isSuffix) return true;
+  for (let startIdx = 1; startIdx < targetSegments.length; startIdx++) {
+    const subTarget = targetSegments.slice(startIdx);
+    if (subTarget.length > pathSegments.length) continue;
+    let subSuffix = true;
+    for (let i = 0; i < subTarget.length; i++) {
+      const tSeg = subTarget[subTarget.length - 1 - i];
+      const pSeg = pathSegments[pathSegments.length - 1 - i];
+      if (tSeg !== "*" && tSeg !== pSeg) {
+        subSuffix = false;
+        break;
+      }
+    }
+    if (subSuffix) return true;
+  }
+  let pIdx = 0;
+  let matchesInOrder = true;
+  let tStart = 0;
+  if (targetSegments.length > 2 && targetSegments[0] !== pathSegments[0] && targetSegments[0] !== "*") {
+    tStart = 1;
+  }
+  for (let tIdx = tStart; tIdx < targetSegments.length; tIdx++) {
+    const tSeg = targetSegments[tIdx];
+    if (tSeg === "*") continue;
+    let found = false;
+    while (pIdx < pathSegments.length) {
+      if (pathSegments[pIdx] === tSeg) {
+        found = true;
+        pIdx++;
+        break;
+      }
+      pIdx++;
+    }
+    if (!found) {
+      matchesInOrder = false;
+      break;
+    }
+  }
+  return matchesInOrder;
 }
 const validationRulesService = ({ strapi: strapi2 }) => ({
   async getStore() {
@@ -3739,10 +3898,13 @@ const validationRulesService = ({ strapi: strapi2 }) => ({
     function componentHasField(compUid, targetField2) {
       const comp = allComponents[compUid];
       if (!comp?.attributes) return false;
+      if (matchesPath(compUid, compUid, targetField2)) return true;
       for (const [attrName, attrDef] of Object.entries(comp.attributes)) {
-        if (matchesPath(attrName, attrName, targetField2)) return true;
+        if (matchesPath(attrName, attrName, targetField2) || matchesPath(`${compUid}.${attrName}`, attrName, targetField2)) return true;
         if (attrDef.type === "component" && attrDef.component) {
           if (componentHasField(attrDef.component, targetField2)) return true;
+        } else if (attrDef.type === "dynamiczone" && Array.isArray(attrDef.components)) {
+          if (attrDef.components.some((c) => componentHasField(c, targetField2))) return true;
         }
       }
       return false;
@@ -3759,15 +3921,15 @@ const validationRulesService = ({ strapi: strapi2 }) => ({
         if (attrDef.type === "component" && attrDef.component) {
           if (componentHasField(attrDef.component, targetField)) {
             hasField = true;
-            populateAttrs[attrKey] = true;
+            populateAttrs[attrKey] = { populate: "*" };
           }
         } else if (attrDef.type === "dynamiczone" && Array.isArray(attrDef.components)) {
           const matchingComp = attrDef.components.some(
-            (compUid) => componentHasField(compUid, targetField)
+            (compUid) => componentHasField(compUid, targetField) || matchesPath(`${attrKey}.${compUid}`, compUid, targetField)
           );
           if (matchingComp) {
             hasField = true;
-            populateAttrs[attrKey] = true;
+            populateAttrs[attrKey] = { populate: "*" };
           }
         }
       }
@@ -3775,7 +3937,11 @@ const validationRulesService = ({ strapi: strapi2 }) => ({
     }
     const candidateUids = Object.keys(allContentTypes).filter((uid) => {
       if (!uid.startsWith("api::") || uid.includes("bulk-updater")) return false;
-      if (rule.collectionUid && rule.collectionUid !== "*" && rule.collectionUid !== uid) {
+      if (rule.collectionUid && rule.collectionUid !== "*") {
+        if (rule.collectionUid === uid) return true;
+        const cleanRuleCol = cleanKey(rule.collectionUid);
+        const cleanUid = cleanKey(uid);
+        if (cleanUid.includes(cleanRuleCol) || cleanRuleCol.includes(cleanUid)) return true;
         return false;
       }
       return true;
@@ -3785,7 +3951,8 @@ const validationRulesService = ({ strapi: strapi2 }) => ({
       const ct = allContentTypes[uid];
       if (!ct) continue;
       const { hasField, populateAttrs } = schemaHasField(ct);
-      if (hasField || rule.collectionUid && rule.collectionUid === uid) {
+      const isTargetCol = rule.collectionUid && (rule.collectionUid === uid || cleanKey(uid).includes(cleanKey(rule.collectionUid)));
+      if (hasField || isTargetCol) {
         relevantCollections.push({
           uid,
           displayName: ct.info?.displayName || uid,
@@ -3808,11 +3975,15 @@ const validationRulesService = ({ strapi: strapi2 }) => ({
             for (const entry of entries) {
               let traverse = function(obj, currentPath = "") {
                 if (!obj || typeof obj !== "object") return;
+                const compName = typeof obj.__component === "string" ? obj.__component : "";
                 for (const key of Object.keys(obj)) {
+                  if (key === "__component") continue;
                   const val = obj[key];
                   const newPath = currentPath ? `${currentPath}.${key}` : key;
                   const normalizedPath = newPath.replace(/\.\d+/g, "");
-                  if (matchesPath(normalizedPath, key, targetField) && typeof val === "string" && val.trim()) {
+                  const compPath = compName ? (currentPath ? `${currentPath}.${compName}.${key}` : `${compName}.${key}`).replace(/\.\d+/g, "") : "";
+                  const isMatch = matchesPath(normalizedPath, key, targetField) || (compPath ? matchesPath(compPath, key, targetField) : false);
+                  if (isMatch && typeof val === "string" && val.trim()) {
                     const lower = val.toLowerCase().trim();
                     structuredCounts[lower] = (structuredCounts[lower] || 0) + 1;
                   }
@@ -34145,12 +34316,16 @@ const index = {
         if (data && typeof data === "object") {
           let scanDataTree = function(obj, currentPath = "") {
             if (!obj || typeof obj !== "object") return;
+            const compName = typeof obj.__component === "string" ? obj.__component : "";
             for (const key of Object.keys(obj)) {
+              if (key === "__component") continue;
               const val = obj[key];
               const newPath = currentPath ? `${currentPath}.${key}` : key;
               const normalizedPath = newPath.replace(/\.\d+/g, "");
+              const compPath = compName ? (currentPath ? `${currentPath}.${compName}.${key}` : `${compName}.${key}`).replace(/\.\d+/g, "") : "";
               for (const rule of effectiveRules) {
-                if (matchesPath(normalizedPath, key, rule.targetField) && typeof val === "string" && val.trim()) {
+                const isMatch = matchesPath(normalizedPath, key, rule.targetField) || (compPath ? matchesPath(compPath, key, rule.targetField) : false);
+                if (isMatch && typeof val === "string" && val.trim()) {
                   const lowerVal = val.toLowerCase().trim();
                   structuredCounts[rule.id] = structuredCounts[rule.id] || {};
                   structuredCounts[rule.id][lowerVal] = (structuredCounts[rule.id][lowerVal] || 0) + 1;
@@ -34188,7 +34363,13 @@ const index = {
             strapi2.log.warn("[bulk-updater] Failed to fetch active UI validation rules:", err);
           }
           const effectiveRules = [
-            ...activeUiRules.filter((r) => !r.collectionUid || r.collectionUid === "*" || r.collectionUid === context.uid).map((r) => ({
+            ...activeUiRules.filter((r) => {
+              if (!r.collectionUid || r.collectionUid === "*") return true;
+              if (r.collectionUid === context.uid) return true;
+              const cleanRuleCol = cleanKey(r.collectionUid);
+              const cleanCtxCol = cleanKey(context.uid);
+              return cleanCtxCol.includes(cleanRuleCol) || cleanRuleCol.includes(cleanCtxCol);
+            }).map((r) => ({
               id: r.id || r.targetField,
               name: r.name || r.targetField,
               collectionUid: r.collectionUid || "*",