strapi-plugin-bulk-updater 1.2.11 → 1.2.13

package/dist/server/index.mjs

@@ -46,6 +46,14 @@ const routes = {
           policies: []
         }
       },
+      {
+        method: "POST",
+        path: "/batch-publish",
+        handler: "bulkUpdater.batchPublish",
+        config: {
+          policies: []
+        }
+      },
       {
         method: "POST",
         path: "/preview",
@@ -182,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",
@@ -340,6 +364,17 @@ const bulkUpdaterController = ({ strapi: strapi2 }) => ({
       ctx.body = { success: false, error: err.message };
     }
   },
+  async batchPublish(ctx) {
+    try {
+      const service = strapi2.plugin("bulk-updater").service("bulkUpdater");
+      const currentUser = ctx.state.user;
+      const result = await service.batchPublish(ctx.request.body || {}, currentUser);
+      ctx.body = result;
+    } catch (err) {
+      ctx.status = 400;
+      ctx.body = { success: false, error: err.message };
+    }
+  },
   async previewBatch(ctx) {
     try {
       const service = strapi2.plugin("bulk-updater").service("bulkUpdater");
@@ -550,20 +585,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;
@@ -1080,6 +1141,164 @@ async function executeBatchInternal(strapi2, {
     results
   };
 }
+async function executePublishBatchInternal(strapi2, {
+  selectedEntries = [],
+  selectedCollections = []
+}, currentUser, existingBatchId) {
+  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 to publish.");
+  }
+  const batchId = existingBatchId || `batch_pub_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
+  const results = [];
+  let publishedCount = 0;
+  let skippedCount = 0;
+  const jobState = {
+    id: batchId,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    createdBy: currentUser ? {
+      id: currentUser.id,
+      email: currentUser.email,
+      firstname: currentUser.firstname,
+      lastname: currentUser.lastname,
+      username: currentUser.username
+    } : { email: "admin@system.local" },
+    status: "processing",
+    executionMode: "immediate",
+    attribute: "(publish)",
+    value: "published",
+    totalTargets: targetsMap.size,
+    processedCount: 0,
+    updatedCount: 0,
+    skippedCount: 0,
+    failedCount: 0,
+    isLive: false,
+    publishOnApproval: true,
+    results: []
+  };
+  batchJobsMap.set(batchId, jobState);
+  const targets = Array.from(targetsMap.values());
+  const CHUNK_SIZE = 25;
+  for (let i = 0; i < targets.length; i += CHUNK_SIZE) {
+    const chunk = targets.slice(i, i + CHUNK_SIZE);
+    const chunkPromises = chunk.map(async (target) => {
+      try {
+        const contentType = strapi2.contentTypes[target.uid];
+        const displayName = contentType?.info?.displayName || target.uid;
+        const isDraftAndPublish = Boolean(contentType?.options?.draftAndPublish);
+        let existingDoc = null;
+        try {
+          existingDoc = await strapi2.documents(target.uid).findOne({
+            documentId: target.documentId
+          });
+        } catch {
+          existingDoc = null;
+        }
+        const entryLabel = existingDoc?.name || existingDoc?.title || existingDoc?.label || existingDoc?.documentId || `Entry #${target.documentId}`;
+        if (!isDraftAndPublish) {
+          return {
+            uid: target.uid,
+            collectionName: displayName,
+            documentId: target.documentId,
+            label: entryLabel,
+            attribute: "(publish)",
+            status: "skipped",
+            message: `Skipped: Draft & Publish is disabled for collection ${displayName}`
+          };
+        }
+        const isAlreadyPublished = Boolean(existingDoc?.publishedAt);
+        await strapi2.documents(target.uid).publish({
+          documentId: target.documentId
+        });
+        invalidateCollectionCache(target.uid);
+        return {
+          uid: target.uid,
+          collectionName: displayName,
+          documentId: target.documentId,
+          label: entryLabel,
+          attribute: "(publish)",
+          oldValue: isAlreadyPublished ? "published" : "draft",
+          newValue: "published",
+          status: "updated",
+          message: isAlreadyPublished ? "Re-published latest version live" : "Successfully published to live"
+        };
+      } catch (pubErr) {
+        return {
+          uid: target.uid,
+          collectionName: strapi2.contentTypes[target.uid]?.info?.displayName || target.uid,
+          documentId: target.documentId,
+          label: `Entry #${target.documentId}`,
+          attribute: "(publish)",
+          status: "error",
+          message: pubErr.message || "Failed to publish entry"
+        };
+      }
+    });
+    const chunkResults = await Promise.all(chunkPromises);
+    for (const res of chunkResults) {
+      if (res.status === "updated") publishedCount++;
+      else if (res.status === "skipped") skippedCount++;
+      results.push(res);
+    }
+    jobState.processedCount = results.length;
+    jobState.updatedCount = publishedCount;
+    jobState.skippedCount = skippedCount;
+    jobState.failedCount = results.filter((r) => r.status === "error").length;
+  }
+  const affectedUids = new Set(targets.map((t) => t.uid));
+  affectedUids.forEach((uid) => {
+    invalidateCollectionCache(uid);
+  });
+  const failedCount = results.filter((r) => r.status === "error").length;
+  jobState.failedCount = failedCount;
+  jobState.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  jobState.isLive = publishedCount > 0;
+  jobState.status = failedCount === 0 && publishedCount > 0 ? "successful" : failedCount > 0 && publishedCount > 0 ? "partial_failure" : failedCount > 0 ? "failed" : "successful";
+  jobState.results = results.map((r) => ({
+    ...r,
+    isLive: r.status === "updated"
+  }));
+  const batchSummary = {
+    batchId,
+    attribute: "(publish)",
+    value: "published",
+    updatedCount: publishedCount,
+    skippedCount,
+    totalTargets: targetsMap.size,
+    publishOnApproval: true
+  };
+  await strapi2.plugin("bulk-updater").service("audit").recordBatch(
+    batchSummary,
+    results,
+    currentUser
+  );
+  return {
+    success: true,
+    batchId,
+    publishedCount,
+    updatedCount: publishedCount,
+    skippedCount,
+    failedCount,
+    totalTargets: targetsMap.size,
+    isLive: publishedCount > 0,
+    status: jobState.status,
+    results
+  };
+}
 const bulkUpdaterService = ({ strapi: strapi2 }) => {
   if (!runnerInterval) {
     runnerInterval = setInterval(async () => {
@@ -1091,7 +1310,7 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
         for (const [id, batch] of pendingBatches.entries()) {
           if (batch.status === "queued_offpeak" && !isBusinessHours) {
             strapi2.log.info(`[bulk-updater] Executing off-peak queued batch: ${id}`);
-            const result = await executeBatchInternal(strapi2, batch.payload, batch.createdBy, id);
+            const result = batch.payload?.action === "publish" ? await executePublishBatchInternal(strapi2, batch.payload, batch.createdBy, id) : await executeBatchInternal(strapi2, batch.payload, batch.createdBy, id);
             batch.status = "executed";
             batch.executionResult = result;
           }
@@ -1188,6 +1407,7 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
             uid,
             kind: contentType.kind,
             isSingleType,
+            draftAndPublish: Boolean(contentType.options?.draftAndPublish),
             singularName: contentType.info?.singularName || uid,
             pluralName: contentType.info?.pluralName || uid,
             displayName: contentType.info?.displayName || uid,
@@ -1369,6 +1589,7 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
             uid,
             displayName: contentType.info?.displayName || uid,
             isSingleType,
+            draftAndPublish: Boolean(contentType.options?.draftAndPublish),
             entries: [],
             pagination: {
               page: 1,
@@ -1460,6 +1681,7 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
           uid,
           displayName: contentType.info?.displayName || uid,
           isSingleType: true,
+          draftAndPublish: Boolean(contentType.options?.draftAndPublish),
           entries: singleDoc ? [singleDoc] : [],
           pagination: {
             page: 1,
@@ -1503,6 +1725,7 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
           uid,
           displayName: contentType.info?.displayName || uid,
           isSingleType: false,
+          draftAndPublish: Boolean(contentType.options?.draftAndPublish),
           entries: (entries || []).map((entry) => ({
             id: entry.id,
             documentId: entry.documentId,
@@ -2003,6 +2226,199 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
         currentUser
       );
     },
+    /**
+     * Bulk Publish selected entries or collections
+     */
+    async batchPublish({
+      selectedEntries = [],
+      selectedCollections = [],
+      executionMode = "immediate",
+      makerNotes = "",
+      forceImmediate = false
+    }, currentUser) {
+      const executionConfig = getExecutionWindowConfig(strapi2);
+      const { isBusinessHours, policyMessage } = checkBusinessHours(executionConfig);
+      if (executionMode === "maker_checker") {
+        const summary = await computeTargetsSummary(strapi2, { selectedCollections, selectedEntries });
+        if (summary.totalTargets === 0) {
+          throw new Error("No collections or entries were selected to publish.");
+        }
+        const batchId = `batch_pub_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
+        const batch = {
+          id: batchId,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          createdBy: currentUser ? {
+            id: currentUser.id,
+            email: currentUser.email,
+            firstname: currentUser.firstname,
+            lastname: currentUser.lastname,
+            username: currentUser.username
+          } : { email: "admin@system.local" },
+          payload: { action: "publish", attribute: "(publish)", value: "published", selectedEntries, selectedCollections, publishOnApproval: true },
+          summary: {
+            attribute: "(publish)",
+            value: "published",
+            totalTargets: summary.totalTargets,
+            collectionBreakdown: summary.collectionBreakdown,
+            publishOnApproval: true
+          },
+          status: "pending_approval",
+          executionMode: "maker_checker",
+          makerNotes
+        };
+        pendingBatches.set(batchId, batch);
+        batchJobsMap.set(batchId, {
+          id: batchId,
+          createdAt: batch.createdAt,
+          createdBy: batch.createdBy,
+          status: "pending_approval",
+          executionMode: "maker_checker",
+          attribute: "(publish)",
+          value: "published",
+          totalTargets: summary.totalTargets,
+          processedCount: 0,
+          updatedCount: 0,
+          skippedCount: 0,
+          failedCount: 0,
+          isLive: false,
+          publishOnApproval: true,
+          makerNotes,
+          results: []
+        });
+        return {
+          success: true,
+          pending: true,
+          batchId,
+          status: "pending_approval",
+          message: "Bulk publish batch submitted for Checker authorization (4-Eyes Maker-Checker Workflow).",
+          batch
+        };
+      }
+      if (executionMode === "queue_offpeak") {
+        const summary = await computeTargetsSummary(strapi2, { selectedCollections, selectedEntries });
+        if (summary.totalTargets === 0) {
+          throw new Error("No collections or entries were selected to publish.");
+        }
+        const batchId = `batch_pub_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
+        const batch = {
+          id: batchId,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          createdBy: currentUser ? {
+            id: currentUser.id,
+            email: currentUser.email,
+            firstname: currentUser.firstname,
+            lastname: currentUser.lastname,
+            username: currentUser.username
+          } : { email: "admin@system.local" },
+          payload: { action: "publish", attribute: "(publish)", value: "published", selectedEntries, selectedCollections, publishOnApproval: true },
+          summary: {
+            attribute: "(publish)",
+            value: "published",
+            totalTargets: summary.totalTargets,
+            collectionBreakdown: summary.collectionBreakdown,
+            publishOnApproval: true
+          },
+          status: "queued_offpeak",
+          executionMode: "queue_offpeak",
+          scheduledFor: executionConfig.offPeakStartTime,
+          makerNotes
+        };
+        pendingBatches.set(batchId, batch);
+        batchJobsMap.set(batchId, {
+          id: batchId,
+          createdAt: batch.createdAt,
+          createdBy: batch.createdBy,
+          status: "queued_offpeak",
+          executionMode: "queue_offpeak",
+          scheduledFor: executionConfig.offPeakStartTime,
+          attribute: "(publish)",
+          value: "published",
+          totalTargets: summary.totalTargets,
+          processedCount: 0,
+          updatedCount: 0,
+          skippedCount: 0,
+          failedCount: 0,
+          isLive: false,
+          publishOnApproval: true,
+          makerNotes,
+          results: []
+        });
+        return {
+          success: true,
+          pending: true,
+          batchId,
+          status: "queued_offpeak",
+          scheduledFor: executionConfig.offPeakStartTime,
+          message: `Bulk publish batch queued for server off-peak maintenance window (${executionConfig.offPeakStartTime}).`,
+          batch
+        };
+      }
+      if (executionConfig.enabled && executionConfig.autoQueueDuringBusinessHours && isBusinessHours && !forceImmediate) {
+        const summary = await computeTargetsSummary(strapi2, { selectedCollections, selectedEntries });
+        if (summary.totalTargets === 0) {
+          throw new Error("No collections or entries were selected to publish.");
+        }
+        const batchId = `batch_pub_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
+        const batch = {
+          id: batchId,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          createdBy: currentUser ? {
+            id: currentUser.id,
+            email: currentUser.email,
+            firstname: currentUser.firstname,
+            lastname: currentUser.lastname,
+            username: currentUser.username
+          } : { email: "admin@system.local" },
+          payload: { action: "publish", attribute: "(publish)", value: "published", selectedEntries, selectedCollections, publishOnApproval: true },
+          summary: {
+            attribute: "(publish)",
+            value: "published",
+            totalTargets: summary.totalTargets,
+            collectionBreakdown: summary.collectionBreakdown,
+            publishOnApproval: true
+          },
+          status: "queued_offpeak",
+          executionMode: "queue_offpeak",
+          scheduledFor: executionConfig.offPeakStartTime,
+          makerNotes: "Automatically queued due to peak business hours restriction."
+        };
+        pendingBatches.set(batchId, batch);
+        batchJobsMap.set(batchId, {
+          id: batchId,
+          createdAt: batch.createdAt,
+          createdBy: batch.createdBy,
+          status: "queued_offpeak",
+          executionMode: "queue_offpeak",
+          scheduledFor: executionConfig.offPeakStartTime,
+          attribute: "(publish)",
+          value: "published",
+          totalTargets: summary.totalTargets,
+          processedCount: 0,
+          updatedCount: 0,
+          skippedCount: 0,
+          failedCount: 0,
+          isLive: false,
+          publishOnApproval: true,
+          policyMessage,
+          makerNotes: "Automatically queued due to peak business hours restriction.",
+          results: []
+        });
+        return {
+          success: true,
+          pending: true,
+          batchId,
+          status: "queued_offpeak",
+          scheduledFor: executionConfig.offPeakStartTime,
+          message: policyMessage,
+          batch
+        };
+      }
+      return await executePublishBatchInternal(
+        strapi2,
+        { selectedEntries, selectedCollections },
+        currentUser
+      );
+    },
     /**
      * Get Pending & Queued Batches
      */
@@ -2046,7 +2462,7 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
       const { isBusinessHours } = checkBusinessHours(config);
       if (options.executeImmediately || !isBusinessHours) {
         batch.status = "approved";
-        const result = await executeBatchInternal(strapi2, batch.payload, checkerUser, batch.id);
+        const result = batch.payload?.action === "publish" ? await executePublishBatchInternal(strapi2, batch.payload, checkerUser, batch.id) : await executeBatchInternal(strapi2, batch.payload, checkerUser, batch.id);
         batch.status = "executed";
         batch.executionResult = result;
         return {
@@ -2107,7 +2523,7 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
       if (batch.status === "executed") {
         throw new Error(`Batch ${batchId} has already been executed.`);
       }
-      const result = await executeBatchInternal(strapi2, batch.payload, currentUser, batch.id);
+      const result = batch.payload?.action === "publish" ? await executePublishBatchInternal(strapi2, batch.payload, currentUser, batch.id) : await executeBatchInternal(strapi2, batch.payload, currentUser, batch.id);
       batch.status = "executed";
       batch.executionResult = result;
       return {
@@ -2207,7 +2623,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;
@@ -2251,7 +2671,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,
@@ -3075,23 +3495,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 += '"';
@@ -3151,6 +3582,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
@@ -3199,9 +3727,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,
@@ -3209,65 +3735,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 } });
@@ -3280,34 +3801,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)
     };
   },
   /**
@@ -3347,11 +3871,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
    */