strapi-plugin-bulk-updater 1.5.2 → 1.5.4

package/dist/server/index.mjs

@@ -362,10 +362,10 @@ const bulkUpdaterController = ({ strapi }) => ({
         ctx.set("ETag", data.etag);
         ctx.set("Cache-Control", "private, no-cache");
       }
-      ctx.body = { success: true, ...data };
+      ctx.body = { success: true, status: "success", ...data };
     } catch (err) {
       ctx.status = 500;
-      ctx.body = { success: false, error: err.message };
+      ctx.body = { success: false, status: "error", error: err.message };
     }
   },
   async getRelationOptions(ctx) {
@@ -967,6 +967,7 @@ function formatEntryRecord(entry) {
   const formatted = {
     id: entry.id,
     documentId: entry.documentId,
+    status: entry.status !== void 0 ? entry.status : void 0,
     ...entry
   };
   if (entry.updatedAt !== void 0 && formatted.updated_at === void 0) {
@@ -989,6 +990,119 @@ function formatEntryRecord(entry) {
   }
   return formatted;
 }
+async function populateDocumentLifecycleStatus(strapi, uid, entries) {
+  if (!entries || !Array.isArray(entries) || entries.length === 0) {
+    return entries;
+  }
+  const contentType = strapi?.contentTypes?.[uid];
+  if (!contentType) {
+    return entries;
+  }
+  const hasDraftAndPublish = Boolean(contentType.options?.draftAndPublish);
+  if (!hasDraftAndPublish) {
+    for (const entry of entries) {
+      if (entry && typeof entry === "object") {
+        entry.status = "published";
+      }
+    }
+    return entries;
+  }
+  const hasSlugInSchema = Boolean(contentType.attributes?.slug);
+  const docIds = [];
+  const slugs = [];
+  for (const entry of entries) {
+    if (!entry || typeof entry !== "object") continue;
+    if (entry.documentId) {
+      docIds.push(String(entry.documentId));
+    } else if (hasSlugInSchema && entry.slug) {
+      slugs.push(String(entry.slug));
+    } else {
+      entry.status = "unknown";
+    }
+  }
+  if (docIds.length === 0 && slugs.length === 0) {
+    return entries;
+  }
+  let filterClause;
+  if (docIds.length > 0 && slugs.length > 0) {
+    filterClause = {
+      $or: [
+        { documentId: { $in: docIds } },
+        { slug: { $in: slugs } }
+      ]
+    };
+  } else if (docIds.length > 0) {
+    filterClause = { documentId: { $in: docIds } };
+  } else {
+    filterClause = { slug: { $in: slugs } };
+  }
+  const queryFields = ["documentId", "updatedAt", "publishedAt"];
+  if (hasSlugInSchema) {
+    queryFields.push("slug");
+  }
+  let publishedRecords = [];
+  try {
+    const docService = strapi?.documents?.(uid);
+    if (docService?.findMany) {
+      publishedRecords = await docService.findMany({
+        status: "published",
+        filters: filterClause,
+        fields: queryFields,
+        limit: Math.max(entries.length, 100)
+      });
+    }
+  } catch (err) {
+    strapi?.log?.warn?.(`[bulk-updater] Failed to fetch published status for ${uid}: ${err?.message || err}`);
+    for (const entry of entries) {
+      if (entry && typeof entry === "object" && entry.status !== "unknown") {
+        entry.status = "unknown";
+      }
+    }
+    return entries;
+  }
+  const publishedByDocId = /* @__PURE__ */ new Map();
+  const publishedBySlug = /* @__PURE__ */ new Map();
+  for (const pub of publishedRecords || []) {
+    if (pub?.documentId) {
+      publishedByDocId.set(String(pub.documentId), pub);
+    }
+    if (pub?.slug && hasSlugInSchema) {
+      publishedBySlug.set(String(pub.slug), pub);
+    }
+  }
+  for (const entry of entries) {
+    if (!entry || typeof entry !== "object") continue;
+    if (entry.status === "unknown") continue;
+    const pub = entry.documentId && publishedByDocId.get(String(entry.documentId)) || hasSlugInSchema && entry.slug && publishedBySlug.get(String(entry.slug));
+    if (!pub) {
+      entry.status = "draft";
+      entry.publishedAt = null;
+      entry.published_at = null;
+    } else {
+      entry.publishedAt = pub.publishedAt || pub.published_at || null;
+      entry.published_at = entry.publishedAt;
+      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) {
+          entry.status = "published";
+        } else {
+          entry.status = "unknown";
+        }
+      } else if (draftUpdatedTime > lastPublishedTime) {
+        entry.status = "modified";
+      } else {
+        entry.status = "published";
+      }
+    }
+  }
+  return entries;
+}
 function resolveContentTypeField(contentType, field) {
   if (!field) return null;
   const attrs = contentType?.attributes || {};
@@ -2053,6 +2167,9 @@ const bulkUpdaterService = ({ strapi }) => {
         isRunnerRunning = false;
       }
     }, 3e4);
+    if (typeof runnerInterval.unref === "function") {
+      runnerInterval.unref();
+    }
   }
   return {
     /**
@@ -2255,6 +2372,7 @@ const bulkUpdaterService = ({ strapi }) => {
               totalCount = 0;
             }
             const formattedEntries = (entries || []).map(formatEntryRecord);
+            await populateDocumentLifecycleStatus(strapi, uid, formattedEntries);
             modelsCache.set(uid, {
               signature,
               totalCount,
@@ -2370,6 +2488,7 @@ const bulkUpdaterService = ({ strapi }) => {
         if (!colHasAttribute) {
           result = {
             uid,
+            status: "success",
             displayName: contentType.info?.displayName || uid,
             isSingleType,
             draftAndPublish: Boolean(contentType.options?.draftAndPublish),
@@ -2511,12 +2630,15 @@ const bulkUpdaterService = ({ strapi }) => {
         } catch {
           singleDoc = null;
         }
+        const formattedEntries = singleDoc ? [formatEntryRecord(singleDoc)] : [];
+        await populateDocumentLifecycleStatus(strapi, uid, formattedEntries);
         result = {
           uid,
+          status: "success",
           displayName: contentType.info?.displayName || uid,
           isSingleType: true,
           draftAndPublish: Boolean(contentType.options?.draftAndPublish),
-          entries: singleDoc ? [formatEntryRecord(singleDoc)] : [],
+          entries: formattedEntries,
           pagination: {
             page: 1,
             pageSize: 1,
@@ -2603,12 +2725,15 @@ const bulkUpdaterService = ({ strapi }) => {
           const matchedEntries = (rawEntries || []).filter(passesDzFilter);
           const totalEntries = matchedEntries.length;
           const paginatedEntries = matchedEntries.slice(start, start + limit);
+          const formattedEntries = paginatedEntries.map(formatEntryRecord);
+          await populateDocumentLifecycleStatus(strapi, uid, formattedEntries);
           result = {
             uid,
+            status: "success",
             displayName: contentType.info?.displayName || uid,
             isSingleType: false,
             draftAndPublish: Boolean(contentType.options?.draftAndPublish),
-            entries: paginatedEntries.map(formatEntryRecord),
+            entries: formattedEntries,
             pagination: {
               page: currentPage,
               pageSize: limit,
@@ -2632,12 +2757,15 @@ const bulkUpdaterService = ({ strapi }) => {
               filters: Object.keys(filters).length > 0 ? filters : void 0
             })
           ]);
+          const formattedEntries = (entries || []).map(formatEntryRecord);
+          await populateDocumentLifecycleStatus(strapi, uid, formattedEntries);
           result = {
             uid,
+            status: "success",
             displayName: contentType.info?.displayName || uid,
             isSingleType: false,
             draftAndPublish: Boolean(contentType.options?.draftAndPublish),
-            entries: (entries || []).map(formatEntryRecord),
+            entries: formattedEntries,
             pagination: {
               page: currentPage,
               pageSize: limit,