strapi-plugin-bulk-updater 1.3.3 → 1.3.6

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();
@@ -3639,77 +3815,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++;
+        currentCell += char;
       }
-      if (current.trim().length > 0) {
-        lines.push(current);
-      }
-      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 +4395,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 +4439,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 +4474,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 +4521,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 +4556,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,8 +34045,8 @@ 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) {
@@ -33909,8 +34146,113 @@ const index = {
           }
         }
       }
-      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 +34266,8 @@ const index = {
     bulkUpdater: bulkUpdaterService,
     audit: auditService,
     validationRules: validationRulesService,
-    csv: csvService
+    csv: csvService,
+    contentHistory: contentHistoryService
   }
 };
 module.exports = index;