strapi-plugin-bulk-updater 1.2.12 → 1.3.0

package/dist/server/index.mjs

@@ -190,6 +190,22 @@ const routes = {
           policies: []
         }
       },
+      {
+        method: "POST",
+        path: "/csv/export/:uid",
+        handler: "csv.exportCollection",
+        config: {
+          policies: []
+        }
+      },
+      {
+        method: "POST",
+        path: "/csv/export-bulk",
+        handler: "csv.exportBulk",
+        config: {
+          policies: []
+        }
+      },
       {
         method: "GET",
         path: "/csv/export-violations/:ruleId",
@@ -299,12 +315,13 @@ const bulkUpdaterController = ({ strapi: strapi2 }) => ({
   async getCollectionEntries(ctx) {
     try {
       const { uid } = ctx.params;
-      const { page, pageSize, attribute, filterOperator, filterQuery, search, sortField, sortOrder } = ctx.query;
+      const { page, pageSize, attribute, searchAttribute, filterOperator, filterQuery, search, sortField, sortOrder } = ctx.query;
       const service = strapi2.plugin("bulk-updater").service("bulkUpdater");
       const data = await service.getCollectionEntries(uid, {
         page: page ? Number(page) : 1,
         pageSize: pageSize ? Number(pageSize) : 10,
         attribute: attribute ? String(attribute) : void 0,
+        searchAttribute: searchAttribute ? String(searchAttribute) : void 0,
         filterOperator: filterOperator ? String(filterOperator) : void 0,
         filterQuery: filterQuery !== void 0 ? String(filterQuery) : void 0,
         search: search ? String(search) : void 0,
@@ -569,20 +586,46 @@ const csvController = ({ strapi: strapi2 }) => ({
   async exportCollection(ctx) {
     try {
       const { uid } = ctx.params;
-      const { search, attribute, filterOperator, filterQuery, limit } = ctx.query;
+      const { search, attribute, filterOperator, filterQuery, limit, documentIds } = {
+        ...ctx.query,
+        ...ctx.request?.body || {}
+      };
       const csvService2 = strapi2.plugin("bulk-updater").service("csv");
+      let parsedDocIds;
+      if (documentIds) {
+        parsedDocIds = Array.isArray(documentIds) ? documentIds : String(documentIds).split(",").map((s) => s.trim()).filter(Boolean);
+      }
       const result = await csvService2.exportCollectionCsv(uid, {
         search: search ? String(search) : void 0,
         attribute: attribute ? String(attribute) : void 0,
         filterOperator: filterOperator ? String(filterOperator) : void 0,
         filterQuery: filterQuery !== void 0 ? String(filterQuery) : void 0,
-        limit: limit ? Number(limit) : void 0
+        limit: limit ? Number(limit) : void 0,
+        documentIds: parsedDocIds
       });
       ctx.body = {
         success: true,
         filename: result.filename,
         csvContent: result.csvContent,
-        count: result.count
+        count: result.count,
+        fields: result.fields
+      };
+    } catch (err) {
+      ctx.status = 500;
+      ctx.body = { success: false, error: err.message };
+    }
+  },
+  async exportBulk(ctx) {
+    try {
+      const { selectedEntries } = ctx.request.body || {};
+      const csvService2 = strapi2.plugin("bulk-updater").service("csv");
+      const result = await csvService2.exportBulkCsv(selectedEntries);
+      ctx.body = {
+        success: true,
+        filename: result.filename,
+        csvContent: result.csvContent,
+        count: result.count,
+        isMultiCollection: result.isMultiCollection
       };
     } catch (err) {
       ctx.status = 500;
@@ -637,6 +680,127 @@ const modelsCache = /* @__PURE__ */ new Map();
 const MAX_QUERY_CACHE_SIZE = 500;
 const CACHE_TTL_MS = 60 * 1e3;
 let staticSchemaCache = null;
+function buildDeepPopulate$1(attributes, allComponents, depth2 = 0) {
+  if (depth2 > 5) return true;
+  const populate2 = {};
+  for (const [key, def] of Object.entries(attributes || {})) {
+    if (def.type === "component" && def.component) {
+      const comp = allComponents[def.component];
+      if (comp?.attributes) {
+        populate2[key] = {
+          populate: buildDeepPopulate$1(comp.attributes, allComponents, depth2 + 1)
+        };
+      } else {
+        populate2[key] = true;
+      }
+    } else if (def.type === "dynamiczone") {
+      populate2[key] = true;
+    } else if (def.type === "relation" || def.type === "media") {
+      populate2[key] = true;
+    }
+  }
+  return Object.keys(populate2).length > 0 ? populate2 : true;
+}
+function discoverComponentAttributes(strapi2, compUid, prefix, currentDepth, maxDepth, systemFields, allContentTypes, relationsByAttr, allRelationsMeta, attributesMeta) {
+  if (currentDepth > maxDepth || !compUid) return [];
+  const compSchema = strapi2.components[compUid];
+  if (!compSchema?.attributes) return [];
+  const discoveredAttrs = [];
+  for (const [subKey, subAttr] of Object.entries(compSchema.attributes)) {
+    if (systemFields.includes(subKey)) continue;
+    if (subAttr.type === "dynamiczone") continue;
+    const fullPath = prefix ? `${prefix}.${subKey}` : subKey;
+    if (subAttr.type === "component") {
+      if (!subAttr.repeatable && subAttr.component) {
+        const deeper = discoverComponentAttributes(
+          strapi2,
+          subAttr.component,
+          fullPath,
+          currentDepth + 1,
+          maxDepth,
+          systemFields,
+          allContentTypes,
+          relationsByAttr,
+          allRelationsMeta,
+          attributesMeta
+        );
+        discoveredAttrs.push(...deeper);
+      }
+    } else if (subAttr.type === "relation") {
+      const targetUid = subAttr.target;
+      if (targetUid && allContentTypes[targetUid]) {
+        const targetInfo = allContentTypes[targetUid]?.info;
+        const isMulti = subAttr.relation === "oneToMany" || subAttr.relation === "manyToMany";
+        const relMeta = {
+          isRelation: true,
+          relationType: subAttr.relation,
+          targetUid,
+          targetDisplayName: targetInfo?.displayName || targetUid,
+          isMulti
+        };
+        relationsByAttr[fullPath] = relMeta;
+        allRelationsMeta[fullPath] = relMeta;
+        attributesMeta[fullPath] = { depth: currentDepth, type: "relation", component: compUid, isRelation: true };
+        discoveredAttrs.push(fullPath);
+      }
+    } else {
+      attributesMeta[fullPath] = { depth: currentDepth, type: subAttr.type, component: compUid };
+      discoveredAttrs.push(fullPath);
+    }
+  }
+  return discoveredAttrs;
+}
+function isDeepComponentField(contentType, allComponents, attribute) {
+  if (!attribute || !attribute.includes(".")) return false;
+  const parts = attribute.split(".");
+  let currentSchema = contentType;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    const attrDef = currentSchema?.attributes?.[part];
+    if (!attrDef || attrDef.type !== "component" || !attrDef.component) return false;
+    currentSchema = allComponents[attrDef.component];
+    if (!currentSchema) return false;
+  }
+  const leafField = parts[parts.length - 1];
+  return Boolean(currentSchema?.attributes?.[leafField]);
+}
+function getLeafAttributeSchema(contentType, allComponents, attribute) {
+  if (!attribute) return null;
+  if (!attribute.includes(".")) return contentType?.attributes?.[attribute] || null;
+  const parts = attribute.split(".");
+  let currentSchema = contentType;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    const attrDef = currentSchema?.attributes?.[part];
+    if (!attrDef || attrDef.type !== "component" || !attrDef.component) return null;
+    currentSchema = allComponents[attrDef.component];
+    if (!currentSchema) return null;
+  }
+  return currentSchema?.attributes?.[parts[parts.length - 1]] || null;
+}
+function setDeepProperty(obj, pathParts, value) {
+  if (pathParts.length === 0) return value;
+  const current = { ...obj || {} };
+  const [head, ...tail] = pathParts;
+  if (tail.length === 0) {
+    current[head] = value;
+  } else {
+    current[head] = setDeepProperty(current[head] || {}, tail, value);
+  }
+  return current;
+}
+function getDeepProperty(obj, path2) {
+  if (!obj || !path2) return void 0;
+  if (!path2.includes(".")) return obj[path2];
+  return path2.split(".").reduce((acc, part) => acc && typeof acc === "object" ? acc[part] : void 0, obj);
+}
+function buildDeepFilter(pathParts, condition) {
+  if (pathParts.length === 0) return condition;
+  const [head, ...tail] = pathParts;
+  return {
+    [head]: buildDeepFilter(tail, condition)
+  };
+}
 function getSafeTimezone(timeZone) {
   if (!timeZone || typeof timeZone !== "string") {
     return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
@@ -845,43 +1009,28 @@ async function executeBatchInternal(strapi2, {
         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 isComponentNested = isNested && isDeepComponentField(contentType, strapi2.components, attribute);
+        const parts = isNested ? attribute.split(".") : [];
+        const rootKey = isNested ? parts[0] : "";
         const attrDef = contentType?.attributes?.[attribute];
         const hasAttribute = Boolean(attrDef) || isComponentNested;
         if (hasAttribute) {
           if (isComponentNested) {
             const currentEntryWithPopulate = await strapi2.documents(target.uid).findOne({
               documentId: target.documentId,
-              populate: [parentKey]
+              populate: buildDeepPopulate$1(contentType.attributes, strapi2.components)
             });
-            const existingParent = currentEntryWithPopulate?.[parentKey] || {};
-            const currentVal2 = existingParent?.[childKey];
+            const existingRoot = currentEntryWithPopulate?.[rootKey] || {};
+            const currentVal2 = getDeepProperty(existingRoot, parts.slice(1).join("."));
             let newValue2 = value;
             if (regexObj && typeof currentVal2 === "string") {
               newValue2 = currentVal2.replace(regexObj, value);
             }
-            const updatedParent = {
-              ...existingParent,
-              [childKey]: newValue2
-            };
+            const updatedRoot = setDeepProperty(existingRoot, parts.slice(1), newValue2);
             await strapi2.documents(target.uid).update({
               documentId: target.documentId,
               data: {
-                [parentKey]: updatedParent
+                [rootKey]: updatedRoot
               }
             });
             const isDraftAndPublishComp = Boolean(contentType?.options?.draftAndPublish);
@@ -1316,12 +1465,14 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
         }
         const metaByUid = {};
         const allRelationsMeta = {};
+        const allAttributesMeta = {};
         for (const uid of targetUids) {
           const contentType = allContentTypes[uid];
           if (!contentType || contentType.kind !== "collectionType" && contentType.kind !== "singleType") continue;
           const isSingleType = contentType.kind === "singleType";
           const rawAttrs = contentType.attributes || {};
           const relationsByAttr = {};
+          const colAttributesMeta = {};
           const nestedComponentAttrs = [];
           const validAttrs = Object.keys(rawAttrs).filter((attrKey) => {
             if (systemFields.includes(attrKey)) return false;
@@ -1329,14 +1480,19 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
             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}`);
-                  }
-                }
+                const compAttrs = discoverComponentAttributes(
+                  strapi2,
+                  compDef.component,
+                  attrKey,
+                  1,
+                  5,
+                  systemFields,
+                  allContentTypes,
+                  relationsByAttr,
+                  allRelationsMeta,
+                  colAttributesMeta
+                );
+                nestedComponentAttrs.push(...compAttrs);
               }
               return false;
             }
@@ -1355,12 +1511,19 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
               };
               relationsByAttr[attrKey] = relMeta;
               allRelationsMeta[attrKey] = relMeta;
+              colAttributesMeta[attrKey] = { depth: 0, type: "relation", isRelation: true };
               return true;
             }
+            colAttributesMeta[attrKey] = { depth: 0, type: rawAttrs[attrKey].type };
             return true;
           });
           const allColAttrs = [...validAttrs, ...nestedComponentAttrs];
-          allColAttrs.forEach((attr) => allAttributesSet.add(attr));
+          allColAttrs.forEach((attr) => {
+            allAttributesSet.add(attr);
+            if (colAttributesMeta[attr]) {
+              allAttributesMeta[attr] = colAttributesMeta[attr];
+            }
+          });
           metaByUid[uid] = {
             uid,
             kind: contentType.kind,
@@ -1370,11 +1533,13 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
             pluralName: contentType.info?.pluralName || uid,
             displayName: contentType.info?.displayName || uid,
             attributes: allColAttrs,
+            attributesMeta: colAttributesMeta,
             relations: relationsByAttr
           };
         }
         staticSchemaCache = {
           attributes: Array.from(allAttributesSet),
+          attributesMeta: allAttributesMeta,
           targetUids: Object.keys(metaByUid),
           metaByUid,
           relationsMeta: allRelationsMeta
@@ -1405,17 +1570,7 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
             let entries = [];
             let totalCount = 0;
             try {
-              const ctAttrs = allContentTypes[uid]?.attributes || {};
-              const relKeys = Object.keys(meta.relations || {});
-              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;
+              const populateOption = buildDeepPopulate$1(allContentTypes[uid]?.attributes || {}, strapi2.components);
               if (meta.isSingleType) {
                 const singleDoc = await strapi2.documents(uid).findFirst({
                   populate: populateOption
@@ -1474,8 +1629,10 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
       return {
         success: true,
         attributes: staticSchemaCache.attributes,
+        attributesMeta: staticSchemaCache.attributesMeta,
         collections,
         relationsMeta: staticSchemaCache.relationsMeta,
+        maxDiscoveredDepth: 5,
         executionWindow: {
           ...executionConfig,
           ...windowStatus
@@ -1494,6 +1651,7 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
       page = 1,
       pageSize = 10,
       attribute,
+      searchAttribute,
       filterOperator,
       filterQuery,
       search,
@@ -1508,8 +1666,9 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
       const currentPage = Math.max(Number(page) || 1, 1);
       const start = (currentPage - 1) * limit;
       const isSingleType = contentType.kind === "singleType";
+      const targetFilterAttr = searchAttribute || attribute;
       const signature = await getCollectionSignature(strapi2, uid);
-      const cacheKey = `${uid}:${limit}:${start}:${attribute || ""}:${filterOperator || ""}:${filterQuery || ""}:${search || ""}:${sortField || ""}:${sortOrder}`;
+      const cacheKey = `${uid}:${limit}:${start}:${attribute || ""}:${searchAttribute || ""}:${filterOperator || ""}:${filterQuery || ""}:${search || ""}:${sortField || ""}:${sortOrder}`;
       const cached = queryCache.get(cacheKey);
       const etag = `W/"entry-${crypto.createHash("md5").update(`${cacheKey}:${signature}`).digest("hex")}"`;
       if (cached && cached.signature === signature && Date.now() - cached.timestamp < CACHE_TTL_MS) {
@@ -1524,19 +1683,15 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
       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;
-            }
+      let parts = [];
+      if (targetFilterAttr) {
+        if (targetFilterAttr.includes(".")) {
+          isNestedAttr = isDeepComponentField(contentType, strapi2.components, targetFilterAttr);
+          if (isNestedAttr) {
+            colHasAttribute = true;
+            parts = targetFilterAttr.split(".");
           }
-        } else if (attrs[attribute]) {
+        } else if (attrs[targetFilterAttr]) {
           colHasAttribute = true;
         }
       }
@@ -1561,7 +1716,7 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
         }
         let condition = void 0;
         const q = (filterQuery || "").trim();
-        const targetAttrSchema = isNestedAttr ? strapi2.components[attrs[parentKey]?.component]?.attributes?.[childKey] : attrs[attribute];
+        const targetAttrSchema = isNestedAttr ? getLeafAttributeSchema(contentType, strapi2.components, targetFilterAttr) : attrs[targetFilterAttr];
         const isStringLike = ["string", "text", "email", "richtext", "uid"].includes(targetAttrSchema?.type);
         if (normOp === "empty") {
           condition = isStringLike ? { $or: [{ $null: true }, { $eq: "" }] } : { $null: true };
@@ -1591,19 +1746,18 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
         }
         if (condition !== void 0) {
           if (isNestedAttr) {
-            filters2[parentKey] = {
-              [childKey]: condition
-            };
+            const deepFilter = buildDeepFilter(parts, condition);
+            Object.assign(filters2, deepFilter);
           } else {
             if (normOp === "empty" && isStringLike) {
               filters2.$or = [
-                { [attribute]: { $null: true } },
-                { [attribute]: { $eq: "" } }
+                { [targetFilterAttr]: { $null: true } },
+                { [targetFilterAttr]: { $eq: "" } }
               ];
             } else if (normOp === "notempty" && isStringLike) {
-              filters2[attribute] = { $notNull: true, $ne: "" };
+              filters2[targetFilterAttr] = { $notNull: true, $ne: "" };
             } else {
-              filters2[attribute] = condition;
+              filters2[targetFilterAttr] = condition;
             }
           }
         }
@@ -1626,11 +1780,13 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
           }
         }
       }
+      const populateOption = buildDeepPopulate$1(contentType.attributes, strapi2.components);
       if (isSingleType) {
         let singleDoc = null;
         try {
           singleDoc = await strapi2.documents(uid).findFirst({
-            filters: Object.keys(filters2).length > 0 ? filters2 : void 0
+            filters: Object.keys(filters2).length > 0 ? filters2 : void 0,
+            populate: populateOption
           });
         } catch {
           singleDoc = null;
@@ -1649,11 +1805,11 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
           }
         };
       } else {
-        const sortClause = {};
+        let sortClause = {};
         if (sortField && sortField.includes(".")) {
-          const [parent, child] = sortField.split(".");
-          if (contentType.attributes?.[parent]?.type === "component") {
-            sortClause[parent] = { [child]: sortOrder };
+          const sortParts = sortField.split(".");
+          if (isDeepComponentField(contentType, strapi2.components, sortField)) {
+            sortClause = buildDeepFilter(sortParts, sortOrder);
           } else {
             sortClause["createdAt"] = "desc";
           }
@@ -1662,10 +1818,6 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
         } else {
           sortClause["createdAt"] = "desc";
         }
-        const populateAttrs = Object.keys(contentType.attributes || {}).filter(
-          (k) => contentType.attributes[k].type === "relation" || contentType.attributes[k].type === "component"
-        );
-        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,
@@ -1787,21 +1939,7 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
         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 isComponentNested = isNested && isDeepComponentField(contentType, strapi2.components, attribute);
           const attrDef = contentType?.attributes?.[attribute];
           const hasAttribute = Boolean(attrDef) || isComponentNested;
           if (!hasAttribute) {
@@ -1826,7 +1964,7 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
           if (isComponentNested) {
             currentEntry = await strapi2.documents(target.uid).findOne({
               documentId: target.documentId,
-              populate: [parentKey]
+              populate: buildDeepPopulate$1(contentType.attributes, strapi2.components)
             });
           } else if (attrDef?.type === "relation") {
             currentEntry = await strapi2.documents(target.uid).findOne({
@@ -1840,8 +1978,7 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
           }
           const entryLabel = currentEntry?.name || currentEntry?.title || currentEntry?.email || `Entry #${target.documentId}`;
           if (isComponentNested) {
-            const existingParent = currentEntry?.[parentKey] || {};
-            const currentVal2 = existingParent?.[childKey];
+            const currentVal2 = getDeepProperty(currentEntry, attribute);
             let newValue2 = value;
             if (regexObj && typeof currentVal2 === "string") {
               newValue2 = currentVal2.replace(regexObj, value);
@@ -2581,7 +2718,11 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
       function escapeCsvVal(val) {
         if (val === null || val === void 0) return "";
         let str2 = typeof val === "object" ? JSON.stringify(val) : String(val);
-        if (str2.includes(",") || str2.includes('"') || str2.includes("\n") || str2.includes("\r")) {
+        str2 = str2.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+        if (/^[=+@-]$/.test(str2.charAt(0))) {
+          str2 = `'${str2}`;
+        }
+        if (str2.includes(",") || str2.includes('"') || str2.includes("\n")) {
           return `"${str2.replace(/"/g, '""')}"`;
         }
         return str2;
@@ -2625,7 +2766,7 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
       return {
         success: true,
         filename,
-        csvContent: rows.join("\n"),
+        csvContent: "\uFEFF" + rows.join("\r\n") + "\r\n",
         summary: {
           batchId: batch.id,
           status: batch.status,
@@ -3449,23 +3590,34 @@ const validationRulesService = ({ strapi: strapi2 }) => ({
 function escapeCsvValue(val) {
   if (val === null || val === void 0) return "";
   let str2 = "";
-  if (typeof val === "object") {
+  if (val instanceof Date) {
+    str2 = val.toISOString();
+  } else if (typeof val === "object") {
     str2 = JSON.stringify(val);
   } else {
     str2 = String(val);
   }
-  if (str2.includes(",") || str2.includes('"') || str2.includes("\n") || str2.includes("\r")) {
+  str2 = str2.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  if (/^[=+@-]$/.test(str2.charAt(0))) {
+    str2 = `'${str2}`;
+  }
+  if (str2.includes(",") || str2.includes('"') || str2.includes("\n")) {
     return `"${str2.replace(/"/g, '""')}"`;
   }
   return str2;
 }
 function parseCsv(csvText) {
+  if (!csvText) return [];
+  let cleanText = csvText;
+  if (cleanText.charCodeAt(0) === 65279) {
+    cleanText = cleanText.slice(1);
+  }
   const lines = [];
   let current = "";
   let inQuotes = false;
-  for (let i = 0; i < csvText.length; i++) {
-    const char = csvText[i];
-    const nextChar = csvText[i + 1];
+  for (let i = 0; i < cleanText.length; i++) {
+    const char = cleanText[i];
+    const nextChar = cleanText[i + 1];
     if (char === '"') {
       if (inQuotes && nextChar === '"') {
         current += '"';
@@ -3525,6 +3677,103 @@ function parseCsv(csvText) {
   }
   return rows;
 }
+function discoverExportFields(ct, allComponents, maxDepth = 4) {
+  const fields2 = [{ key: "documentId", label: "documentId", type: "string" }];
+  const excluded = ["createdBy", "updatedBy", "localizations"];
+  function walkComponent(compUid, pathPrefix, labelPrefix, depth2) {
+    if (depth2 >= maxDepth) return;
+    const comp = allComponents[compUid];
+    if (!comp?.attributes) return;
+    for (const [subKey, subDef] of Object.entries(comp.attributes)) {
+      if (excluded.includes(subKey)) continue;
+      const keyPath = `${pathPrefix}.${subKey}`;
+      const displayLabel = `${labelPrefix} > ${subKey}`;
+      if (subDef.type === "component" && subDef.component) {
+        if (!subDef.repeatable) {
+          walkComponent(subDef.component, keyPath, displayLabel, depth2 + 1);
+        } else {
+          fields2.push({ key: keyPath, label: displayLabel, type: "component" });
+        }
+      } else {
+        fields2.push({ key: keyPath, label: displayLabel, type: subDef.type });
+      }
+    }
+  }
+  for (const [attrName, attrDef] of Object.entries(ct.attributes || {})) {
+    if (excluded.includes(attrName)) continue;
+    if (attrDef.type === "component" && attrDef.component) {
+      if (!attrDef.repeatable) {
+        walkComponent(attrDef.component, attrName, attrName, 0);
+      } else {
+        fields2.push({ key: attrName, label: attrName, type: "component" });
+      }
+    } else {
+      fields2.push({ key: attrName, label: attrName, type: attrDef.type });
+    }
+  }
+  return fields2;
+}
+function buildDeepPopulate(attributes, allComponents, depth2 = 0) {
+  if (depth2 > 4) return true;
+  const populate2 = {};
+  for (const [key, def] of Object.entries(attributes || {})) {
+    if (def.type === "component" && def.component) {
+      const comp = allComponents[def.component];
+      if (comp?.attributes) {
+        populate2[key] = {
+          populate: buildDeepPopulate(comp.attributes, allComponents, depth2 + 1)
+        };
+      } else {
+        populate2[key] = true;
+      }
+    } else if (def.type === "dynamiczone") {
+      populate2[key] = true;
+    } else if (def.type === "relation" || def.type === "media") {
+      populate2[key] = true;
+    }
+  }
+  return Object.keys(populate2).length > 0 ? populate2 : true;
+}
+function getNestedExportValue(entry, path2) {
+  if (!entry || !path2) return "";
+  const parts = path2.split(".");
+  let current = entry;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (current === null || current === void 0) return "";
+    if (Array.isArray(current)) {
+      const subPath = parts.slice(i).join(".");
+      return current.map((item) => {
+        if (!item) return "";
+        if (typeof item === "object") {
+          const val = getNestedExportValue(item, subPath);
+          return typeof val === "object" ? JSON.stringify(val) : String(val ?? "");
+        }
+        return String(item);
+      }).filter(Boolean).join("; ");
+    }
+    current = current[part];
+  }
+  if (current === null || current === void 0) return "";
+  if (typeof current === "object" && current.url) {
+    return current.url;
+  }
+  if (typeof current === "object" && !Array.isArray(current)) {
+    if (current.documentId || current.name || current.title) {
+      return current.name || current.title || current.documentId;
+    }
+  }
+  if (Array.isArray(current)) {
+    return current.map((item) => {
+      if (!item) return "";
+      if (typeof item === "object") {
+        return item.name || item.title || item.documentId || JSON.stringify(item);
+      }
+      return String(item);
+    }).filter(Boolean).join("; ");
+  }
+  return current;
+}
 const csvService = ({ strapi: strapi2 }) => ({
   /**
    * Generates a sample template CSV with schema attribute headers and sample values
@@ -3573,9 +3822,7 @@ const csvService = ({ strapi: strapi2 }) => ({
       }
       sampleRow.push(sampleVal);
     }
-    const csvContent = `${headers.map(escapeCsvValue).join(",")}
-${sampleRow.map(escapeCsvValue).join(",")}
-`;
+    const csvContent = "\uFEFF" + headers.map(escapeCsvValue).join(",") + "\r\n" + sampleRow.map(escapeCsvValue).join(",") + "\r\n";
     return {
       filename: `${ct.info?.singularName || "template"}_template.csv`,
       csvContent,
@@ -3583,65 +3830,60 @@ ${sampleRow.map(escapeCsvValue).join(",")}
     };
   },
   /**
-   * Exports entries of a collection to CSV, with optional filters
+   * Exports entries of a collection to CSV with deep nested component support,
+   * RFC-4180 CRLF line endings, and UTF-8 BOM for 100% Microsoft Excel compatibility.
    */
   async exportCollectionCsv(uid, options = {}) {
     const ct = strapi2.contentTypes[uid];
     if (!ct) {
       throw new Error(`Content type ${uid} not found`);
     }
-    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 (["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 allComponents = strapi2.components || {};
+    const fields2 = discoverExportFields(ct, allComponents);
     const filters2 = {};
-    const { attribute, filterOperator, filterQuery, search } = options;
-    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;
+    const { attribute, filterOperator, filterQuery, search, documentIds } = options;
+    if (documentIds && Array.isArray(documentIds) && documentIds.length > 0) {
+      filters2.documentId = { $in: documentIds };
+    }
+    if (attribute && filterOperator && filterOperator !== "none") {
+      const isNested = attribute.includes(".");
+      if (filterOperator === "empty") {
+        if (isNested) {
+          const [parent, child] = attribute.split(".");
+          filters2[parent] = { [child]: { $null: true } };
+        } else {
+          filters2[attribute] = { $null: true };
+        }
+      } else if (filterOperator === "not_empty") {
+        if (isNested) {
+          const [parent, child] = attribute.split(".");
+          filters2[parent] = { [child]: { $notNull: true } };
+        } else {
+          filters2[attribute] = { $notNull: true };
+        }
+      } else if (filterQuery !== void 0 && filterQuery !== "") {
+        const opMap = {
+          equals: "$eq",
+          notEquals: "$ne",
+          contains: "$containsi",
+          notContains: "$notContainsi",
+          startsWith: "$startsWith",
+          endsWith: "$endsWith"
+        };
+        const strapiOp = opMap[filterOperator] || "$eq";
+        if (isNested) {
+          const [parent, child] = attribute.split(".");
+          filters2[parent] = { [child]: { [strapiOp]: filterQuery } };
+        } else {
+          filters2[attribute] = { [strapiOp]: filterQuery };
+        }
       }
     }
     if (search && search.trim() !== "") {
       const q = search.trim();
       const searchConditions = [];
       const searchFields = ["name", "title", "email", "slug", "description"].filter(
-        (f) => attrs[f] && ["string", "text", "email"].includes(attrs[f].type)
+        (f) => ct.attributes?.[f] && ["string", "text", "email"].includes(ct.attributes[f].type)
       );
       for (const field of searchFields) {
         searchConditions.push({ [field]: { $containsi: q } });
@@ -3654,34 +3896,37 @@ ${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" },
-      populate: populateOption
-    });
+    const deepPopulate = buildDeepPopulate(ct.attributes || {}, allComponents);
+    let entries = [];
+    if (ct.kind === "singleType") {
+      const doc = await strapi2.documents(uid).findFirst({
+        populate: deepPopulate
+      });
+      entries = doc ? [doc] : [];
+    } else {
+      entries = await strapi2.documents(uid).findMany({
+        filters: Object.keys(filters2).length > 0 ? filters2 : void 0,
+        limit: options.limit || 5e3,
+        sort: { createdAt: "desc" },
+        populate: deepPopulate
+      });
+    }
     const lines = [];
-    lines.push(exportFields.map(escapeCsvValue).join(","));
+    lines.push(fields2.map((f) => escapeCsvValue(f.key)).join(","));
     for (const entry of entries || []) {
-      const rowValues = exportFields.map((field) => {
-        let val;
-        if (field.includes(".")) {
-          const [parent, child] = field.split(".");
-          val = entry[parent]?.[child];
-        } else {
-          val = entry[field];
-        }
+      const rowValues = fields2.map((f) => {
+        const val = getNestedExportValue(entry, f.key);
         return escapeCsvValue(val);
       });
       lines.push(rowValues.join(","));
     }
-    const csvContent = lines.join("\n");
+    const csvContent = "\uFEFF" + lines.join("\r\n") + "\r\n";
     const filename = `${ct.info?.singularName || uid}_export_${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.csv`;
     return {
       filename,
       csvContent,
-      count: entries ? entries.length : 0
+      count: entries ? entries.length : 0,
+      fields: fields2.map((f) => f.key)
     };
   },
   /**
@@ -3721,11 +3966,76 @@ ${sampleRow.map(escapeCsvValue).join(",")}
     const filename = `violations_${safeRuleName}_${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.csv`;
     return {
       filename,
-      csvContent: lines.join("\n"),
+      csvContent: "\uFEFF" + lines.join("\r\n") + "\r\n",
       count: scanReport.violations.length,
       ruleName: scanReport.rule.name
     };
   },
+  /**
+   * Bulk Export: Exports selected entries across multiple collections or a multi-collection batch.
+   */
+  async exportBulkCsv(selectedEntries) {
+    if (!selectedEntries || selectedEntries.length === 0) {
+      throw new Error("No entries selected for bulk export");
+    }
+    const byUid = {};
+    for (const item of selectedEntries) {
+      if (!byUid[item.uid]) byUid[item.uid] = [];
+      byUid[item.uid].push(item.documentId);
+    }
+    const uids = Object.keys(byUid);
+    if (uids.length === 1) {
+      const uid = uids[0];
+      return await this.exportCollectionCsv(uid, { documentIds: byUid[uid] });
+    }
+    const rows = [];
+    const headers = [
+      "Collection UID",
+      "Collection Name",
+      "Document ID",
+      "Record Title / Name",
+      "Primary Identifier",
+      "Created At",
+      "Updated At",
+      "Published Status"
+    ];
+    rows.push(headers.map(escapeCsvValue).join(","));
+    let totalExported = 0;
+    for (const uid of uids) {
+      const ct = strapi2.contentTypes[uid];
+      if (!ct) continue;
+      const displayName = ct.info?.displayName || uid;
+      const docIds = byUid[uid];
+      const entries = await strapi2.documents(uid).findMany({
+        filters: { documentId: { $in: docIds } },
+        limit: docIds.length
+      });
+      for (const entry of entries || []) {
+        const titleOrName = entry.title || entry.name || entry.subject || entry.email || `Entry #${entry.documentId}`;
+        const identifier = entry.slug || entry.email || entry.username || entry.documentId;
+        const isPublished = Boolean(entry.publishedAt);
+        const row = [
+          uid,
+          displayName,
+          entry.documentId,
+          titleOrName,
+          identifier,
+          entry.createdAt || "",
+          entry.updatedAt || "",
+          isPublished ? "Published" : "Draft"
+        ];
+        rows.push(row.map(escapeCsvValue).join(","));
+        totalExported++;
+      }
+    }
+    const filename = `bulk_export_selected_${totalExported}_entries_${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.csv`;
+    return {
+      filename,
+      csvContent: "\uFEFF" + rows.join("\r\n") + "\r\n",
+      count: totalExported,
+      isMultiCollection: true
+    };
+  },
   /**
    * Imports CSV records to update existing records or insert/override records
    */