strapi-plugin-bulk-updater 1.2.3 → 1.2.8

package/dist/server/index.js

@@ -91,6 +91,30 @@ const routes = {
           policies: []
         }
       },
+      {
+        method: "GET",
+        path: "/batches/recent",
+        handler: "bulkUpdater.getRecentBatches",
+        config: {
+          policies: []
+        }
+      },
+      {
+        method: "GET",
+        path: "/batches/:batchId/status",
+        handler: "bulkUpdater.getBatchStatus",
+        config: {
+          policies: []
+        }
+      },
+      {
+        method: "GET",
+        path: "/batches/:batchId/report",
+        handler: "bulkUpdater.getBatchReport",
+        config: {
+          policies: []
+        }
+      },
       {
         method: "GET",
         path: "/audit/history",
@@ -376,6 +400,39 @@ const bulkUpdaterController = ({ strapi: strapi2 }) => ({
       ctx.status = 400;
       ctx.body = { success: false, error: err.message };
     }
+  },
+  async getBatchStatus(ctx) {
+    try {
+      const { batchId } = ctx.params;
+      const service = strapi2.plugin("bulk-updater").service("bulkUpdater");
+      const result = await service.getBatchStatus(batchId);
+      ctx.body = result;
+    } catch (err) {
+      ctx.status = 404;
+      ctx.body = { success: false, error: err.message };
+    }
+  },
+  async getBatchReport(ctx) {
+    try {
+      const { batchId } = ctx.params;
+      const { format = "csv" } = ctx.query;
+      const service = strapi2.plugin("bulk-updater").service("bulkUpdater");
+      const result = await service.getBatchReport(batchId, format);
+      ctx.body = result;
+    } catch (err) {
+      ctx.status = 500;
+      ctx.body = { success: false, error: err.message };
+    }
+  },
+  async getRecentBatches(ctx) {
+    try {
+      const service = strapi2.plugin("bulk-updater").service("bulkUpdater");
+      const result = await service.getRecentBatches();
+      ctx.body = result;
+    } catch (err) {
+      ctx.status = 500;
+      ctx.body = { success: false, error: err.message };
+    }
   }
 });
 const auditController = ({ strapi: strapi2 }) => ({
@@ -548,7 +605,7 @@ const csvController = ({ strapi: strapi2 }) => ({
       }
       const csvService2 = strapi2.plugin("bulk-updater").service("csv");
       const result = await csvService2.importCsv(uid, csvText, {
-        mode: mode2 === "create_or_override" ? "create_or_override" : "update",
+        mode: mode2 === "update" ? "update" : mode2 === "create_or_override" ? "create_or_override" : "auto",
         publish: publish !== false,
         user: ctx.state.user
       });
@@ -621,6 +678,7 @@ function checkBusinessHours(config, testDate) {
   };
 }
 const pendingBatches = /* @__PURE__ */ new Map();
+const batchJobsMap = /* @__PURE__ */ new Map();
 let isRunnerRunning = false;
 let runnerInterval = null;
 function invalidateCollectionCache(uid) {
@@ -720,6 +778,31 @@ async function executeBatchInternal(strapi2, {
   const results = [];
   let updatedCount = 0;
   let skippedCount = 0;
+  const jobState = {
+    id: batchId,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    createdBy: currentUser ? {
+      id: currentUser.id,
+      email: currentUser.email,
+      firstname: currentUser.firstname,
+      lastname: currentUser.lastname,
+      username: currentUser.username
+    } : { email: "admin@system.local" },
+    status: "processing",
+    executionMode: "immediate",
+    attribute,
+    value,
+    totalTargets: targetsMap.size,
+    processedCount: 0,
+    updatedCount: 0,
+    skippedCount: 0,
+    failedCount: 0,
+    isLive: false,
+    publishOnApproval: Boolean(publishOnApproval),
+    results: []
+  };
+  batchJobsMap.set(batchId, jobState);
   let regexObj = null;
   if (isRegex && regexPattern) {
     regexObj = new RegExp(regexPattern, "g");
@@ -954,11 +1037,24 @@ async function executeBatchInternal(strapi2, {
       else if (res.status === "skipped") skippedCount++;
       results.push(res);
     }
+    jobState.processedCount = results.length;
+    jobState.updatedCount = updatedCount;
+    jobState.skippedCount = skippedCount;
+    jobState.failedCount = results.filter((r) => r.status === "error").length;
   }
   const affectedUids = new Set(targets.map((t) => t.uid));
   affectedUids.forEach((uid) => {
     invalidateCollectionCache(uid);
   });
+  const failedCount = results.filter((r) => r.status === "error").length;
+  jobState.failedCount = failedCount;
+  jobState.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  jobState.isLive = updatedCount > 0;
+  jobState.status = failedCount === 0 && updatedCount > 0 ? "successful" : failedCount > 0 && updatedCount > 0 ? "partial_failure" : failedCount > 0 ? "failed" : "successful";
+  jobState.results = results.map((r) => ({
+    ...r,
+    isLive: r.status === "updated"
+  }));
   const batchSummary = {
     batchId,
     attribute,
@@ -980,7 +1076,10 @@ async function executeBatchInternal(strapi2, {
     value,
     updatedCount,
     skippedCount,
+    failedCount,
     totalTargets: targetsMap.size,
+    isLive: jobState.isLive,
+    status: jobState.status,
     results
   };
 }
@@ -1108,69 +1207,87 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
       }
       const collections = [];
       const signatures = [];
-      for (const uid of staticSchemaCache.targetUids) {
-        const meta = staticSchemaCache.metaByUid[uid];
-        if (!meta) continue;
-        const signature = await getCollectionSignature(strapi2, uid);
-        signatures.push(`${uid}=${signature}`);
-        const cached = modelsCache.get(uid);
-        if (cached && cached.signature === signature) {
-          collections.push({
-            ...meta,
-            totalEntries: cached.totalCount,
-            entries: cached.entries
-          });
-        } else {
-          let entries = [];
-          let totalCount = 0;
-          try {
-            const ctAttrs = allContentTypes[uid]?.attributes || {};
-            const relKeys = Object.keys(meta.relations || {});
-            const compKeys = Object.keys(ctAttrs).filter((k) => ctAttrs[k].type === "component");
-            const populateOptionObj = {};
-            relKeys.forEach((k) => {
-              populateOptionObj[k] = true;
-            });
-            compKeys.forEach((k) => {
-              populateOptionObj[k] = true;
-            });
-            const populateOption = Object.keys(populateOptionObj).length > 0 ? populateOptionObj : void 0;
-            if (meta.isSingleType) {
-              const singleDoc = await strapi2.documents(uid).findFirst({
-                populate: populateOption
+      const BATCH_CONCURRENCY = 10;
+      const collectionResults = [];
+      for (let i = 0; i < staticSchemaCache.targetUids.length; i += BATCH_CONCURRENCY) {
+        const batchUids = staticSchemaCache.targetUids.slice(i, i + BATCH_CONCURRENCY);
+        const batchRes = await Promise.all(
+          batchUids.map(async (uid) => {
+            const meta = staticSchemaCache.metaByUid[uid];
+            if (!meta) return null;
+            const signature = await getCollectionSignature(strapi2, uid);
+            const cached = modelsCache.get(uid);
+            if (cached && cached.signature === signature) {
+              return {
+                collection: {
+                  ...meta,
+                  totalEntries: cached.totalCount,
+                  entries: cached.entries
+                },
+                signature: `${uid}=${signature}`
+              };
+            }
+            let entries = [];
+            let totalCount = 0;
+            try {
+              const ctAttrs = allContentTypes[uid]?.attributes || {};
+              const relKeys = Object.keys(meta.relations || {});
+              const compKeys = Object.keys(ctAttrs).filter((k) => ctAttrs[k].type === "component");
+              const populateOptionObj = {};
+              relKeys.forEach((k) => {
+                populateOptionObj[k] = true;
               });
-              if (singleDoc) {
-                entries = [singleDoc];
-                totalCount = 1;
-              }
-            } else {
-              totalCount = await strapi2.documents(uid).count();
-              entries = await strapi2.documents(uid).findMany({
-                limit: 10,
-                sort: { createdAt: "desc" },
-                populate: populateOption
+              compKeys.forEach((k) => {
+                populateOptionObj[k] = true;
               });
+              const populateOption = Object.keys(populateOptionObj).length > 0 ? populateOptionObj : void 0;
+              if (meta.isSingleType) {
+                const singleDoc = await strapi2.documents(uid).findFirst({
+                  populate: populateOption
+                });
+                if (singleDoc) {
+                  entries = [singleDoc];
+                  totalCount = 1;
+                }
+              } else {
+                totalCount = await strapi2.documents(uid).count();
+                entries = await strapi2.documents(uid).findMany({
+                  limit: 10,
+                  sort: { createdAt: "desc" },
+                  populate: populateOption
+                });
+              }
+            } catch (err) {
+              strapi2.log.error(`[bulk-updater] Failed to fetch entries for ${uid}:`, err);
+              entries = [];
+              totalCount = 0;
             }
-          } catch (err) {
-            strapi2.log.error(`[bulk-updater] Failed to fetch entries for ${uid}:`, err);
-            entries = [];
-            totalCount = 0;
-          }
-          const formattedEntries = (entries || []).map((entry) => ({
-            id: entry.id,
-            documentId: entry.documentId,
-            ...entry
-          }));
-          modelsCache.set(uid, {
-            signature,
-            totalCount,
-            entries: formattedEntries
-          });
-          collections.push({
-            ...meta,
-            totalEntries: totalCount,
-            entries: formattedEntries
-          });
+            const formattedEntries = (entries || []).map((entry) => ({
+              id: entry.id,
+              documentId: entry.documentId,
+              ...entry
+            }));
+            modelsCache.set(uid, {
+              signature,
+              totalCount,
+              entries: formattedEntries
+            });
+            return {
+              collection: {
+                ...meta,
+                totalEntries: totalCount,
+                entries: formattedEntries
+              },
+              signature: `${uid}=${signature}`
+            };
+          })
+        );
+        collectionResults.push(...batchRes);
+      }
+      for (const res of collectionResults) {
+        if (res) {
+          collections.push(res.collection);
+          signatures.push(res.signature);
         }
       }
       const executionConfig = getExecutionWindowConfig(strapi2);
@@ -1489,6 +1606,24 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
           makerNotes
         };
         pendingBatches.set(batchId, batch);
+        batchJobsMap.set(batchId, {
+          id: batchId,
+          createdAt: batch.createdAt,
+          createdBy: batch.createdBy,
+          status: "pending_approval",
+          executionMode: "maker_checker",
+          attribute,
+          value,
+          totalTargets: summary.totalTargets,
+          processedCount: 0,
+          updatedCount: 0,
+          skippedCount: 0,
+          failedCount: 0,
+          isLive: false,
+          publishOnApproval: Boolean(publishOnApproval),
+          makerNotes,
+          results: []
+        });
         return {
           success: true,
           pending: true,
@@ -1528,6 +1663,25 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
           makerNotes
         };
         pendingBatches.set(batchId, batch);
+        batchJobsMap.set(batchId, {
+          id: batchId,
+          createdAt: batch.createdAt,
+          createdBy: batch.createdBy,
+          status: "queued_offpeak",
+          executionMode: "queue_offpeak",
+          scheduledFor: executionConfig.offPeakStartTime,
+          attribute,
+          value,
+          totalTargets: summary.totalTargets,
+          processedCount: 0,
+          updatedCount: 0,
+          skippedCount: 0,
+          failedCount: 0,
+          isLive: false,
+          publishOnApproval: Boolean(publishOnApproval),
+          makerNotes,
+          results: []
+        });
         return {
           success: true,
           pending: true,
@@ -1568,6 +1722,26 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
           makerNotes: "Automatically queued due to peak business hours restriction."
         };
         pendingBatches.set(batchId, batch);
+        batchJobsMap.set(batchId, {
+          id: batchId,
+          createdAt: batch.createdAt,
+          createdBy: batch.createdBy,
+          status: "queued_offpeak",
+          executionMode: "queue_offpeak",
+          scheduledFor: executionConfig.offPeakStartTime,
+          attribute,
+          value,
+          totalTargets: summary.totalTargets,
+          processedCount: 0,
+          updatedCount: 0,
+          skippedCount: 0,
+          failedCount: 0,
+          isLive: false,
+          publishOnApproval: Boolean(publishOnApproval),
+          policyMessage,
+          makerNotes: "Automatically queued due to peak business hours restriction.",
+          results: []
+        });
         return {
           success: true,
           pending: true,
@@ -1700,6 +1874,226 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
         result
       };
     },
+    /**
+     * Get real-time or historical processing status of a batch job
+     */
+    async getBatchStatus(batchId) {
+      if (!batchId) throw new Error("batchId is required");
+      let job = batchJobsMap.get(batchId);
+      if (job) {
+        return { success: true, batch: job };
+      }
+      const pending = pendingBatches.get(batchId);
+      if (pending) {
+        const pendingJob = {
+          id: pending.id,
+          createdAt: pending.createdAt,
+          createdBy: pending.createdBy,
+          status: pending.status,
+          executionMode: pending.executionMode,
+          scheduledFor: pending.scheduledFor,
+          attribute: pending.payload.attribute,
+          value: pending.payload.value,
+          totalTargets: pending.summary.totalTargets,
+          processedCount: 0,
+          updatedCount: 0,
+          skippedCount: 0,
+          failedCount: 0,
+          isLive: false,
+          publishOnApproval: Boolean(pending.payload.publishOnApproval),
+          policyMessage: pending.makerNotes,
+          results: []
+        };
+        return { success: true, batch: pendingJob };
+      }
+      try {
+        const auditService2 = strapi2.plugin("bulk-updater").service("audit");
+        const historyData = await auditService2.getHistory();
+        const records = Array.isArray(historyData?.history) ? historyData.history : [];
+        const found = records.find((r) => r.batchId === batchId);
+        if (found) {
+          const total = found.totalTargets || found.updatedCount + found.skippedCount || 1;
+          const historicalJob = {
+            id: found.batchId,
+            createdAt: found.executedAt || found.createdAt || (/* @__PURE__ */ new Date()).toISOString(),
+            startedAt: found.executedAt || found.createdAt,
+            completedAt: found.executedAt || found.createdAt,
+            createdBy: {
+              email: found.userEmail || "admin@strapi.io",
+              firstname: found.userName || "Admin"
+            },
+            status: found.isRolledBack ? "failed" : "successful",
+            executionMode: "immediate",
+            attribute: found.attribute,
+            value: found.value,
+            totalTargets: total,
+            processedCount: total,
+            updatedCount: found.updatedCount || 0,
+            skippedCount: found.skippedCount || 0,
+            failedCount: 0,
+            isLive: !found.isRolledBack && found.updatedCount > 0,
+            publishOnApproval: true,
+            results: (found.diffs || []).map((d) => ({
+              uid: d.uid,
+              collectionName: d.collectionName || d.uid,
+              documentId: d.documentId,
+              label: d.label || `Entry #${d.documentId}`,
+              attribute: d.attribute || found.attribute,
+              oldValue: d.oldValue,
+              newValue: d.newValue,
+              status: d.status || "updated",
+              isLive: !found.isRolledBack,
+              message: d.message || "Updated via bulk update"
+            }))
+          };
+          batchJobsMap.set(batchId, historicalJob);
+          return { success: true, batch: historicalJob };
+        }
+      } catch (err) {
+      }
+      throw new Error(`Batch with ID "${batchId}" was not found.`);
+    },
+    /**
+     * Downloadable execution report (CSV or JSON)
+     */
+    async getBatchReport(batchId, format = "csv") {
+      const statusRes = await this.getBatchStatus(batchId);
+      const batch = statusRes.batch;
+      function escapeCsvVal(val) {
+        if (val === null || val === void 0) return "";
+        let str2 = typeof val === "object" ? JSON.stringify(val) : String(val);
+        if (str2.includes(",") || str2.includes('"') || str2.includes("\n") || str2.includes("\r")) {
+          return `"${str2.replace(/"/g, '""')}"`;
+        }
+        return str2;
+      }
+      const headers = [
+        "Batch ID",
+        "Collection UID",
+        "Collection Name",
+        "Document ID",
+        "Record Title / Identifier",
+        "Attribute Name",
+        "Previous Value",
+        "New Live Value",
+        "Processing Status",
+        "Live On Server",
+        "Details / Message",
+        "Executed At",
+        "Operator"
+      ];
+      const rows = [headers.join(",")];
+      for (const item of batch.results || []) {
+        const row = [
+          escapeCsvVal(batch.id),
+          escapeCsvVal(item.uid),
+          escapeCsvVal(item.collectionName),
+          escapeCsvVal(item.documentId),
+          escapeCsvVal(item.label),
+          escapeCsvVal(item.attribute),
+          escapeCsvVal(item.oldValue),
+          escapeCsvVal(item.newValue),
+          escapeCsvVal(item.status === "updated" ? "Updated" : item.status === "error" ? "Failed" : "Skipped"),
+          escapeCsvVal(item.isLive ? "YES (Live on Site)" : "NO"),
+          escapeCsvVal(item.message),
+          escapeCsvVal(batch.completedAt || batch.createdAt),
+          escapeCsvVal(batch.createdBy?.email || "admin@strapi.io")
+        ];
+        rows.push(row.join(","));
+      }
+      const safeBatchId = batch.id.replace(/[^a-zA-Z0-9_-]/g, "_");
+      const filename = `bulk_update_report_${safeBatchId}_${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.csv`;
+      return {
+        success: true,
+        filename,
+        csvContent: rows.join("\n"),
+        summary: {
+          batchId: batch.id,
+          status: batch.status,
+          isLive: batch.isLive,
+          totalTargets: batch.totalTargets,
+          updatedCount: batch.updatedCount,
+          skippedCount: batch.skippedCount,
+          failedCount: batch.failedCount,
+          executedAt: batch.completedAt || batch.createdAt,
+          operator: batch.createdBy?.email || "admin@strapi.io"
+        },
+        batch
+      };
+    },
+    /**
+     * Get recent batch jobs for the processing dashboard
+     */
+    async getRecentBatches() {
+      const mergedMap = /* @__PURE__ */ new Map();
+      for (const [id, job] of batchJobsMap.entries()) {
+        mergedMap.set(id, {
+          id: job.id,
+          createdAt: job.createdAt,
+          completedAt: job.completedAt,
+          status: job.status,
+          isLive: job.isLive,
+          executionMode: job.executionMode,
+          attribute: job.attribute,
+          value: job.value,
+          totalTargets: job.totalTargets,
+          updatedCount: job.updatedCount,
+          skippedCount: job.skippedCount,
+          failedCount: job.failedCount,
+          operator: job.createdBy?.email || "admin@strapi.io"
+        });
+      }
+      for (const [id, p] of pendingBatches.entries()) {
+        if (!mergedMap.has(id)) {
+          mergedMap.set(id, {
+            id: p.id,
+            createdAt: p.createdAt,
+            status: p.status,
+            isLive: false,
+            executionMode: p.executionMode,
+            attribute: p.payload.attribute,
+            value: p.payload.value,
+            totalTargets: p.summary.totalTargets,
+            updatedCount: 0,
+            skippedCount: 0,
+            failedCount: 0,
+            operator: p.createdBy?.email || "admin@strapi.io"
+          });
+        }
+      }
+      try {
+        const auditService2 = strapi2.plugin("bulk-updater").service("audit");
+        const historyData = await auditService2.getHistory();
+        const records = Array.isArray(historyData?.history) ? historyData.history : [];
+        for (const r of records) {
+          if (!mergedMap.has(r.batchId)) {
+            mergedMap.set(r.batchId, {
+              id: r.batchId,
+              createdAt: r.executedAt || r.createdAt,
+              completedAt: r.executedAt,
+              status: r.isRolledBack ? "failed" : "successful",
+              isLive: !r.isRolledBack && r.updatedCount > 0,
+              executionMode: "immediate",
+              attribute: r.attribute,
+              value: r.value,
+              totalTargets: r.totalTargets || r.updatedCount + r.skippedCount || 1,
+              updatedCount: r.updatedCount || 0,
+              skippedCount: r.skippedCount || 0,
+              failedCount: 0,
+              operator: r.userEmail || "admin@strapi.io"
+            });
+          }
+        }
+      } catch {
+      }
+      const batches = Array.from(mergedMap.values()).sort(
+        (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+      );
+      return {
+        success: true,
+        batches: batches.slice(0, 50)
+      };
+    },
     invalidateCache(uid) {
       if (uid) {
         invalidateCollectionCache(uid);
@@ -1811,6 +2205,33 @@ const auditService = ({ strapi: strapi2 }) => ({
       isEnterpriseNativeAvailable: false
     };
   },
+  /**
+   * Checks whether audit logging is enabled.
+   */
+  isAuditEnabled() {
+    const config = this.getAuditConfig();
+    return Boolean(config && config.enabled);
+  },
+  /**
+   * Convenience alias to log an operation into the audit trail.
+   */
+  async logOperation(data) {
+    return this.recordBatch(
+      {
+        batchId: data.batchId,
+        attribute: data.attribute,
+        value: data.value,
+        updatedCount: data.updatedCount,
+        skippedCount: data.skippedCount,
+        totalTargets: data.totalTargets
+      },
+      data.diffs || [],
+      {
+        email: data.userEmail,
+        firstname: data.userName
+      }
+    );
+  },
   /**
    * Optionally writes an audit event directly to Strapi Enterprise's native Audit Logs table.
    */
@@ -2302,56 +2723,102 @@ const validationRulesService = ({ strapi: strapi2 }) => ({
     const violations = [];
     let totalScanned = 0;
     const allContentTypes = strapi2.contentTypes || {};
+    const allComponents = strapi2.components || {};
+    function schemaHasField(ctSchema) {
+      if (!ctSchema || !ctSchema.attributes) return { hasField: false, populateAttrs: {} };
+      const rawAttrs = ctSchema.attributes;
+      const populateAttrs = {};
+      let hasField = Boolean(rawAttrs[targetField]);
+      for (const [attrKey, attrDef] of Object.entries(rawAttrs)) {
+        if (attrDef.type === "component" && attrDef.component) {
+          const comp = allComponents[attrDef.component];
+          if (comp?.attributes?.[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]
+          );
+          if (matchingComp) {
+            hasField = true;
+            populateAttrs[attrKey] = true;
+          }
+        }
+      }
+      return { hasField, populateAttrs };
+    }
     const candidateUids = Object.keys(allContentTypes).filter(
       (uid) => uid.startsWith("api::") && !uid.includes("bulk-updater")
     );
+    const relevantCollections = [];
     for (const uid of candidateUids) {
       const ct = allContentTypes[uid];
       if (!ct) continue;
-      const displayName = ct.info?.displayName || uid;
-      try {
-        const entries = await strapi2.documents(uid).findMany({
-          populate: "*"
+      const { hasField, populateAttrs } = schemaHasField(ct);
+      if (hasField) {
+        relevantCollections.push({
+          uid,
+          displayName: ct.info?.displayName || uid,
+          populateOption: Object.keys(populateAttrs).length > 0 ? populateAttrs : void 0
         });
-        for (const entry of entries || []) {
-          let traverse = function(obj) {
-            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;
-              }
-              if (typeof val === "object" && val !== null) {
-                traverse(val);
+      }
+    }
+    const BATCH_SIZE = 250;
+    await Promise.all(
+      relevantCollections.map(async ({ uid, displayName, populateOption }) => {
+        try {
+          let page = 1;
+          while (true) {
+            const entries = await strapi2.documents(uid).findMany({
+              page,
+              pageSize: BATCH_SIZE,
+              populate: populateOption
+            });
+            if (!entries || entries.length === 0) break;
+            for (const entry of entries) {
+              let traverse = function(obj) {
+                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;
+                  }
+                  if (typeof val === "object" && val !== null) {
+                    traverse(val);
+                  }
+                }
+              };
+              totalScanned++;
+              const counts = {};
+              traverse(entry);
+              for (const [optKey, max] of Object.entries(quotas)) {
+                const lowerOpt = optKey.toLowerCase();
+                const actualCount = counts[lowerOpt] || 0;
+                if (actualCount > max) {
+                  const entryLabel = entry.title || entry.name || entry.email || `Entry #${entry.documentId}`;
+                  violations.push({
+                    uid,
+                    collectionDisplayName: displayName,
+                    documentId: entry.documentId,
+                    entryLabel,
+                    violatingOption: optKey.toUpperCase(),
+                    foundCount: actualCount,
+                    maxAllowed: max,
+                    editUrl: `/admin/content-manager/collection-types/${uid}/${entry.documentId}`
+                  });
+                }
               }
             }
-          };
-          totalScanned++;
-          const counts = {};
-          traverse(entry);
-          for (const [optKey, max] of Object.entries(quotas)) {
-            const lowerOpt = optKey.toLowerCase();
-            const actualCount = counts[lowerOpt] || 0;
-            if (actualCount > max) {
-              const entryLabel = entry.title || entry.name || entry.email || `Entry #${entry.documentId}`;
-              violations.push({
-                uid,
-                collectionDisplayName: displayName,
-                documentId: entry.documentId,
-                entryLabel,
-                violatingOption: optKey.toUpperCase(),
-                foundCount: actualCount,
-                maxAllowed: max,
-                editUrl: `/admin/content-manager/collection-types/${uid}/${entry.documentId}`
-              });
-            }
+            if (entries.length < BATCH_SIZE) break;
+            page++;
           }
+        } catch (err) {
+          strapi2.log.warn(`[bulk-updater] Failed scanning ${uid} for rule ${ruleId}:`, err);
         }
-      } catch (err) {
-        strapi2.log.warn(`[bulk-updater] Failed scanning ${uid} for rule ${ruleId}:`, err);
-      }
-    }
+      })
+    );
     return {
       rule,
       totalScanned,
@@ -2653,12 +3120,13 @@ ${sampleRow.map(escapeCsvValue).join(",")}
       throw new Error("CSV is empty or could not be parsed.");
     }
     const attrs = ct.attributes || {};
-    const { mode: mode2, publish = true, user } = options;
+    const { mode: mode2 = "auto", publish = true, user } = options;
     const stats = {
       total: parsedRows.length,
       created: 0,
       updated: 0,
       skipped: 0,
+      newWithoutDocId: 0,
       errors: [],
       diffs: []
     };
@@ -2730,7 +3198,7 @@ ${sampleRow.map(escapeCsvValue).join(",")}
             stats.skipped++;
             stats.errors.push({
               row: rowNumber,
-              error: "Missing documentId for Update mode."
+              error: "Missing documentId for Update mode. (Tip: Use Smart Auto-Detect mode to auto-add entries without document IDs)."
             });
             continue;
           }
@@ -2775,7 +3243,7 @@ ${sampleRow.map(escapeCsvValue).join(",")}
             status: "updated",
             message: `Updated via CSV import (row ${rowNumber})`
           });
-        } else {
+        } else if (mode2 === "create_or_override") {
           if (docId) {
             const existing = await strapi2.documents(uid).findOne({
               documentId: docId
@@ -2825,6 +3293,9 @@ ${sampleRow.map(escapeCsvValue).join(",")}
             }
           }
           stats.created++;
+          if (!docId) {
+            stats.newWithoutDocId++;
+          }
           stats.diffs.push({
             uid,
             collectionName: ct.info?.displayName || uid,
@@ -2834,7 +3305,71 @@ ${sampleRow.map(escapeCsvValue).join(",")}
             oldValue: null,
             newValue: payload,
             status: "updated",
-            message: `Created via CSV import (row ${rowNumber})`
+            message: docId ? `Created via CSV import (row ${rowNumber})` : `Created as new entry (no documentId provided in CSV - row ${rowNumber})`
+          });
+        } else {
+          if (docId) {
+            const existing = await strapi2.documents(uid).findOne({
+              documentId: docId
+            });
+            if (existing) {
+              const mergedPayload = { ...payload };
+              for (const key of Object.keys(payload)) {
+                if (attrs[key]?.type === "component" && typeof payload[key] === "object" && payload[key] !== null) {
+                  mergedPayload[key] = { ...existing[key] || {}, ...payload[key] };
+                }
+              }
+              await strapi2.documents(uid).update({
+                documentId: docId,
+                data: mergedPayload
+              });
+              if (publish && ct.options?.draftAndPublish) {
+                try {
+                  await strapi2.documents(uid).publish({ documentId: docId });
+                } catch (pubErr) {
+                  strapi2.log.warn(`[bulk-updater] Auto-publish failed for ${docId}:`, pubErr);
+                }
+              }
+              stats.updated++;
+              stats.diffs.push({
+                uid,
+                collectionName: ct.info?.displayName || uid,
+                documentId: docId,
+                label: existing.title || existing.name || `Entry #${docId}`,
+                attribute: Object.keys(payload).join(", "),
+                oldValue: existing,
+                newValue: payload,
+                status: "updated",
+                message: `Updated existing entry via smart match (row ${rowNumber})`
+              });
+              continue;
+            }
+          }
+          const created = await strapi2.documents(uid).create({
+            data: payload
+          });
+          const newDocId = created?.documentId || docId;
+          if (publish && ct.options?.draftAndPublish && newDocId) {
+            try {
+              await strapi2.documents(uid).publish({ documentId: newDocId });
+            } catch (pubErr) {
+              strapi2.log.warn(`[bulk-updater] Auto-publish failed for ${newDocId}:`, pubErr);
+            }
+          }
+          stats.created++;
+          if (!docId) {
+            stats.newWithoutDocId++;
+          }
+          stats.diffs.push({
+            uid,
+            collectionName: ct.info?.displayName || uid,
+            documentId: newDocId,
+            label: created?.title || created?.name || `New Entry #${newDocId}`,
+            attribute: Object.keys(payload).join(", "),
+            oldValue: null,
+            newValue: payload,
+            status: "updated",
+            message: docId ? `Created as new entry (documentId "${docId}" not found in database - row ${rowNumber})` : `Created as new entry (no documentId provided in CSV - row ${rowNumber})`
           });
         }
       } catch (err) {
@@ -2855,18 +3390,32 @@ ${sampleRow.map(escapeCsvValue).join(",")}
     if (stats.updated > 0 || stats.created > 0) {
       try {
         const auditService2 = strapi2.plugin("bulk-updater").service("audit");
-        if (auditService2 && auditService2.isAuditEnabled()) {
-          await auditService2.logOperation({
-            batchId,
-            attribute: "CSV_IMPORT",
-            value: `Mode: ${mode2} (${stats.created} created, ${stats.updated} updated)`,
-            userEmail,
-            userName,
-            updatedCount: stats.updated + stats.created,
-            skippedCount: stats.skipped,
-            totalTargets: stats.total,
-            diffs: stats.diffs
-          });
+        if (auditService2) {
+          const isEnabled = typeof auditService2.isAuditEnabled === "function" ? auditService2.isAuditEnabled() : Boolean(auditService2.getAuditConfig?.().enabled ?? true);
+          if (isEnabled) {
+            const batchSummary = {
+              batchId,
+              attribute: "CSV_IMPORT",
+              value: `Mode: ${mode2} (${stats.created} created, ${stats.updated} updated)`,
+              updatedCount: stats.updated + stats.created,
+              skippedCount: stats.skipped,
+              totalTargets: stats.total
+            };
+            const userObj = {
+              email: userEmail || "admin@strapi.io",
+              firstname: userName || "Admin"
+            };
+            if (typeof auditService2.recordBatch === "function") {
+              await auditService2.recordBatch(batchSummary, stats.diffs, userObj);
+            } else if (typeof auditService2.logOperation === "function") {
+              await auditService2.logOperation({
+                ...batchSummary,
+                userEmail,
+                userName,
+                diffs: stats.diffs
+              });
+            }
+          }
         }
       } catch (auditErr) {
         strapi2.log.warn("[bulk-updater] Failed logging CSV import audit:", auditErr);