strapi-plugin-bulk-updater 1.3.9 → 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,
@@ -3625,10 +3729,62 @@ function matchesPath(normalizedPath, leafKey, targetField) {
   const pClean = cleanKey(normalizedPath);
   const kClean = cleanKey(leafKey);
   const tClean = cleanKey(targetField);
-  if (!tClean.includes(".")) {
-    return kClean === tClean || pClean === tClean || pClean.endsWith(`.${tClean}`);
+  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 pClean === tClean || pClean.endsWith(`.${tClean}`) || pClean.endsWith(tClean) || pClean.includes(`.${tClean}`);
+  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() {
@@ -3747,6 +3903,8 @@ const validationRulesService = ({ strapi: strapi2 }) => ({
         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;
@@ -3763,7 +3921,7 @@ 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(
@@ -3771,7 +3929,7 @@ const validationRulesService = ({ strapi: strapi2 }) => ({
           );
           if (matchingComp) {
             hasField = true;
-            populateAttrs[attrKey] = true;
+            populateAttrs[attrKey] = { populate: "*" };
           }
         }
       }
@@ -3779,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;
@@ -3789,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,
@@ -34200,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 || "*",