strapi-plugin-bulk-updater 1.2.13 → 1.3.1

package/dist/server/index.mjs

@@ -315,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,
@@ -679,6 +680,132 @@ 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 void 0;
+  const populate2 = {};
+  for (const [key, def] of Object.entries(attributes || {})) {
+    if (def.type === "component" && def.component) {
+      const comp = allComponents[def.component];
+      if (comp?.attributes) {
+        const subPopulate = buildDeepPopulate$1(comp.attributes, allComponents, depth2 + 1);
+        if (subPopulate && Object.keys(subPopulate).length > 0) {
+          populate2[key] = {
+            populate: subPopulate
+          };
+        } else {
+          populate2[key] = true;
+        }
+      } 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 : void 0;
+}
+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";
@@ -887,43 +1014,30 @@ 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]
-            });
-            const existingParent = currentEntryWithPopulate?.[parentKey] || {};
-            const currentVal2 = existingParent?.[childKey];
+            const populateOption = buildDeepPopulate$1(contentType.attributes, strapi2.components);
+            const findOneArgs = { documentId: target.documentId };
+            if (populateOption) {
+              findOneArgs.populate = populateOption;
+            }
+            const currentEntryWithPopulate = await strapi2.documents(target.uid).findOne(findOneArgs);
+            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);
@@ -1358,12 +1472,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;
@@ -1371,14 +1487,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;
             }
@@ -1397,12 +1518,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,
@@ -1412,11 +1540,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
@@ -1447,32 +1577,27 @@ 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
-                });
+                const singleArgs = {};
+                if (populateOption) {
+                  singleArgs.populate = populateOption;
+                }
+                const singleDoc = await strapi2.documents(uid).findFirst(singleArgs);
                 if (singleDoc) {
                   entries = [singleDoc];
                   totalCount = 1;
                 }
               } else {
                 totalCount = await strapi2.documents(uid).count();
-                entries = await strapi2.documents(uid).findMany({
+                const findArgs = {
                   limit: 10,
-                  sort: { createdAt: "desc" },
-                  populate: populateOption
-                });
+                  sort: { createdAt: "desc" }
+                };
+                if (populateOption) {
+                  findArgs.populate = populateOption;
+                }
+                entries = await strapi2.documents(uid).findMany(findArgs);
               }
             } catch (err) {
               strapi2.log.error(`[bulk-updater] Failed to fetch entries for ${uid}:`, err);
@@ -1516,8 +1641,10 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
       return {
         success: true,
         attributes: staticSchemaCache.attributes,
+        attributesMeta: staticSchemaCache.attributesMeta,
         collections,
         relationsMeta: staticSchemaCache.relationsMeta,
+        maxDiscoveredDepth: 5,
         executionWindow: {
           ...executionConfig,
           ...windowStatus
@@ -1536,6 +1663,7 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
       page = 1,
       pageSize = 10,
       attribute,
+      searchAttribute,
       filterOperator,
       filterQuery,
       search,
@@ -1550,8 +1678,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) {
@@ -1566,19 +1695,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;
         }
       }
@@ -1603,7 +1728,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 };
@@ -1633,19 +1758,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;
             }
           }
         }
@@ -1668,12 +1792,17 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
           }
         }
       }
+      const populateOption = buildDeepPopulate$1(contentType.attributes, strapi2.components);
       if (isSingleType) {
         let singleDoc = null;
         try {
-          singleDoc = await strapi2.documents(uid).findFirst({
+          const singleArgs = {
             filters: Object.keys(filters2).length > 0 ? filters2 : void 0
-          });
+          };
+          if (populateOption) {
+            singleArgs.populate = populateOption;
+          }
+          singleDoc = await strapi2.documents(uid).findFirst(singleArgs);
         } catch {
           singleDoc = null;
         }
@@ -1691,11 +1820,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";
           }
@@ -1704,18 +1833,17 @@ 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 findManyArgs = {
+          start,
+          limit,
+          filters: Object.keys(filters2).length > 0 ? filters2 : void 0,
+          sort: sortClause
+        };
+        if (populateOption) {
+          findManyArgs.populate = populateOption;
+        }
         const [entries, totalEntries] = await Promise.all([
-          strapi2.documents(uid).findMany({
-            start,
-            limit,
-            filters: Object.keys(filters2).length > 0 ? filters2 : void 0,
-            sort: sortClause,
-            populate: populateOption
-          }),
+          strapi2.documents(uid).findMany(findManyArgs),
           strapi2.documents(uid).count({
             filters: Object.keys(filters2).length > 0 ? filters2 : void 0
           })
@@ -1829,21 +1957,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) {
@@ -1866,10 +1980,12 @@ const bulkUpdaterService = ({ strapi: strapi2 }) => {
           }
           let currentEntry;
           if (isComponentNested) {
-            currentEntry = await strapi2.documents(target.uid).findOne({
-              documentId: target.documentId,
-              populate: [parentKey]
-            });
+            const findOneArgs = { documentId: target.documentId };
+            const populateOption = buildDeepPopulate$1(contentType.attributes, strapi2.components);
+            if (populateOption) {
+              findOneArgs.populate = populateOption;
+            }
+            currentEntry = await strapi2.documents(target.uid).findOne(findOneArgs);
           } else if (attrDef?.type === "relation") {
             currentEntry = await strapi2.documents(target.uid).findOne({
               documentId: target.documentId,
@@ -1882,8 +1998,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);
@@ -3619,15 +3734,20 @@ function discoverExportFields(ct, allComponents, maxDepth = 4) {
   return fields2;
 }
 function buildDeepPopulate(attributes, allComponents, depth2 = 0) {
-  if (depth2 > 4) return true;
+  if (depth2 > 5) return void 0;
   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)
-        };
+        const subPopulate = buildDeepPopulate(comp.attributes, allComponents, depth2 + 1);
+        if (subPopulate && Object.keys(subPopulate).length > 0) {
+          populate2[key] = {
+            populate: subPopulate
+          };
+        } else {
+          populate2[key] = true;
+        }
       } else {
         populate2[key] = true;
       }
@@ -3637,7 +3757,7 @@ function buildDeepPopulate(attributes, allComponents, depth2 = 0) {
       populate2[key] = true;
     }
   }
-  return Object.keys(populate2).length > 0 ? populate2 : true;
+  return Object.keys(populate2).length > 0 ? populate2 : void 0;
 }
 function getNestedExportValue(entry, path2) {
   if (!entry || !path2) return "";
@@ -3804,17 +3924,22 @@ const csvService = ({ strapi: strapi2 }) => ({
     const deepPopulate = buildDeepPopulate(ct.attributes || {}, allComponents);
     let entries = [];
     if (ct.kind === "singleType") {
-      const doc = await strapi2.documents(uid).findFirst({
-        populate: deepPopulate
-      });
+      const findFirstArgs = {};
+      if (deepPopulate) {
+        findFirstArgs.populate = deepPopulate;
+      }
+      const doc = await strapi2.documents(uid).findFirst(findFirstArgs);
       entries = doc ? [doc] : [];
     } else {
-      entries = await strapi2.documents(uid).findMany({
+      const findManyArgs = {
         filters: Object.keys(filters2).length > 0 ? filters2 : void 0,
         limit: options.limit || 5e3,
-        sort: { createdAt: "desc" },
-        populate: deepPopulate
-      });
+        sort: { createdAt: "desc" }
+      };
+      if (deepPopulate) {
+        findManyArgs.populate = deepPopulate;
+      }
+      entries = await strapi2.documents(uid).findMany(findManyArgs);
     }
     const lines = [];
     lines.push(fields2.map((f) => escapeCsvValue(f.key)).join(","));