strapi-plugin-bulk-updater 1.2.12 → 1.2.13

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",
@@ -569,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;
@@ -2581,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;
@@ -2625,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,
@@ -3449,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 += '"';
@@ -3525,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
@@ -3573,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,
@@ -3583,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 } });
@@ -3654,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)
     };
   },
   /**
@@ -3721,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
    */