strapi-plugin-bulk-updater 1.5.0 → 1.5.3

package/dist/admin/index.js

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

package/dist/admin/index.mjs

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

package/dist/server/index.js

@@ -365,10 +365,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) {
@@ -970,6 +970,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) {
@@ -992,6 +993,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 || {};
@@ -1116,14 +1230,15 @@ function discoverComponentAttributes(strapi, compUid, prefix, currentDepth, maxD
 }
 function parseDynamicZonePath(path) {
   if (!path) return { cleanPath: "", rootKey: "", subPath: "" };
-  const bracketMatch = path.match(/^([^.[]+)\[([^\]]+)\]\.(.+)$/);
+  const bracketMatch = path.match(/^([^.[]+)\[([^\]]+)\](?:\.(.+))?$/);
   if (bracketMatch) {
     const rootKey = bracketMatch[1];
-    const selector = bracketMatch[2];
-    const subPath = bracketMatch[3];
-    const cleanPath = `${rootKey}.${subPath}`;
-    if (/^\d+$/.test(selector)) {
-      return { cleanPath, rootKey, subPath, targetIndex: parseInt(selector, 10) };
+    const selector = bracketMatch[2].trim();
+    const subPath = bracketMatch[3] || "";
+    const cleanPath = subPath ? `${rootKey}.${subPath}` : rootKey;
+    const numMatch = selector.match(/^#?(\d+)/);
+    if (numMatch) {
+      return { cleanPath, rootKey, subPath, targetIndex: parseInt(numMatch[1], 10) };
     }
     return { cleanPath, rootKey, subPath, targetComponentUid: selector };
   }
@@ -2055,6 +2170,9 @@ const bulkUpdaterService = ({ strapi }) => {
         isRunnerRunning = false;
       }
     }, 3e4);
+    if (typeof runnerInterval.unref === "function") {
+      runnerInterval.unref();
+    }
   }
   return {
     /**
@@ -2257,6 +2375,7 @@ const bulkUpdaterService = ({ strapi }) => {
               totalCount = 0;
             }
             const formattedEntries = (entries || []).map(formatEntryRecord);
+            await populateDocumentLifecycleStatus(strapi, uid, formattedEntries);
             modelsCache.set(uid, {
               signature,
               totalCount,
@@ -2372,6 +2491,7 @@ const bulkUpdaterService = ({ strapi }) => {
         if (!colHasAttribute) {
           result = {
             uid,
+            status: "success",
             displayName: contentType.info?.displayName || uid,
             isSingleType,
             draftAndPublish: Boolean(contentType.options?.draftAndPublish),
@@ -2513,12 +2633,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,
@@ -2605,12 +2728,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,
@@ -2634,12 +2760,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,
@@ -4276,42 +4405,74 @@ const auditService = ({ strapi }) => ({
     for (const item of diffs) {
       if (item.status === "updated" && item.uid && item.documentId && item.attribute) {
         try {
+          const ct = strapi.contentTypes[item.uid];
+          if (!ct) {
+            throw new Error(`Content type "${item.uid}" does not exist in schema.`);
+          }
           const isRel = item.oldValue && typeof item.oldValue === "object" && item.oldValue.isRelation;
           let rollbackPayload;
           if (isRel) {
             const oldDocIds = Array.isArray(item.oldValue.documentIds) ? item.oldValue.documentIds : [];
             rollbackPayload = { set: oldDocIds };
           } else {
-            rollbackPayload = item.oldValue;
+            rollbackPayload = item.oldValue ?? null;
           }
-          if (item.attribute.includes(".")) {
-            const [parentKey, childKey] = item.attribute.split(".");
-            const ct2 = strapi.contentTypes[item.uid];
-            if (ct2?.attributes?.[parentKey]?.type === "component") {
-              const currentDoc = await strapi.documents(item.uid).findOne({
-                documentId: item.documentId,
-                populate: [parentKey]
-              });
-              const currentParent = currentDoc?.[parentKey] || {};
-              const restoredParent = {
-                ...currentParent,
-                [childKey]: rollbackPayload
-              };
-              await strapi.documents(item.uid).update({
-                documentId: item.documentId,
-                data: {
-                  [parentKey]: restoredParent
-                }
-              });
+          const parsed = parseDynamicZonePath(item.attribute);
+          const rootKey = parsed.rootKey;
+          const rootAttrDef = ct.attributes?.[rootKey];
+          const isComponent = rootAttrDef?.type === "component";
+          const isDynamicZone = rootAttrDef?.type === "dynamiczone";
+          const isNested = item.attribute.includes(".") || item.attribute.includes("[") || isComponent || isDynamicZone || isDeepComponentField(ct, strapi.components, item.attribute);
+          let wasPublished = false;
+          if (isNested && (isComponent || isDynamicZone || rootAttrDef)) {
+            const populateOption = buildDeepPopulate$1(ct.attributes, strapi.components);
+            const findOneArgs = { documentId: item.documentId };
+            if (populateOption) {
+              findOneArgs.populate = populateOption;
+            }
+            const currentDoc = await strapi.documents(item.uid).findOne(findOneArgs);
+            if (!currentDoc) {
+              throw new Error(`Document "${item.documentId}" not found in collection "${item.uid}".`);
+            }
+            wasPublished = Boolean(currentDoc?.publishedAt);
+            const isRootDz = isDynamicZone;
+            const existingRoot = currentDoc?.[rootKey] || (isRootDz ? [] : {});
+            let restoredRoot;
+            if (Array.isArray(item.dynamicZoneDiffs) && item.dynamicZoneDiffs.length > 0) {
+              let workingRoot = existingRoot;
+              for (const dzDiff of item.dynamicZoneDiffs) {
+                const parsedDz = parseDynamicZonePath(dzDiff.attribute || item.attribute);
+                const dzParts = parsedDz.cleanPath.split(".").slice(1);
+                const targetIndexes = dzDiff.index !== void 0 ? [dzDiff.index] : parsedDz.targetIndex !== void 0 ? [parsedDz.targetIndex] : void 0;
+                workingRoot = setDeepProperty(workingRoot, dzParts, dzDiff.oldValue ?? null, {
+                  targetIndexes,
+                  targetComponentUid: dzDiff.componentUid || parsedDz.targetComponentUid,
+                  strapi
+                });
+              }
+              restoredRoot = workingRoot;
             } else {
-              await strapi.documents(item.uid).update({
-                documentId: item.documentId,
-                data: {
-                  [item.attribute]: rollbackPayload
-                }
+              const parts = parsed.cleanPath.split(".");
+              const pathParts = parts.slice(1);
+              const targetIndexes = parsed.targetIndex !== void 0 ? [parsed.targetIndex] : void 0;
+              const targetComponentUid = parsed.targetComponentUid;
+              restoredRoot = setDeepProperty(existingRoot, pathParts, rollbackPayload, {
+                targetIndexes,
+                targetComponentUid,
+                strapi
               });
             }
+            await strapi.documents(item.uid).update({
+              documentId: item.documentId,
+              data: {
+                [rootKey]: restoredRoot
+              }
+            });
           } else {
+            const currentDoc = await strapi.documents(item.uid).findOne({
+              documentId: item.documentId
+            });
+            wasPublished = Boolean(currentDoc?.publishedAt);
             await strapi.documents(item.uid).update({
               documentId: item.documentId,
               data: {
@@ -4319,13 +4480,13 @@ const auditService = ({ strapi }) => ({
               }
             });
           }
-          const ct = strapi.contentTypes[item.uid];
-          if (ct?.options?.draftAndPublish) {
+          if (ct?.options?.draftAndPublish && wasPublished) {
             try {
               await strapi.documents(item.uid).publish({
                 documentId: item.documentId
               });
-            } catch {
+            } catch (publishErr) {
+              strapi.log.warn(`[bulk-updater] Failed to auto-publish rollback for ${item.uid}/${item.documentId}:`, publishErr?.message);
             }
           }
           try {
@@ -4333,7 +4494,7 @@ const auditService = ({ strapi }) => ({
               uid: item.uid,
               documentId: item.documentId,
               userId,
-              statusOverride: ct?.options?.draftAndPublish ? "published" : void 0
+              statusOverride: ct?.options?.draftAndPublish ? wasPublished ? "published" : "draft" : void 0
             });
           } catch {
           }