fix(plugin-import-export): preview table to include all selected columns regardless of populated data (#12985)

### What?

Ensure the export preview table includes all field keys as columns, even
if those fields are not populated in any of the returned documents.

### Why?

Previously, if none of the documents in the preview result had a value
for a given field, that column would be missing entirely from the
preview table.

### How?

- Introduced a `getFlattenedFieldKeys` utility that recursively extracts
all missing flattened field accessors from the collection’s config that
are undefined

- Updates the preview UI logic to build columns from all flattened keys,
not just the first document

Author: PatrikKozak

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

@@ -74,11 +74,12 @@ export const Preview = () => {
           return
         }
 
-        const { docs, totalDocs } = await res.json()
+        const { docs, totalDocs }: { docs: Record<string, unknown>[]; totalDocs: number } =
+          await res.json()
 
         setResultCount(limit && limit < totalDocs ? limit : totalDocs)
 
-        const allKeys = Object.keys(docs[0] || {})
+        const allKeys = Array.from(new Set(docs.flatMap((doc) => Object.keys(doc))))
         const defaultMetaFields = ['createdAt', 'updatedAt', '_status', 'id']
 
         // Match CSV column ordering by building keys based on fields and regex
@@ -96,13 +97,10 @@ export const Preview = () => {
               })
             : allKeys.filter((key) => !defaultMetaFields.includes(key))
 
-        const includedMeta = new Set(selectedKeys)
-        const missingMetaFields = defaultMetaFields.flatMap((field) => {
-          const regex = fieldToRegex(field)
-          return allKeys.filter((key) => regex.test(key) && !includedMeta.has(key))
-        })
-
-        const fieldKeys = [...selectedKeys, ...missingMetaFields]
+        const fieldKeys =
+          Array.isArray(fields) && fields.length > 0
+            ? selectedKeys // strictly only what was selected
+            : [...selectedKeys, ...defaultMetaFields.filter((key) => allKeys.includes(key))]
 
         // Build columns based on flattened keys
         const newColumns: Column[] = fieldKeys.map((key) => ({

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

@@ -11,6 +11,7 @@ import { getCustomFieldFunctions } from './export/getCustomFieldFunctions.js'
 import { getSelect } from './export/getSelect.js'
 import { getExportCollection } from './getExportCollection.js'
 import { translations } from './translations/index.js'
+import { getFlattenedFieldKeys } from './utilities/getFlattenedFieldKeys.js'
 
 export const importExportPlugin =
   (pluginConfig: ImportExportPluginConfig) =>
@@ -112,13 +113,23 @@ export const importExportPlugin =
           select,
         })
 
-        const transformed = docs.map((doc) =>
-          flattenObject({
+        const possibleKeys = getFlattenedFieldKeys(collection.config.fields as FlattenedField[])
+
+        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
+        })
 
         return Response.json({
           docs: transformed,

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

@@ -0,0 +1,75 @@
+import { type FlattenedField } from 'payload'
+
+type FieldWithPresentational =
+  | {
+      fields?: FlattenedField[]
+      name?: string
+      tabs?: {
+        fields: FlattenedField[]
+        name?: string
+      }[]
+      type: 'collapsible' | 'row' | 'tabs'
+    }
+  | FlattenedField
+
+export const getFlattenedFieldKeys = (fields: FieldWithPresentational[], prefix = ''): string[] => {
+  const keys: string[] = []
+
+  fields.forEach((field) => {
+    if (!('name' in field) || typeof field.name !== 'string') {
+      return
+    }
+
+    const name = prefix ? `${prefix}_${field.name}` : field.name
+
+    switch (field.type) {
+      case 'array': {
+        const subKeys = getFlattenedFieldKeys(field.fields as FlattenedField[], `${name}_0`)
+        keys.push(...subKeys)
+        break
+      }
+      case 'blocks':
+        field.blocks.forEach((block) => {
+          const blockKeys = getFlattenedFieldKeys(block.fields as FlattenedField[], `${name}_0`)
+          keys.push(...blockKeys)
+        })
+        break
+      case 'collapsible':
+      case 'group':
+      case 'row':
+        keys.push(...getFlattenedFieldKeys(field.fields as FlattenedField[], name))
+        break
+      case 'relationship':
+        if (field.hasMany) {
+          // e.g. hasManyPolymorphic_0_value_id
+          keys.push(`${name}_0_relationTo`, `${name}_0_value_id`)
+        } else {
+          // e.g. hasOnePolymorphic_id
+          keys.push(`${name}_id`, `${name}_relationTo`)
+        }
+        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))
+            }
+          })
+        }
+        break
+      default:
+        if ('hasMany' in field && field.hasMany) {
+          // Push placeholder for first index
+          keys.push(`${name}_0`)
+        } else {
+          keys.push(name)
+        }
+        break
+    }
+  })
+
+  return keys
+}

test/plugin-import-export/payload-types.ts

@@ -143,6 +143,13 @@ export interface User {
   hash?: string | null;
   loginAttempts?: number | null;
   lockUntil?: string | null;
+  sessions?:
+    | {
+        id: string;
+        createdAt?: string | null;
+        expiresAt: string;
+      }[]
+    | null;
   password?: string | null;
 }
 /**
@@ -502,6 +509,13 @@ export interface UsersSelect<T extends boolean = true> {
   hash?: T;
   loginAttempts?: T;
   lockUntil?: T;
+  sessions?:
+    | T
+    | {
+        id?: T;
+        createdAt?: T;
+        expiresAt?: T;
+      };
 }
 /**
  * This interface was referenced by `Config`'s JSON-Schema