strapi-plugin-bulk-updater 1.5.6 → 1.5.7

package/dist/admin/index.js

@@ -68,7 +68,7 @@ const index = {
         id: `${PLUGIN_ID}.plugin.name`,
         defaultMessage: "Bulk Attribute Updater"
       },
-      Component: () => Promise.resolve().then(() => require("../_chunks/BulkUpdater-BTWJq8UX.js")),
+      Component: () => Promise.resolve().then(() => require("../_chunks/BulkUpdater-KtGgE0LO.js")),
       permissions: [],
       position: 3
     });

package/dist/admin/index.mjs

@@ -65,7 +65,7 @@ const index = {
         id: `${PLUGIN_ID}.plugin.name`,
         defaultMessage: "Bulk Attribute Updater"
       },
-      Component: () => import("../_chunks/BulkUpdater-7YA96VJT.mjs"),
+      Component: () => import("../_chunks/BulkUpdater-Ci_Uojtf.mjs"),
       permissions: [],
       position: 3
     });

package/dist/server/index.js

@@ -995,16 +995,48 @@ function formatEntryRecord(entry) {
 }
 function extractStageName(val) {
   if (val === void 0 || val === null) return "";
+  if (typeof val === "string") {
+    const trimmed = val.trim();
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed && typeof parsed === "object") {
+          const fromParsed = extractStageName(parsed);
+          if (fromParsed) return fromParsed;
+        }
+      } catch {
+      }
+    }
+    return trimmed;
+  }
+  if (typeof val === "number") {
+    return String(val);
+  }
   if (typeof val === "object") {
     const candidateProps = [
       "strapi_stage",
       "strapi_stage.name",
+      "strapi_stage[name]",
+      "strapi_stage.title",
       "strapiStage",
       "Strapi Stage",
       "strapi-stage",
+      "strapi_stage_name",
       "stage",
       "Stage",
-      "review_stage"
+      "stage.name",
+      "stage[name]",
+      "stage_name",
+      "Stage Name",
+      "review_stage",
+      "review_stage.name",
+      "review_stage[name]",
+      "Review Stage",
+      "reviewStage",
+      "workflow_stage",
+      "workflow_stage.name",
+      "Workflow Stage",
+      "workflowStage"
     ];
     for (const prop of candidateProps) {
       if (val[prop] !== void 0 && val[prop] !== null) {
@@ -1012,23 +1044,35 @@ function extractStageName(val) {
         if (fromProp) return fromProp;
       }
     }
-    return String(val.name || val.title || val.status || val.label || "").trim();
-  }
-  if (typeof val === "string") {
-    const trimmed = val.trim();
-    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
-      try {
-        const parsed = JSON.parse(trimmed);
-        if (parsed && typeof parsed === "object") {
-          const fromParsed = String(parsed.name || parsed.title || parsed.status || parsed.label || "").trim();
-          if (fromParsed) return fromParsed;
+    const keys = Object.keys(val);
+    for (const k of keys) {
+      const norm = k.toLowerCase().replace(/[\s_\-\.\[\]]+/g, "");
+      if (norm === "strapistage" || norm === "strapistagename" || norm === "stagename" || norm === "reviewstage" || norm === "reviewstagename" || norm === "workflowstage" || norm === "workflowstagename") {
+        if (val[k] !== void 0 && val[k] !== null) {
+          const fromNorm = extractStageName(val[k]);
+          if (fromNorm) return fromNorm;
         }
-      } catch {
       }
     }
-    return trimmed;
+    if (val.documentId && !val.color && !val.workflow) {
+      return "";
+    }
+    const candidateStageValues = [
+      val.name,
+      val.title,
+      val.label,
+      val.value,
+      val.stageName,
+      val.stage_name,
+      val.status
+    ];
+    for (const sv of candidateStageValues) {
+      if (sv !== void 0 && sv !== null && typeof sv === "string" && sv.trim()) {
+        return sv.trim();
+      }
+    }
   }
-  return String(val).trim();
+  return "";
 }
 function isStageApproved(stageVal) {
   const name = extractStageName(stageVal);
@@ -1038,14 +1082,33 @@ function isStageEditingOrPending(stageVal) {
   const name = extractStageName(stageVal).toLowerCase();
   return name === "editing" || name === "in review" || name === "in_review" || name === "pending review" || name === "pending_review";
 }
-function inspectPreUpdateStatus(entry) {
+function inspectPreUpdateStatus(entry, publishedCounterpart) {
   if (!entry || typeof entry !== "object") {
     return { hadPublishedVersion: false, isModified: false };
   }
-  const isModified = entry.status === "modified";
-  const isPublished = entry.status === "published" || Boolean(entry.publishedAt);
-  const hadPublishedVersion = isModified || isPublished;
-  return { hadPublishedVersion, isModified };
+  const status = String(entry.status || "").toLowerCase();
+  if (status === "published") {
+    return { hadPublishedVersion: true, isModified: false };
+  }
+  if (status === "modified" || status === "modified draft") {
+    return { hadPublishedVersion: true, isModified: true };
+  }
+  if (status === "draft") {
+    return { hadPublishedVersion: false, isModified: false };
+  }
+  if (publishedCounterpart) {
+    const draftUpdatedTime = new Date(entry.updatedAt || entry.updated_at || 0).getTime();
+    const pubUpdatedTime = new Date(publishedCounterpart.updatedAt || publishedCounterpart.updated_at || 0).getTime();
+    const pubPublishedTime = new Date(publishedCounterpart.publishedAt || publishedCounterpart.published_at || 0).getTime();
+    const lastPublishedTime = Math.max(
+      isNaN(pubUpdatedTime) ? 0 : pubUpdatedTime,
+      isNaN(pubPublishedTime) ? 0 : pubPublishedTime
+    );
+    const isModified = !isNaN(draftUpdatedTime) && lastPublishedTime > 0 && draftUpdatedTime > lastPublishedTime;
+    return { hadPublishedVersion: true, isModified };
+  }
+  const hasPubAt = Boolean(entry.publishedAt || entry.published_at);
+  return { hadPublishedVersion: hasPubAt, isModified: false };
 }
 function determineShouldPublish({
   isDraftAndPublish,
@@ -1718,11 +1781,8 @@ async function executeBatchInternal(strapi, {
   const getDocumentDeduplicated = (uid, documentId) => {
     const loaderKey = `${uid}@@@${documentId}`;
     if (!documentLoader.has(loaderKey)) {
-      const ct = strapi.contentTypes[uid];
-      const findOneArgs = { documentId };
-      if (ct?.attributes?.strapi_stage) {
-        findOneArgs.populate = ["strapi_stage"];
-      }
+      strapi.contentTypes[uid];
+      const findOneArgs = { documentId, populate: ["strapi_stage", "stage"] };
       documentLoader.set(
         loaderKey,
         strapi.documents(uid).findOne(findOneArgs)
@@ -1732,6 +1792,34 @@ async function executeBatchInternal(strapi, {
   };
   for (let i = 0; i < targets.length; i += CHUNK_SIZE) {
     const chunk = targets.slice(i, i + CHUNK_SIZE);
+    const chunkByUid = /* @__PURE__ */ new Map();
+    for (const t of chunk) {
+      if (t.uid && t.documentId) {
+        if (!chunkByUid.has(t.uid)) chunkByUid.set(t.uid, []);
+        chunkByUid.get(t.uid).push(t.documentId);
+      }
+    }
+    const publishedCounterparts = /* @__PURE__ */ new Map();
+    for (const [colUid, docIds] of chunkByUid.entries()) {
+      const colCt = strapi.contentTypes[colUid];
+      if (colCt?.options?.draftAndPublish && docIds.length > 0) {
+        try {
+          const pubList = await strapi.documents(colUid).findMany({
+            status: "published",
+            filters: { documentId: { $in: docIds } },
+            fields: ["documentId", "updatedAt", "publishedAt"],
+            limit: docIds.length
+          });
+          for (const pub of pubList || []) {
+            if (pub?.documentId) {
+              publishedCounterparts.set(`${colUid}@@@${pub.documentId}`, pub);
+            }
+          }
+        } catch (err) {
+          strapi.log.warn(`[bulk-updater] Failed to pre-fetch published status for ${colUid}:`, err);
+        }
+      }
+    }
     const chunkPromises = chunk.map(async (target) => {
       const contentType = strapi.contentTypes[target.uid];
       const displayName = contentType?.info?.displayName || target.uid;
@@ -1783,7 +1871,24 @@ async function executeBatchInternal(strapi, {
               }
             });
             const isDraftAndPublishComp = Boolean(contentType?.options?.draftAndPublish);
-            const { hadPublishedVersion: hadPubComp, isModified: isModComp } = inspectPreUpdateStatus(currentEntry);
+            let pubRecordComp = publishedCounterparts.get(`${target.uid}@@@${target.documentId}`);
+            if (!pubRecordComp && isDraftAndPublishComp && target.documentId) {
+              try {
+                const singlePub = await strapi.documents(target.uid).findMany({
+                  status: "published",
+                  filters: { documentId: target.documentId },
+                  fields: ["documentId", "updatedAt", "publishedAt"],
+                  limit: 1
+                });
+                if (singlePub && singlePub.length > 0) {
+                  pubRecordComp = singlePub[0];
+                  publishedCounterparts.set(`${target.uid}@@@${target.documentId}`, pubRecordComp);
+                }
+              } catch {
+              }
+            }
+            const inspectionTargetComp = target.status || target.publishedAt ? { ...currentEntry, status: target.status, publishedAt: target.publishedAt } : currentEntry;
+            const { hadPublishedVersion: hadPubComp, isModified: isModComp } = inspectPreUpdateStatus(inspectionTargetComp, pubRecordComp);
             const targetStageComp = attribute.toLowerCase() === "strapi_stage" || attribute.toLowerCase() === "stage" ? value : currentEntry?.strapi_stage ?? currentEntry?.stage ?? target?.strapi_stage ?? target?.stage;
             const shouldPublishComp = determineShouldPublish({
               isDraftAndPublish: isDraftAndPublishComp,
@@ -1797,8 +1902,9 @@ async function executeBatchInternal(strapi, {
             if (shouldPublishComp) {
               try {
                 const pubArgs = { documentId: target.documentId };
-                if (target.locale || currentEntry?.locale) {
-                  pubArgs.locale = target.locale || currentEntry?.locale;
+                const candLoc = target.locale || currentEntry?.locale;
+                if (Boolean(contentType?.pluginOptions?.i18n?.localized) && candLoc && candLoc !== "null" && candLoc !== "undefined") {
+                  pubArgs.locale = candLoc;
                 }
                 await strapi.documents(target.uid).publish(pubArgs);
               } catch (publishErr) {
@@ -1893,7 +1999,24 @@ async function executeBatchInternal(strapi, {
               }
             });
             const isDraftAndPublishRel = Boolean(contentType?.options?.draftAndPublish);
-            const { hadPublishedVersion: hadPubRel, isModified: isModRel } = inspectPreUpdateStatus(currentEntry);
+            let pubRecordRel = publishedCounterparts.get(`${target.uid}@@@${target.documentId}`);
+            if (!pubRecordRel && isDraftAndPublishRel && target.documentId) {
+              try {
+                const singlePub = await strapi.documents(target.uid).findMany({
+                  status: "published",
+                  filters: { documentId: target.documentId },
+                  fields: ["documentId", "updatedAt", "publishedAt"],
+                  limit: 1
+                });
+                if (singlePub && singlePub.length > 0) {
+                  pubRecordRel = singlePub[0];
+                  publishedCounterparts.set(`${target.uid}@@@${target.documentId}`, pubRecordRel);
+                }
+              } catch {
+              }
+            }
+            const inspectionTargetRel = target.status || target.publishedAt ? { ...currentEntry, status: target.status, publishedAt: target.publishedAt } : currentEntry;
+            const { hadPublishedVersion: hadPubRel, isModified: isModRel } = inspectPreUpdateStatus(inspectionTargetRel, pubRecordRel);
             const targetStageRel = attribute.toLowerCase() === "strapi_stage" || attribute.toLowerCase() === "stage" ? value : currentEntry?.strapi_stage ?? currentEntry?.stage ?? target?.strapi_stage ?? target?.stage;
             const shouldPublishRel = determineShouldPublish({
               isDraftAndPublish: isDraftAndPublishRel,
@@ -1907,8 +2030,9 @@ async function executeBatchInternal(strapi, {
             if (shouldPublishRel) {
               try {
                 const pubArgs = { documentId: target.documentId };
-                if (target.locale || currentEntry?.locale) {
-                  pubArgs.locale = target.locale || currentEntry?.locale;
+                const candLoc = target.locale || currentEntry?.locale;
+                if (Boolean(contentType?.pluginOptions?.i18n?.localized) && candLoc && candLoc !== "null" && candLoc !== "undefined") {
+                  pubArgs.locale = candLoc;
                 }
                 await strapi.documents(target.uid).publish(pubArgs);
               } catch (publishErr) {
@@ -1949,7 +2073,24 @@ async function executeBatchInternal(strapi, {
             }
           });
           const isDraftAndPublishScalar = Boolean(contentType?.options?.draftAndPublish);
-          const { hadPublishedVersion: hadPubScalar, isModified: isModScalar } = inspectPreUpdateStatus(currentEntry);
+          let pubRecordScalar = publishedCounterparts.get(`${target.uid}@@@${target.documentId}`);
+          if (!pubRecordScalar && isDraftAndPublishScalar && target.documentId) {
+            try {
+              const singlePub = await strapi.documents(target.uid).findMany({
+                status: "published",
+                filters: { documentId: target.documentId },
+                fields: ["documentId", "updatedAt", "publishedAt"],
+                limit: 1
+              });
+              if (singlePub && singlePub.length > 0) {
+                pubRecordScalar = singlePub[0];
+                publishedCounterparts.set(`${target.uid}@@@${target.documentId}`, pubRecordScalar);
+              }
+            } catch {
+            }
+          }
+          const inspectionTargetScalar = target.status || target.publishedAt ? { ...currentEntry, status: target.status, publishedAt: target.publishedAt } : currentEntry;
+          const { hadPublishedVersion: hadPubScalar, isModified: isModScalar } = inspectPreUpdateStatus(inspectionTargetScalar, pubRecordScalar);
           const targetStageScalar = attribute.toLowerCase() === "strapi_stage" || attribute.toLowerCase() === "stage" ? value : currentEntry?.strapi_stage ?? currentEntry?.stage ?? target?.strapi_stage ?? target?.stage;
           const shouldPublishScalar = determineShouldPublish({
             isDraftAndPublish: isDraftAndPublishScalar,
@@ -1963,8 +2104,9 @@ async function executeBatchInternal(strapi, {
           if (shouldPublishScalar) {
             try {
               const pubArgs = { documentId: target.documentId };
-              if (target.locale || currentEntry?.locale) {
-                pubArgs.locale = target.locale || currentEntry?.locale;
+              const candLoc = target.locale || currentEntry?.locale;
+              if (Boolean(contentType?.pluginOptions?.i18n?.localized) && candLoc && candLoc !== "null" && candLoc !== "undefined") {
+                pubArgs.locale = candLoc;
               }
               await strapi.documents(target.uid).publish(pubArgs);
             } catch (publishErr) {
@@ -5338,54 +5480,30 @@ function getEffectiveLocale(ct, rowLocale) {
   }
   return trimmed;
 }
-function isRowInEditingStage(row) {
-  if (!row || typeof row !== "object") return false;
-  const candidates = [
-    row.strapi_stage,
-    row["strapi_stage"],
-    row.strapiStage,
-    row["Strapi Stage"],
-    row["strapi-stage"],
-    row.stage,
-    row.Stage,
-    row.status,
-    row.Status
-  ];
-  for (const c of candidates) {
-    if (c !== void 0 && c !== null) {
-      let stageName = "";
-      if (typeof c === "object") {
-        stageName = String(c.name || c.title || c.status || c.documentId || c.id || "").trim();
-      } else if (typeof c === "string") {
-        const trimmed = c.trim();
-        if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
-          try {
-            const parsed = JSON.parse(trimmed);
-            if (typeof parsed === "object" && parsed !== null) {
-              stageName = String(parsed.name || parsed.title || parsed.status || parsed.documentId || parsed.id || "").trim();
-            }
-          } catch {
-          }
-        }
-        if (!stageName) {
-          stageName = trimmed;
-        }
-      } else {
-        stageName = String(c).trim();
-      }
-      if (stageName) {
-        const s = stageName.toLowerCase();
-        if (s === "editing" || s === "in review" || s === "in_review" || s === "pending review" || s === "pending_review") {
-          return true;
-        }
-      }
+function resolveStageValue(row, existing) {
+  if (row && typeof row === "object") {
+    const stageNameFromRow = extractStageName(row);
+    if (stageNameFromRow) return stageNameFromRow;
+  }
+  if (existing && typeof existing === "object") {
+    if (existing.strapi_stage !== void 0 && existing.strapi_stage !== null) {
+      return existing.strapi_stage;
     }
+    if (existing.stage !== void 0 && existing.stage !== null) {
+      return existing.stage;
+    }
+    const stageNameFromExisting = extractStageName(existing);
+    if (stageNameFromExisting) return stageNameFromExisting;
   }
-  return false;
+  return void 0;
 }
-function isRowInApprovedStage(row) {
-  if (!row || typeof row !== "object") return false;
-  return isStageApproved(row);
+function isRowInEditingStage(row, existing) {
+  const stage = resolveStageValue(row, existing);
+  return isStageEditingOrPending(stage);
+}
+function isRowInApprovedStage(row, existing) {
+  const stage = resolveStageValue(row, existing);
+  return isStageApproved(stage);
 }
 function extractDetailedErrorMessage(err) {
   if (!err) return "Error processing row";
@@ -5583,7 +5701,7 @@ async function findExistingDocument(strapi, uid, targetDocId, docLocale) {
   try {
     const queryArgs = { documentId: targetDocId };
     if (effectiveLocale) queryArgs.locale = effectiveLocale;
-    if (ct?.attributes?.strapi_stage) queryArgs.populate = ["strapi_stage"];
+    queryArgs.populate = ["strapi_stage", "stage"];
     const found = await strapi.documents(uid).findOne(queryArgs);
     if (found) return found;
   } catch {
@@ -5963,6 +6081,25 @@ async function processCsvRows(strapi, ct, uid, rows, startRowNumber, options) {
     errors: [],
     diffs: []
   };
+  const docIdsInChunk = rows.map((r) => extractDocId(r)).filter(Boolean);
+  const publishedCounterparts = /* @__PURE__ */ new Map();
+  if (isDraftAndPublish && docIdsInChunk.length > 0) {
+    try {
+      const pubList = await strapi.documents(uid).findMany({
+        status: "published",
+        filters: { documentId: { $in: docIdsInChunk } },
+        fields: ["documentId", "updatedAt", "publishedAt"],
+        limit: docIdsInChunk.length
+      });
+      for (const pub of pubList || []) {
+        if (pub?.documentId) {
+          publishedCounterparts.set(String(pub.documentId), pub);
+        }
+      }
+    } catch (err) {
+      strapi.log.warn(`[csv] Failed to pre-fetch published status for CSV chunk:`, err);
+    }
+  }
   for (let i = 0; i < rows.length; i++) {
     const rowNumber = startRowNumber + i;
     const row = rows[i];
@@ -6030,8 +6167,24 @@ async function processCsvRows(strapi, ct, uid, rows, startRowNumber, options) {
         };
         if (effectiveLocale) updateArgs.locale = effectiveLocale;
         await strapi.documents(uid).update(updateArgs);
-        const { hadPublishedVersion, isModified } = inspectPreUpdateStatus(existing);
-        const stageVal = row.strapi_stage ?? row["strapi_stage"] ?? row.stage ?? existing?.strapi_stage;
+        let pubRecord = publishedCounterparts.get(String(resolvedDocId));
+        if (!pubRecord && isDraftAndPublish && resolvedDocId) {
+          try {
+            const singlePub = await strapi.documents(uid).findMany({
+              status: "published",
+              filters: { documentId: resolvedDocId },
+              fields: ["documentId", "updatedAt", "publishedAt"],
+              limit: 1
+            });
+            if (singlePub && singlePub.length > 0) {
+              pubRecord = singlePub[0];
+              publishedCounterparts.set(String(resolvedDocId), pubRecord);
+            }
+          } catch {
+          }
+        }
+        const { hadPublishedVersion, isModified } = inspectPreUpdateStatus(existing, pubRecord);
+        const stageVal = resolveStageValue(row, existing);
         const shouldPublish = determineShouldPublish({
           isDraftAndPublish,
           hadPublishedVersion,
@@ -6044,7 +6197,10 @@ async function processCsvRows(strapi, ct, uid, rows, startRowNumber, options) {
         if (shouldPublish) {
           try {
             const pubArgs = { documentId: resolvedDocId };
-            if (effectiveLocale) pubArgs.locale = effectiveLocale;
+            const isLoc = Boolean(ct?.pluginOptions?.i18n?.localized);
+            if (isLoc && effectiveLocale && effectiveLocale !== "null" && effectiveLocale !== "undefined") {
+              pubArgs.locale = effectiveLocale;
+            }
             await strapi.documents(uid).publish(pubArgs);
           } catch (pubErr) {
             strapi.log.warn(`[bulk-updater] Auto-publish failed for ${resolvedDocId}:`, pubErr);
@@ -6094,8 +6250,24 @@ async function processCsvRows(strapi, ct, uid, rows, startRowNumber, options) {
           };
           if (effectiveLocale) updateArgs.locale = effectiveLocale;
           await strapi.documents(uid).update(updateArgs);
-          const { hadPublishedVersion, isModified } = inspectPreUpdateStatus(existing);
-          const stageVal = row.strapi_stage ?? row["strapi_stage"] ?? row.stage ?? existing?.strapi_stage;
+          let pubRecord = publishedCounterparts.get(String(resolvedDocId));
+          if (!pubRecord && isDraftAndPublish && resolvedDocId) {
+            try {
+              const singlePub = await strapi.documents(uid).findMany({
+                status: "published",
+                filters: { documentId: resolvedDocId },
+                fields: ["documentId", "updatedAt", "publishedAt"],
+                limit: 1
+              });
+              if (singlePub && singlePub.length > 0) {
+                pubRecord = singlePub[0];
+                publishedCounterparts.set(String(resolvedDocId), pubRecord);
+              }
+            } catch {
+            }
+          }
+          const { hadPublishedVersion, isModified } = inspectPreUpdateStatus(existing, pubRecord);
+          const stageVal = resolveStageValue(row, existing);
           const shouldPublish = determineShouldPublish({
             isDraftAndPublish,
             hadPublishedVersion,
@@ -6108,7 +6280,8 @@ async function processCsvRows(strapi, ct, uid, rows, startRowNumber, options) {
           if (shouldPublish) {
             try {
               const pubArgs = { documentId: resolvedDocId };
-              if (effectiveLocale) pubArgs.locale = effectiveLocale;
+              const isLoc = Boolean(ct?.pluginOptions?.i18n?.localized);
+              if (isLoc && effectiveLocale && effectiveLocale !== "null" && effectiveLocale !== "undefined") pubArgs.locale = effectiveLocale;
               await strapi.documents(uid).publish(pubArgs);
             } catch (pubErr) {
               strapi.log.warn(`[bulk-updater] Auto-publish failed for ${resolvedDocId}:`, pubErr);
@@ -6150,7 +6323,8 @@ async function processCsvRows(strapi, ct, uid, rows, startRowNumber, options) {
         if (shouldPublishNew && newDocId) {
           try {
             const pubArgs = { documentId: newDocId };
-            if (effectiveLocale) pubArgs.locale = effectiveLocale;
+            const isLoc = Boolean(ct?.pluginOptions?.i18n?.localized);
+            if (isLoc && effectiveLocale && effectiveLocale !== "null" && effectiveLocale !== "undefined") pubArgs.locale = effectiveLocale;
             await strapi.documents(uid).publish(pubArgs);
           } catch (pubErr) {
             strapi.log.warn(`[bulk-updater] Auto-publish failed for ${newDocId}:`, pubErr);
@@ -6201,8 +6375,24 @@ async function processCsvRows(strapi, ct, uid, rows, startRowNumber, options) {
           };
           if (effectiveLocale) updateArgs.locale = effectiveLocale;
           await strapi.documents(uid).update(updateArgs);
-          const { hadPublishedVersion, isModified } = inspectPreUpdateStatus(existing);
-          const stageVal = row.strapi_stage ?? row["strapi_stage"] ?? row.stage ?? existing?.strapi_stage;
+          let pubRecord = publishedCounterparts.get(String(resolvedDocId));
+          if (!pubRecord && isDraftAndPublish && resolvedDocId) {
+            try {
+              const singlePub = await strapi.documents(uid).findMany({
+                status: "published",
+                filters: { documentId: resolvedDocId },
+                fields: ["documentId", "updatedAt", "publishedAt"],
+                limit: 1
+              });
+              if (singlePub && singlePub.length > 0) {
+                pubRecord = singlePub[0];
+                publishedCounterparts.set(String(resolvedDocId), pubRecord);
+              }
+            } catch {
+            }
+          }
+          const { hadPublishedVersion, isModified } = inspectPreUpdateStatus(existing, pubRecord);
+          const stageVal = resolveStageValue(row, existing);
           const shouldPublish = determineShouldPublish({
             isDraftAndPublish,
             hadPublishedVersion,
@@ -6215,7 +6405,8 @@ async function processCsvRows(strapi, ct, uid, rows, startRowNumber, options) {
           if (shouldPublish) {
             try {
               const pubArgs = { documentId: resolvedDocId };
-              if (effectiveLocale) pubArgs.locale = effectiveLocale;
+              const isLoc = Boolean(ct?.pluginOptions?.i18n?.localized);
+              if (isLoc && effectiveLocale && effectiveLocale !== "null" && effectiveLocale !== "undefined") pubArgs.locale = effectiveLocale;
               await strapi.documents(uid).publish(pubArgs);
             } catch (pubErr) {
               strapi.log.warn(`[bulk-updater] Auto-publish failed for ${resolvedDocId}:`, pubErr);
@@ -6257,7 +6448,8 @@ async function processCsvRows(strapi, ct, uid, rows, startRowNumber, options) {
         if (shouldPublishNew && newDocId) {
           try {
             const pubArgs = { documentId: newDocId };
-            if (effectiveLocale) pubArgs.locale = effectiveLocale;
+            const isLoc = Boolean(ct?.pluginOptions?.i18n?.localized);
+            if (isLoc && effectiveLocale && effectiveLocale !== "null" && effectiveLocale !== "undefined") pubArgs.locale = effectiveLocale;
             await strapi.documents(uid).publish(pubArgs);
           } catch (pubErr) {
             strapi.log.warn(`[bulk-updater] Auto-publish failed for ${newDocId}:`, pubErr);
@@ -6845,6 +7037,25 @@ const csvService = ({ strapi }) => ({
       draft: 0,
       unreviewedCount: 0
     };
+    const docIdsInPreflight = rows.map((r) => extractDocId(r)).filter(Boolean);
+    const publishedCounterparts = /* @__PURE__ */ new Map();
+    if (isDraftAndPublish && docIdsInPreflight.length > 0) {
+      try {
+        const pubList = await strapi.documents(uid).findMany({
+          status: "published",
+          filters: { documentId: { $in: docIdsInPreflight } },
+          fields: ["documentId", "updatedAt", "publishedAt"],
+          limit: docIdsInPreflight.length
+        });
+        for (const pub of pubList || []) {
+          if (pub?.documentId) {
+            publishedCounterparts.set(String(pub.documentId), pub);
+          }
+        }
+      } catch (err) {
+        strapi.log.warn(`[csv] Failed to pre-fetch published status for CSV preflight:`, err);
+      }
+    }
     const errors = [];
     const warnings = [];
     for (let i = 0; i < rows.length; i++) {
@@ -6861,8 +7072,25 @@ const csvService = ({ strapi }) => ({
       }
       if (existing && isDraftAndPublish) {
         lifecycleStats.totalChecked++;
-        const { hadPublishedVersion, isModified } = inspectPreUpdateStatus(existing);
-        const stageVal = row.strapi_stage ?? row["strapi_stage"] ?? row.stage ?? existing?.strapi_stage;
+        const targetDocId = existing.documentId || docId;
+        let pubRecord = publishedCounterparts.get(String(targetDocId));
+        if (!pubRecord && isDraftAndPublish && targetDocId) {
+          try {
+            const singlePub = await strapi.documents(uid).findMany({
+              status: "published",
+              filters: { documentId: targetDocId },
+              fields: ["documentId", "updatedAt", "publishedAt"],
+              limit: 1
+            });
+            if (singlePub && singlePub.length > 0) {
+              pubRecord = singlePub[0];
+              publishedCounterparts.set(String(targetDocId), pubRecord);
+            }
+          } catch {
+          }
+        }
+        const { hadPublishedVersion, isModified } = inspectPreUpdateStatus(existing, pubRecord);
+        const stageVal = resolveStageValue(row, existing);
         const willPublish = determineShouldPublish({
           isDraftAndPublish,
           hadPublishedVersion,