strapi-plugin-bulk-updater 1.1.0 → 1.2.0

package/dist/server/index.js

@@ -224,7 +224,7 @@ const bulkUpdaterController = ({ strapi: strapi2 }) => ({
           return;
         }
       }
-      ctx.body = data;
+      ctx.body = { success: true, ...data };
     } catch (err) {
       ctx.status = 500;
       ctx.body = { success: false, error: err.message };
@@ -673,9 +673,69 @@ async function executeBatchInternal(strapi2, {
       try {
         const currentEntry = await getDocumentDeduplicated(target.uid, target.documentId);
         const entryLabel = currentEntry?.name || currentEntry?.title || currentEntry?.email || `Entry #${target.documentId}`;
+        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);
+        const hasAttribute = Boolean(attrDef) || isComponentNested;
         if (hasAttribute) {
+          if (isComponentNested) {
+            const currentEntryWithPopulate = await strapi2.documents(target.uid).findOne({
+              documentId: target.documentId,
+              populate: [parentKey]
+            });
+            const existingParent = currentEntryWithPopulate?.[parentKey] || {};
+            const currentVal2 = existingParent?.[childKey];
+            let newValue2 = value;
+            if (regexObj && typeof currentVal2 === "string") {
+              newValue2 = currentVal2.replace(regexObj, value);
+            }
+            const updatedParent = {
+              ...existingParent,
+              [childKey]: newValue2
+            };
+            await strapi2.documents(target.uid).update({
+              documentId: target.documentId,
+              data: {
+                [parentKey]: updatedParent
+              }
+            });
+            const isDraftAndPublishComp = Boolean(contentType?.options?.draftAndPublish);
+            if (publishOnApproval && isDraftAndPublishComp) {
+              try {
+                await strapi2.documents(target.uid).publish({
+                  documentId: target.documentId
+                });
+              } catch (publishErr) {
+                strapi2.log.warn(`[bulk-updater] Failed to auto-publish ${target.uid}/${target.documentId}:`, publishErr);
+              }
+            }
+            invalidateCollectionCache(target.uid);
+            return {
+              uid: target.uid,
+              collectionName: displayName,
+              documentId: target.documentId,
+              label: entryLabel,
+              attribute,
+              oldValue: currentVal2 ?? null,
+              newValue: newValue2,
+              status: "updated",
+              message: `Successfully updated nested field ${attribute}`
+            };
+          }
           if (attrDef.type === "relation") {
             const isMulti = attrDef.relation === "oneToMany" || attrDef.relation === "manyToMany";
             const currentEntryWithPopulate = await strapi2.documents(target.uid).findOne({
@@ -917,9 +977,24 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
           const isSingleType = contentType.kind === "singleType";
           const rawAttrs = contentType.attributes || {};
           const relationsByAttr = {};
+          const nestedComponentAttrs = [];
           const validAttrs = Object.keys(rawAttrs).filter((attrKey) => {
             if (systemFields.includes(attrKey)) return false;
-            if (rawAttrs[attrKey].type === "component" || rawAttrs[attrKey].type === "dynamiczone") return false;
+            if (rawAttrs[attrKey].type === "dynamiczone") return false;
+            if (rawAttrs[attrKey].type === "component") {
+              const compDef = rawAttrs[attrKey];
+              if (!compDef.repeatable && compDef.component) {
+                const componentSchema = strapi2.components[compDef.component];
+                if (componentSchema && componentSchema.attributes) {
+                  for (const [subKey, subAttr] of Object.entries(componentSchema.attributes)) {
+                    if (systemFields.includes(subKey)) continue;
+                    if (["component", "dynamiczone", "relation"].includes(subAttr.type)) continue;
+                    nestedComponentAttrs.push(`${attrKey}.${subKey}`);
+                  }
+                }
+              }
+              return false;
+            }
             if (rawAttrs[attrKey].type === "relation") {
               const rel = rawAttrs[attrKey];
               const targetUid = rel.target;
@@ -939,7 +1014,8 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
             }
             return true;
           });
-          validAttrs.forEach((attr) => allAttributesSet.add(attr));
+          const allColAttrs = [...validAttrs, ...nestedComponentAttrs];
+          allColAttrs.forEach((attr) => allAttributesSet.add(attr));
           metaByUid[uid] = {
             uid,
             kind: contentType.kind,
@@ -947,7 +1023,7 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
             singularName: contentType.info?.singularName || uid,
             pluralName: contentType.info?.pluralName || uid,
             displayName: contentType.info?.displayName || uid,
-            attributes: validAttrs,
+            attributes: allColAttrs,
             relations: relationsByAttr
           };
         }
@@ -976,8 +1052,17 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
           let entries = [];
           let totalCount = 0;
           try {
+            const ctAttrs = allContentTypes[uid]?.attributes || {};
             const relKeys = Object.keys(meta.relations || {});
-            const populateOption = relKeys.length > 0 ? relKeys.reduce((acc, k) => ({ ...acc, [k]: true }), {}) : void 0;
+            const compKeys = Object.keys(ctAttrs).filter((k) => ctAttrs[k].type === "component");
+            const populateOptionObj = {};
+            relKeys.forEach((k) => {
+              populateOptionObj[k] = true;
+            });
+            compKeys.forEach((k) => {
+              populateOptionObj[k] = true;
+            });
+            const populateOption = Object.keys(populateOptionObj).length > 0 ? populateOptionObj : void 0;
             if (meta.isSingleType) {
               const singleDoc = await strapi2.documents(uid).findFirst({
                 populate: populateOption
@@ -1055,7 +1140,7 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
       if (!contentType) {
         throw new Error(`Collection with UID "${uid}" does not exist.`);
       }
-      const limit = Math.min(Math.max(Number(pageSize) || 10, 1), 100);
+      const limit = Math.min(Math.max(Number(pageSize) || 10, 1), 500);
       const currentPage = Math.max(Number(page) || 1, 1);
       const start = (currentPage - 1) * limit;
       const isSingleType = contentType.kind === "singleType";
@@ -1071,8 +1156,118 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
         };
       }
       let result;
+      const filters2 = {};
+      const attrs = contentType.attributes || {};
+      let colHasAttribute = false;
+      let isNestedAttr = false;
+      let parentKey = "";
+      let childKey = "";
+      if (attribute) {
+        if (attribute.includes(".")) {
+          [parentKey, childKey] = attribute.split(".");
+          if (attrs[parentKey]?.type === "component" && !attrs[parentKey].repeatable && attrs[parentKey].component) {
+            const compSchema = strapi2.components[attrs[parentKey].component];
+            if (compSchema?.attributes?.[childKey]) {
+              colHasAttribute = true;
+              isNestedAttr = true;
+            }
+          }
+        } else if (attrs[attribute]) {
+          colHasAttribute = true;
+        }
+      }
+      const normOp = (filterOperator || "").toLowerCase().replace(/_/g, "");
+      if (normOp && normOp !== "none") {
+        if (!colHasAttribute) {
+          result = {
+            uid,
+            displayName: contentType.info?.displayName || uid,
+            isSingleType,
+            entries: [],
+            pagination: {
+              page: 1,
+              pageSize: limit,
+              total: 0,
+              pageCount: 0
+            }
+          };
+          queryCache.set(cacheKey, { signature, data: result, timestamp: Date.now() });
+          return { ...result, cached: false, etag };
+        }
+        let condition = void 0;
+        const q = (filterQuery || "").trim();
+        if (normOp === "empty") {
+          condition = { $or: [{ $null: true }, { $eq: "" }] };
+        } else if (normOp === "notempty") {
+          condition = { $and: [{ $notNull: true }, { $ne: "" }] };
+        } else if (q !== "") {
+          switch (normOp) {
+            case "equals":
+              condition = { $containsi: q };
+              break;
+            case "notequals":
+              condition = { $notContainsi: q };
+              break;
+            case "contains":
+              condition = { $containsi: q };
+              break;
+            case "notcontains":
+              condition = { $notContainsi: q };
+              break;
+            case "startswith":
+              condition = { $startsWith: q };
+              break;
+            case "endswith":
+              condition = { $endsWith: q };
+              break;
+          }
+        }
+        if (condition !== void 0) {
+          if (isNestedAttr) {
+            filters2[parentKey] = {
+              [childKey]: condition
+            };
+          } else {
+            if (normOp === "empty") {
+              filters2.$or = [
+                { [attribute]: { $null: true } },
+                { [attribute]: { $eq: "" } }
+              ];
+            } else if (normOp === "notempty") {
+              filters2[attribute] = { $notNull: true, $ne: "" };
+            } else {
+              filters2[attribute] = condition;
+            }
+          }
+        }
+      }
+      if (search && search.trim() !== "") {
+        const q = search.trim();
+        const searchableAttrs = Object.keys(attrs).filter(
+          (k) => ["string", "text", "email", "uid"].includes(attrs[k]?.type)
+        );
+        if (searchableAttrs.length > 0) {
+          const orList = searchableAttrs.slice(0, 6).map((k) => ({
+            [k]: { $containsi: q }
+          }));
+          if (Object.keys(filters2).length > 0) {
+            const existingFilters = { ...filters2 };
+            Object.keys(filters2).forEach((k) => delete filters2[k]);
+            filters2.$and = [existingFilters, { $or: orList }];
+          } else {
+            filters2.$or = orList;
+          }
+        }
+      }
       if (isSingleType) {
-        const singleDoc = await strapi2.documents(uid).findFirst();
+        let singleDoc = null;
+        try {
+          singleDoc = await strapi2.documents(uid).findFirst({
+            filters: Object.keys(filters2).length > 0 ? filters2 : void 0
+          });
+        } catch {
+          singleDoc = null;
+        }
         result = {
           uid,
           displayName: contentType.info?.displayName || uid,
@@ -1086,55 +1281,23 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
           }
         };
       } else {
-        const filters2 = {};
-        if (attribute && filterOperator && filterQuery !== void 0 && filterQuery !== "") {
-          switch (filterOperator) {
-            case "equals":
-              filters2[attribute] = { $eq: filterQuery };
-              break;
-            case "notEquals":
-              filters2[attribute] = { $ne: filterQuery };
-              break;
-            case "contains":
-              filters2[attribute] = { $containsi: filterQuery };
-              break;
-            case "notContains":
-              filters2[attribute] = { $notContainsi: filterQuery };
-              break;
-            case "startsWith":
-              filters2[attribute] = { $startsWith: filterQuery };
-              break;
-            case "endsWith":
-              filters2[attribute] = { $endsWith: filterQuery };
-              break;
-            case "empty":
-              filters2[attribute] = { $null: true };
-              break;
-            case "notEmpty":
-              filters2[attribute] = { $notNull: true };
-              break;
-          }
-        }
-        if (search && search.trim() !== "") {
-          const stringAttrs = Object.keys(contentType.attributes || {}).filter(
-            (k) => contentType.attributes[k].type === "string" || contentType.attributes[k].type === "text" || contentType.attributes[k].type === "email"
-          );
-          if (stringAttrs.length > 0) {
-            filters2.$or = stringAttrs.slice(0, 5).map((attr) => ({
-              [attr]: { $containsi: search.trim() }
-            }));
-          }
-        }
         const sortClause = {};
-        if (sortField && contentType.attributes?.[sortField]) {
+        if (sortField && sortField.includes(".")) {
+          const [parent, child] = sortField.split(".");
+          if (contentType.attributes?.[parent]?.type === "component") {
+            sortClause[parent] = { [child]: sortOrder };
+          } else {
+            sortClause["createdAt"] = "desc";
+          }
+        } else if (sortField && contentType.attributes?.[sortField]) {
           sortClause[sortField] = sortOrder;
         } else {
           sortClause["createdAt"] = "desc";
         }
-        const relationAttrs = Object.keys(contentType.attributes || {}).filter(
-          (k) => contentType.attributes[k].type === "relation"
+        const populateAttrs = Object.keys(contentType.attributes || {}).filter(
+          (k) => contentType.attributes[k].type === "relation" || contentType.attributes[k].type === "component"
         );
-        const populateOption = relationAttrs.length > 0 ? relationAttrs.reduce((acc, k) => ({ ...acc, [k]: true }), {}) : void 0;
+        const populateOption = populateAttrs.length > 0 ? populateAttrs.reduce((acc, k) => ({ ...acc, [k]: true }), {}) : void 0;
         const [entries, totalEntries] = await Promise.all([
           strapi2.documents(uid).findMany({
             start,
@@ -1473,6 +1636,9 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
         modelsCache.clear();
         staticSchemaCache = null;
       }
+    },
+    invalidateCollectionCache(uid) {
+      invalidateCollectionCache(uid);
     }
   };
 };
@@ -1734,12 +1900,41 @@ const auditService = ({ strapi: strapi2 }) => ({
           } else {
             rollbackPayload = item.oldValue;
           }
-          await strapi2.documents(item.uid).update({
-            documentId: item.documentId,
-            data: {
-              [item.attribute]: rollbackPayload
+          if (item.attribute.includes(".")) {
+            const [parentKey, childKey] = item.attribute.split(".");
+            const ct2 = strapi2.contentTypes[item.uid];
+            if (ct2?.attributes?.[parentKey]?.type === "component") {
+              const currentDoc = await strapi2.documents(item.uid).findOne({
+                documentId: item.documentId,
+                populate: [parentKey]
+              });
+              const currentParent = currentDoc?.[parentKey] || {};
+              const restoredParent = {
+                ...currentParent,
+                [childKey]: rollbackPayload
+              };
+              await strapi2.documents(item.uid).update({
+                documentId: item.documentId,
+                data: {
+                  [parentKey]: restoredParent
+                }
+              });
+            } else {
+              await strapi2.documents(item.uid).update({
+                documentId: item.documentId,
+                data: {
+                  [item.attribute]: rollbackPayload
+                }
+              });
             }
-          });
+          } else {
+            await strapi2.documents(item.uid).update({
+              documentId: item.documentId,
+              data: {
+                [item.attribute]: rollbackPayload
+              }
+            });
+          }
           const ct = strapi2.contentTypes[item.uid];
           if (ct?.options?.draftAndPublish) {
             try {
@@ -1750,7 +1945,10 @@ const auditService = ({ strapi: strapi2 }) => ({
             }
           }
           try {
-            strapi2.plugin("bulk-updater").service("bulkUpdater").invalidateCollectionCache(item.uid);
+            const bulkService = strapi2.plugin("bulk-updater").service("bulkUpdater");
+            if (bulkService?.invalidateCache) {
+              bulkService.invalidateCache(item.uid);
+            }
           } catch {
           }
           revertedCount++;
@@ -2130,10 +2328,24 @@ ${sampleRow.map(escapeCsvValue).join(",")}
     const attrs = ct.attributes || {};
     const excluded = ["createdBy", "updatedBy", "localizations"];
     const exportFields = ["documentId"];
+    const compFieldsToPopulate = [];
     for (const [attrName, attrDef] of Object.entries(attrs)) {
       if (excluded.includes(attrName)) continue;
-      if (["component", "dynamiczone", "media"].includes(attrDef.type)) continue;
-      if (attrDef.type === "relation") continue;
+      if (["dynamiczone", "media", "relation"].includes(attrDef.type)) continue;
+      if (attrDef.type === "component") {
+        if (!attrDef.repeatable && attrDef.component) {
+          const comp = strapi2.components[attrDef.component];
+          if (comp?.attributes) {
+            compFieldsToPopulate.push(attrName);
+            for (const [subKey, subDef] of Object.entries(comp.attributes)) {
+              if (excluded.includes(subKey)) continue;
+              if (["component", "dynamiczone", "media", "relation"].includes(subDef.type)) continue;
+              exportFields.push(`${attrName}.${subKey}`);
+            }
+          }
+        }
+        continue;
+      }
       exportFields.push(attrName);
     }
     const filters2 = {};
@@ -2177,16 +2389,25 @@ ${sampleRow.map(escapeCsvValue).join(",")}
         }
       }
     }
+    const populateOption = compFieldsToPopulate.length > 0 ? compFieldsToPopulate.reduce((acc, k) => ({ ...acc, [k]: true }), {}) : void 0;
     const entries = await strapi2.documents(uid).findMany({
       filters: Object.keys(filters2).length > 0 ? filters2 : void 0,
       limit: options.limit || 5e3,
-      sort: { createdAt: "desc" }
+      sort: { createdAt: "desc" },
+      populate: populateOption
     });
     const lines = [];
     lines.push(exportFields.map(escapeCsvValue).join(","));
     for (const entry of entries || []) {
       const rowValues = exportFields.map((field) => {
-        return escapeCsvValue(entry[field]);
+        let val;
+        if (field.includes(".")) {
+          const [parent, child] = field.split(".");
+          val = entry[parent]?.[child];
+        } else {
+          val = entry[field];
+        }
+        return escapeCsvValue(val);
       });
       lines.push(rowValues.join(","));
     }
@@ -2272,6 +2493,29 @@ ${sampleRow.map(escapeCsvValue).join(",")}
       const payload = {};
       for (const [key, rawVal] of Object.entries(row)) {
         if (key === "documentId" || key === "id") continue;
+        if (key.includes(".")) {
+          const [parent, child] = key.split(".");
+          const parentDef = attrs[parent];
+          if (parentDef?.type === "component" && !parentDef.repeatable && parentDef.component) {
+            const comp = strapi2.components[parentDef.component];
+            const childDef = comp?.attributes?.[child];
+            if (childDef) {
+              if (!payload[parent]) payload[parent] = {};
+              let val = rawVal;
+              if (rawVal === "" || rawVal === null || rawVal === void 0) {
+                val = null;
+              } else if (childDef.type === "integer" || childDef.type === "biginteger") {
+                val = parseInt(rawVal, 10);
+              } else if (childDef.type === "float" || childDef.type === "decimal") {
+                val = parseFloat(rawVal);
+              } else if (childDef.type === "boolean") {
+                val = rawVal.toLowerCase() === "true" || rawVal === "1";
+              }
+              payload[parent][child] = val;
+            }
+          }
+          continue;
+        }
         const attrDef = attrs[key];
         if (!attrDef) continue;
         if (rawVal === "" || rawVal === null || rawVal === void 0) {
@@ -2323,9 +2567,15 @@ ${sampleRow.map(escapeCsvValue).join(",")}
             });
             continue;
           }
+          const mergedPayload = { ...payload };
+          for (const key of Object.keys(payload)) {
+            if (attrs[key]?.type === "component" && typeof payload[key] === "object" && payload[key] !== null) {
+              mergedPayload[key] = { ...existing[key] || {}, ...payload[key] };
+            }
+          }
           await strapi2.documents(uid).update({
             documentId: docId,
-            data: payload
+            data: mergedPayload
           });
           if (publish && ct.options?.draftAndPublish) {
             try {
@@ -2352,9 +2602,15 @@ ${sampleRow.map(escapeCsvValue).join(",")}
               documentId: docId
             });
             if (existing) {
+              const mergedPayload = { ...payload };
+              for (const key of Object.keys(payload)) {
+                if (attrs[key]?.type === "component" && typeof payload[key] === "object" && payload[key] !== null) {
+                  mergedPayload[key] = { ...existing[key] || {}, ...payload[key] };
+                }
+              }
               await strapi2.documents(uid).update({
                 documentId: docId,
-                data: payload
+                data: mergedPayload
               });
               if (publish && ct.options?.draftAndPublish) {
                 try {