payload 4.0.0-internal.cd69eef → 4.0.0-internal.d1cc1d3

package/dist/fields/config/sanitize.spec.js

@@ -4,7 +4,7 @@ import { describe, it, expect } from 'vitest';
 describe('sanitizeFields', ()=>{
     const config = {};
     const collectionConfig = {};
-    it('should throw on missing type field', async ()=>{
+    it('should throw on missing type field', ()=>{
         const fields = [
             // @ts-expect-error
             {
@@ -12,16 +12,16 @@ describe('sanitizeFields', ()=>{
                 label: 'some-collection'
             }
         ];
-        await expect(async ()=>{
-            await sanitizeFields({
+        expect(()=>{
+            sanitizeFields({
                 config,
                 collectionConfig,
                 fields,
                 validRelationships: []
             });
-        }).rejects.toThrow(MissingFieldType);
+        }).toThrow(MissingFieldType);
     });
-    it('should throw on invalid field name', async ()=>{
+    it('should throw on invalid field name', ()=>{
         const fields = [
             {
                 name: 'some.collection',
@@ -29,16 +29,16 @@ describe('sanitizeFields', ()=>{
                 label: 'some.collection'
             }
         ];
-        await expect(async ()=>{
-            await sanitizeFields({
+        expect(()=>{
+            sanitizeFields({
                 config,
                 collectionConfig,
                 fields,
                 validRelationships: []
             });
-        }).rejects.toThrow(InvalidFieldName);
+        }).toThrow(InvalidFieldName);
     });
-    it('should throw on duplicate field name', async ()=>{
+    it('should throw on duplicate field name', ()=>{
         const fields = [
             {
                 name: 'someField',
@@ -51,16 +51,16 @@ describe('sanitizeFields', ()=>{
                 label: 'someField'
             }
         ];
-        await expect(async ()=>{
-            await sanitizeFields({
+        expect(()=>{
+            sanitizeFields({
                 config,
                 collectionConfig,
                 fields,
                 validRelationships: []
             });
-        }).rejects.toThrow(DuplicateFieldName);
+        }).toThrow(DuplicateFieldName);
     });
-    it('should throw on duplicate block slug', async ()=>{
+    it('should throw on duplicate block slug', ()=>{
         const fields = [
             {
                 name: 'blocks',
@@ -87,34 +87,34 @@ describe('sanitizeFields', ()=>{
                 ]
             }
         ];
-        await expect(async ()=>{
-            await sanitizeFields({
+        expect(()=>{
+            sanitizeFields({
                 config,
                 collectionConfig,
                 fields,
                 validRelationships: []
             });
-        }).rejects.toThrow(DuplicateFieldName);
+        }).toThrow(DuplicateFieldName);
     });
     describe('auto-labeling', ()=>{
-        it('should populate label if missing', async ()=>{
+        it('should populate label if missing', ()=>{
             const fields = [
                 {
                     name: 'someField',
                     type: 'text'
                 }
             ];
-            const sanitizedField = (await sanitizeFields({
+            const sanitizedField = sanitizeFields({
                 config,
                 collectionConfig,
                 fields,
                 validRelationships: []
-            }))[0];
+            })[0];
             expect(sanitizedField.name).toStrictEqual('someField');
             expect(sanitizedField.label).toStrictEqual('Some Field');
             expect(sanitizedField.type).toStrictEqual('text');
         });
-        it('should allow auto-label override', async ()=>{
+        it('should allow auto-label override', ()=>{
             const fields = [
                 {
                     name: 'someField',
@@ -122,18 +122,18 @@ describe('sanitizeFields', ()=>{
                     label: 'Do not label'
                 }
             ];
-            const sanitizedField = (await sanitizeFields({
+            const sanitizedField = sanitizeFields({
                 config,
                 collectionConfig,
                 fields,
                 validRelationships: []
-            }))[0];
+            })[0];
             expect(sanitizedField.name).toStrictEqual('someField');
             expect(sanitizedField.label).toStrictEqual('Do not label');
             expect(sanitizedField.type).toStrictEqual('text');
         });
         describe('opt-out', ()=>{
-            it('should allow label opt-out', async ()=>{
+            it('should allow label opt-out', ()=>{
                 const fields = [
                     {
                         name: 'someField',
@@ -141,17 +141,17 @@ describe('sanitizeFields', ()=>{
                         label: false
                     }
                 ];
-                const sanitizedField = (await sanitizeFields({
+                const sanitizedField = sanitizeFields({
                     config,
                     collectionConfig,
                     fields,
                     validRelationships: []
-                }))[0];
+                })[0];
                 expect(sanitizedField.name).toStrictEqual('someField');
                 expect(sanitizedField.label).toStrictEqual(false);
                 expect(sanitizedField.type).toStrictEqual('text');
             });
-            it('should allow label opt-out for arrays', async ()=>{
+            it('should allow label opt-out for arrays', ()=>{
                 const arrayField = {
                     name: 'items',
                     type: 'array',
@@ -163,20 +163,20 @@ describe('sanitizeFields', ()=>{
                     ],
                     label: false
                 };
-                const sanitizedField = (await sanitizeFields({
+                const sanitizedField = sanitizeFields({
                     config,
                     collectionConfig,
                     fields: [
                         arrayField
                     ],
                     validRelationships: []
-                }))[0];
+                })[0];
                 expect(sanitizedField.name).toStrictEqual('items');
                 expect(sanitizedField.label).toStrictEqual(false);
                 expect(sanitizedField.type).toStrictEqual('array');
                 expect(sanitizedField.labels).toBeUndefined();
             });
-            it('should allow label opt-out for blocks', async ()=>{
+            it('should allow label opt-out for blocks', ()=>{
                 const fields = [
                     {
                         name: 'noLabelBlock',
@@ -195,19 +195,19 @@ describe('sanitizeFields', ()=>{
                         label: false
                     }
                 ];
-                const sanitizedField = (await sanitizeFields({
+                const sanitizedField = sanitizeFields({
                     config,
                     collectionConfig,
                     fields,
                     validRelationships: []
-                }))[0];
+                })[0];
                 expect(sanitizedField.name).toStrictEqual('noLabelBlock');
                 expect(sanitizedField.label).toStrictEqual(false);
                 expect(sanitizedField.type).toStrictEqual('blocks');
                 expect(sanitizedField.labels).toBeUndefined();
             });
         });
-        it('should label arrays with plural and singular', async ()=>{
+        it('should label arrays with plural and singular', ()=>{
             const fields = [
                 {
                     name: 'items',
@@ -220,12 +220,12 @@ describe('sanitizeFields', ()=>{
                     ]
                 }
             ];
-            const sanitizedField = (await sanitizeFields({
+            const sanitizedField = sanitizeFields({
                 config,
                 collectionConfig,
                 fields,
                 validRelationships: []
-            }))[0];
+            })[0];
             expect(sanitizedField.name).toStrictEqual('items');
             expect(sanitizedField.label).toStrictEqual('Items');
             expect(sanitizedField.type).toStrictEqual('array');
@@ -234,7 +234,7 @@ describe('sanitizeFields', ()=>{
                 singular: 'Item'
             });
         });
-        it('should label blocks with plural and singular', async ()=>{
+        it('should label blocks with plural and singular', ()=>{
             const fields = [
                 {
                     name: 'specialBlock',
@@ -252,12 +252,12 @@ describe('sanitizeFields', ()=>{
                     ]
                 }
             ];
-            const sanitizedField = (await sanitizeFields({
+            const sanitizedField = sanitizeFields({
                 config,
                 collectionConfig,
                 fields,
                 validRelationships: []
-            }))[0];
+            })[0];
             expect(sanitizedField.name).toStrictEqual('specialBlock');
             expect(sanitizedField.label).toStrictEqual('Special Block');
             expect(sanitizedField.type).toStrictEqual('blocks');
@@ -269,7 +269,7 @@ describe('sanitizeFields', ()=>{
         });
     });
     describe('relationships', ()=>{
-        it('should not throw on valid relationship', async ()=>{
+        it('should not throw on valid relationship', ()=>{
             const validRelationships = [
                 'some-collection'
             ];
@@ -281,8 +281,8 @@ describe('sanitizeFields', ()=>{
                     relationTo: 'some-collection'
                 }
             ];
-            await expect(async ()=>{
-                await sanitizeFields({
+            expect(()=>{
+                sanitizeFields({
                     config,
                     collectionConfig,
                     fields,
@@ -290,7 +290,7 @@ describe('sanitizeFields', ()=>{
                 });
             }).not.toThrow();
         });
-        it('should not throw on valid relationship - multiple', async ()=>{
+        it('should not throw on valid relationship - multiple', ()=>{
             const validRelationships = [
                 'some-collection',
                 'another-collection'
@@ -306,8 +306,8 @@ describe('sanitizeFields', ()=>{
                     ]
                 }
             ];
-            await expect(async ()=>{
-                await sanitizeFields({
+            expect(()=>{
+                sanitizeFields({
                     config,
                     collectionConfig,
                     fields,
@@ -315,7 +315,7 @@ describe('sanitizeFields', ()=>{
                 });
             }).not.toThrow();
         });
-        it('should not throw on valid relationship inside blocks', async ()=>{
+        it('should not throw on valid relationship inside blocks', ()=>{
             const validRelationships = [
                 'some-collection'
             ];
@@ -340,8 +340,8 @@ describe('sanitizeFields', ()=>{
                     label: 'Layout Blocks'
                 }
             ];
-            await expect(async ()=>{
-                await sanitizeFields({
+            expect(()=>{
+                sanitizeFields({
                     config,
                     collectionConfig,
                     fields,
@@ -349,7 +349,7 @@ describe('sanitizeFields', ()=>{
                 });
             }).not.toThrow();
         });
-        it('should throw on invalid relationship', async ()=>{
+        it('should throw on invalid relationship', ()=>{
             const validRelationships = [
                 'some-collection'
             ];
@@ -361,16 +361,16 @@ describe('sanitizeFields', ()=>{
                     relationTo: 'not-valid'
                 }
             ];
-            await expect(async ()=>{
-                await sanitizeFields({
+            expect(()=>{
+                sanitizeFields({
                     config,
                     collectionConfig,
                     fields,
                     validRelationships
                 });
-            }).rejects.toThrow(InvalidFieldRelationship);
+            }).toThrow(InvalidFieldRelationship);
         });
-        it('should throw on invalid relationship - multiple', async ()=>{
+        it('should throw on invalid relationship - multiple', ()=>{
             const validRelationships = [
                 'some-collection',
                 'another-collection'
@@ -386,16 +386,16 @@ describe('sanitizeFields', ()=>{
                     ]
                 }
             ];
-            await expect(async ()=>{
-                await sanitizeFields({
+            expect(()=>{
+                sanitizeFields({
                     config,
                     collectionConfig,
                     fields,
                     validRelationships
                 });
-            }).rejects.toThrow(InvalidFieldRelationship);
+            }).toThrow(InvalidFieldRelationship);
         });
-        it('should throw on invalid relationship inside blocks', async ()=>{
+        it('should throw on invalid relationship inside blocks', ()=>{
             const validRelationships = [
                 'some-collection'
             ];
@@ -420,16 +420,16 @@ describe('sanitizeFields', ()=>{
                     label: 'Layout Blocks'
                 }
             ];
-            await expect(async ()=>{
-                await sanitizeFields({
+            expect(()=>{
+                sanitizeFields({
                     config,
                     collectionConfig,
                     fields,
                     validRelationships
                 });
-            }).rejects.toThrow(InvalidFieldRelationship);
+            }).toThrow(InvalidFieldRelationship);
         });
-        it('should throw on empty relationTo array', async ()=>{
+        it('should throw on empty relationTo array', ()=>{
             const validRelationships = [
                 'some-collection'
             ];
@@ -441,16 +441,16 @@ describe('sanitizeFields', ()=>{
                     relationTo: []
                 }
             ];
-            await expect(async ()=>{
-                await sanitizeFields({
+            expect(()=>{
+                sanitizeFields({
                     config,
                     collectionConfig,
                     fields,
                     validRelationships
                 });
-            }).rejects.toThrow('has an empty relationTo array');
+            }).toThrow('has an empty relationTo array');
         });
-        it('should throw on empty relationTo array for upload field', async ()=>{
+        it('should throw on empty relationTo array for upload field', ()=>{
             const validRelationships = [
                 'some-collection'
             ];
@@ -462,16 +462,16 @@ describe('sanitizeFields', ()=>{
                     relationTo: []
                 }
             ];
-            await expect(async ()=>{
-                await sanitizeFields({
+            expect(()=>{
+                sanitizeFields({
                     config,
                     collectionConfig,
                     fields,
                     validRelationships
                 });
-            }).rejects.toThrow('has an empty relationTo array');
+            }).toThrow('has an empty relationTo array');
         });
-        it('should throw on empty relationTo array inside blocks', async ()=>{
+        it('should throw on empty relationTo array inside blocks', ()=>{
             const validRelationships = [
                 'some-collection'
             ];
@@ -496,16 +496,16 @@ describe('sanitizeFields', ()=>{
                     label: 'Layout Blocks'
                 }
             ];
-            await expect(async ()=>{
-                await sanitizeFields({
+            expect(()=>{
+                sanitizeFields({
                     config,
                     collectionConfig,
                     fields,
                     validRelationships
                 });
-            }).rejects.toThrow('has an empty relationTo array');
+            }).toThrow('has an empty relationTo array');
         });
-        it('should defaultValue of checkbox to false if required and undefined', async ()=>{
+        it('should defaultValue of checkbox to false if required and undefined', ()=>{
             const fields = [
                 {
                     name: 'My Checkbox',
@@ -513,16 +513,16 @@ describe('sanitizeFields', ()=>{
                     required: true
                 }
             ];
-            const sanitizedField = (await sanitizeFields({
+            const sanitizedField = sanitizeFields({
                 config,
                 collectionConfig,
                 fields,
                 validRelationships: []
-            }))[0];
+            })[0];
             expect(sanitizedField.defaultValue).toStrictEqual(false);
         });
-        it('should return empty field array if no fields', async ()=>{
-            const sanitizedFields = await sanitizeFields({
+        it('should return empty field array if no fields', ()=>{
+            const sanitizedFields = sanitizeFields({
                 config,
                 collectionConfig,
                 fields: [],
@@ -531,8 +531,31 @@ describe('sanitizeFields', ()=>{
             expect(sanitizedFields).toStrictEqual([]);
         });
     });
+    it('should sanitize rich text inline', ()=>{
+        const editor = {
+            CellComponent: '',
+            FieldComponent: '',
+            validate: ()=>true
+        };
+        const configWithEditor = {
+            editor: ()=>editor
+        };
+        const fields = [
+            {
+                name: 'richText',
+                type: 'richText'
+            }
+        ];
+        const sanitizedFields = sanitizeFields({
+            config: configWithEditor,
+            fields,
+            parentIsLocalized: false,
+            validRelationships: []
+        });
+        expect(sanitizedFields[0].editor).toBe(editor);
+    });
     describe('blocks', ()=>{
-        it('should maintain admin.blockName true after sanitization', async ()=>{
+        it('should maintain admin.blockName true after sanitization', ()=>{
             const fields = [
                 {
                     name: 'noLabelBlock',
@@ -554,16 +577,16 @@ describe('sanitizeFields', ()=>{
                     label: false
                 }
             ];
-            const sanitizedField = (await sanitizeFields({
+            const sanitizedField = sanitizeFields({
                 config,
                 collectionConfig,
                 fields,
                 validRelationships: []
-            }))[0];
+            })[0];
             const sanitizedBlock = sanitizedField.blocks[0];
             expect(sanitizedBlock.admin?.disableBlockName).toStrictEqual(true);
         });
-        it('should default admin.disableBlockName to true after sanitization', async ()=>{
+        it('should default admin.disableBlockName to true after sanitization', ()=>{
             const fields = [
                 {
                     name: 'noLabelBlock',
@@ -582,18 +605,18 @@ describe('sanitizeFields', ()=>{
                     label: false
                 }
             ];
-            const sanitizedField = (await sanitizeFields({
+            const sanitizedField = sanitizeFields({
                 config,
                 collectionConfig,
                 fields,
                 validRelationships: []
-            }))[0];
+            })[0];
             const sanitizedBlock = sanitizedField.blocks[0];
             expect(sanitizedBlock.admin?.disableBlockName).toStrictEqual(undefined);
         });
     });
     describe('virtual fields', ()=>{
-        it('should assign a noop validate for virtual: true fields', async ()=>{
+        it('should assign a noop validate for virtual: true fields', ()=>{
             const fields = [
                 {
                     name: 'virtualText',
@@ -601,17 +624,17 @@ describe('sanitizeFields', ()=>{
                     virtual: true
                 }
             ];
-            const sanitizedField = (await sanitizeFields({
+            const sanitizedField = sanitizeFields({
                 config,
                 collectionConfig,
                 fields,
                 validRelationships: []
-            }))[0];
+            })[0];
             expect(sanitizedField.validate).toBeDefined();
             expect(sanitizedField.validate('', {})).toBe(true);
             expect(sanitizedField.validate(undefined, {})).toBe(true);
         });
-        it('should assign a noop validate for virtual: "string" fields', async ()=>{
+        it('should assign a noop validate for virtual: "string" fields', ()=>{
             const fields = [
                 {
                     name: 'virtualRef',
@@ -619,16 +642,16 @@ describe('sanitizeFields', ()=>{
                     virtual: 'post.title'
                 }
             ];
-            const sanitizedField = (await sanitizeFields({
+            const sanitizedField = sanitizeFields({
                 config,
                 collectionConfig,
                 fields,
                 validRelationships: []
-            }))[0];
+            })[0];
             expect(sanitizedField.validate).toBeDefined();
             expect(sanitizedField.validate(undefined, {})).toBe(true);
         });
-        it('should not override an explicit validate on a virtual field', async ()=>{
+        it('should not override an explicit validate on a virtual field', ()=>{
             const customValidate = ()=>true;
             const fields = [
                 {
@@ -638,27 +661,27 @@ describe('sanitizeFields', ()=>{
                     validate: customValidate
                 }
             ];
-            const sanitizedField = (await sanitizeFields({
+            const sanitizedField = sanitizeFields({
                 config,
                 collectionConfig,
                 fields,
                 validRelationships: []
-            }))[0];
+            })[0];
             expect(sanitizedField.validate).toBe(customValidate);
         });
-        it('should assign default type-based validate for non-virtual fields', async ()=>{
+        it('should assign default type-based validate for non-virtual fields', ()=>{
             const fields = [
                 {
                     name: 'normalText',
                     type: 'text'
                 }
             ];
-            const sanitizedField = (await sanitizeFields({
+            const sanitizedField = sanitizeFields({
                 config,
                 collectionConfig,
                 fields,
                 validRelationships: []
-            }))[0];
+            })[0];
             expect(sanitizedField.validate).toBeDefined();
             // Non-virtual text field should use the text validator which checks required/minLength/etc.
             // Passing undefined with required should fail
@@ -673,7 +696,7 @@ describe('sanitizeFields', ()=>{
             });
             expect(result).not.toBe(true);
         });
-        it('should default readOnly to true for virtual: true fields', async ()=>{
+        it('should default readOnly to true for virtual: true fields', ()=>{
             const fields = [
                 {
                     name: 'virtualText',
@@ -681,15 +704,15 @@ describe('sanitizeFields', ()=>{
                     virtual: true
                 }
             ];
-            const sanitizedField = (await sanitizeFields({
+            const sanitizedField = sanitizeFields({
                 config,
                 collectionConfig,
                 fields,
                 validRelationships: []
-            }))[0];
+            })[0];
             expect(sanitizedField.admin?.readOnly).toBe(true);
         });
-        it('should default readOnly to true for virtual: "string" fields', async ()=>{
+        it('should default readOnly to true for virtual: "string" fields', ()=>{
             const fields = [
                 {
                     name: 'virtualRef',
@@ -697,15 +720,15 @@ describe('sanitizeFields', ()=>{
                     virtual: 'post.title'
                 }
             ];
-            const sanitizedField = (await sanitizeFields({
+            const sanitizedField = sanitizeFields({
                 config,
                 collectionConfig,
                 fields,
                 validRelationships: []
-            }))[0];
+            })[0];
             expect(sanitizedField.admin?.readOnly).toBe(true);
         });
-        it('should not override readOnly: false on virtual fields', async ()=>{
+        it('should not override readOnly: false on virtual fields', ()=>{
             const fields = [
                 {
                     name: 'virtualText',
@@ -716,27 +739,27 @@ describe('sanitizeFields', ()=>{
                     }
                 }
             ];
-            const sanitizedField = (await sanitizeFields({
+            const sanitizedField = sanitizeFields({
                 config,
                 collectionConfig,
                 fields,
                 validRelationships: []
-            }))[0];
+            })[0];
             expect(sanitizedField.admin?.readOnly).toBe(false);
         });
-        it('should not set readOnly on non-virtual fields', async ()=>{
+        it('should not set readOnly on non-virtual fields', ()=>{
             const fields = [
                 {
                     name: 'normalText',
                     type: 'text'
                 }
             ];
-            const sanitizedField = (await sanitizeFields({
+            const sanitizedField = sanitizeFields({
                 config,
                 collectionConfig,
                 fields,
                 validRelationships: []
-            }))[0];
+            })[0];
             expect(sanitizedField.admin?.readOnly).toBeUndefined();
         });
     });