strapi-plugin-bulk-updater 1.5.5 → 1.5.7

package/dist/server/index.mjs

@@ -990,6 +990,151 @@ function formatEntryRecord(entry) {
   }
   return formatted;
 }
+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",
+      "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) {
+        const fromProp = extractStageName(val[prop]);
+        if (fromProp) return fromProp;
+      }
+    }
+    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;
+        }
+      }
+    }
+    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 "";
+}
+function isStageApproved(stageVal) {
+  const name = extractStageName(stageVal);
+  return name.toLowerCase() === "approved";
+}
+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, publishedCounterpart) {
+  if (!entry || typeof entry !== "object") {
+    return { hadPublishedVersion: false, isModified: false };
+  }
+  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,
+  hadPublishedVersion,
+  isModified = false,
+  stageValue,
+  publish = true,
+  publishStrategy = "safe",
+  unreviewedConsent = false
+}) {
+  if (!isDraftAndPublish || !publish) {
+    return false;
+  }
+  if (!hadPublishedVersion) {
+    return false;
+  }
+  const isApproved = isStageApproved(stageValue);
+  const isEditingOrPending = isStageEditingOrPending(stageValue);
+  if (isApproved) {
+    return true;
+  }
+  if (isEditingOrPending) {
+    return false;
+  }
+  if (publishStrategy === "all" || unreviewedConsent) {
+    return true;
+  }
+  return hadPublishedVersion && !isModified;
+}
 async function populateDocumentLifecycleStatus(strapi, uid, entries) {
   if (!entries || !Array.isArray(entries) || entries.length === 0) {
     return entries;
@@ -1633,15 +1778,45 @@ async function executeBatchInternal(strapi, {
   const getDocumentDeduplicated = (uid, documentId) => {
     const loaderKey = `${uid}@@@${documentId}`;
     if (!documentLoader.has(loaderKey)) {
+      strapi.contentTypes[uid];
+      const findOneArgs = { documentId, populate: ["strapi_stage", "stage"] };
       documentLoader.set(
         loaderKey,
-        strapi.documents(uid).findOne({ documentId })
+        strapi.documents(uid).findOne(findOneArgs)
       );
     }
     return documentLoader.get(loaderKey);
   };
   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;
@@ -1693,13 +1868,42 @@ async function executeBatchInternal(strapi, {
               }
             });
             const isDraftAndPublishComp = Boolean(contentType?.options?.draftAndPublish);
-            const isApprovedComp = isDraftAndPublishComp && Boolean(currentEntry?.publishedAt) && currentEntry?.status !== "modified";
-            const shouldPublishComp = isDraftAndPublishComp && Boolean(publishOnApproval) && (publishStrategy === "all" ? true : isApprovedComp);
-            if (shouldPublishComp) {
+            let pubRecordComp = publishedCounterparts.get(`${target.uid}@@@${target.documentId}`);
+            if (!pubRecordComp && isDraftAndPublishComp && target.documentId) {
               try {
-                await strapi.documents(target.uid).publish({
-                  documentId: target.documentId
+                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,
+              hadPublishedVersion: hadPubComp,
+              isModified: isModComp,
+              stageValue: targetStageComp,
+              publish: Boolean(publishOnApproval),
+              publishStrategy,
+              unreviewedConsent
+            });
+            if (shouldPublishComp) {
+              try {
+                const pubArgs = { documentId: target.documentId };
+                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) {
                 strapi.log.warn(`[bulk-updater] Failed to auto-publish ${target.uid}/${target.documentId}:`, publishErr);
               }
@@ -1709,7 +1913,7 @@ async function executeBatchInternal(strapi, {
               uid: target.uid,
               documentId: target.documentId,
               userId: currentUser?.id,
-              statusOverride: shouldPublishComp ? "published" : isDraftAndPublishComp ? "draft" : void 0
+              statusOverride: shouldPublishComp ? "published" : isDraftAndPublishComp ? hadPubComp ? "modified" : "draft" : void 0
             });
             const dzDiffs = isRootDz && affectedMatches.length > 0 ? affectedMatches.map((m) => ({
               index: m.index,
@@ -1792,13 +1996,42 @@ async function executeBatchInternal(strapi, {
               }
             });
             const isDraftAndPublishRel = Boolean(contentType?.options?.draftAndPublish);
-            const isApprovedRel = isDraftAndPublishRel && Boolean(currentEntry?.publishedAt) && currentEntry?.status !== "modified";
-            const shouldPublishRel = isDraftAndPublishRel && Boolean(publishOnApproval) && (publishStrategy === "all" ? true : isApprovedRel);
-            if (shouldPublishRel) {
+            let pubRecordRel = publishedCounterparts.get(`${target.uid}@@@${target.documentId}`);
+            if (!pubRecordRel && isDraftAndPublishRel && target.documentId) {
               try {
-                await strapi.documents(target.uid).publish({
-                  documentId: target.documentId
+                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,
+              hadPublishedVersion: hadPubRel,
+              isModified: isModRel,
+              stageValue: targetStageRel,
+              publish: Boolean(publishOnApproval),
+              publishStrategy,
+              unreviewedConsent
+            });
+            if (shouldPublishRel) {
+              try {
+                const pubArgs = { documentId: target.documentId };
+                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) {
                 strapi.log.warn(`[bulk-updater] Failed to auto-publish ${target.uid}/${target.documentId}:`, publishErr);
               }
@@ -1811,7 +2044,7 @@ async function executeBatchInternal(strapi, {
               uid: target.uid,
               documentId: target.documentId,
               userId: currentUser?.id,
-              statusOverride: shouldPublishRel ? "published" : isDraftAndPublishRel ? "draft" : void 0
+              statusOverride: shouldPublishRel ? "published" : isDraftAndPublishRel ? hadPubRel ? "modified" : "draft" : void 0
             });
             return {
               uid: target.uid,
@@ -1837,13 +2070,42 @@ async function executeBatchInternal(strapi, {
             }
           });
           const isDraftAndPublishScalar = Boolean(contentType?.options?.draftAndPublish);
-          const isApprovedScalar = isDraftAndPublishScalar && Boolean(currentEntry?.publishedAt) && currentEntry?.status !== "modified";
-          const shouldPublishScalar = isDraftAndPublishScalar && Boolean(publishOnApproval) && (publishStrategy === "all" ? true : isApprovedScalar);
-          if (shouldPublishScalar) {
+          let pubRecordScalar = publishedCounterparts.get(`${target.uid}@@@${target.documentId}`);
+          if (!pubRecordScalar && isDraftAndPublishScalar && target.documentId) {
             try {
-              await strapi.documents(target.uid).publish({
-                documentId: target.documentId
+              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,
+            hadPublishedVersion: hadPubScalar,
+            isModified: isModScalar,
+            stageValue: targetStageScalar,
+            publish: Boolean(publishOnApproval),
+            publishStrategy,
+            unreviewedConsent
+          });
+          if (shouldPublishScalar) {
+            try {
+              const pubArgs = { documentId: target.documentId };
+              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) {
               strapi.log.warn(`[bulk-updater] Failed to auto-publish ${target.uid}/${target.documentId}:`, publishErr);
             }
@@ -1852,7 +2114,7 @@ async function executeBatchInternal(strapi, {
             uid: target.uid,
             documentId: target.documentId,
             userId: currentUser?.id,
-            statusOverride: shouldPublishScalar ? "published" : isDraftAndPublishScalar ? "draft" : void 0
+            statusOverride: shouldPublishScalar ? "published" : isDraftAndPublishScalar ? hadPubScalar ? "modified" : "draft" : void 0
           });
           return {
             uid: target.uid,
@@ -5215,50 +5477,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 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";
@@ -5456,6 +5698,7 @@ async function findExistingDocument(strapi, uid, targetDocId, docLocale) {
   try {
     const queryArgs = { documentId: targetDocId };
     if (effectiveLocale) queryArgs.locale = effectiveLocale;
+    queryArgs.populate = ["strapi_stage", "stage"];
     const found = await strapi.documents(uid).findOne(queryArgs);
     if (found) return found;
   } catch {
@@ -5835,6 +6078,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];
@@ -5902,12 +6164,40 @@ async function processCsvRows(strapi, ct, uid, rows, startRowNumber, options) {
         };
         if (effectiveLocale) updateArgs.locale = effectiveLocale;
         await strapi.documents(uid).update(updateArgs);
-        const isApproved = !isEditing && isDraftAndPublish && Boolean(existing?.publishedAt) && existing?.status !== "modified";
-        const shouldPublish = !isEditing && isDraftAndPublish && Boolean(publish) && (publishStrategy === "all" || options.unreviewedConsent ? true : isApproved);
+        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,
+          isModified,
+          stageValue: stageVal,
+          publish: Boolean(publish),
+          publishStrategy,
+          unreviewedConsent: options.unreviewedConsent
+        });
         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);
@@ -5918,7 +6208,7 @@ async function processCsvRows(strapi, ct, uid, rows, startRowNumber, options) {
             uid,
             documentId: resolvedDocId,
             userId: user?.id,
-            statusOverride: shouldPublish ? "published" : isDraftAndPublish ? existing?.publishedAt ? "modified" : "draft" : void 0
+            statusOverride: shouldPublish ? "published" : isDraftAndPublish ? hadPublishedVersion ? "modified" : "draft" : void 0
           });
         } catch {
         }
@@ -5957,12 +6247,38 @@ async function processCsvRows(strapi, ct, uid, rows, startRowNumber, options) {
           };
           if (effectiveLocale) updateArgs.locale = effectiveLocale;
           await strapi.documents(uid).update(updateArgs);
-          const isApproved = !isEditing && isDraftAndPublish && Boolean(existing?.publishedAt) && existing?.status !== "modified";
-          const shouldPublish = !isEditing && isDraftAndPublish && Boolean(publish) && (publishStrategy === "all" || options.unreviewedConsent ? true : isApproved);
+          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,
+            isModified,
+            stageValue: stageVal,
+            publish: Boolean(publish),
+            publishStrategy,
+            unreviewedConsent: options.unreviewedConsent
+          });
           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);
@@ -5973,7 +6289,7 @@ async function processCsvRows(strapi, ct, uid, rows, startRowNumber, options) {
               uid,
               documentId: resolvedDocId,
               userId: user?.id,
-              statusOverride: shouldPublish ? "published" : isDraftAndPublish ? existing?.publishedAt ? "modified" : "draft" : void 0
+              statusOverride: shouldPublish ? "published" : isDraftAndPublish ? hadPublishedVersion ? "modified" : "draft" : void 0
             });
           } catch {
           }
@@ -5999,11 +6315,13 @@ async function processCsvRows(strapi, ct, uid, rows, startRowNumber, options) {
         if (effectiveLocale) createArgs.locale = effectiveLocale;
         const created = await strapi.documents(uid).create(createArgs);
         const newDocId = created?.documentId || docId;
-        const shouldPublishNew = !isEditing && isDraftAndPublish && Boolean(publish) && (publishStrategy === "all" || options.unreviewedConsent ? true : false);
+        const isApprovedStage = isRowInApprovedStage(row);
+        const shouldPublishNew = !isEditing && !isApprovedStage && isDraftAndPublish && Boolean(publish) && (publishStrategy === "all" || options.unreviewedConsent ? true : false);
         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);
@@ -6054,12 +6372,38 @@ async function processCsvRows(strapi, ct, uid, rows, startRowNumber, options) {
           };
           if (effectiveLocale) updateArgs.locale = effectiveLocale;
           await strapi.documents(uid).update(updateArgs);
-          const isApproved = !isEditing && isDraftAndPublish && Boolean(existing?.publishedAt) && existing?.status !== "modified";
-          const shouldPublish = !isEditing && isDraftAndPublish && Boolean(publish) && (publishStrategy === "all" || options.unreviewedConsent ? true : isApproved);
+          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,
+            isModified,
+            stageValue: stageVal,
+            publish: Boolean(publish),
+            publishStrategy,
+            unreviewedConsent: options.unreviewedConsent
+          });
           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);
@@ -6070,7 +6414,7 @@ async function processCsvRows(strapi, ct, uid, rows, startRowNumber, options) {
               uid,
               documentId: resolvedDocId,
               userId: user?.id,
-              statusOverride: shouldPublish ? "published" : isDraftAndPublish ? existing?.publishedAt ? "modified" : "draft" : void 0
+              statusOverride: shouldPublish ? "published" : isDraftAndPublish ? hadPublishedVersion ? "modified" : "draft" : void 0
             });
           } catch {
           }
@@ -6096,11 +6440,13 @@ async function processCsvRows(strapi, ct, uid, rows, startRowNumber, options) {
         if (effectiveLocale) createArgs.locale = effectiveLocale;
         const created = await strapi.documents(uid).create(createArgs);
         const newDocId = created?.documentId || docId;
-        const shouldPublishNew = !isEditing && isDraftAndPublish && Boolean(publish) && (publishStrategy === "all" || options.unreviewedConsent ? true : false);
+        const isApprovedStage = isRowInApprovedStage(row);
+        const shouldPublishNew = !isEditing && !isApprovedStage && isDraftAndPublish && Boolean(publish) && (publishStrategy === "all" || options.unreviewedConsent ? true : false);
         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);
@@ -6688,6 +7034,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 errors2 = [];
     const warnings = [];
     for (let i = 0; i < rows.length; i++) {
@@ -6696,7 +7061,7 @@ const csvService = ({ strapi }) => ({
       const docId = extractDocId(row);
       const rowLocale = extractLocale(row);
       const effectiveLocale = getEffectiveLocale(ct, rowLocale);
-      const isEditing = isRowInEditingStage(row);
+      isRowInEditingStage(row);
       let rowHasError = false;
       let existing = null;
       if (docId) {
@@ -6704,15 +7069,44 @@ const csvService = ({ strapi }) => ({
       }
       if (existing && isDraftAndPublish) {
         lifecycleStats.totalChecked++;
-        const isApproved = !isEditing && Boolean(existing.publishedAt) && existing.status !== "modified";
-        if (isApproved) {
+        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,
+          isModified,
+          stageValue: stageVal,
+          publish: true,
+          publishStrategy: options.publishStrategy || "safe",
+          unreviewedConsent: options.unreviewedConsent
+        });
+        if (willPublish) {
           lifecycleStats.published++;
-        } else if (existing.status === "modified" || existing.publishedAt && isEditing) {
+        } else if (hadPublishedVersion && (isModified || isRowInEditingStage(row))) {
           lifecycleStats.modified++;
           lifecycleStats.unreviewedCount++;
-        } else {
+        } else if (!hadPublishedVersion) {
           lifecycleStats.draft++;
           lifecycleStats.unreviewedCount++;
+        } else {
+          lifecycleStats.published++;
         }
       }
       if (mode === "update") {