strapi-plugin-bulk-updater 1.3.3 → 1.3.8

package/dist/server/index.js

@@ -688,6 +688,149 @@ const csvController = ({ strapi: strapi2 }) => ({
     }
   }
 });
+const FIELDS_TO_IGNORE = [
+  "createdAt",
+  "updatedAt",
+  "publishedAt",
+  "createdBy",
+  "updatedBy",
+  "strapi_stage",
+  "strapi_assignee"
+];
+function buildHistoryPopulate(attributes, allComponents, depth2 = 0) {
+  if (depth2 > 5) return void 0;
+  const populate2 = {};
+  for (const [key, def] of Object.entries(attributes || {})) {
+    if (def.type === "component" && def.component) {
+      const comp = allComponents[def.component];
+      if (comp?.attributes) {
+        const subPopulate = buildHistoryPopulate(comp.attributes, allComponents, depth2 + 1);
+        if (subPopulate && Object.keys(subPopulate).length > 0) {
+          populate2[key] = {
+            populate: subPopulate
+          };
+        } else {
+          populate2[key] = true;
+        }
+      } else {
+        populate2[key] = true;
+      }
+    } else if (def.type === "dynamiczone") {
+      populate2[key] = true;
+    } else if (def.type === "relation" || def.type === "media") {
+      populate2[key] = true;
+    }
+  }
+  return Object.keys(populate2).length > 0 ? populate2 : void 0;
+}
+let cachedAdminUserId = null;
+async function recordContentHistoryVersion(strapi2, options) {
+  const { uid, documentId, userId, statusOverride } = options;
+  if (!uid || !uid.startsWith("api::") || !documentId) {
+    return;
+  }
+  try {
+    const historyQuery = strapi2.db?.query?.("plugin::content-manager.history-version");
+    if (!historyQuery) {
+      return;
+    }
+    const model = strapi2.getModel?.(uid);
+    if (!model) {
+      return;
+    }
+    let entry = null;
+    try {
+      entry = await strapi2.db.query(uid).findOne({
+        where: { documentId },
+        populate: true
+      });
+    } catch {
+      try {
+        const populateOption = buildHistoryPopulate(model.attributes || {}, strapi2.components || {});
+        entry = await strapi2.documents(uid).findOne({
+          documentId,
+          ...populateOption ? { populate: populateOption } : {}
+        });
+      } catch {
+        entry = null;
+      }
+    }
+    if (!entry) {
+      return;
+    }
+    const attributesSchema = model.attributes || {};
+    const sanitizedSchema = Object.fromEntries(
+      Object.entries(attributesSchema).filter(([k]) => !FIELDS_TO_IGNORE.includes(k))
+    );
+    const sanitizedData = Object.fromEntries(
+      Object.entries(entry).filter(([k]) => !FIELDS_TO_IGNORE.includes(k) && k !== "id")
+    );
+    let status2 = statusOverride || "published";
+    if (!statusOverride) {
+      const hasDraftAndPublish = Boolean(model.options?.draftAndPublish);
+      if (hasDraftAndPublish) {
+        try {
+          const docMetaService = strapi2.plugin("content-manager")?.service("document-metadata");
+          if (docMetaService) {
+            const meta = await docMetaService.getMetadata(uid, entry);
+            status2 = docMetaService.getStatus(entry, meta.availableStatus);
+          } else {
+            status2 = entry.publishedAt ? "published" : "draft";
+          }
+        } catch {
+          status2 = entry.publishedAt ? "published" : "draft";
+        }
+      } else {
+        status2 = "published";
+      }
+    }
+    let authorId = userId;
+    if (!authorId) {
+      authorId = strapi2.requestContext?.get?.()?.state?.user?.id || null;
+    }
+    let numericUserId = authorId ? Number(authorId) : null;
+    if (!numericUserId || isNaN(numericUserId)) {
+      if (cachedAdminUserId) {
+        numericUserId = cachedAdminUserId;
+      } else {
+        try {
+          const firstAdmin = await strapi2.db?.query?.("admin::user")?.findOne?.({ select: ["id"] });
+          if (firstAdmin?.id) {
+            cachedAdminUserId = Number(firstAdmin.id);
+            numericUserId = cachedAdminUserId;
+          }
+        } catch {
+        }
+      }
+    }
+    await historyQuery.create({
+      data: {
+        contentType: uid,
+        relatedDocumentId: documentId,
+        locale: entry.locale || null,
+        status: status2,
+        data: sanitizedData,
+        schema: sanitizedSchema,
+        createdAt: /* @__PURE__ */ new Date(),
+        ...numericUserId && !isNaN(numericUserId) ? { createdBy: numericUserId } : {}
+      }
+    });
+  } catch (err) {
+    strapi2.log?.warn?.(`[bulk-updater] Non-blocking Content History notice for ${uid}/${documentId}: ${err?.message}`);
+  }
+}
+async function recordContentHistoryVersionsBatch(strapi2, items) {
+  if (!items || items.length === 0) return;
+  const BATCH_SIZE = 10;
+  for (let i = 0; i < items.length; i += BATCH_SIZE) {
+    const slice = items.slice(i, i + BATCH_SIZE);
+    await Promise.all(slice.map((item) => recordContentHistoryVersion(strapi2, item)));
+  }
+}
+const contentHistoryService = {
+  recordContentHistoryVersion,
+  recordContentHistoryVersionsBatch
+};
 const queryCache = /* @__PURE__ */ new Map();
 const modelsCache = /* @__PURE__ */ new Map();
 const MAX_QUERY_CACHE_SIZE = 500;
@@ -1064,6 +1207,12 @@ async function executeBatchInternal(strapi2, {
               }
             }
             invalidateCollectionCache(target.uid);
+            await recordContentHistoryVersion(strapi2, {
+              uid: target.uid,
+              documentId: target.documentId,
+              userId: currentUser?.id,
+              statusOverride: publishOnApproval && isDraftAndPublishComp ? "published" : void 0
+            });
             return {
               uid: target.uid,
               collectionName: displayName,
@@ -1149,6 +1298,12 @@ async function executeBatchInternal(strapi2, {
             if (attrDef.target) {
               invalidateCollectionCache(attrDef.target);
             }
+            await recordContentHistoryVersion(strapi2, {
+              uid: target.uid,
+              documentId: target.documentId,
+              userId: currentUser?.id,
+              statusOverride: publishOnApproval && isDraftAndPublishRel ? "published" : void 0
+            });
             return {
               uid: target.uid,
               collectionName: displayName,
@@ -1182,6 +1337,12 @@ async function executeBatchInternal(strapi2, {
               strapi2.log.warn(`[bulk-updater] Failed to auto-publish ${target.uid}/${target.documentId}:`, publishErr);
             }
           }
+          await recordContentHistoryVersion(strapi2, {
+            uid: target.uid,
+            documentId: target.documentId,
+            userId: currentUser?.id,
+            statusOverride: publishOnApproval && isDraftAndPublishScalar ? "published" : void 0
+          });
           return {
             uid: target.uid,
             collectionName: displayName,
@@ -1352,6 +1513,12 @@ async function executePublishBatchInternal(strapi2, {
           documentId: target.documentId
         });
         invalidateCollectionCache(target.uid);
+        await recordContentHistoryVersion(strapi2, {
+          uid: target.uid,
+          documentId: target.documentId,
+          userId: currentUser?.id,
+          statusOverride: "published"
+        });
         return {
           uid: target.uid,
           collectionName: displayName,
@@ -3207,7 +3374,7 @@ const auditService = ({ strapi: strapi2 }) => ({
   /**
    * Helper to revert diff items back to original values
    */
-  async revertDiffItems(diffs) {
+  async revertDiffItems(diffs, userId) {
     let revertedCount = 0;
     const rollbackDetails = [];
     for (const item of diffs) {
@@ -3265,6 +3432,15 @@ const auditService = ({ strapi: strapi2 }) => ({
             } catch {
             }
           }
+          try {
+            await recordContentHistoryVersion(strapi2, {
+              uid: item.uid,
+              documentId: item.documentId,
+              userId,
+              statusOverride: ct?.options?.draftAndPublish ? "published" : void 0
+            });
+          } catch {
+          }
           try {
             const bulkService = strapi2.plugin("bulk-updater").service("bulkUpdater");
             if (bulkService?.invalidateCache) {
@@ -3315,7 +3491,7 @@ const auditService = ({ strapi: strapi2 }) => ({
         throw new Error(`Batch "${batchId}" has already been rolled back.`);
       }
       const diffs2 = Array.isArray(record2.diffs) ? record2.diffs : [];
-      const { revertedCount: revertedCount2, rollbackDetails: rollbackDetails2 } = await this.revertDiffItems(diffs2);
+      const { revertedCount: revertedCount2, rollbackDetails: rollbackDetails2 } = await this.revertDiffItems(diffs2, currentUser?.id);
       record2.isRolledBack = true;
       record2.rolledBackAt = (/* @__PURE__ */ new Date()).toISOString();
       record2.rolledBackBy = currentUser?.email || "Admin";
@@ -3363,7 +3539,7 @@ const auditService = ({ strapi: strapi2 }) => ({
       throw new Error(`Batch "${batchId}" has already been rolled back.`);
     }
     const diffs = typeof record[f.diffs] === "string" ? JSON.parse(record[f.diffs]) : record[f.diffs] || [];
-    const { revertedCount, rollbackDetails } = await this.revertDiffItems(diffs);
+    const { revertedCount, rollbackDetails } = await this.revertDiffItems(diffs, currentUser?.id);
     const updateData = {};
     if (f.isRolledBack) updateData[f.isRolledBack] = true;
     if (f.rolledBackAt) updateData[f.rolledBackAt] = (/* @__PURE__ */ new Date()).toISOString();
@@ -3404,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,
@@ -3413,10 +3590,56 @@ 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 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}`);
+  }
+  return pLower === tLower || pLower.endsWith(`.${tLower}`) || pLower.endsWith(tLower);
+}
 const validationRulesService = ({ strapi: strapi2 }) => ({
   async getStore() {
     return strapi2.store({
@@ -3445,6 +3668,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;
@@ -3453,11 +3679,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
         };
@@ -3469,11 +3698,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
       };
@@ -3517,21 +3749,34 @@ 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;
+      for (const [attrName, attrDef] of Object.entries(comp.attributes)) {
+        if (matchesPath(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)
           );
           if (matchingComp) {
             hasField = true;
@@ -3541,19 +3786,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 : "*"
         });
       }
     }
@@ -3570,35 +3819,69 @@ 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;
                 for (const key of Object.keys(obj)) {
                   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, "");
+                  if (matchesPath(normalizedPath, key, targetField) && 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}`
                   });
                 }
@@ -3639,77 +3922,93 @@ function escapeCsvValue(val) {
   }
   return str2;
 }
-function parseCsv(csvText) {
+function parseCsvRows(csvText) {
   if (!csvText) return [];
-  let cleanText = csvText;
-  if (cleanText.charCodeAt(0) === 65279) {
-    cleanText = cleanText.slice(1);
+  let text = csvText;
+  if (text.charCodeAt(0) === 65279) {
+    text = text.slice(1);
   }
-  const lines = [];
-  let current = "";
+  const rows = [];
+  let currentRow = [];
+  let currentCell = "";
   let inQuotes = false;
-  for (let i = 0; i < cleanText.length; i++) {
-    const char = cleanText[i];
-    const nextChar = cleanText[i + 1];
-    if (char === '"') {
-      if (inQuotes && nextChar === '"') {
-        current += '"';
-        i++;
+  let cellIsQuoted = false;
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    const nextChar = text[i + 1];
+    if (inQuotes) {
+      if (char === '"') {
+        if (nextChar === '"') {
+          currentCell += '"';
+          i++;
+        } else {
+          inQuotes = false;
+        }
       } else {
-        inQuotes = !inQuotes;
-      }
-    } else if ((char === "\r" || char === "\n") && !inQuotes) {
-      if (char === "\r" && nextChar === "\n") {
-        i++;
-      }
-      if (current.trim().length > 0) {
-        lines.push(current);
+        currentCell += char;
       }
-      current = "";
     } else {
-      current += char;
-    }
-  }
-  if (current.trim().length > 0) {
-    lines.push(current);
-  }
-  if (lines.length < 1) return [];
-  function splitLine(line) {
-    const fields2 = [];
-    let field = "";
-    let inQ = false;
-    for (let i = 0; i < line.length; i++) {
-      const c = line[i];
-      const nc = line[i + 1];
-      if (c === '"') {
-        if (inQ && nc === '"') {
-          field += '"';
+      if (char === '"' && !cellIsQuoted && currentCell.trim() === "") {
+        inQuotes = true;
+        cellIsQuoted = true;
+        currentCell = "";
+      } else if (char === ",") {
+        currentRow.push(cellIsQuoted ? currentCell : currentCell.trim());
+        currentCell = "";
+        cellIsQuoted = false;
+      } else if (char === "\r") {
+        if (nextChar === "\n") {
           i++;
-        } else {
-          inQ = !inQ;
         }
-      } else if (c === "," && !inQ) {
-        fields2.push(field);
-        field = "";
+        currentRow.push(cellIsQuoted ? currentCell : currentCell.trim());
+        if (currentRow.length > 1 || currentRow.length === 1 && currentRow[0] !== "") {
+          rows.push(currentRow);
+        }
+        currentRow = [];
+        currentCell = "";
+        cellIsQuoted = false;
+      } else if (char === "\n") {
+        currentRow.push(cellIsQuoted ? currentCell : currentCell.trim());
+        if (currentRow.length > 1 || currentRow.length === 1 && currentRow[0] !== "") {
+          rows.push(currentRow);
+        }
+        currentRow = [];
+        currentCell = "";
+        cellIsQuoted = false;
       } else {
-        field += c;
+        if (!(cellIsQuoted && !inQuotes && (char === " " || char === "	"))) {
+          currentCell += char;
+        }
       }
     }
-    fields2.push(field);
-    return fields2.map((f) => f.trim());
   }
-  const headers = splitLine(lines[0]);
-  const rows = [];
-  for (let i = 1; i < lines.length; i++) {
-    const values = splitLine(lines[i]);
-    const rowObj = {};
-    headers.forEach((h, index2) => {
-      rowObj[h] = values[index2] !== void 0 ? values[index2] : "";
-    });
-    rows.push(rowObj);
+  if (currentCell !== "" || cellIsQuoted || currentRow.length > 0) {
+    currentRow.push(cellIsQuoted ? currentCell : currentCell.trim());
+    if (currentRow.length > 1 || currentRow.length === 1 && currentRow[0] !== "") {
+      rows.push(currentRow);
+    }
   }
   return rows;
 }
+function parseCsv(csvText) {
+  const rows = parseCsvRows(csvText);
+  if (rows.length < 2) return [];
+  const headers = rows[0].map((h) => h.trim());
+  const records = [];
+  for (let i = 1; i < rows.length; i++) {
+    const row = rows[i];
+    const record = {};
+    headers.forEach((h, idx) => {
+      let val = row[idx] !== void 0 ? row[idx] : "";
+      if (typeof val === "string" && /^'[=+@-]/.test(val)) {
+        val = val.substring(1);
+      }
+      record[h] = val;
+    });
+    records.push(record);
+  }
+  return records;
+}
 function discoverExportFields(ct, allComponents, maxDepth = 4) {
   const fields2 = [{ key: "documentId", label: "documentId", type: "string" }];
   const excluded = ["createdBy", "updatedBy", "localizations"];
@@ -4203,6 +4502,15 @@ const csvService = ({ strapi: strapi2 }) => ({
               strapi2.log.warn(`[bulk-updater] Auto-publish failed for ${docId}:`, pubErr);
             }
           }
+          try {
+            await recordContentHistoryVersion(strapi2, {
+              uid,
+              documentId: docId,
+              userId: user?.id,
+              statusOverride: publish && ct.options?.draftAndPublish ? "published" : void 0
+            });
+          } catch {
+          }
           stats.updated++;
           stats.diffs.push({
             uid,
@@ -4238,6 +4546,15 @@ const csvService = ({ strapi: strapi2 }) => ({
                   strapi2.log.warn(`[bulk-updater] Auto-publish failed for ${docId}:`, pubErr);
                 }
               }
+              try {
+                await recordContentHistoryVersion(strapi2, {
+                  uid,
+                  documentId: docId,
+                  userId: user?.id,
+                  statusOverride: publish && ct.options?.draftAndPublish ? "published" : void 0
+                });
+              } catch {
+              }
               stats.updated++;
               stats.diffs.push({
                 uid,
@@ -4264,6 +4581,15 @@ const csvService = ({ strapi: strapi2 }) => ({
               strapi2.log.warn(`[bulk-updater] Auto-publish failed for ${newDocId}:`, pubErr);
             }
           }
+          try {
+            await recordContentHistoryVersion(strapi2, {
+              uid,
+              documentId: newDocId,
+              userId: user?.id,
+              statusOverride: publish && ct.options?.draftAndPublish ? "published" : void 0
+            });
+          } catch {
+          }
           stats.created++;
           if (!docId) {
             stats.newWithoutDocId++;
@@ -4302,6 +4628,15 @@ const csvService = ({ strapi: strapi2 }) => ({
                   strapi2.log.warn(`[bulk-updater] Auto-publish failed for ${docId}:`, pubErr);
                 }
               }
+              try {
+                await recordContentHistoryVersion(strapi2, {
+                  uid,
+                  documentId: docId,
+                  userId: user?.id,
+                  statusOverride: publish && ct.options?.draftAndPublish ? "published" : void 0
+                });
+              } catch {
+              }
               stats.updated++;
               stats.diffs.push({
                 uid,
@@ -4328,6 +4663,15 @@ const csvService = ({ strapi: strapi2 }) => ({
               strapi2.log.warn(`[bulk-updater] Auto-publish failed for ${newDocId}:`, pubErr);
             }
           }
+          try {
+            await recordContentHistoryVersion(strapi2, {
+              uid,
+              documentId: newDocId,
+              userId: user?.id,
+              statusOverride: publish && ct.options?.draftAndPublish ? "published" : void 0
+            });
+          } catch {
+          }
           stats.created++;
           if (!docId) {
             stats.newWithoutDocId++;
@@ -33808,21 +34152,41 @@ const index = {
   },
   bootstrap({ strapi: strapi2 }) {
     strapi2.documents.use(async (context, next) => {
+      const params = context.params;
       if (["create", "update"].includes(context.action)) {
-        const params = context.params;
         const data = params?.data;
         if (data && typeof data === "object") {
-          let scanDataTree = function(obj) {
+          let scanDataTree = function(obj, currentPath = "") {
             if (!obj || typeof obj !== "object") return;
             for (const key of Object.keys(obj)) {
               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, "");
+              for (const rule of effectiveRules) {
+                if (matchesPath(normalizedPath, key, rule.targetField) && 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);
               }
             }
           };
@@ -33836,20 +34200,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 = {};
@@ -33858,35 +34224,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 };
@@ -33896,21 +34260,135 @@ 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}`);
               }
             }
           }
         }
       }
-      return next();
+      const result = await next();
+      return result;
     });
+    strapi2.server.use(async (ctx, next) => {
+      if (!ctx.path.startsWith("/content-manager/history-versions")) {
+        await next();
+        return;
+      }
+      await next();
+      if (ctx.status === 404 || ctx.status === 405) {
+        if (ctx.method === "GET" && ctx.path === "/content-manager/history-versions") {
+          const { contentType, documentId, locale: locale2, page = 1, pageSize = 20 } = ctx.query;
+          if (!contentType) return;
+          const historyQuery = strapi2.db?.query?.("plugin::content-manager.history-version");
+          if (!historyQuery) return;
+          const pageNum = Math.max(1, parseInt(page, 10) || 1);
+          const limit = Math.min(100, Math.max(1, parseInt(pageSize, 10) || 20));
+          const whereClause = {
+            contentType,
+            ...documentId ? { relatedDocumentId: documentId } : {},
+            ...locale2 ? { locale: locale2 } : {}
+          };
+          const [results, total] = await Promise.all([
+            historyQuery.findMany({
+              where: whereClause,
+              populate: ["createdBy"],
+              orderBy: { createdAt: "desc" },
+              limit,
+              offset: (pageNum - 1) * limit
+            }),
+            historyQuery.count({ where: whereClause })
+          ]);
+          const sanitizedResults = (results || []).map((ver) => ({
+            ...ver,
+            createdBy: ver.createdBy ? {
+              id: ver.createdBy.id,
+              firstname: ver.createdBy.firstname,
+              lastname: ver.createdBy.lastname,
+              username: ver.createdBy.username,
+              email: ver.createdBy.email
+            } : void 0,
+            meta: {
+              unknownAttributes: { added: {}, removed: {} }
+            }
+          }));
+          ctx.status = 200;
+          ctx.body = {
+            data: sanitizedResults,
+            meta: {
+              pagination: {
+                page: pageNum,
+                pageSize: limit,
+                pageCount: Math.ceil(total / limit) || 1,
+                total
+              }
+            }
+          };
+        } else if (ctx.method === "PUT" && ctx.path.endsWith("/restore")) {
+          const match = ctx.path.match(/\/content-manager\/history-versions\/([^/]+)\/restore/);
+          const versionId = match?.[1];
+          if (!versionId) return;
+          const historyQuery = strapi2.db?.query?.("plugin::content-manager.history-version");
+          const version = await historyQuery?.findOne?.({ where: { id: versionId } });
+          if (!version) {
+            ctx.status = 404;
+            ctx.body = { error: "Version not found" };
+            return;
+          }
+          const restored = await strapi2.documents(version.contentType).update({
+            documentId: version.relatedDocumentId,
+            locale: version.locale || void 0,
+            data: version.data
+          });
+          await recordContentHistoryVersion(strapi2, {
+            uid: version.contentType,
+            documentId: version.relatedDocumentId,
+            statusOverride: version.status || "published"
+          });
+          ctx.status = 200;
+          ctx.body = {
+            data: {
+              documentId: restored?.documentId || version.relatedDocumentId
+            }
+          };
+        }
+      }
+    });
+    try {
+      const knex = strapi2.db?.connection;
+      if (knex) {
+        if (knex.client?.config?.client === "sqlite3" || knex.client?.dialect === "sqlite3") {
+          knex.raw("PRAGMA busy_timeout = 10000;").catch(() => {
+          });
+        }
+        knex.schema.hasTable("strapi_history_versions").then((hasTable) => {
+          if (hasTable) {
+            knex.raw(`
+              CREATE INDEX IF NOT EXISTS idx_history_versions_lookup 
+              ON strapi_history_versions (content_type, related_document_id, created_at)
+            `).catch(() => {
+            });
+          }
+        }).catch(() => {
+        });
+      }
+    } catch {
+    }
   },
   routes,
   contentTypes,
@@ -33924,7 +34402,8 @@ const index = {
     bulkUpdater: bulkUpdaterService,
     audit: auditService,
     validationRules: validationRulesService,
-    csv: csvService
+    csv: csvService,
+    contentHistory: contentHistoryService
   }
 };
 module.exports = index;