@payloadcms/plugin-import-export 3.84.1 → 3.85.0

package/dist/utilities/siblingDoc.spec.js

@@ -0,0 +1,278 @@
+import { applyFieldHooks } from './applyFieldHooks.js';
+import { flattenObject } from './flattenObject.js';
+import { getExportFieldFunctions } from './getExportFieldFunctions.js';
+import { getImportFieldFunctions } from './getImportFieldFunctions.js';
+import { unflattenObject } from './unflattenObject.js';
+import { describe, expect, it, vi } from 'vitest';
+const mockReq = {
+    payload: {
+        logger: {
+            error: vi.fn()
+        }
+    }
+};
+describe('beforeExport / beforeImport siblingDoc arg', ()=>{
+    describe('CSV export (flattenObject)', ()=>{
+        it('passes the source doc at the current nesting level as siblingDoc', ()=>{
+            const received = [];
+            const fields = [
+                {
+                    name: 'title',
+                    type: 'text'
+                },
+                {
+                    name: 'group',
+                    type: 'group',
+                    flattenedFields: [
+                        {
+                            name: 'inner',
+                            type: 'text',
+                            custom: {
+                                'plugin-import-export': {
+                                    hooks: {
+                                        beforeExport: ({ columnName, siblingData, siblingDoc, value })=>{
+                                            received.push({
+                                                columnName,
+                                                isSiblingDocSource: siblingDoc && typeof siblingDoc === 'object' && siblingDoc.inner === value,
+                                                isSiblingDocRow: siblingDoc === siblingData
+                                            });
+                                            return value;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    ]
+                }
+            ];
+            const exportFieldHooks = getExportFieldFunctions({
+                fields
+            });
+            flattenObject({
+                data: {
+                    group: {
+                        inner: 'deep'
+                    },
+                    title: 'Top'
+                },
+                exportFieldHooks,
+                format: 'csv',
+                req: mockReq
+            });
+            expect(received).toEqual([
+                {
+                    columnName: 'group_inner',
+                    isSiblingDocSource: true,
+                    isSiblingDocRow: false
+                }
+            ]);
+        });
+        it('lets a hook read another sibling by reading siblingDoc', ()=>{
+            const fields = [
+                {
+                    name: 'firstName',
+                    type: 'text'
+                },
+                {
+                    name: 'fullName',
+                    type: 'text',
+                    custom: {
+                        'plugin-import-export': {
+                            hooks: {
+                                beforeExport: ({ siblingDoc, value })=>{
+                                    const last = siblingDoc.lastName;
+                                    const first = siblingDoc.firstName;
+                                    if (first && last) {
+                                        return `${first} ${last}`;
+                                    }
+                                    return value;
+                                }
+                            }
+                        }
+                    }
+                },
+                {
+                    name: 'lastName',
+                    type: 'text'
+                }
+            ];
+            const exportFieldHooks = getExportFieldFunctions({
+                fields
+            });
+            const result = flattenObject({
+                data: {
+                    firstName: 'Ada',
+                    fullName: '(computed)',
+                    lastName: 'Lovelace'
+                },
+                exportFieldHooks,
+                format: 'csv',
+                req: mockReq
+            });
+            expect(result.fullName).toBe('Ada Lovelace');
+        });
+    });
+    describe('JSON export (applyFieldHooks)', ()=>{
+        it('passes the untouched source sibling as siblingDoc and the mutable output as siblingData', ()=>{
+            let capturedSiblingDoc = null;
+            let capturedSiblingData = null;
+            const fields = [
+                {
+                    name: 'outer',
+                    type: 'group',
+                    flattenedFields: [
+                        {
+                            name: 'tracked',
+                            type: 'text',
+                            custom: {
+                                'plugin-import-export': {
+                                    hooks: {
+                                        beforeExport: ({ siblingData, siblingDoc, value })=>{
+                                            capturedSiblingDoc = siblingDoc;
+                                            capturedSiblingData = siblingData;
+                                            siblingData.injected = 'written-into-output';
+                                            return String(value) + '_changed';
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    ]
+                }
+            ];
+            const exportFieldHooks = getExportFieldFunctions({
+                fields
+            });
+            const source = {
+                outer: {
+                    tracked: 'original'
+                }
+            };
+            applyFieldHooks({
+                data: source,
+                fieldHooks: exportFieldHooks,
+                fields,
+                format: 'json',
+                operation: 'export',
+                req: mockReq,
+                type: 'beforeExport'
+            });
+            expect(capturedSiblingDoc).toEqual({
+                tracked: 'original'
+            });
+            // The hook's mutation lives on siblingData, not siblingDoc
+            expect(capturedSiblingData?.injected).toBe('written-into-output');
+            expect(capturedSiblingDoc?.injected).toBeUndefined();
+            // And the source object itself is not mutated
+            expect(source).toEqual({
+                outer: {
+                    tracked: 'original'
+                }
+            });
+        });
+    });
+    describe('CSV import (unflattenObject)', ()=>{
+        it('passes the full flat row as siblingDoc (equal to data)', ()=>{
+            const received = [];
+            const fields = [
+                {
+                    name: 'title',
+                    type: 'text'
+                },
+                {
+                    name: 'note',
+                    type: 'text',
+                    custom: {
+                        'plugin-import-export': {
+                            hooks: {
+                                beforeImport: ({ data, siblingDoc, value })=>{
+                                    received.push({
+                                        siblingDocIsData: siblingDoc === data
+                                    });
+                                    return value;
+                                }
+                            }
+                        }
+                    }
+                }
+            ];
+            const importFieldHooks = getImportFieldFunctions({
+                fields
+            });
+            unflattenObject({
+                data: {
+                    note: 'hello',
+                    title: 'Top'
+                },
+                fields,
+                format: 'csv',
+                importFieldHooks,
+                req: mockReq
+            });
+            expect(received).toEqual([
+                {
+                    siblingDocIsData: true
+                }
+            ]);
+        });
+    });
+    describe('JSON import (applyFieldHooks)', ()=>{
+        it('passes the untouched source sibling as siblingDoc and the mutable output as siblingData', ()=>{
+            let capturedSiblingDoc = null;
+            let capturedSiblingData = null;
+            const fields = [
+                {
+                    name: 'outer',
+                    type: 'group',
+                    flattenedFields: [
+                        {
+                            name: 'tracked',
+                            type: 'text',
+                            custom: {
+                                'plugin-import-export': {
+                                    hooks: {
+                                        beforeImport: ({ siblingData, siblingDoc, value })=>{
+                                            capturedSiblingDoc = siblingDoc;
+                                            capturedSiblingData = siblingData;
+                                            siblingData.injected = 'written-into-output';
+                                            return value;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    ]
+                }
+            ];
+            const importFieldHooks = getImportFieldFunctions({
+                fields
+            });
+            const source = {
+                outer: {
+                    tracked: 'original'
+                }
+            };
+            applyFieldHooks({
+                data: source,
+                fieldHooks: importFieldHooks,
+                fields,
+                format: 'json',
+                operation: 'import',
+                req: mockReq,
+                type: 'beforeImport'
+            });
+            expect(capturedSiblingDoc).toEqual({
+                tracked: 'original'
+            });
+            expect(capturedSiblingData?.injected).toBe('written-into-output');
+            expect(capturedSiblingDoc?.injected).toBeUndefined();
+            expect(source).toEqual({
+                outer: {
+                    tracked: 'original'
+                }
+            });
+        });
+    });
+});
+
+//# sourceMappingURL=siblingDoc.spec.js.map

package/dist/utilities/siblingDoc.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/siblingDoc.spec.ts"],"sourcesContent":["import { FlattenedField, PayloadRequest } from 'payload'\n\nimport type { FieldBeforeExportHook, FieldBeforeImportHook } from '../types.js'\n\nimport { applyFieldHooks } from './applyFieldHooks.js'\nimport { flattenObject } from './flattenObject.js'\nimport { getExportFieldFunctions } from './getExportFieldFunctions.js'\nimport { getImportFieldFunctions } from './getImportFieldFunctions.js'\nimport { unflattenObject } from './unflattenObject.js'\n\nimport { describe, expect, it, vi } from 'vitest'\n\nconst mockReq = {\n  payload: {\n    logger: {\n      error: vi.fn(),\n    },\n  },\n} as unknown as PayloadRequest\n\ndescribe('beforeExport / beforeImport siblingDoc arg', () => {\n  describe('CSV export (flattenObject)', () => {\n    it('passes the source doc at the current nesting level as siblingDoc', () => {\n      const received: Array<{\n        columnName: string\n        isSiblingDocSource: boolean\n        isSiblingDocRow: boolean\n      }> = []\n\n      const fields: FlattenedField[] = [\n        { name: 'title', type: 'text' } as FlattenedField,\n        {\n          name: 'group',\n          type: 'group',\n          flattenedFields: [\n            {\n              name: 'inner',\n              type: 'text',\n              custom: {\n                'plugin-import-export': {\n                  hooks: {\n                    beforeExport: (({ columnName, siblingData, siblingDoc, value }) => {\n                      received.push({\n                        columnName,\n                        isSiblingDocSource:\n                          siblingDoc &&\n                          typeof siblingDoc === 'object' &&\n                          siblingDoc.inner === value,\n                        isSiblingDocRow: siblingDoc === siblingData,\n                      })\n                      return value\n                    }) satisfies FieldBeforeExportHook,\n                  },\n                },\n              },\n            },\n          ],\n        } as unknown as FlattenedField,\n      ]\n\n      const exportFieldHooks = getExportFieldFunctions({ fields })\n\n      flattenObject({\n        data: { group: { inner: 'deep' }, title: 'Top' },\n        exportFieldHooks,\n        format: 'csv',\n        req: mockReq,\n      })\n\n      expect(received).toEqual([\n        {\n          columnName: 'group_inner',\n          isSiblingDocSource: true,\n          isSiblingDocRow: false,\n        },\n      ])\n    })\n\n    it('lets a hook read another sibling by reading siblingDoc', () => {\n      const fields: FlattenedField[] = [\n        { name: 'firstName', type: 'text' } as FlattenedField,\n        {\n          name: 'fullName',\n          type: 'text',\n          custom: {\n            'plugin-import-export': {\n              hooks: {\n                beforeExport: (({ siblingDoc, value }) => {\n                  const last = siblingDoc.lastName as string | undefined\n                  const first = siblingDoc.firstName as string | undefined\n                  if (first && last) {\n                    return `${first} ${last}`\n                  }\n                  return value\n                }) satisfies FieldBeforeExportHook,\n              },\n            },\n          },\n        } as FlattenedField,\n        { name: 'lastName', type: 'text' } as FlattenedField,\n      ]\n\n      const exportFieldHooks = getExportFieldFunctions({ fields })\n\n      const result = flattenObject({\n        data: { firstName: 'Ada', fullName: '(computed)', lastName: 'Lovelace' },\n        exportFieldHooks,\n        format: 'csv',\n        req: mockReq,\n      })\n\n      expect(result.fullName).toBe('Ada Lovelace')\n    })\n  })\n\n  describe('JSON export (applyFieldHooks)', () => {\n    it('passes the untouched source sibling as siblingDoc and the mutable output as siblingData', () => {\n      let capturedSiblingDoc: Record<string, unknown> | null = null\n      let capturedSiblingData: Record<string, unknown> | null = null\n\n      const fields: FlattenedField[] = [\n        {\n          name: 'outer',\n          type: 'group',\n          flattenedFields: [\n            {\n              name: 'tracked',\n              type: 'text',\n              custom: {\n                'plugin-import-export': {\n                  hooks: {\n                    beforeExport: (({ siblingData, siblingDoc, value }) => {\n                      capturedSiblingDoc = siblingDoc\n                      capturedSiblingData = siblingData\n                      siblingData.injected = 'written-into-output'\n                      return String(value) + '_changed'\n                    }) satisfies FieldBeforeExportHook,\n                  },\n                },\n              },\n            },\n          ],\n        } as unknown as FlattenedField,\n      ]\n\n      const exportFieldHooks = getExportFieldFunctions({ fields })\n\n      const source = { outer: { tracked: 'original' } }\n\n      applyFieldHooks({\n        data: source,\n        fieldHooks: exportFieldHooks,\n        fields,\n        format: 'json',\n        operation: 'export',\n        req: mockReq,\n        type: 'beforeExport',\n      })\n\n      expect(capturedSiblingDoc).toEqual({ tracked: 'original' })\n      // The hook's mutation lives on siblingData, not siblingDoc\n      expect((capturedSiblingData as unknown as Record<string, unknown>)?.injected).toBe(\n        'written-into-output',\n      )\n      expect((capturedSiblingDoc as unknown as Record<string, unknown>)?.injected).toBeUndefined()\n      // And the source object itself is not mutated\n      expect(source).toEqual({ outer: { tracked: 'original' } })\n    })\n  })\n\n  describe('CSV import (unflattenObject)', () => {\n    it('passes the full flat row as siblingDoc (equal to data)', () => {\n      const received: Array<{ siblingDocIsData: boolean }> = []\n\n      const fields: FlattenedField[] = [\n        { name: 'title', type: 'text' } as FlattenedField,\n        {\n          name: 'note',\n          type: 'text',\n          custom: {\n            'plugin-import-export': {\n              hooks: {\n                beforeImport: (({ data, siblingDoc, value }) => {\n                  received.push({ siblingDocIsData: siblingDoc === data })\n                  return value\n                }) satisfies FieldBeforeImportHook,\n              },\n            },\n          },\n        } as FlattenedField,\n      ]\n\n      const importFieldHooks = getImportFieldFunctions({ fields })\n\n      unflattenObject({\n        data: { note: 'hello', title: 'Top' },\n        fields,\n        format: 'csv',\n        importFieldHooks,\n        req: mockReq,\n      })\n\n      expect(received).toEqual([{ siblingDocIsData: true }])\n    })\n  })\n\n  describe('JSON import (applyFieldHooks)', () => {\n    it('passes the untouched source sibling as siblingDoc and the mutable output as siblingData', () => {\n      let capturedSiblingDoc: Record<string, unknown> | null = null\n      let capturedSiblingData: Record<string, unknown> | null = null\n\n      const fields: FlattenedField[] = [\n        {\n          name: 'outer',\n          type: 'group',\n          flattenedFields: [\n            {\n              name: 'tracked',\n              type: 'text',\n              custom: {\n                'plugin-import-export': {\n                  hooks: {\n                    beforeImport: (({ siblingData, siblingDoc, value }) => {\n                      capturedSiblingDoc = siblingDoc\n                      capturedSiblingData = siblingData\n                      siblingData.injected = 'written-into-output'\n                      return value\n                    }) satisfies FieldBeforeImportHook,\n                  },\n                },\n              },\n            },\n          ],\n        } as unknown as FlattenedField,\n      ]\n\n      const importFieldHooks = getImportFieldFunctions({ fields })\n\n      const source = { outer: { tracked: 'original' } }\n\n      applyFieldHooks({\n        data: source,\n        fieldHooks: importFieldHooks,\n        fields,\n        format: 'json',\n        operation: 'import',\n        req: mockReq,\n        type: 'beforeImport',\n      })\n\n      expect(capturedSiblingDoc).toEqual({ tracked: 'original' })\n      expect((capturedSiblingData as unknown as Record<string, unknown>)?.injected).toBe(\n        'written-into-output',\n      )\n      expect((capturedSiblingDoc as unknown as Record<string, unknown>)?.injected).toBeUndefined()\n      expect(source).toEqual({ outer: { tracked: 'original' } })\n    })\n  })\n})\n"],"names":["applyFieldHooks","flattenObject","getExportFieldFunctions","getImportFieldFunctions","unflattenObject","describe","expect","it","vi","mockReq","payload","logger","error","fn","received","fields","name","type","flattenedFields","custom","hooks","beforeExport","columnName","siblingData","siblingDoc","value","push","isSiblingDocSource","inner","isSiblingDocRow","exportFieldHooks","data","group","title","format","req","toEqual","last","lastName","first","firstName","result","fullName","toBe","capturedSiblingDoc","capturedSiblingData","injected","String","source","outer","tracked","fieldHooks","operation","toBeUndefined","beforeImport","siblingDocIsData","importFieldHooks","note"],"mappings":"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"}

package/dist/utilities/unflattenObject.d.ts

@@ -1,9 +1,10 @@
 import type { FlattenedField, PayloadRequest } from 'payload';
-import type { FromCSVFunction } from '../types.js';
+import type { ImportFieldHookEntry } from '../types.js';
 type UnflattenArgs = {
     data: Record<string, unknown>;
     fields: FlattenedField[];
-    fromCSVFunctions?: Record<string, FromCSVFunction>;
+    format?: 'csv' | 'json' | ({} & string);
+    importFieldHooks?: Record<string, ImportFieldHookEntry>;
     req: PayloadRequest;
 };
 /**
@@ -19,6 +20,6 @@ type UnflattenArgs = {
  *    - Regular nested objects
  * 4. Post-processes to handle localized fields, hasMany conversions, and relationship transforms
  */
-export declare const unflattenObject: ({ data, fields, fromCSVFunctions, req, }: UnflattenArgs) => Record<string, unknown>;
+export declare const unflattenObject: ({ data, fields, format, importFieldHooks, req, }: UnflattenArgs) => Record<string, unknown>;
 export {};
 //# sourceMappingURL=unflattenObject.d.ts.map

package/dist/utilities/unflattenObject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unflattenObject.d.ts","sourceRoot":"","sources":["../../src/utilities/unflattenObject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAIlD,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC7B,MAAM,EAAE,cAAc,EAAE,CAAA;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;IAClD,GAAG,EAAE,cAAc,CAAA;CACpB,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe,6CAKzB,aAAa,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CA0SxC,CAAA"}
+{"version":3,"file":"unflattenObject.d.ts","sourceRoot":"","sources":["../../src/utilities/unflattenObject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAKvD,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC7B,MAAM,EAAE,cAAc,EAAE,CAAA;IACxB,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,CAAC,EAAE,GAAG,MAAM,CAAC,CAAA;IACvC,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAA;IACvD,GAAG,EAAE,cAAc,CAAA;CACpB,CAAA;AAiCD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe,qDAMzB,aAAa,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAkUxC,CAAA"}

package/dist/utilities/unflattenObject.js

@@ -1,4 +1,30 @@
-import { processRichTextField } from './processRichTextField.js';
+import { getNestedFlattenedFields } from './flattenedFields.js';
+import { postProcessDocument } from './unflattenPostProcess.js';
+const indexSegment = /^\d+$/;
+const collectArrayLikeNames = (fields, into)=>{
+    for (const field of fields){
+        if (!('name' in field) || !field.name) {
+            continue;
+        }
+        if (field.type === 'array' || field.type === 'blocks') {
+            into.add(field.name);
+        }
+        const nested = getNestedFlattenedFields(field);
+        if (nested) {
+            collectArrayLikeNames(nested, into);
+        }
+    }
+};
+/**
+ * Drops numeric array-index segments from a flat key so a runtime key like
+ * `items_0_note` matches the static, index-free key a user hook is registered
+ * under. A digit-only segment is only stripped when the segment immediately
+ * before it names an array or blocks field, so a literal field name like
+ * `2024` is preserved.
+ */ const toLogicalKey = (flatKey, arrayLikeNames)=>{
+    const segments = flatKey.split('_');
+    return segments.filter((seg, i)=>!indexSegment.test(seg) || !arrayLikeNames.has(segments[i - 1] ?? '')).join('_');
+};
 /**
  * Converts flattened CSV data back into a nested document structure.
  *
@@ -11,11 +37,13 @@ import { processRichTextField } from './processRichTextField.js';
  *    - Polymorphic relationships (_relationTo and _id suffix pairs)
  *    - Regular nested objects
  * 4. Post-processes to handle localized fields, hasMany conversions, and relationship transforms
- */ export const unflattenObject = ({ data, fields, fromCSVFunctions = {}, req })=>{
+ */ export const unflattenObject = ({ data, fields, format = 'csv', importFieldHooks = {}, req })=>{
     if (!data || typeof data !== 'object') {
         return {};
     }
     const result = {};
+    const arrayLikeNames = new Set();
+    collectArrayLikeNames(fields, arrayLikeNames);
     // Sort keys to ensure array indices are processed in order
     const sortedKeys = Object.keys(data).sort((a, b)=>{
         // Extract array indices from flattened keys (e.g., "field_0_subfield" -> "0")
@@ -72,13 +100,33 @@ import { processRichTextField } from './processRichTextField.js';
                 }
             }
         }
-        // Apply fromCSV function if available
-        if (fromCSVFunctions[flatKey]) {
-            value = fromCSVFunctions[flatKey]({
-                columnName: flatKey,
-                data,
-                value
-            });
+        const importHookEntry = importFieldHooks[flatKey] ?? importFieldHooks[toLogicalKey(flatKey, arrayLikeNames)];
+        if (importHookEntry) {
+            try {
+                if (importHookEntry.type === 'beforeImport') {
+                    value = importHookEntry.fn({
+                        columnName: flatKey,
+                        data,
+                        format,
+                        siblingData: data,
+                        siblingDoc: data,
+                        value
+                    });
+                } else {
+                    value = importHookEntry.fn({
+                        columnName: flatKey,
+                        data,
+                        value
+                    });
+                }
+            } catch (error) {
+                req.payload.logger.error({
+                    err: error,
+                    msg: `[plugin-import-export] Field-level beforeImport hook for "${flatKey}" threw — falling back to original value`
+                });
+            // Keep the original value so the row is not dropped — downstream
+            // validation will surface any deeper issue per-row.
+            }
         }
         // Example: "blocks_0_content_text" -> ["blocks", "0", "content", "text"]
         const pathSegments = flatKey.split('_');
@@ -271,165 +319,5 @@ const getParentObject = (obj, segments)=>{
     }
     return current;
 };
-/**
- * Post-processes the unflattened document to handle special field types:
- * - Localized fields: transforms field_locale keys to nested { field: { locale: value } }
- * - Number hasMany: converts comma-separated strings or arrays to number arrays
- * - Relationship hasMany: converts comma-separated IDs to arrays
- * - Polymorphic relationships: transforms flat {relationTo, id} to {relationTo, value}
- * - Rich text fields: ensures proper data structure
- */ const postProcessDocument = (doc, fields)=>{
-    const localizedFields = fields.filter((field)=>field.localized);
-    const processedLocalizedFields = new Set();
-    for (const field of localizedFields){
-        if (processedLocalizedFields.has(field.name)) {
-            continue;
-        }
-        // Look for all locale-specific keys for this field
-        const localePattern = new RegExp(`^${field.name}_([a-z]{2}(?:_[A-Z]{2})?)$`);
-        const localeData = {};
-        const keysToDelete = [];
-        for (const [key, value] of Object.entries(doc)){
-            const match = key.match(localePattern);
-            if (match && match[1]) {
-                const locale = match[1];
-                localeData[locale] = value;
-                keysToDelete.push(key);
-            }
-        }
-        // If we found locale-specific data, restructure it as Payload expects
-        if (Object.keys(localeData).length > 0) {
-            // Payload stores localized fields as nested objects: { field: { en: 'value', es: 'value' } }
-            doc[field.name] = localeData;
-            keysToDelete.forEach((key)=>delete doc[key]);
-            processedLocalizedFields.add(field.name);
-        }
-    }
-    // Handle number fields with hasMany - convert string arrays to number arrays
-    const numberFields = fields.filter((field)=>field.type === 'number' && field.hasMany);
-    for (const field of numberFields){
-        const value = doc[field.name];
-        // Skip if field doesn't exist in document
-        if (!(field.name in doc)) {
-            continue;
-        }
-        // Handle comma-separated string (e.g., "1,2,3,4,5")
-        if (typeof value === 'string' && value.includes(',')) {
-            doc[field.name] = value.split(',').map((v)=>v.trim()).filter((v)=>v !== '').map((v)=>{
-                const num = parseFloat(v);
-                return isNaN(num) ? 0 : num;
-            });
-        } else if (Array.isArray(value)) {
-            // Filter out null, undefined, and empty string values, then convert to numbers
-            doc[field.name] = value.filter((v)=>v !== null && v !== undefined && v !== '').map((v)=>{
-                if (typeof v === 'string') {
-                    const num = parseFloat(v);
-                    return isNaN(num) ? 0 : num;
-                }
-                return v;
-            });
-        } else if (value !== null && value !== undefined && value !== '') {
-            const num = typeof value === 'string' ? parseFloat(value) : value;
-            doc[field.name] = isNaN(num) ? [] : [
-                num
-            ];
-        } else {
-            doc[field.name] = [];
-        }
-    }
-    // Handle relationship fields with hasMany - convert comma-separated IDs to arrays
-    const relationshipFields = fields.filter((field)=>(field.type === 'relationship' || field.type === 'upload') && field.hasMany === true && !Array.isArray(field.relationTo));
-    for (const field of relationshipFields){
-        const value = doc[field.name];
-        // Handle comma-separated string of IDs (e.g., "id1,id2,id3")
-        if (typeof value === 'string' && value.includes(',')) {
-            doc[field.name] = value.split(',').map((v)=>v.trim()).filter((v)=>v !== '');
-        } else if (Array.isArray(value)) {
-            doc[field.name] = value.filter((v)=>v !== null && v !== undefined && v !== '');
-        } else if (value !== null && value !== undefined && value !== '') {
-            doc[field.name] = [
-                value
-            ];
-        }
-    }
-    // Handle polymorphic relationships - transform from flat structure to proper format
-    for (const [key, value] of Object.entries(doc)){
-        // Handle arrays of polymorphic relationships
-        if (Array.isArray(value)) {
-            // Check if this array contains polymorphic relationship objects
-            const hasPolymorphicItems = value.some((item)=>typeof item === 'object' && item !== null && 'relationTo' in item);
-            if (hasPolymorphicItems) {
-                // Filter out null/invalid polymorphic items and transform valid ones
-                const processedArray = [];
-                for(let i = 0; i < value.length; i++){
-                    const item = value[i];
-                    if (typeof item === 'object' && item !== null && 'relationTo' in item) {
-                        const typedItem = item;
-                        // Skip if both relationTo and value/id are null/empty
-                        if (!typedItem.relationTo || !typedItem.id && !typedItem.value) {
-                            continue;
-                        }
-                        // Transform from {relationTo: 'collection', id: '123'} to {relationTo: 'collection', value: '123'}
-                        if ('id' in typedItem) {
-                            typedItem.value = typedItem.id;
-                            delete typedItem.id;
-                        }
-                        processedArray.push(typedItem);
-                    } else if (item !== null && item !== undefined) {
-                        processedArray.push(item);
-                    }
-                }
-                // Update the array with filtered results
-                if (value.length !== processedArray.length) {
-                    doc[key] = processedArray.length > 0 ? processedArray : [];
-                }
-            }
-        // For non-polymorphic arrays, preserve null placeholders for sparse arrays
-        } else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-            // Check if this is a single polymorphic relationship
-            if ('relationTo' in value && ('id' in value || 'value' in value)) {
-                const typedValue = value;
-                // If both relationTo and value are null/empty, set the whole field to null
-                if (!typedValue.relationTo || !typedValue.id && !typedValue.value) {
-                    doc[key] = null;
-                } else {
-                    // If it has 'id', transform to 'value'
-                    if ('id' in typedValue && !('value' in typedValue)) {
-                        typedValue.value = typedValue.id;
-                        delete typedValue.id;
-                    }
-                }
-            } else {
-                // Recursively process nested objects
-                postProcessDocument(value, fields);
-            }
-        }
-    }
-    // Process rich text fields to ensure proper data types
-    const richTextFields = fields.filter((field)=>field.type === 'richText');
-    for (const field of richTextFields){
-        if (field.name in doc && doc[field.name]) {
-            doc[field.name] = processRichTextField(doc[field.name]);
-        }
-    }
-    // Also process rich text fields in blocks
-    const blockFields = fields.filter((field)=>field.type === 'blocks');
-    for (const field of blockFields){
-        if (field.name in doc && Array.isArray(doc[field.name])) {
-            const blocks = doc[field.name];
-            for (const block of blocks){
-                if (!block || typeof block !== 'object') {
-                    continue;
-                }
-                // Look for richText fields directly in the block
-                for (const [key, value] of Object.entries(block)){
-                    if (key === 'richText' || typeof key === 'string' && key.includes('richText')) {
-                        block[key] = processRichTextField(value);
-                    }
-                }
-            }
-        }
-    }
-};
 
 //# sourceMappingURL=unflattenObject.js.map