strapi-plugin-bulk-updater 1.2.8 → 1.2.10

package/dist/admin/index.js

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

package/dist/admin/index.mjs

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

package/dist/server/index.js

@@ -59,6 +59,14 @@ const routes = {
           policies: []
         }
       },
+      {
+        method: "POST",
+        path: "/preview",
+        handler: "bulkUpdater.previewBatch",
+        config: {
+          policies: []
+        }
+      },
       {
         method: "GET",
         path: "/pending-batches",
@@ -353,6 +361,16 @@ const bulkUpdaterController = ({ strapi: strapi2 }) => ({
       ctx.body = { success: false, error: err.message };
     }
   },
+  async previewBatch(ctx) {
+    try {
+      const service = strapi2.plugin("bulk-updater").service("bulkUpdater");
+      const result = await service.previewBatch(ctx.request.body || {});
+      ctx.body = result;
+    } catch (err) {
+      ctx.status = 400;
+      ctx.body = { success: false, error: err.message };
+    }
+  },
   async getPendingBatches(ctx) {
     try {
       const service = strapi2.plugin("bulk-updater").service("bulkUpdater");
@@ -1557,6 +1575,252 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
       queryCache.set(cacheKey, { signature, data: result, timestamp: Date.now() });
       return result;
     },
+    /**
+     * Preview bulk update changes before execution:
+     * Reads current values and computes proposed new values without mutating data.
+     */
+    async previewBatch({
+      attribute,
+      value,
+      selectedEntries = [],
+      selectedCollections = [],
+      isRegex = false,
+      regexPattern = ""
+    }) {
+      if (!attribute) {
+        throw new Error("Attribute name is required.");
+      }
+      const targetsMap = /* @__PURE__ */ new Map();
+      for (const colUid of selectedCollections) {
+        if (!strapi2.contentTypes[colUid]) continue;
+        const entries = await strapi2.documents(colUid).findMany();
+        for (const entry of entries || []) {
+          const key = `${colUid}@@@${entry.documentId}`;
+          targetsMap.set(key, { uid: colUid, documentId: entry.documentId });
+        }
+      }
+      for (const item of selectedEntries) {
+        if (!item.uid || !item.documentId) continue;
+        const key = `${item.uid}@@@${item.documentId}`;
+        targetsMap.set(key, { uid: item.uid, documentId: item.documentId });
+      }
+      if (targetsMap.size === 0) {
+        throw new Error("No collections or entries were selected for preview.");
+      }
+      let regexObj = null;
+      if (isRegex && regexPattern) {
+        try {
+          regexObj = new RegExp(regexPattern, "g");
+        } catch (e) {
+          throw new Error(`Invalid regular expression: ${e.message}`);
+        }
+      }
+      const targets = Array.from(targetsMap.values());
+      const diffs = [];
+      let willUpdateCount = 0;
+      let unchangedCount = 0;
+      let skippedCount = 0;
+      for (const target of targets) {
+        const contentType = strapi2.contentTypes[target.uid];
+        const displayName = contentType?.info?.displayName || target.uid;
+        try {
+          const isNested = attribute.includes(".");
+          let isComponentNested = false;
+          let parentKey = "";
+          let childKey = "";
+          if (isNested) {
+            const parts = attribute.split(".");
+            parentKey = parts[0];
+            childKey = parts[1];
+            const parentAttrDef = contentType?.attributes?.[parentKey];
+            if (parentAttrDef?.type === "component" && !parentAttrDef.repeatable && parentAttrDef.component) {
+              const compSchema = strapi2.components[parentAttrDef.component];
+              if (compSchema?.attributes?.[childKey]) {
+                isComponentNested = true;
+              }
+            }
+          }
+          const attrDef = contentType?.attributes?.[attribute];
+          const hasAttribute = Boolean(attrDef) || isComponentNested;
+          if (!hasAttribute) {
+            skippedCount++;
+            diffs.push({
+              uid: target.uid,
+              collectionName: displayName,
+              documentId: target.documentId,
+              label: `Entry #${target.documentId}`,
+              attribute,
+              oldValue: null,
+              newValue: null,
+              oldDisplay: "—",
+              newDisplay: "—",
+              hasChange: false,
+              status: "will_skip",
+              message: `Attribute "${attribute}" does not exist in schema for ${displayName}`
+            });
+            continue;
+          }
+          let currentEntry;
+          if (isComponentNested) {
+            currentEntry = await strapi2.documents(target.uid).findOne({
+              documentId: target.documentId,
+              populate: [parentKey]
+            });
+          } else if (attrDef?.type === "relation") {
+            currentEntry = await strapi2.documents(target.uid).findOne({
+              documentId: target.documentId,
+              populate: [attribute]
+            });
+          } else {
+            currentEntry = await strapi2.documents(target.uid).findOne({
+              documentId: target.documentId
+            });
+          }
+          const entryLabel = currentEntry?.name || currentEntry?.title || currentEntry?.email || `Entry #${target.documentId}`;
+          if (isComponentNested) {
+            const existingParent = currentEntry?.[parentKey] || {};
+            const currentVal2 = existingParent?.[childKey];
+            let newValue2 = value;
+            if (regexObj && typeof currentVal2 === "string") {
+              newValue2 = currentVal2.replace(regexObj, value);
+            }
+            const hasChange2 = String(currentVal2 ?? "") !== String(newValue2 ?? "");
+            if (hasChange2) {
+              willUpdateCount++;
+            } else {
+              unchangedCount++;
+            }
+            diffs.push({
+              uid: target.uid,
+              collectionName: displayName,
+              documentId: target.documentId,
+              label: entryLabel,
+              attribute,
+              oldValue: currentVal2 ?? null,
+              newValue: newValue2,
+              oldDisplay: currentVal2 !== void 0 && currentVal2 !== null ? String(currentVal2) : "(empty)",
+              newDisplay: String(newValue2 ?? ""),
+              hasChange: hasChange2,
+              status: hasChange2 ? "will_update" : "unchanged",
+              message: hasChange2 ? "Value will be updated" : "Already has target value"
+            });
+            continue;
+          }
+          if (attrDef?.type === "relation") {
+            const isMulti = attrDef.relation === "oneToMany" || attrDef.relation === "manyToMany";
+            const currentRel = currentEntry?.[attribute];
+            let oldDocIds = [];
+            let oldDisplay = "";
+            if (isMulti && Array.isArray(currentRel)) {
+              oldDocIds = currentRel.map((r) => r.documentId).filter(Boolean);
+              oldDisplay = currentRel.map((r) => r.name || r.title || r.email || r.documentId).join(", ") || "(empty)";
+            } else if (currentRel) {
+              oldDocIds = currentRel.documentId ? [currentRel.documentId] : [];
+              oldDisplay = currentRel.name || currentRel.title || currentRel.email || currentRel.documentId || "(empty)";
+            } else {
+              oldDisplay = "(unlinked / none)";
+            }
+            let mode2 = "set";
+            let targetDocIds = [];
+            let newDisplay = "";
+            if (value === "__clear__" || value === "") {
+              mode2 = "clear";
+              newDisplay = "(cleared / unlinked)";
+            } else {
+              try {
+                const parsed = JSON.parse(value);
+                if (parsed && typeof parsed === "object" && parsed.mode) {
+                  mode2 = parsed.mode;
+                  targetDocIds = Array.isArray(parsed.documentIds) ? parsed.documentIds : parsed.documentId ? [parsed.documentId] : [];
+                  newDisplay = parsed.label || targetDocIds.join(", ") || `[${mode2}]`;
+                } else if (Array.isArray(parsed)) {
+                  targetDocIds = parsed;
+                  newDisplay = targetDocIds.join(", ");
+                } else {
+                  targetDocIds = [value];
+                  newDisplay = value;
+                }
+              } catch {
+                targetDocIds = [value];
+                newDisplay = value;
+              }
+            }
+            const hasChange2 = oldDisplay !== newDisplay;
+            if (hasChange2) {
+              willUpdateCount++;
+            } else {
+              unchangedCount++;
+            }
+            diffs.push({
+              uid: target.uid,
+              collectionName: displayName,
+              documentId: target.documentId,
+              label: entryLabel,
+              attribute,
+              oldValue: { isRelation: true, documentIds: oldDocIds, display: oldDisplay },
+              newValue: { isRelation: true, mode: mode2, documentIds: targetDocIds, display: newDisplay },
+              oldDisplay,
+              newDisplay,
+              hasChange: hasChange2,
+              status: hasChange2 ? "will_update" : "unchanged",
+              message: hasChange2 ? `Relation will be modified (${mode2})` : "Relation already set to this target"
+            });
+            continue;
+          }
+          let newValue = value;
+          const currentVal = currentEntry?.[attribute];
+          if (regexObj && typeof currentVal === "string") {
+            newValue = currentVal.replace(regexObj, value);
+          }
+          const hasChange = String(currentVal ?? "") !== String(newValue ?? "");
+          if (hasChange) {
+            willUpdateCount++;
+          } else {
+            unchangedCount++;
+          }
+          diffs.push({
+            uid: target.uid,
+            collectionName: displayName,
+            documentId: target.documentId,
+            label: entryLabel,
+            attribute,
+            oldValue: currentVal ?? null,
+            newValue,
+            oldDisplay: currentVal !== void 0 && currentVal !== null ? String(currentVal) : "(empty)",
+            newDisplay: String(newValue ?? ""),
+            hasChange,
+            status: hasChange ? "will_update" : "unchanged",
+            message: hasChange ? "Value will be updated" : "Already matches target value"
+          });
+        } catch (err) {
+          skippedCount++;
+          diffs.push({
+            uid: target.uid,
+            collectionName: displayName,
+            documentId: target.documentId,
+            label: `Entry #${target.documentId}`,
+            attribute,
+            oldValue: null,
+            newValue: null,
+            oldDisplay: "—",
+            newDisplay: "—",
+            hasChange: false,
+            status: "will_skip",
+            message: `Error inspecting entry: ${err.message}`
+          });
+        }
+      }
+      return {
+        success: true,
+        summary: {
+          total: targets.length,
+          willUpdate: willUpdateCount,
+          unchanged: unchangedCount,
+          skipped: skippedCount
+        },
+        diffs
+      };
+    },
     /**
      * Batch Update API with Maker-Checker and Off-Peak Scheduling:
      */