fix(plugin-import-export): json preview and downloads preserve nesting and exclude disabled fields (#13210)

### What?

Improves both the JSON preview and export functionality in the
import-export plugin:
- Preserves proper nesting of object and array fields (e.g., groups,
tabs, arrays)
- Excludes any fields explicitly marked as `disabled` via
`custom.plugin-import-export`
- Ensures downloaded files use proper JSON formatting when `format` is
`json` (no CSV-style flattening)

### Why?

Previously:
- The JSON preview flattened all fields to a single level and included
disabled fields.
- Exported files with `format: json` were still CSV-style data encoded
as `.json`, rather than real JSON.

### How?

- Refactored `/preview-data` JSON handling to preserve original document
shape.
- Applied `removeDisabledFields` to clean nested fields using
dot-notation paths.
- Updated `createExport` to skip `flattenObject` for JSON formats, using
a nested JSON filter instead.
- Fixed streaming and buffered export paths to output valid JSON arrays
when `format` is `json`.

Author: PatrikKozak

packages/plugin-import-export/src/components/Preview/index.tsx

@@ -68,6 +68,7 @@ export const Preview = () => {
             collectionSlug,
             draft,
             fields,
+            format,
             limit,
             locale,
             sort,
@@ -115,8 +116,13 @@ export const Preview = () => {
 
         const fieldKeys =
           Array.isArray(fields) && fields.length > 0
-            ? selectedKeys // strictly only what was selected
-            : [...selectedKeys, ...defaultMetaFields.filter((key) => allKeys.includes(key))]
+            ? selectedKeys // strictly use selected fields only
+            : [
+                ...selectedKeys,
+                ...defaultMetaFields.filter(
+                  (key) => allKeys.includes(key) && !selectedKeys.includes(key),
+                ),
+              ]
 
         // Build columns based on flattened keys
         const newColumns: Column[] = fieldKeys.map((key) => ({
@@ -158,6 +164,7 @@ export const Preview = () => {
     disabledFieldRegexes,
     draft,
     fields,
+    format,
     i18n,
     limit,
     locale,

packages/plugin-import-export/src/export/createExport.ts

@@ -114,7 +114,7 @@ export const createExport = async (args: CreateExportArgs) => {
 
   const disabledRegexes: RegExp[] = disabledFields.map(buildDisabledFieldRegex)
 
-  const filterDisabled = (row: Record<string, unknown>): Record<string, unknown> => {
+  const filterDisabledCSV = (row: Record<string, unknown>): Record<string, unknown> => {
     const filtered: Record<string, unknown> = {}
 
     for (const [key, value] of Object.entries(row)) {
@@ -127,35 +127,62 @@ export const createExport = async (args: CreateExportArgs) => {
     return filtered
   }
 
+  const filterDisabledJSON = (doc: any, parentPath = ''): any => {
+    if (Array.isArray(doc)) {
+      return doc.map((item) => filterDisabledJSON(item, parentPath))
+    }
+
+    if (typeof doc !== 'object' || doc === null) {
+      return doc
+    }
+
+    const filtered: Record<string, any> = {}
+    for (const [key, value] of Object.entries(doc)) {
+      const currentPath = parentPath ? `${parentPath}.${key}` : key
+
+      // Only remove if this exact path is disabled
+      const isDisabled = disabledFields.includes(currentPath)
+
+      if (!isDisabled) {
+        filtered[key] = filterDisabledJSON(value, currentPath)
+      }
+    }
+
+    return filtered
+  }
+
   if (download) {
     if (debug) {
       req.payload.logger.debug('Pre-scanning all columns before streaming')
     }
 
-    const allColumnsSet = new Set<string>()
     const allColumns: string[] = []
-    let scanPage = 1
-    let hasMore = true
-
-    while (hasMore) {
-      const result = await payload.find({ ...findArgs, page: scanPage })
-
-      result.docs.forEach((doc) => {
-        const flat = filterDisabled(flattenObject({ doc, fields, toCSVFunctions }))
-        Object.keys(flat).forEach((key) => {
-          if (!allColumnsSet.has(key)) {
-            allColumnsSet.add(key)
-            allColumns.push(key)
-          }
+
+    if (isCSV) {
+      const allColumnsSet = new Set<string>()
+      let scanPage = 1
+      let hasMore = true
+
+      while (hasMore) {
+        const result = await payload.find({ ...findArgs, page: scanPage })
+
+        result.docs.forEach((doc) => {
+          const flat = filterDisabledCSV(flattenObject({ doc, fields, toCSVFunctions }))
+          Object.keys(flat).forEach((key) => {
+            if (!allColumnsSet.has(key)) {
+              allColumnsSet.add(key)
+              allColumns.push(key)
+            }
+          })
         })
-      })
 
-      hasMore = result.hasNextPage
-      scanPage += 1
-    }
+        hasMore = result.hasNextPage
+        scanPage += 1
+      }
 
-    if (debug) {
-      req.payload.logger.debug(`Discovered ${allColumns.length} columns`)
+      if (debug) {
+        req.payload.logger.debug(`Discovered ${allColumns.length} columns`)
+      }
     }
 
     const encoder = new TextEncoder()
@@ -171,35 +198,58 @@ export const createExport = async (args: CreateExportArgs) => {
         }
 
         if (result.docs.length === 0) {
+          // Close JSON array properly if JSON
+          if (!isCSV) {
+            this.push(encoder.encode(']'))
+          }
           this.push(null)
           return
         }
 
-        const batchRows = result.docs.map((doc) =>
-          filterDisabled(flattenObject({ doc, fields, toCSVFunctions })),
-        )
-
-        const paddedRows = batchRows.map((row) => {
-          const fullRow: Record<string, unknown> = {}
-          for (const col of allColumns) {
-            fullRow[col] = row[col] ?? ''
+        if (isCSV) {
+          // --- CSV Streaming ---
+          const batchRows = result.docs.map((doc) =>
+            filterDisabledCSV(flattenObject({ doc, fields, toCSVFunctions })),
+          )
+
+          const paddedRows = batchRows.map((row) => {
+            const fullRow: Record<string, unknown> = {}
+            for (const col of allColumns) {
+              fullRow[col] = row[col] ?? ''
+            }
+            return fullRow
+          })
+
+          const csvString = stringify(paddedRows, {
+            header: isFirstBatch,
+            columns: allColumns,
+          })
+
+          this.push(encoder.encode(csvString))
+        } else {
+          // --- JSON Streaming ---
+          const batchRows = result.docs.map((doc) => filterDisabledJSON(doc))
+
+          // Convert each filtered/flattened row into JSON string
+          const batchJSON = batchRows.map((row) => JSON.stringify(row)).join(',')
+
+          if (isFirstBatch) {
+            this.push(encoder.encode('[' + batchJSON))
+          } else {
+            this.push(encoder.encode(',' + batchJSON))
           }
-          return fullRow
-        })
-
-        const csvString = stringify(paddedRows, {
-          header: isFirstBatch,
-          columns: allColumns,
-        })
+        }
 
-        this.push(encoder.encode(csvString))
         isFirstBatch = false
         streamPage += 1
 
         if (!result.hasNextPage) {
           if (debug) {
             req.payload.logger.debug('Stream complete - no more pages')
           }
+          if (!isCSV) {
+            this.push(encoder.encode(']'))
+          }
           this.push(null) // End the stream
         }
       },
@@ -239,7 +289,7 @@ export const createExport = async (args: CreateExportArgs) => {
 
     if (isCSV) {
       const batchRows = result.docs.map((doc) =>
-        filterDisabled(flattenObject({ doc, fields, toCSVFunctions })),
+        filterDisabledCSV(flattenObject({ doc, fields, toCSVFunctions })),
       )
 
       // Track discovered column keys
@@ -254,8 +304,8 @@ export const createExport = async (args: CreateExportArgs) => {
 
       rows.push(...batchRows)
     } else {
-      const jsonInput = result.docs.map((doc) => JSON.stringify(doc))
-      outputData.push(jsonInput.join(',\n'))
+      const batchRows = result.docs.map((doc) => filterDisabledJSON(doc))
+      outputData.push(batchRows.map((doc) => JSON.stringify(doc)).join(',\n'))
     }
 
     hasNextPage = result.hasNextPage

packages/plugin-import-export/src/index.ts

@@ -13,6 +13,9 @@ import { getExportCollection } from './getExportCollection.js'
 import { translations } from './translations/index.js'
 import { collectDisabledFieldPaths } from './utilities/collectDisabledFieldPaths.js'
 import { getFlattenedFieldKeys } from './utilities/getFlattenedFieldKeys.js'
+import { getValueAtPath } from './utilities/getvalueAtPath.js'
+import { removeDisabledFields } from './utilities/removeDisabledFields.js'
+import { setNestedValue } from './utilities/setNestedValue.js'
 
 export const importExportPlugin =
   (pluginConfig: ImportExportPluginConfig) =>
@@ -91,6 +94,7 @@ export const importExportPlugin =
           collectionSlug: string
           draft?: 'no' | 'yes'
           fields?: string[]
+          format?: 'csv' | 'json'
           limit?: number
           locale?: string
           sort?: any
@@ -120,29 +124,58 @@ export const importExportPlugin =
           where,
         })
 
+        const isCSV = req?.data?.format === 'csv'
         const docs = result.docs
 
-        const toCSVFunctions = getCustomFieldFunctions({
-          fields: collection.config.fields as FlattenedField[],
-        })
+        let transformed: Record<string, unknown>[] = []
+
+        if (isCSV) {
+          const toCSVFunctions = getCustomFieldFunctions({
+            fields: collection.config.fields as FlattenedField[],
+          })
+
+          const possibleKeys = getFlattenedFieldKeys(collection.config.fields as FlattenedField[])
 
-        const possibleKeys = getFlattenedFieldKeys(collection.config.fields as FlattenedField[])
+          transformed = docs.map((doc) => {
+            const row = flattenObject({
+              doc,
+              fields,
+              toCSVFunctions,
+            })
 
-        const transformed = docs.map((doc) => {
-          const row = flattenObject({
-            doc,
-            fields,
-            toCSVFunctions,
+            for (const key of possibleKeys) {
+              if (!(key in row)) {
+                row[key] = null
+              }
+            }
+
+            return row
           })
+        } else {
+          const disabledFields =
+            collection.config.admin.custom?.['plugin-import-export']?.disabledFields
+
+          transformed = docs.map((doc) => {
+            let output: Record<string, unknown> = { ...doc }
 
-          for (const key of possibleKeys) {
-            if (!(key in row)) {
-              row[key] = null
+            // Remove disabled fields first
+            output = removeDisabledFields(output, disabledFields)
+
+            // Then trim to selected fields only (if fields are provided)
+            if (Array.isArray(fields) && fields.length > 0) {
+              const trimmed: Record<string, unknown> = {}
+
+              for (const key of fields) {
+                const value = getValueAtPath(output, key)
+                setNestedValue(trimmed, key, value ?? null)
+              }
+
+              output = trimmed
             }
-          }
 
-          return row
-        })
+            return output
+          })
+        }
 
         return Response.json({
           docs: transformed,

packages/plugin-import-export/src/utilities/getFlattenedFieldKeys.ts

@@ -22,21 +22,18 @@ export const getFlattenedFieldKeys = (fields: FieldWithPresentational[], prefix
       'plugin-import-export' in field.custom &&
       field.custom['plugin-import-export']?.toCSV
 
-    if (!('name' in field) || typeof field.name !== 'string' || fieldHasToCSVFunction) {
-      return
-    }
-
-    const name = prefix ? `${prefix}_${field.name}` : field.name
+    const name = 'name' in field && typeof field.name === 'string' ? field.name : undefined
+    const fullKey = name && prefix ? `${prefix}_${name}` : (name ?? prefix)
 
     switch (field.type) {
       case 'array': {
-        const subKeys = getFlattenedFieldKeys(field.fields as FlattenedField[], `${name}_0`)
+        const subKeys = getFlattenedFieldKeys(field.fields as FlattenedField[], `${fullKey}_0`)
         keys.push(...subKeys)
         break
       }
       case 'blocks': {
         field.blocks.forEach((block) => {
-          const blockPrefix = `${name}_0_${block.slug}`
+          const blockPrefix = `${fullKey}_0_${block.slug}`
           keys.push(`${blockPrefix}_blockType`)
           keys.push(`${blockPrefix}_id`)
           keys.push(...getFlattenedFieldKeys(block.fields as FlattenedField[], blockPrefix))
@@ -46,45 +43,42 @@ export const getFlattenedFieldKeys = (fields: FieldWithPresentational[], prefix
       case 'collapsible':
       case 'group':
       case 'row':
-        keys.push(...getFlattenedFieldKeys(field.fields as FlattenedField[], name))
+        keys.push(...getFlattenedFieldKeys(field.fields as FlattenedField[], fullKey))
         break
       case 'relationship':
         if (field.hasMany) {
           if (Array.isArray(field.relationTo)) {
             // hasMany polymorphic
-            keys.push(`${name}_0_relationTo`, `${name}_0_id`)
+            keys.push(`${fullKey}_0_relationTo`, `${fullKey}_0_id`)
           } else {
             // hasMany monomorphic
-            keys.push(`${name}_0`)
+            keys.push(`${fullKey}_0`)
           }
         } else {
           if (Array.isArray(field.relationTo)) {
             // hasOne polymorphic
-            keys.push(`${name}_relationTo`, `${name}_id`)
+            keys.push(`${fullKey}_relationTo`, `${fullKey}_id`)
           } else {
             // hasOne monomorphic
-            keys.push(name)
+            keys.push(fullKey)
           }
         }
         break
       case 'tabs':
-        if (field.tabs) {
-          field.tabs.forEach((tab) => {
-            if (tab.name) {
-              const tabPrefix = prefix ? `${prefix}_${tab.name}` : tab.name
-              keys.push(...getFlattenedFieldKeys(tab.fields, tabPrefix))
-            } else {
-              keys.push(...getFlattenedFieldKeys(tab.fields, prefix))
-            }
-          })
-        }
+        field.tabs?.forEach((tab) => {
+          const tabPrefix = tab.name ? `${fullKey}_${tab.name}` : fullKey
+          keys.push(...getFlattenedFieldKeys(tab.fields || [], tabPrefix))
+        })
         break
       default:
+        if (!name || fieldHasToCSVFunction) {
+          break
+        }
         if ('hasMany' in field && field.hasMany) {
           // Push placeholder for first index
-          keys.push(`${name}_0`)
+          keys.push(`${fullKey}_0`)
         } else {
-          keys.push(name)
+          keys.push(fullKey)
         }
         break
     }