strapi-plugin-bulk-updater 1.3.6 → 1.3.9

package/dist/server/index.js

@@ -3580,7 +3580,8 @@ const DEFAULT_RULES = [
   {
     id: "rule_seo_heading_h1",
     name: "SEO Single H1 Page Rule",
-    description: "Enforces that only one H1 heading tag can be selected across all dynamic zone heading blocks within an entry.",
+    description: "Enforces that only one H1 heading tag can be selected across all dynamic zone heading blocks within an entry, combined with rich text HTML.",
+    collectionUid: "*",
     targetField: "headingLevel",
     quotas: {
       h1: 1,
@@ -3589,10 +3590,59 @@ const DEFAULT_RULES = [
     exceededAction: "disable",
     enabled: true,
     scope: "entry",
+    includeRichTextHtml: true,
+    richTextFields: [],
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   }
 ];
+function extractHeadingsFromRichText(content) {
+  const counts = { h1: 0, h2: 0, h3: 0, h4: 0, h5: 0, h6: 0 };
+  if (!content) return counts;
+  if (Array.isArray(content)) {
+    for (const node of content) {
+      if (node && typeof node === "object") {
+        if (node.type === "heading" && typeof node.level === "number") {
+          const tag = `h${node.level}`;
+          if (counts[tag] !== void 0) counts[tag]++;
+        }
+        if (Array.isArray(node.children)) {
+          const sub = extractHeadingsFromRichText(node.children);
+          for (const k of Object.keys(counts)) counts[k] += sub[k];
+        }
+      }
+    }
+    return counts;
+  }
+  if (typeof content === "string") {
+    for (let level = 1; level <= 6; level++) {
+      const tag = `h${level}`;
+      const htmlMatches = content.match(new RegExp(`<${tag}\\b[^>]*>`, "gi"));
+      if (htmlMatches) {
+        counts[tag] += htmlMatches.length;
+      }
+      const mdRegex = new RegExp(`(?:^|\\n)${"#".repeat(level)}\\s+[^\\n]+`, "g");
+      const mdMatches = content.match(mdRegex);
+      if (mdMatches) {
+        counts[tag] += mdMatches.length;
+      }
+    }
+  }
+  return counts;
+}
+function cleanKey(str2) {
+  return (str2 || "").replace(/[-_]/g, "").toLowerCase().trim();
+}
+function matchesPath(normalizedPath, leafKey, targetField) {
+  if (!targetField) return false;
+  const pClean = cleanKey(normalizedPath);
+  const kClean = cleanKey(leafKey);
+  const tClean = cleanKey(targetField);
+  if (!tClean.includes(".")) {
+    return kClean === tClean || pClean === tClean || pClean.endsWith(`.${tClean}`);
+  }
+  return pClean === tClean || pClean.endsWith(`.${tClean}`) || pClean.endsWith(tClean) || pClean.includes(`.${tClean}`);
+}
 const validationRulesService = ({ strapi: strapi2 }) => ({
   async getStore() {
     return strapi2.store({
@@ -3621,6 +3671,9 @@ const validationRulesService = ({ strapi: strapi2 }) => ({
         savedRule = {
           ...rules[index2],
           ...ruleData,
+          collectionUid: ruleData.collectionUid !== void 0 ? ruleData.collectionUid : rules[index2].collectionUid || "*",
+          includeRichTextHtml: ruleData.includeRichTextHtml !== void 0 ? Boolean(ruleData.includeRichTextHtml) : Boolean(rules[index2].includeRichTextHtml),
+          richTextFields: Array.isArray(ruleData.richTextFields) ? ruleData.richTextFields : rules[index2].richTextFields || [],
           updatedAt: now
         };
         rules[index2] = savedRule;
@@ -3629,11 +3682,14 @@ const validationRulesService = ({ strapi: strapi2 }) => ({
           id: ruleData.id,
           name: ruleData.name || "New Rule",
           description: ruleData.description || "",
+          collectionUid: ruleData.collectionUid || "*",
           targetField: ruleData.targetField || "headingLevel",
           quotas: ruleData.quotas || { h1: 1 },
           exceededAction: ruleData.exceededAction || "disable",
           enabled: ruleData.enabled ?? true,
           scope: ruleData.scope || "entry",
+          includeRichTextHtml: Boolean(ruleData.includeRichTextHtml),
+          richTextFields: Array.isArray(ruleData.richTextFields) ? ruleData.richTextFields : [],
           createdAt: now,
           updatedAt: now
         };
@@ -3645,11 +3701,14 @@ const validationRulesService = ({ strapi: strapi2 }) => ({
         id,
         name: ruleData.name || "Custom Quota Rule",
         description: ruleData.description || "",
+        collectionUid: ruleData.collectionUid || "*",
         targetField: ruleData.targetField || "headingLevel",
         quotas: ruleData.quotas || { h1: 1 },
         exceededAction: ruleData.exceededAction || "disable",
         enabled: ruleData.enabled ?? true,
         scope: ruleData.scope || "entry",
+        includeRichTextHtml: Boolean(ruleData.includeRichTextHtml),
+        richTextFields: Array.isArray(ruleData.richTextFields) ? ruleData.richTextFields : [],
         createdAt: now,
         updatedAt: now
       };
@@ -3693,21 +3752,35 @@ const validationRulesService = ({ strapi: strapi2 }) => ({
     let totalScanned = 0;
     const allContentTypes = strapi2.contentTypes || {};
     const allComponents = strapi2.components || {};
+    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) || matchesPath(`${compUid}.${attrName}`, attrName, targetField2)) return true;
+        if (attrDef.type === "component" && attrDef.component) {
+          if (componentHasField(attrDef.component, targetField2)) return true;
+        }
+      }
+      return false;
+    }
     function schemaHasField(ctSchema) {
       if (!ctSchema || !ctSchema.attributes) return { hasField: false, populateAttrs: {} };
       const rawAttrs = ctSchema.attributes;
       const populateAttrs = {};
-      let hasField = Boolean(rawAttrs[targetField]);
+      let hasField = false;
       for (const [attrKey, attrDef] of Object.entries(rawAttrs)) {
+        if (matchesPath(attrKey, attrKey, targetField)) {
+          hasField = true;
+        }
         if (attrDef.type === "component" && attrDef.component) {
-          const comp = allComponents[attrDef.component];
-          if (comp?.attributes?.[targetField]) {
+          if (componentHasField(attrDef.component, targetField)) {
             hasField = true;
             populateAttrs[attrKey] = true;
           }
         } else if (attrDef.type === "dynamiczone" && Array.isArray(attrDef.components)) {
           const matchingComp = attrDef.components.some(
-            (compUid) => allComponents[compUid]?.attributes?.[targetField]
+            (compUid) => componentHasField(compUid, targetField) || matchesPath(`${attrKey}.${compUid}`, compUid, targetField)
           );
           if (matchingComp) {
             hasField = true;
@@ -3717,19 +3790,23 @@ const validationRulesService = ({ strapi: strapi2 }) => ({
       }
       return { hasField, populateAttrs };
     }
-    const candidateUids = Object.keys(allContentTypes).filter(
-      (uid) => uid.startsWith("api::") && !uid.includes("bulk-updater")
-    );
+    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) {
+        return false;
+      }
+      return true;
+    });
     const relevantCollections = [];
     for (const uid of candidateUids) {
       const ct = allContentTypes[uid];
       if (!ct) continue;
       const { hasField, populateAttrs } = schemaHasField(ct);
-      if (hasField) {
+      if (hasField || rule.collectionUid && rule.collectionUid === uid) {
         relevantCollections.push({
           uid,
           displayName: ct.info?.displayName || uid,
-          populateOption: Object.keys(populateAttrs).length > 0 ? populateAttrs : void 0
+          populateOption: Object.keys(populateAttrs).length > 0 ? populateAttrs : "*"
         });
       }
     }
@@ -3746,35 +3823,73 @@ const validationRulesService = ({ strapi: strapi2 }) => ({
             });
             if (!entries || entries.length === 0) break;
             for (const entry of entries) {
-              let traverse = function(obj) {
+              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];
-                  if (key === targetField && typeof val === "string" && val) {
-                    const lower = val.toLowerCase();
-                    counts[lower] = (counts[lower] || 0) + 1;
+                  const newPath = currentPath ? `${currentPath}.${key}` : key;
+                  const normalizedPath = newPath.replace(/\.\d+/g, "");
+                  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;
+                  }
+                  if (rule.includeRichTextHtml) {
+                    if (typeof val === "string" && (val.includes("<h") || val.includes("#"))) {
+                      const headings = extractHeadingsFromRichText(val);
+                      for (const [tag, count] of Object.entries(headings)) {
+                        if (count > 0) {
+                          richTextCounts[tag] = (richTextCounts[tag] || 0) + count;
+                        }
+                      }
+                    } else if (Array.isArray(val) && val.length > 0 && typeof val[0] === "object" && val[0]?.type) {
+                      const headings = extractHeadingsFromRichText(val);
+                      for (const [tag, count] of Object.entries(headings)) {
+                        if (count > 0) {
+                          richTextCounts[tag] = (richTextCounts[tag] || 0) + count;
+                        }
+                      }
+                      continue;
+                    }
                   }
                   if (typeof val === "object" && val !== null) {
-                    traverse(val);
+                    traverse(val, newPath);
                   }
                 }
               };
               totalScanned++;
-              const counts = {};
+              const structuredCounts = {};
+              const richTextCounts = { h1: 0, h2: 0, h3: 0, h4: 0, h5: 0, h6: 0 };
               traverse(entry);
               for (const [optKey, max] of Object.entries(quotas)) {
-                const lowerOpt = optKey.toLowerCase();
-                const actualCount = counts[lowerOpt] || 0;
-                if (actualCount > max) {
+                const lowerOpt = optKey.toLowerCase().trim();
+                const structCount = structuredCounts[lowerOpt] || 0;
+                const rtCount = rule.includeRichTextHtml ? richTextCounts[lowerOpt] || 0 : 0;
+                const combinedCount = structCount + rtCount;
+                if (combinedCount > max) {
                   const entryLabel = entry.title || entry.name || entry.email || `Entry #${entry.documentId}`;
+                  let detail = "";
+                  if (rtCount > 0 && structCount > 0) {
+                    detail = `${structCount} structured + ${rtCount} in rich text HTML`;
+                  } else if (rtCount > 0) {
+                    detail = `${rtCount} in rich text HTML / Markdown`;
+                  } else {
+                    detail = `${structCount} in structured component`;
+                  }
                   violations.push({
                     uid,
                     collectionDisplayName: displayName,
                     documentId: entry.documentId,
                     entryLabel,
                     violatingOption: optKey.toUpperCase(),
-                    foundCount: actualCount,
+                    foundCount: combinedCount,
+                    structuredCount: structCount,
+                    richTextCount: rtCount,
                     maxAllowed: max,
+                    detail,
                     editUrl: `/admin/content-manager/collection-types/${uid}/${entry.documentId}`
                   });
                 }
@@ -34049,17 +34164,41 @@ const index = {
       if (["create", "update"].includes(context.action)) {
         const data = params?.data;
         if (data && typeof data === "object") {
-          let scanDataTree = function(obj) {
+          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];
-              if (fieldQuotas[key] && typeof val === "string" && val) {
-                const lowerVal = val.toLowerCase();
-                counts[key] = counts[key] || {};
-                counts[key][lowerVal] = (counts[key][lowerVal] || 0) + 1;
+              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) {
+                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;
+                }
+              }
+              if (typeof val === "string" && (val.includes("<h") || val.includes("#"))) {
+                const headings = extractHeadingsFromRichText(val);
+                for (const [tag, count] of Object.entries(headings)) {
+                  if (count > 0) {
+                    richTextCounts[tag] = (richTextCounts[tag] || 0) + count;
+                  }
+                }
+              } else if (Array.isArray(val) && val.length > 0 && typeof val[0] === "object" && val[0]?.type) {
+                const headings = extractHeadingsFromRichText(val);
+                for (const [tag, count] of Object.entries(headings)) {
+                  if (count > 0) {
+                    richTextCounts[tag] = (richTextCounts[tag] || 0) + count;
+                  }
+                }
+                continue;
               }
               if (typeof val === "object" && val !== null) {
-                scanDataTree(val);
+                scanDataTree(val, newPath);
               }
             }
           };
@@ -34073,20 +34212,22 @@ const index = {
           } catch (err) {
             strapi2.log.warn("[bulk-updater] Failed to fetch active UI validation rules:", err);
           }
-          const fieldQuotas = {};
-          for (const rule of activeUiRules) {
-            if (rule.targetField && rule.quotas) {
-              fieldQuotas[rule.targetField] = {
-                quotas: rule.quotas,
-                ruleName: rule.name
-              };
-            }
-          }
+          const effectiveRules = [
+            ...activeUiRules.filter((r) => !r.collectionUid || r.collectionUid === "*" || r.collectionUid === context.uid).map((r) => ({
+              id: r.id || r.targetField,
+              name: r.name || r.targetField,
+              collectionUid: r.collectionUid || "*",
+              targetField: r.targetField,
+              quotas: r.quotas || {},
+              includeRichTextHtml: Boolean(r.includeRichTextHtml),
+              richTextFields: r.richTextFields || []
+            }))
+          ];
           const allComponents = strapi2.components || {};
           for (const comp of Object.values(allComponents)) {
             const attrs = comp.attributes || {};
             for (const [attrName, attrDef] of Object.entries(attrs)) {
-              if (attrDef.type === "customField" && (attrDef.customField === "plugin::bulk-updater.scoped-select" || attrDef.customField === "global::scoped-select") && !fieldQuotas[attrName]) {
+              if (attrDef.type === "customField" && (attrDef.customField === "plugin::bulk-updater.scoped-select" || attrDef.customField === "global::scoped-select") && !effectiveRules.some((r) => matchesPath(attrName, attrName, r.targetField))) {
                 const quotas = attrDef.options?.quotas || {};
                 const items = attrDef.options?.items || [];
                 const itemQuotas = {};
@@ -34095,35 +34236,33 @@ const index = {
                     itemQuotas[item.value] = item.maxAllowed;
                   }
                 }
-                const mergedQuotas = {
-                  h1: 1,
-                  h2: 3,
-                  ...itemQuotas,
-                  ...quotas
-                };
-                fieldQuotas[attrName] = {
-                  quotas: mergedQuotas,
-                  ruleName: `${attrName} quota rule`
-                };
+                effectiveRules.push({
+                  id: `schema_${attrName}`,
+                  name: `${attrName} quota rule`,
+                  collectionUid: "*",
+                  targetField: attrName,
+                  quotas: {
+                    h1: 1,
+                    h2: 3,
+                    ...itemQuotas,
+                    ...quotas
+                  },
+                  includeRichTextHtml: true,
+                  richTextFields: []
+                });
               }
             }
           }
-          if (!fieldQuotas.headingLevel) {
-            fieldQuotas.headingLevel = {
-              quotas: { h1: 1, h2: 3 },
-              ruleName: "Default SEO Heading Rule"
-            };
-          }
-          const counts = {};
+          const structuredCounts = {};
+          const richTextCounts = { h1: 0, h2: 0, h3: 0, h4: 0, h5: 0, h6: 0 };
           let dataToScan = data;
           if (context.action === "update" && (params?.documentId || params?.where?.documentId)) {
             const docId = params?.documentId || params?.where?.documentId;
-            const hasQuotaFieldInPayload = Object.keys(fieldQuotas).some((k) => k in data);
-            if (hasQuotaFieldInPayload && context.uid) {
+            if (context.uid && docId) {
               try {
-                const existing = await strapi2.documents(context.uid).findOne({
-                  documentId: docId,
-                  populate: "*"
+                const existing = await strapi2.db?.query?.(context.uid)?.findOne?.({
+                  where: { documentId: docId },
+                  populate: true
                 });
                 if (existing) {
                   dataToScan = { ...existing, ...data };
@@ -34133,14 +34272,23 @@ const index = {
             }
           }
           scanDataTree(dataToScan);
-          for (const [fieldKey, ruleMeta] of Object.entries(fieldQuotas)) {
-            for (const [val, maxAllowed] of Object.entries(ruleMeta.quotas)) {
-              const lowerVal = val.toLowerCase();
-              const actualCount = counts[fieldKey]?.[lowerVal] || 0;
-              if (actualCount > maxAllowed) {
-                throw new ApplicationError(
-                  `Validation Error (${ruleMeta.ruleName}): Option "${val.toUpperCase()}" on field "${fieldKey}" cannot appear more than ${maxAllowed} time(s) across this entry (found ${actualCount}).`
-                );
+          for (const rule of effectiveRules) {
+            const ruleCounts = structuredCounts[rule.id] || {};
+            for (const [quotaKey, maxAllowed] of Object.entries(rule.quotas || {})) {
+              const lowerVal = quotaKey.toLowerCase().trim();
+              const structCount = ruleCounts[lowerVal] || 0;
+              const rtCount = rule.includeRichTextHtml ? richTextCounts[lowerVal] || 0 : 0;
+              const totalFound = structCount + rtCount;
+              if (totalFound > maxAllowed) {
+                let detailMsg = `Option "${quotaKey.toUpperCase()}" cannot appear more than ${maxAllowed} time(s) across this entry.`;
+                if (rtCount > 0 && structCount > 0) {
+                  detailMsg += ` Found ${totalFound} occurrences combined: ${structCount} in structured component ('${rule.targetField}') and ${rtCount} in rich text HTML / Markdown.`;
+                } else if (rtCount > 0) {
+                  detailMsg += ` Found ${totalFound} in rich text HTML / Markdown content.`;
+                } else {
+                  detailMsg += ` Found ${totalFound} in structured field '${rule.targetField}'.`;
+                }
+                throw new ApplicationError(`Validation Error (${rule.name}): ${detailMsg}`);
               }
             }
           }