strapi-plugin-bulk-updater 1.5.7 → 1.5.8

package/dist/server/index.mjs

@@ -990,150 +990,111 @@ 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 {
-      }
+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 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;
+  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 (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();
+      if (stageName) {
+        const s = stageName.toLowerCase();
+        if (s === "editing" || s === "in review" || s === "in_review" || s === "pending review" || s === "pending_review") {
+          return true;
+        }
       }
     }
   }
-  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";
+  return false;
 }
-function inspectPreUpdateStatus(entry, publishedCounterpart) {
+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 status = String(entry.status || "").toLowerCase();
-  if (status === "published") {
-    return { hadPublishedVersion: true, isModified: false };
+  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 };
+    }
   }
-  if (status === "modified" || status === "modified draft") {
-    return { hadPublishedVersion: true, isModified: true };
+  const pub = publishedRecord || (entry.publishedAt ? entry : null);
+  if (!pub) {
+    return { status: "draft", hadPublishedVersion: false };
   }
-  if (status === "draft") {
-    return { hadPublishedVersion: false, isModified: 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 (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 };
+  if (draftUpdatedTime > lastPublishedTime) {
+    return { status: "modified", hadPublishedVersion: true };
   }
-  const hasPubAt = Boolean(entry.publishedAt || entry.published_at);
-  return { hadPublishedVersion: hasPubAt, isModified: false };
+  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) {
@@ -1774,49 +1735,56 @@ 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)) {
-      strapi.contentTypes[uid];
-      const findOneArgs = { documentId, populate: ["strapi_stage", "stage"] };
       documentLoader.set(
         loaderKey,
-        strapi.documents(uid).findOne(findOneArgs)
+        strapi.documents(uid).findOne({ documentId })
       );
     }
     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;
@@ -1861,20 +1829,15 @@ async function executeBatchInternal(strapi, {
               targetIndexes,
               targetComponentUid
             });
-            await strapi.documents(target.uid).update({
-              documentId: target.documentId,
-              data: {
-                [rootKey]: updatedRoot
-              }
-            });
             const isDraftAndPublishComp = Boolean(contentType?.options?.draftAndPublish);
-            let pubRecordComp = publishedCounterparts.get(`${target.uid}@@@${target.documentId}`);
+            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"],
+                  fields: ["documentId", "updatedAt", "publishedAt", "locale"],
                   limit: 1
                 });
                 if (singlePub && singlePub.length > 0) {
@@ -1885,23 +1848,37 @@ async function executeBatchInternal(strapi, {
               }
             }
             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({
+            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 };
-                const candLoc = target.locale || currentEntry?.locale;
-                if (Boolean(contentType?.pluginOptions?.i18n?.localized) && candLoc && candLoc !== "null" && candLoc !== "undefined") {
-                  pubArgs.locale = candLoc;
+                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) {
@@ -1989,20 +1966,15 @@ 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);
-            let pubRecordRel = publishedCounterparts.get(`${target.uid}@@@${target.documentId}`);
+            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"],
+                  fields: ["documentId", "updatedAt", "publishedAt", "locale"],
                   limit: 1
                 });
                 if (singlePub && singlePub.length > 0) {
@@ -2013,23 +1985,37 @@ async function executeBatchInternal(strapi, {
               }
             }
             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({
+            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 };
-                const candLoc = target.locale || currentEntry?.locale;
-                if (Boolean(contentType?.pluginOptions?.i18n?.localized) && candLoc && candLoc !== "null" && candLoc !== "undefined") {
-                  pubArgs.locale = candLoc;
+                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) {
@@ -2063,20 +2049,15 @@ 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);
-          let pubRecordScalar = publishedCounterparts.get(`${target.uid}@@@${target.documentId}`);
+          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"],
+                fields: ["documentId", "updatedAt", "publishedAt", "locale"],
                 limit: 1
               });
               if (singlePub && singlePub.length > 0) {
@@ -2087,23 +2068,37 @@ async function executeBatchInternal(strapi, {
             }
           }
           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({
+          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 };
-              const candLoc = target.locale || currentEntry?.locale;
-              if (Boolean(contentType?.pluginOptions?.i18n?.localized) && candLoc && candLoc !== "null" && candLoc !== "undefined") {
-                pubArgs.locale = candLoc;
+              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) {
@@ -5477,30 +5472,50 @@ function getEffectiveLocale(ct, rowLocale) {
   }
   return trimmed;
 }
-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;
+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;
+        }
+      }
     }
-    const stageNameFromExisting = extractStageName(existing);
-    if (stageNameFromExisting) return stageNameFromExisting;
   }
-  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);
+  return false;
 }
 function extractDetailedErrorMessage(err) {
   if (!err) return "Error processing row";
@@ -5698,7 +5713,6 @@ 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 {
@@ -6069,34 +6083,36 @@ 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 stats = {
-    total: rows.length,
-    created: 0,
-    updated: 0,
-    skipped: 0,
-    newWithoutDocId: 0,
-    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({
+      const pubDocs = await strapi.documents(uid).findMany({
         status: "published",
         filters: { documentId: { $in: docIdsInChunk } },
-        fields: ["documentId", "updatedAt", "publishedAt"],
-        limit: docIdsInChunk.length
+        fields: ["documentId", "updatedAt", "publishedAt", "locale"],
+        limit: Math.max(docIdsInChunk.length, 100)
       });
-      for (const pub of pubList || []) {
+      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 (err) {
-      strapi.log.warn(`[csv] Failed to pre-fetch published status for CSV chunk:`, err);
+    } catch {
     }
   }
+  const stats = {
+    total: rows.length,
+    created: 0,
+    updated: 0,
+    skipped: 0,
+    newWithoutDocId: 0,
+    errors: [],
+    diffs: []
+  };
   for (let i = 0; i < rows.length; i++) {
     const rowNumber = startRowNumber + i;
     const row = rows[i];
@@ -6164,13 +6180,13 @@ async function processCsvRows(strapi, ct, uid, rows, startRowNumber, options) {
         };
         if (effectiveLocale) updateArgs.locale = effectiveLocale;
         await strapi.documents(uid).update(updateArgs);
-        let pubRecord = publishedCounterparts.get(String(resolvedDocId));
+        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"],
+              fields: ["documentId", "updatedAt", "publishedAt", "locale"],
               limit: 1
             });
             if (singlePub && singlePub.length > 0) {
@@ -6180,24 +6196,24 @@ async function processCsvRows(strapi, ct, uid, rows, startRowNumber, options) {
           } catch {
           }
         }
-        const { hadPublishedVersion, isModified } = inspectPreUpdateStatus(existing, pubRecord);
-        const stageVal = resolveStageValue(row, existing);
-        const shouldPublish = determineShouldPublish({
+        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
         });
         if (shouldPublish) {
           try {
             const pubArgs = { documentId: resolvedDocId };
-            const isLoc = Boolean(ct?.pluginOptions?.i18n?.localized);
-            if (isLoc && effectiveLocale && effectiveLocale !== "null" && effectiveLocale !== "undefined") {
-              pubArgs.locale = effectiveLocale;
-            }
+            if (effectiveLocale) pubArgs.locale = effectiveLocale;
             await strapi.documents(uid).publish(pubArgs);
           } catch (pubErr) {
             strapi.log.warn(`[bulk-updater] Auto-publish failed for ${resolvedDocId}:`, pubErr);
@@ -6247,13 +6263,13 @@ async function processCsvRows(strapi, ct, uid, rows, startRowNumber, options) {
           };
           if (effectiveLocale) updateArgs.locale = effectiveLocale;
           await strapi.documents(uid).update(updateArgs);
-          let pubRecord = publishedCounterparts.get(String(resolvedDocId));
+          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"],
+                fields: ["documentId", "updatedAt", "publishedAt", "locale"],
                 limit: 1
               });
               if (singlePub && singlePub.length > 0) {
@@ -6263,22 +6279,24 @@ async function processCsvRows(strapi, ct, uid, rows, startRowNumber, options) {
             } catch {
             }
           }
-          const { hadPublishedVersion, isModified } = inspectPreUpdateStatus(existing, pubRecord);
-          const stageVal = resolveStageValue(row, existing);
-          const shouldPublish = determineShouldPublish({
+          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
           });
           if (shouldPublish) {
             try {
               const pubArgs = { documentId: resolvedDocId };
-              const isLoc = Boolean(ct?.pluginOptions?.i18n?.localized);
-              if (isLoc && effectiveLocale && effectiveLocale !== "null" && effectiveLocale !== "undefined") pubArgs.locale = effectiveLocale;
+              if (effectiveLocale) pubArgs.locale = effectiveLocale;
               await strapi.documents(uid).publish(pubArgs);
             } catch (pubErr) {
               strapi.log.warn(`[bulk-updater] Auto-publish failed for ${resolvedDocId}:`, pubErr);
@@ -6315,13 +6333,11 @@ 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 };
-            const isLoc = Boolean(ct?.pluginOptions?.i18n?.localized);
-            if (isLoc && effectiveLocale && effectiveLocale !== "null" && effectiveLocale !== "undefined") pubArgs.locale = effectiveLocale;
+            if (effectiveLocale) pubArgs.locale = effectiveLocale;
             await strapi.documents(uid).publish(pubArgs);
           } catch (pubErr) {
             strapi.log.warn(`[bulk-updater] Auto-publish failed for ${newDocId}:`, pubErr);
@@ -6372,13 +6388,13 @@ async function processCsvRows(strapi, ct, uid, rows, startRowNumber, options) {
           };
           if (effectiveLocale) updateArgs.locale = effectiveLocale;
           await strapi.documents(uid).update(updateArgs);
-          let pubRecord = publishedCounterparts.get(String(resolvedDocId));
+          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"],
+                fields: ["documentId", "updatedAt", "publishedAt", "locale"],
                 limit: 1
               });
               if (singlePub && singlePub.length > 0) {
@@ -6388,22 +6404,24 @@ async function processCsvRows(strapi, ct, uid, rows, startRowNumber, options) {
             } catch {
             }
           }
-          const { hadPublishedVersion, isModified } = inspectPreUpdateStatus(existing, pubRecord);
-          const stageVal = resolveStageValue(row, existing);
-          const shouldPublish = determineShouldPublish({
+          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
           });
           if (shouldPublish) {
             try {
               const pubArgs = { documentId: resolvedDocId };
-              const isLoc = Boolean(ct?.pluginOptions?.i18n?.localized);
-              if (isLoc && effectiveLocale && effectiveLocale !== "null" && effectiveLocale !== "undefined") pubArgs.locale = effectiveLocale;
+              if (effectiveLocale) pubArgs.locale = effectiveLocale;
               await strapi.documents(uid).publish(pubArgs);
             } catch (pubErr) {
               strapi.log.warn(`[bulk-updater] Auto-publish failed for ${resolvedDocId}:`, pubErr);
@@ -6440,13 +6458,11 @@ 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 };
-            const isLoc = Boolean(ct?.pluginOptions?.i18n?.localized);
-            if (isLoc && effectiveLocale && effectiveLocale !== "null" && effectiveLocale !== "undefined") pubArgs.locale = effectiveLocale;
+            if (effectiveLocale) pubArgs.locale = effectiveLocale;
             await strapi.documents(uid).publish(pubArgs);
           } catch (pubErr) {
             strapi.log.warn(`[bulk-updater] Auto-publish failed for ${newDocId}:`, pubErr);
@@ -7034,25 +7050,6 @@ 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++) {
@@ -7061,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) {
@@ -7069,44 +7066,21 @@ const csvService = ({ strapi }) => ({
       }
       if (existing && isDraftAndPublish) {
         lifecycleStats.totalChecked++;
-        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) {
+        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") {