strapi-plugin-bulk-updater 1.5.6 → 1.5.8

package/dist/server/index.mjs

@@ -990,87 +990,111 @@ function formatEntryRecord(entry) {
   }
   return formatted;
 }
-function extractStageName(val) {
-  if (val === void 0 || val === null) return "";
-  if (typeof val === "object") {
-    const candidateProps = [
-      "strapi_stage",
-      "strapi_stage.name",
-      "strapiStage",
-      "Strapi Stage",
-      "strapi-stage",
-      "stage",
-      "Stage",
-      "review_stage"
-    ];
-    for (const prop of candidateProps) {
-      if (val[prop] !== void 0 && val[prop] !== null) {
-        const fromProp = extractStageName(val[prop]);
-        if (fromProp) return fromProp;
-      }
+function isRowInEditingStage$1(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.review_stage,
+    row.workflow_stage
+  ];
+  if (row.status && typeof row.status === "string") {
+    const s = row.status.trim().toLowerCase();
+    if (s === "editing" || s === "in review" || s === "in_review" || s === "pending review" || s === "pending_review") {
+      candidates.push(row.status);
     }
-    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;
+  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;
         }
-      } catch {
       }
     }
-    return trimmed;
   }
-  return String(val).trim();
-}
-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";
+  return false;
 }
-function inspectPreUpdateStatus(entry) {
+function resolveRecordPublicationStatus(entry, publishedRecord, isDraftAndPublish) {
+  if (isDraftAndPublish === false) {
+    return { status: "published", hadPublishedVersion: true };
+  }
   if (!entry || typeof entry !== "object") {
-    return { hadPublishedVersion: false, isModified: false };
+    return { status: "unknown", hadPublishedVersion: false };
   }
-  const isModified = entry.status === "modified";
-  const isPublished = entry.status === "published" || Boolean(entry.publishedAt);
-  const hadPublishedVersion = isModified || isPublished;
-  return { hadPublishedVersion, isModified };
+  if (typeof entry.status === "string" && entry.status.trim()) {
+    const s = entry.status.trim().toLowerCase();
+    if (s === "published") {
+      return { status: "published", hadPublishedVersion: true };
+    }
+    if (s === "modified") {
+      return { status: "modified", hadPublishedVersion: true };
+    }
+    if (s === "draft") {
+      return { status: "draft", hadPublishedVersion: false };
+    }
+  }
+  const pub = publishedRecord || (entry.publishedAt ? entry : null);
+  if (!pub) {
+    return { status: "draft", hadPublishedVersion: false };
+  }
+  const draftUpdatedTime = new Date(entry.updatedAt || entry.updated_at || 0).getTime();
+  const pubUpdatedTime = new Date(pub.updatedAt || pub.updated_at || 0).getTime();
+  const pubPublishedTime = new Date(pub.publishedAt || pub.published_at || 0).getTime();
+  const lastPublishedTime = Math.max(
+    isNaN(pubUpdatedTime) ? 0 : pubUpdatedTime,
+    isNaN(pubPublishedTime) ? 0 : pubPublishedTime
+  );
+  if (isNaN(draftUpdatedTime) || lastPublishedTime === 0) {
+    if (pub.publishedAt || pub.published_at) {
+      return { status: "published", hadPublishedVersion: true };
+    }
+    return { status: "unknown", hadPublishedVersion: false };
+  }
+  if (draftUpdatedTime > lastPublishedTime) {
+    return { status: "modified", hadPublishedVersion: true };
+  }
+  return { status: "published", hadPublishedVersion: true };
 }
-function determineShouldPublish({
+function evaluateShouldPublish({
   isDraftAndPublish,
   hadPublishedVersion,
-  isModified = false,
-  stageValue,
-  publish = true,
+  isEditing,
+  publishOnApproval = 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;
+  if (!isDraftAndPublish) return false;
+  if (!hadPublishedVersion) return false;
+  if (!publishOnApproval) return false;
+  if (isEditing) return false;
+  return true;
 }
 async function populateDocumentLifecycleStatus(strapi, uid, entries) {
   if (!entries || !Array.isArray(entries) || entries.length === 0) {
@@ -1711,18 +1735,50 @@ async function executeBatchInternal(strapi, {
   }
   const targets = Array.from(targetsMap.values());
   const CHUNK_SIZE = 25;
+  const publishedCounterparts = /* @__PURE__ */ new Map();
+  const uidsWithDraftAndPublish = /* @__PURE__ */ new Set();
+  const docIdsByUid = /* @__PURE__ */ new Map();
+  for (const target of targets) {
+    if (target.uid && target.documentId) {
+      const ct = strapi.contentTypes[target.uid];
+      if (ct?.options?.draftAndPublish) {
+        uidsWithDraftAndPublish.add(target.uid);
+        if (!docIdsByUid.has(target.uid)) {
+          docIdsByUid.set(target.uid, []);
+        }
+        docIdsByUid.get(target.uid).push(target.documentId);
+      }
+    }
+  }
+  for (const colUid of uidsWithDraftAndPublish) {
+    const docIds = docIdsByUid.get(colUid) || [];
+    if (docIds.length > 0) {
+      try {
+        const pubDocs = await strapi.documents(colUid).findMany({
+          status: "published",
+          filters: { documentId: { $in: docIds } },
+          fields: ["documentId", "updatedAt", "publishedAt", "locale"],
+          limit: Math.max(docIds.length, 100)
+        });
+        for (const pub of pubDocs || []) {
+          if (pub?.documentId) {
+            publishedCounterparts.set(`${colUid}@@@${pub.documentId}`, pub);
+            if (pub.locale) {
+              publishedCounterparts.set(`${colUid}@@@${pub.documentId}@@@${pub.locale}`, pub);
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  }
   const documentLoader = /* @__PURE__ */ new Map();
   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"];
-      }
       documentLoader.set(
         loaderKey,
-        strapi.documents(uid).findOne(findOneArgs)
+        strapi.documents(uid).findOne({ documentId })
       );
     }
     return documentLoader.get(loaderKey);
@@ -1773,29 +1829,56 @@ async function executeBatchInternal(strapi, {
               targetIndexes,
               targetComponentUid
             });
-            await strapi.documents(target.uid).update({
-              documentId: target.documentId,
-              data: {
-                [rootKey]: updatedRoot
-              }
-            });
             const isDraftAndPublishComp = Boolean(contentType?.options?.draftAndPublish);
-            const { hadPublishedVersion: hadPubComp, isModified: isModComp } = inspectPreUpdateStatus(currentEntry);
-            const targetStageComp = attribute.toLowerCase() === "strapi_stage" || attribute.toLowerCase() === "stage" ? value : currentEntry?.strapi_stage ?? currentEntry?.stage ?? target?.strapi_stage ?? target?.stage;
-            const shouldPublishComp = determineShouldPublish({
+            const candLocaleComp = target.locale || currentEntry?.locale;
+            let pubRecordComp = candLocaleComp && publishedCounterparts.get(`${target.uid}@@@${target.documentId}@@@${candLocaleComp}`) || 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", "locale"],
+                  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 } = resolveRecordPublicationStatus(
+              inspectionTargetComp,
+              pubRecordComp,
+              isDraftAndPublishComp
+            );
+            const isEditingComp = isRowInEditingStage$1(inspectionTargetComp) || isRowInEditingStage$1(target);
+            const shouldPublishComp = evaluateShouldPublish({
               isDraftAndPublish: isDraftAndPublishComp,
               hadPublishedVersion: hadPubComp,
-              isModified: isModComp,
-              stageValue: targetStageComp,
-              publish: Boolean(publishOnApproval),
+              isEditing: isEditingComp,
+              publishOnApproval: Boolean(publishOnApproval),
               publishStrategy,
               unreviewedConsent
             });
+            const updateArgsComp = {
+              documentId: target.documentId,
+              data: {
+                [rootKey]: updatedRoot
+              }
+            };
+            if (Boolean(contentType?.pluginOptions?.i18n?.localized) && candLocaleComp && candLocaleComp !== "null" && candLocaleComp !== "undefined") {
+              updateArgsComp.locale = candLocaleComp;
+            }
+            await strapi.documents(target.uid).update(updateArgsComp);
             if (shouldPublishComp) {
               try {
-                const pubArgs = { documentId: target.documentId };
-                if (target.locale || currentEntry?.locale) {
-                  pubArgs.locale = target.locale || currentEntry?.locale;
+                const pubArgs = {
+                  documentId: target.documentId
+                };
+                if (Boolean(contentType?.pluginOptions?.i18n?.localized) && candLocaleComp && candLocaleComp !== "null" && candLocaleComp !== "undefined") {
+                  pubArgs.locale = candLocaleComp;
                 }
                 await strapi.documents(target.uid).publish(pubArgs);
               } catch (publishErr) {
@@ -1883,29 +1966,56 @@ async function executeBatchInternal(strapi, {
             } else if (mode === "disconnect") {
               relationPayload = { disconnect: targetDocIds };
             }
-            await strapi.documents(target.uid).update({
-              documentId: target.documentId,
-              data: {
-                [attribute]: relationPayload
-              }
-            });
             const isDraftAndPublishRel = Boolean(contentType?.options?.draftAndPublish);
-            const { hadPublishedVersion: hadPubRel, isModified: isModRel } = inspectPreUpdateStatus(currentEntry);
-            const targetStageRel = attribute.toLowerCase() === "strapi_stage" || attribute.toLowerCase() === "stage" ? value : currentEntry?.strapi_stage ?? currentEntry?.stage ?? target?.strapi_stage ?? target?.stage;
-            const shouldPublishRel = determineShouldPublish({
+            const candLocaleRel = target.locale || currentEntry?.locale;
+            let pubRecordRel = candLocaleRel && publishedCounterparts.get(`${target.uid}@@@${target.documentId}@@@${candLocaleRel}`) || 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", "locale"],
+                  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 } = resolveRecordPublicationStatus(
+              inspectionTargetRel,
+              pubRecordRel,
+              isDraftAndPublishRel
+            );
+            const isEditingRel = isRowInEditingStage$1(inspectionTargetRel) || isRowInEditingStage$1(target);
+            const shouldPublishRel = evaluateShouldPublish({
               isDraftAndPublish: isDraftAndPublishRel,
               hadPublishedVersion: hadPubRel,
-              isModified: isModRel,
-              stageValue: targetStageRel,
-              publish: Boolean(publishOnApproval),
+              isEditing: isEditingRel,
+              publishOnApproval: Boolean(publishOnApproval),
               publishStrategy,
               unreviewedConsent
             });
+            const updateArgsRel = {
+              documentId: target.documentId,
+              data: {
+                [attribute]: relationPayload
+              }
+            };
+            if (Boolean(contentType?.pluginOptions?.i18n?.localized) && candLocaleRel && candLocaleRel !== "null" && candLocaleRel !== "undefined") {
+              updateArgsRel.locale = candLocaleRel;
+            }
+            await strapi.documents(target.uid).update(updateArgsRel);
             if (shouldPublishRel) {
               try {
-                const pubArgs = { documentId: target.documentId };
-                if (target.locale || currentEntry?.locale) {
-                  pubArgs.locale = target.locale || currentEntry?.locale;
+                const pubArgs = {
+                  documentId: target.documentId
+                };
+                if (Boolean(contentType?.pluginOptions?.i18n?.localized) && candLocaleRel && candLocaleRel !== "null" && candLocaleRel !== "undefined") {
+                  pubArgs.locale = candLocaleRel;
                 }
                 await strapi.documents(target.uid).publish(pubArgs);
               } catch (publishErr) {
@@ -1939,29 +2049,56 @@ async function executeBatchInternal(strapi, {
           if (regexObj && typeof currentVal === "string") {
             newValue = currentVal.replace(regexObj, value);
           }
-          await strapi.documents(target.uid).update({
-            documentId: target.documentId,
-            data: {
-              [attribute]: newValue
-            }
-          });
           const isDraftAndPublishScalar = Boolean(contentType?.options?.draftAndPublish);
-          const { hadPublishedVersion: hadPubScalar, isModified: isModScalar } = inspectPreUpdateStatus(currentEntry);
-          const targetStageScalar = attribute.toLowerCase() === "strapi_stage" || attribute.toLowerCase() === "stage" ? value : currentEntry?.strapi_stage ?? currentEntry?.stage ?? target?.strapi_stage ?? target?.stage;
-          const shouldPublishScalar = determineShouldPublish({
+          const candLocaleScalar = target.locale || currentEntry?.locale;
+          let pubRecordScalar = candLocaleScalar && publishedCounterparts.get(`${target.uid}@@@${target.documentId}@@@${candLocaleScalar}`) || 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", "locale"],
+                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 } = resolveRecordPublicationStatus(
+            inspectionTargetScalar,
+            pubRecordScalar,
+            isDraftAndPublishScalar
+          );
+          const isEditingScalar = isRowInEditingStage$1(inspectionTargetScalar) || isRowInEditingStage$1(target);
+          const shouldPublishScalar = evaluateShouldPublish({
             isDraftAndPublish: isDraftAndPublishScalar,
             hadPublishedVersion: hadPubScalar,
-            isModified: isModScalar,
-            stageValue: targetStageScalar,
-            publish: Boolean(publishOnApproval),
+            isEditing: isEditingScalar,
+            publishOnApproval: Boolean(publishOnApproval),
             publishStrategy,
             unreviewedConsent
           });
+          const updateArgsScalar = {
+            documentId: target.documentId,
+            data: {
+              [attribute]: newValue
+            }
+          };
+          if (Boolean(contentType?.pluginOptions?.i18n?.localized) && candLocaleScalar && candLocaleScalar !== "null" && candLocaleScalar !== "undefined") {
+            updateArgsScalar.locale = candLocaleScalar;
+          }
+          await strapi.documents(target.uid).update(updateArgsScalar);
           if (shouldPublishScalar) {
             try {
-              const pubArgs = { documentId: target.documentId };
-              if (target.locale || currentEntry?.locale) {
-                pubArgs.locale = target.locale || currentEntry?.locale;
+              const pubArgs = {
+                documentId: target.documentId
+              };
+              if (Boolean(contentType?.pluginOptions?.i18n?.localized) && candLocaleScalar && candLocaleScalar !== "null" && candLocaleScalar !== "undefined") {
+                pubArgs.locale = candLocaleScalar;
               }
               await strapi.documents(target.uid).publish(pubArgs);
             } catch (publishErr) {
@@ -5380,10 +5517,6 @@ function isRowInEditingStage(row) {
   }
   return false;
 }
-function isRowInApprovedStage(row) {
-  if (!row || typeof row !== "object") return false;
-  return isStageApproved(row);
-}
 function extractDetailedErrorMessage(err) {
   if (!err) return "Error processing row";
   const detailsErrors = err.details?.errors || err.error?.details?.errors;
@@ -5580,7 +5713,6 @@ 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"];
     const found = await strapi.documents(uid).findOne(queryArgs);
     if (found) return found;
   } catch {
@@ -5951,6 +6083,27 @@ async function processCsvRows(strapi, ct, uid, rows, startRowNumber, options) {
   const attrs = ct.attributes || {};
   const { mode = "auto", publish = true, publishStrategy = "safe", user } = options;
   const isDraftAndPublish = Boolean(ct.options?.draftAndPublish);
+  const docIdsInChunk = rows.map((r) => extractDocId(r)).filter(Boolean);
+  const publishedCounterparts = /* @__PURE__ */ new Map();
+  if (isDraftAndPublish && docIdsInChunk.length > 0) {
+    try {
+      const pubDocs = await strapi.documents(uid).findMany({
+        status: "published",
+        filters: { documentId: { $in: docIdsInChunk } },
+        fields: ["documentId", "updatedAt", "publishedAt", "locale"],
+        limit: Math.max(docIdsInChunk.length, 100)
+      });
+      for (const pub of pubDocs || []) {
+        if (pub?.documentId) {
+          publishedCounterparts.set(String(pub.documentId), pub);
+          if (pub.locale) {
+            publishedCounterparts.set(`${pub.documentId}@@@${pub.locale}`, pub);
+          }
+        }
+      }
+    } catch {
+    }
+  }
   const stats = {
     total: rows.length,
     created: 0,
@@ -6027,14 +6180,33 @@ 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;
-        const shouldPublish = determineShouldPublish({
+        let pubRecord = effectiveLocale && publishedCounterparts.get(`${resolvedDocId}@@@${effectiveLocale}`) || 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", "locale"],
+              limit: 1
+            });
+            if (singlePub && singlePub.length > 0) {
+              pubRecord = singlePub[0];
+              publishedCounterparts.set(String(resolvedDocId), pubRecord);
+            }
+          } catch {
+          }
+        }
+        const inspectionExisting = row.status || row.publishedAt ? { ...existing, status: row.status, publishedAt: row.publishedAt } : existing;
+        const { hadPublishedVersion } = resolveRecordPublicationStatus(
+          inspectionExisting,
+          pubRecord,
+          isDraftAndPublish
+        );
+        const shouldPublish = evaluateShouldPublish({
           isDraftAndPublish,
           hadPublishedVersion,
-          isModified,
-          stageValue: stageVal,
-          publish: Boolean(publish),
+          isEditing,
+          publishOnApproval: Boolean(publish),
           publishStrategy,
           unreviewedConsent: options.unreviewedConsent
         });
@@ -6091,14 +6263,33 @@ 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;
-          const shouldPublish = determineShouldPublish({
+          let pubRecord = effectiveLocale && publishedCounterparts.get(`${resolvedDocId}@@@${effectiveLocale}`) || 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", "locale"],
+                limit: 1
+              });
+              if (singlePub && singlePub.length > 0) {
+                pubRecord = singlePub[0];
+                publishedCounterparts.set(String(resolvedDocId), pubRecord);
+              }
+            } catch {
+            }
+          }
+          const inspectionExisting = row.status || row.publishedAt ? { ...existing, status: row.status, publishedAt: row.publishedAt } : existing;
+          const { hadPublishedVersion } = resolveRecordPublicationStatus(
+            inspectionExisting,
+            pubRecord,
+            isDraftAndPublish
+          );
+          const shouldPublish = evaluateShouldPublish({
             isDraftAndPublish,
             hadPublishedVersion,
-            isModified,
-            stageValue: stageVal,
-            publish: Boolean(publish),
+            isEditing,
+            publishOnApproval: Boolean(publish),
             publishStrategy,
             unreviewedConsent: options.unreviewedConsent
           });
@@ -6142,8 +6333,7 @@ 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 isApprovedStage = isRowInApprovedStage(row);
-        const shouldPublishNew = !isEditing && !isApprovedStage && isDraftAndPublish && Boolean(publish) && (publishStrategy === "all" || options.unreviewedConsent ? true : false);
+        const shouldPublishNew = !isEditing && isDraftAndPublish && Boolean(publish) && (publishStrategy === "all" || options.unreviewedConsent ? true : false);
         if (shouldPublishNew && newDocId) {
           try {
             const pubArgs = { documentId: newDocId };
@@ -6198,14 +6388,33 @@ 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;
-          const shouldPublish = determineShouldPublish({
+          let pubRecord = effectiveLocale && publishedCounterparts.get(`${resolvedDocId}@@@${effectiveLocale}`) || 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", "locale"],
+                limit: 1
+              });
+              if (singlePub && singlePub.length > 0) {
+                pubRecord = singlePub[0];
+                publishedCounterparts.set(String(resolvedDocId), pubRecord);
+              }
+            } catch {
+            }
+          }
+          const inspectionExisting = row.status || row.publishedAt ? { ...existing, status: row.status, publishedAt: row.publishedAt } : existing;
+          const { hadPublishedVersion } = resolveRecordPublicationStatus(
+            inspectionExisting,
+            pubRecord,
+            isDraftAndPublish
+          );
+          const shouldPublish = evaluateShouldPublish({
             isDraftAndPublish,
             hadPublishedVersion,
-            isModified,
-            stageValue: stageVal,
-            publish: Boolean(publish),
+            isEditing,
+            publishOnApproval: Boolean(publish),
             publishStrategy,
             unreviewedConsent: options.unreviewedConsent
           });
@@ -6249,8 +6458,7 @@ 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 isApprovedStage = isRowInApprovedStage(row);
-        const shouldPublishNew = !isEditing && !isApprovedStage && isDraftAndPublish && Boolean(publish) && (publishStrategy === "all" || options.unreviewedConsent ? true : false);
+        const shouldPublishNew = !isEditing && isDraftAndPublish && Boolean(publish) && (publishStrategy === "all" || options.unreviewedConsent ? true : false);
         if (shouldPublishNew && newDocId) {
           try {
             const pubArgs = { documentId: newDocId };
@@ -6850,7 +7058,7 @@ const csvService = ({ strapi }) => ({
       const docId = extractDocId(row);
       const rowLocale = extractLocale(row);
       const effectiveLocale = getEffectiveLocale(ct, rowLocale);
-      isRowInEditingStage(row);
+      const isEditing = isRowInEditingStage(row);
       let rowHasError = false;
       let existing = null;
       if (docId) {
@@ -6858,27 +7066,21 @@ 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 willPublish = determineShouldPublish({
-          isDraftAndPublish,
-          hadPublishedVersion,
-          isModified,
-          stageValue: stageVal,
-          publish: true,
-          publishStrategy: options.publishStrategy || "safe",
-          unreviewedConsent: options.unreviewedConsent
-        });
-        if (willPublish) {
+        const inspectionExisting = row.status || row.publishedAt ? { ...existing, status: row.status, publishedAt: row.publishedAt } : existing;
+        const { status: preStatus, hadPublishedVersion } = resolveRecordPublicationStatus(
+          inspectionExisting,
+          void 0,
+          isDraftAndPublish
+        );
+        const isApproved = !isEditing && hadPublishedVersion;
+        if (isApproved) {
           lifecycleStats.published++;
-        } else if (hadPublishedVersion && (isModified || isRowInEditingStage(row))) {
+        } else if (preStatus === "modified" || hadPublishedVersion && isEditing) {
           lifecycleStats.modified++;
           lifecycleStats.unreviewedCount++;
-        } else if (!hadPublishedVersion) {
+        } else {
           lifecycleStats.draft++;
           lifecycleStats.unreviewedCount++;
-        } else {
-          lifecycleStats.published++;
         }
       }
       if (mode === "update") {