payload 3.0.0-beta.13 → 3.0.0-beta.131

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

@@ -1,172 +1,163 @@
-import { InvalidFieldName, InvalidFieldRelationship, MissingFieldType } from '../../errors';
-import { sanitizeFields } from './sanitize';
-const dummyConfig = {
-    collections: [],
-    db: {
-        defaultIDType: 'text',
-        init: ()=>({})
-    }
-};
+import { InvalidFieldName, InvalidFieldRelationship, MissingFieldType } from '../../errors/index.js';
+import { sanitizeFields } from './sanitize.js';
 describe('sanitizeFields', ()=>{
-    it('should throw on missing type field', ()=>{
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
+    const config = {};
+    it('should throw on missing type field', async ()=>{
         const fields = [
+            // @ts-expect-error
             {
-                label: 'some-collection',
-                name: 'Some Collection'
+                name: 'Some Collection',
+                label: 'some-collection'
             }
         ];
-        expect(()=>{
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore
-            sanitizeFields({
-                config: dummyConfig,
+        await expect(async ()=>{
+            await sanitizeFields({
+                config,
                 fields,
                 validRelationships: []
             });
-        }).toThrow(MissingFieldType);
+        }).rejects.toThrow(MissingFieldType);
     });
-    it('should throw on invalid field name', ()=>{
+    it('should throw on invalid field name', async ()=>{
         const fields = [
             {
-                label: 'some.collection',
                 name: 'some.collection',
-                type: 'text'
+                type: 'text',
+                label: 'some.collection'
             }
         ];
-        expect(()=>{
-            sanitizeFields({
-                config: dummyConfig,
+        await expect(async ()=>{
+            await sanitizeFields({
+                config,
                 fields,
                 validRelationships: []
             });
-        }).toThrow(InvalidFieldName);
+        }).rejects.toThrow(InvalidFieldName);
     });
     describe('auto-labeling', ()=>{
-        it('should populate label if missing', ()=>{
+        it('should populate label if missing', async ()=>{
             const fields = [
                 {
                     name: 'someField',
                     type: 'text'
                 }
             ];
-            const sanitizedField = sanitizeFields({
-                config: dummyConfig,
+            const sanitizedField = (await sanitizeFields({
+                config,
                 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', ()=>{
+        it('should allow auto-label override', async ()=>{
             const fields = [
                 {
-                    label: 'Do not label',
                     name: 'someField',
-                    type: 'text'
+                    type: 'text',
+                    label: 'Do not label'
                 }
             ];
-            const sanitizedField = sanitizeFields({
-                config: dummyConfig,
+            const sanitizedField = (await sanitizeFields({
+                config,
                 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', ()=>{
+            it('should allow label opt-out', async ()=>{
                 const fields = [
                     {
-                        label: false,
                         name: 'someField',
-                        type: 'text'
+                        type: 'text',
+                        label: false
                     }
                 ];
-                const sanitizedField = sanitizeFields({
-                    config: dummyConfig,
+                const sanitizedField = (await sanitizeFields({
+                    config,
                     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', ()=>{
+            it('should allow label opt-out for arrays', async ()=>{
                 const arrayField = {
+                    name: 'items',
+                    type: 'array',
                     fields: [
                         {
                             name: 'itemName',
                             type: 'text'
                         }
                     ],
-                    label: false,
-                    name: 'items',
-                    type: 'array'
+                    label: false
                 };
-                const sanitizedField = sanitizeFields({
-                    config: dummyConfig,
+                const sanitizedField = (await sanitizeFields({
+                    config,
                     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', ()=>{
+            it('should allow label opt-out for blocks', async ()=>{
                 const fields = [
                     {
+                        name: 'noLabelBlock',
+                        type: 'blocks',
                         blocks: [
                             {
+                                slug: 'number',
                                 fields: [
                                     {
                                         name: 'testNumber',
                                         type: 'number'
                                     }
-                                ],
-                                slug: 'number'
+                                ]
                             }
                         ],
-                        label: false,
-                        name: 'noLabelBlock',
-                        type: 'blocks'
+                        label: false
                     }
                 ];
-                const sanitizedField = sanitizeFields({
-                    config: dummyConfig,
+                const sanitizedField = (await sanitizeFields({
+                    config,
                     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', ()=>{
+        it('should label arrays with plural and singular', async ()=>{
             const fields = [
                 {
+                    name: 'items',
+                    type: 'array',
                     fields: [
                         {
                             name: 'itemName',
                             type: 'text'
                         }
-                    ],
-                    name: 'items',
-                    type: 'array'
+                    ]
                 }
             ];
-            const sanitizedField = sanitizeFields({
-                config: dummyConfig,
+            const sanitizedField = (await sanitizeFields({
+                config,
                 fields,
                 validRelationships: []
-            })[0];
+            }))[0];
             expect(sanitizedField.name).toStrictEqual('items');
             expect(sanitizedField.label).toStrictEqual('Items');
             expect(sanitizedField.type).toStrictEqual('array');
@@ -175,29 +166,29 @@ describe('sanitizeFields', ()=>{
                 singular: 'Item'
             });
         });
-        it('should label blocks with plural and singular', ()=>{
+        it('should label blocks with plural and singular', async ()=>{
             const fields = [
                 {
+                    name: 'specialBlock',
+                    type: 'blocks',
                     blocks: [
                         {
+                            slug: 'number',
                             fields: [
                                 {
                                     name: 'testNumber',
                                     type: 'number'
                                 }
-                            ],
-                            slug: 'number'
+                            ]
                         }
-                    ],
-                    name: 'specialBlock',
-                    type: 'blocks'
+                    ]
                 }
             ];
-            const sanitizedField = sanitizeFields({
-                config: dummyConfig,
+            const sanitizedField = (await sanitizeFields({
+                config,
                 fields,
                 validRelationships: []
-            })[0];
+            }))[0];
             expect(sanitizedField.name).toStrictEqual('specialBlock');
             expect(sanitizedField.label).toStrictEqual('Special Block');
             expect(sanitizedField.type).toStrictEqual('blocks');
@@ -209,178 +200,178 @@ describe('sanitizeFields', ()=>{
         });
     });
     describe('relationships', ()=>{
-        it('should not throw on valid relationship', ()=>{
+        it('should not throw on valid relationship', async ()=>{
             const validRelationships = [
                 'some-collection'
             ];
             const fields = [
                 {
-                    label: 'my-relationship',
                     name: 'My Relationship',
-                    relationTo: 'some-collection',
-                    type: 'relationship'
+                    type: 'relationship',
+                    label: 'my-relationship',
+                    relationTo: 'some-collection'
                 }
             ];
-            expect(()=>{
-                sanitizeFields({
-                    config: dummyConfig,
+            await expect(async ()=>{
+                await sanitizeFields({
+                    config,
                     fields,
                     validRelationships
                 });
             }).not.toThrow();
         });
-        it('should not throw on valid relationship - multiple', ()=>{
+        it('should not throw on valid relationship - multiple', async ()=>{
             const validRelationships = [
                 'some-collection',
                 'another-collection'
             ];
             const fields = [
                 {
-                    label: 'my-relationship',
                     name: 'My Relationship',
+                    type: 'relationship',
+                    label: 'my-relationship',
                     relationTo: [
                         'some-collection',
                         'another-collection'
-                    ],
-                    type: 'relationship'
+                    ]
                 }
             ];
-            expect(()=>{
-                sanitizeFields({
-                    config: dummyConfig,
+            await expect(async ()=>{
+                await sanitizeFields({
+                    config,
                     fields,
                     validRelationships
                 });
             }).not.toThrow();
         });
-        it('should not throw on valid relationship inside blocks', ()=>{
+        it('should not throw on valid relationship inside blocks', async ()=>{
             const validRelationships = [
                 'some-collection'
             ];
             const relationshipBlock = {
+                slug: 'relationshipBlock',
                 fields: [
                     {
-                        label: 'my-relationship',
                         name: 'My Relationship',
-                        relationTo: 'some-collection',
-                        type: 'relationship'
+                        type: 'relationship',
+                        label: 'my-relationship',
+                        relationTo: 'some-collection'
                     }
-                ],
-                slug: 'relationshipBlock'
+                ]
             };
             const fields = [
                 {
+                    name: 'layout',
+                    type: 'blocks',
                     blocks: [
                         relationshipBlock
                     ],
-                    label: 'Layout Blocks',
-                    name: 'layout',
-                    type: 'blocks'
+                    label: 'Layout Blocks'
                 }
             ];
-            expect(()=>{
-                sanitizeFields({
-                    config: dummyConfig,
+            await expect(async ()=>{
+                await sanitizeFields({
+                    config,
                     fields,
                     validRelationships
                 });
             }).not.toThrow();
         });
-        it('should throw on invalid relationship', ()=>{
+        it('should throw on invalid relationship', async ()=>{
             const validRelationships = [
                 'some-collection'
             ];
             const fields = [
                 {
-                    label: 'my-relationship',
                     name: 'My Relationship',
-                    relationTo: 'not-valid',
-                    type: 'relationship'
+                    type: 'relationship',
+                    label: 'my-relationship',
+                    relationTo: 'not-valid'
                 }
             ];
-            expect(()=>{
-                sanitizeFields({
-                    config: dummyConfig,
+            await expect(async ()=>{
+                await sanitizeFields({
+                    config,
                     fields,
                     validRelationships
                 });
-            }).toThrow(InvalidFieldRelationship);
+            }).rejects.toThrow(InvalidFieldRelationship);
         });
-        it('should throw on invalid relationship - multiple', ()=>{
+        it('should throw on invalid relationship - multiple', async ()=>{
             const validRelationships = [
                 'some-collection',
                 'another-collection'
             ];
             const fields = [
                 {
-                    label: 'my-relationship',
                     name: 'My Relationship',
+                    type: 'relationship',
+                    label: 'my-relationship',
                     relationTo: [
                         'some-collection',
                         'not-valid'
-                    ],
-                    type: 'relationship'
+                    ]
                 }
             ];
-            expect(()=>{
-                sanitizeFields({
-                    config: dummyConfig,
+            await expect(async ()=>{
+                await sanitizeFields({
+                    config,
                     fields,
                     validRelationships
                 });
-            }).toThrow(InvalidFieldRelationship);
+            }).rejects.toThrow(InvalidFieldRelationship);
         });
-        it('should throw on invalid relationship inside blocks', ()=>{
+        it('should throw on invalid relationship inside blocks', async ()=>{
             const validRelationships = [
                 'some-collection'
             ];
             const relationshipBlock = {
+                slug: 'relationshipBlock',
                 fields: [
                     {
-                        label: 'my-relationship',
                         name: 'My Relationship',
-                        relationTo: 'not-valid',
-                        type: 'relationship'
+                        type: 'relationship',
+                        label: 'my-relationship',
+                        relationTo: 'not-valid'
                     }
-                ],
-                slug: 'relationshipBlock'
+                ]
             };
             const fields = [
                 {
+                    name: 'layout',
+                    type: 'blocks',
                     blocks: [
                         relationshipBlock
                     ],
-                    label: 'Layout Blocks',
-                    name: 'layout',
-                    type: 'blocks'
+                    label: 'Layout Blocks'
                 }
             ];
-            expect(()=>{
-                sanitizeFields({
-                    config: dummyConfig,
+            await expect(async ()=>{
+                await sanitizeFields({
+                    config,
                     fields,
                     validRelationships
                 });
-            }).toThrow(InvalidFieldRelationship);
+            }).rejects.toThrow(InvalidFieldRelationship);
         });
-        it('should defaultValue of checkbox to false if required and undefined', ()=>{
+        it('should defaultValue of checkbox to false if required and undefined', async ()=>{
             const fields = [
                 {
                     name: 'My Checkbox',
-                    required: true,
-                    type: 'checkbox'
+                    type: 'checkbox',
+                    required: true
                 }
             ];
-            const sanitizedField = sanitizeFields({
-                config: dummyConfig,
+            const sanitizedField = (await sanitizeFields({
+                config,
                 fields,
                 validRelationships: []
-            })[0];
+            }))[0];
             expect(sanitizedField.defaultValue).toStrictEqual(false);
         });
-        it('should return empty field array if no fields', ()=>{
-            const sanitizedFields = sanitizeFields({
-                config: dummyConfig,
+        it('should return empty field array if no fields', async ()=>{
+            const sanitizedFields = await sanitizeFields({
+                config,
                 fields: [],
                 validRelationships: []
             });

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/fields/config/sanitize.spec.ts"],"sourcesContent":["import type {\n  ArrayField,\n  Block,\n  BlockField,\n  CheckboxField,\n  Field,\n  NumberField,\n  TextField,\n} from './types'\nimport { Config } from '../../config/types'\nimport { InvalidFieldName, InvalidFieldRelationship, MissingFieldType } from '../../errors'\nimport { sanitizeFields } from './sanitize'\nimport type { BaseDatabaseAdapter } from '../../database/types.js'\n\nconst dummyConfig: Config = {\n  collections: [],\n  db: {\n    defaultIDType: 'text',\n    init: () => ({}) as BaseDatabaseAdapter['init'],\n  } as BaseDatabaseAdapter,\n}\n\ndescribe('sanitizeFields', () => {\n  it('should throw on missing type field', () => {\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore\n    const fields: Field[] = [\n      {\n        label: 'some-collection',\n        name: 'Some Collection',\n      },\n    ]\n    expect(() => {\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      // @ts-ignore\n      sanitizeFields({\n        config: dummyConfig,\n        fields,\n        validRelationships: [],\n      })\n    }).toThrow(MissingFieldType)\n  })\n  it('should throw on invalid field name', () => {\n    const fields: Field[] = [\n      {\n        label: 'some.collection',\n        name: 'some.collection',\n        type: 'text',\n      },\n    ]\n    expect(() => {\n      sanitizeFields({\n        config: dummyConfig,\n        fields,\n        validRelationships: [],\n      })\n    }).toThrow(InvalidFieldName)\n  })\n\n  describe('auto-labeling', () => {\n    it('should populate label if missing', () => {\n      const fields: Field[] = [\n        {\n          name: 'someField',\n          type: 'text',\n        },\n      ]\n      const sanitizedField = sanitizeFields({\n        config: dummyConfig,\n        fields,\n        validRelationships: [],\n      })[0] as TextField\n      expect(sanitizedField.name).toStrictEqual('someField')\n      expect(sanitizedField.label).toStrictEqual('Some Field')\n      expect(sanitizedField.type).toStrictEqual('text')\n    })\n    it('should allow auto-label override', () => {\n      const fields: Field[] = [\n        {\n          label: 'Do not label',\n          name: 'someField',\n          type: 'text',\n        },\n      ]\n      const sanitizedField = sanitizeFields({\n        config: dummyConfig,\n        fields,\n        validRelationships: [],\n      })[0] as TextField\n      expect(sanitizedField.name).toStrictEqual('someField')\n      expect(sanitizedField.label).toStrictEqual('Do not label')\n      expect(sanitizedField.type).toStrictEqual('text')\n    })\n\n    describe('opt-out', () => {\n      it('should allow label opt-out', () => {\n        const fields: Field[] = [\n          {\n            label: false,\n            name: 'someField',\n            type: 'text',\n          },\n        ]\n        const sanitizedField = sanitizeFields({\n          config: dummyConfig,\n          fields,\n          validRelationships: [],\n        })[0] as TextField\n        expect(sanitizedField.name).toStrictEqual('someField')\n        expect(sanitizedField.label).toStrictEqual(false)\n        expect(sanitizedField.type).toStrictEqual('text')\n      })\n\n      it('should allow label opt-out for arrays', () => {\n        const arrayField: ArrayField = {\n          fields: [\n            {\n              name: 'itemName',\n              type: 'text',\n            },\n          ],\n          label: false,\n          name: 'items',\n          type: 'array',\n        }\n        const sanitizedField = sanitizeFields({\n          config: dummyConfig,\n          fields: [arrayField],\n          validRelationships: [],\n        })[0] as ArrayField\n        expect(sanitizedField.name).toStrictEqual('items')\n        expect(sanitizedField.label).toStrictEqual(false)\n        expect(sanitizedField.type).toStrictEqual('array')\n        expect(sanitizedField.labels).toBeUndefined()\n      })\n      it('should allow label opt-out for blocks', () => {\n        const fields: Field[] = [\n          {\n            blocks: [\n              {\n                fields: [\n                  {\n                    name: 'testNumber',\n                    type: 'number',\n                  },\n                ],\n                slug: 'number',\n              },\n            ],\n            label: false,\n            name: 'noLabelBlock',\n            type: 'blocks',\n          },\n        ]\n        const sanitizedField = sanitizeFields({\n          config: dummyConfig,\n          fields,\n          validRelationships: [],\n        })[0] as BlockField\n        expect(sanitizedField.name).toStrictEqual('noLabelBlock')\n        expect(sanitizedField.label).toStrictEqual(false)\n        expect(sanitizedField.type).toStrictEqual('blocks')\n        expect(sanitizedField.labels).toBeUndefined()\n      })\n    })\n\n    it('should label arrays with plural and singular', () => {\n      const fields: Field[] = [\n        {\n          fields: [\n            {\n              name: 'itemName',\n              type: 'text',\n            },\n          ],\n          name: 'items',\n          type: 'array',\n        },\n      ]\n      const sanitizedField = sanitizeFields({\n        config: dummyConfig,\n        fields,\n        validRelationships: [],\n      })[0] as ArrayField\n      expect(sanitizedField.name).toStrictEqual('items')\n      expect(sanitizedField.label).toStrictEqual('Items')\n      expect(sanitizedField.type).toStrictEqual('array')\n      expect(sanitizedField.labels).toMatchObject({ plural: 'Items', singular: 'Item' })\n    })\n\n    it('should label blocks with plural and singular', () => {\n      const fields: Field[] = [\n        {\n          blocks: [\n            {\n              fields: [{ name: 'testNumber', type: 'number' }],\n              slug: 'number',\n            },\n          ],\n          name: 'specialBlock',\n          type: 'blocks',\n        },\n      ]\n      const sanitizedField = sanitizeFields({\n        config: dummyConfig,\n        fields,\n        validRelationships: [],\n      })[0] as BlockField\n      expect(sanitizedField.name).toStrictEqual('specialBlock')\n      expect(sanitizedField.label).toStrictEqual('Special Block')\n      expect(sanitizedField.type).toStrictEqual('blocks')\n      expect(sanitizedField.labels).toMatchObject({\n        plural: 'Special Blocks',\n        singular: 'Special Block',\n      })\n      expect((sanitizedField.blocks[0].fields[0] as NumberField).label).toStrictEqual('Test Number')\n    })\n  })\n\n  describe('relationships', () => {\n    it('should not throw on valid relationship', () => {\n      const validRelationships = ['some-collection']\n      const fields: Field[] = [\n        {\n          label: 'my-relationship',\n          name: 'My Relationship',\n          relationTo: 'some-collection',\n          type: 'relationship',\n        },\n      ]\n      expect(() => {\n        sanitizeFields({ config: dummyConfig, fields, validRelationships })\n      }).not.toThrow()\n    })\n\n    it('should not throw on valid relationship - multiple', () => {\n      const validRelationships = ['some-collection', 'another-collection']\n      const fields: Field[] = [\n        {\n          label: 'my-relationship',\n          name: 'My Relationship',\n          relationTo: ['some-collection', 'another-collection'],\n          type: 'relationship',\n        },\n      ]\n      expect(() => {\n        sanitizeFields({ config: dummyConfig, fields, validRelationships })\n      }).not.toThrow()\n    })\n\n    it('should not throw on valid relationship inside blocks', () => {\n      const validRelationships = ['some-collection']\n      const relationshipBlock: Block = {\n        fields: [\n          {\n            label: 'my-relationship',\n            name: 'My Relationship',\n            relationTo: 'some-collection',\n            type: 'relationship',\n          },\n        ],\n        slug: 'relationshipBlock',\n      }\n      const fields: Field[] = [\n        {\n          blocks: [relationshipBlock],\n          label: 'Layout Blocks',\n          name: 'layout',\n          type: 'blocks',\n        },\n      ]\n      expect(() => {\n        sanitizeFields({ config: dummyConfig, fields, validRelationships })\n      }).not.toThrow()\n    })\n\n    it('should throw on invalid relationship', () => {\n      const validRelationships = ['some-collection']\n      const fields: Field[] = [\n        {\n          label: 'my-relationship',\n          name: 'My Relationship',\n          relationTo: 'not-valid',\n          type: 'relationship',\n        },\n      ]\n      expect(() => {\n        sanitizeFields({ config: dummyConfig, fields, validRelationships })\n      }).toThrow(InvalidFieldRelationship)\n    })\n\n    it('should throw on invalid relationship - multiple', () => {\n      const validRelationships = ['some-collection', 'another-collection']\n      const fields: Field[] = [\n        {\n          label: 'my-relationship',\n          name: 'My Relationship',\n          relationTo: ['some-collection', 'not-valid'],\n          type: 'relationship',\n        },\n      ]\n      expect(() => {\n        sanitizeFields({ config: dummyConfig, fields, validRelationships })\n      }).toThrow(InvalidFieldRelationship)\n    })\n\n    it('should throw on invalid relationship inside blocks', () => {\n      const validRelationships = ['some-collection']\n      const relationshipBlock: Block = {\n        fields: [\n          {\n            label: 'my-relationship',\n            name: 'My Relationship',\n            relationTo: 'not-valid',\n            type: 'relationship',\n          },\n        ],\n        slug: 'relationshipBlock',\n      }\n      const fields: Field[] = [\n        {\n          blocks: [relationshipBlock],\n          label: 'Layout Blocks',\n          name: 'layout',\n          type: 'blocks',\n        },\n      ]\n      expect(() => {\n        sanitizeFields({ config: dummyConfig, fields, validRelationships })\n      }).toThrow(InvalidFieldRelationship)\n    })\n\n    it('should defaultValue of checkbox to false if required and undefined', () => {\n      const fields: Field[] = [\n        {\n          name: 'My Checkbox',\n          required: true,\n          type: 'checkbox',\n        },\n      ]\n\n      const sanitizedField = sanitizeFields({\n        config: dummyConfig,\n        fields,\n        validRelationships: [],\n      })[0] as CheckboxField\n      expect(sanitizedField.defaultValue).toStrictEqual(false)\n    })\n\n    it('should return empty field array if no fields', () => {\n      const sanitizedFields = sanitizeFields({\n        config: dummyConfig,\n        fields: [],\n        validRelationships: [],\n      })\n      expect(sanitizedFields).toStrictEqual([])\n    })\n  })\n})\n"],"names":["InvalidFieldName","InvalidFieldRelationship","MissingFieldType","sanitizeFields","dummyConfig","collections","db","defaultIDType","init","describe","it","fields","label","name","expect","config","validRelationships","toThrow","type","sanitizedField","toStrictEqual","arrayField","labels","toBeUndefined","blocks","slug","toMatchObject","plural","singular","relationTo","not","relationshipBlock","required","defaultValue","sanitizedFields"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../../../src/fields/config/sanitize.spec.ts"],"sourcesContent":["import type { Config } from '../../config/types.js'\nimport type {\n  ArrayField,\n  Block,\n  BlocksField,\n  CheckboxField,\n  Field,\n  NumberField,\n  TextField,\n} from './types.js'\n\nimport { InvalidFieldName, InvalidFieldRelationship, MissingFieldType } from '../../errors/index.js'\nimport { sanitizeFields } from './sanitize.js'\n\ndescribe('sanitizeFields', () => {\n  const config = {} as Config\n  it('should throw on missing type field', async () => {\n    const fields: Field[] = [\n      // @ts-expect-error\n      {\n        name: 'Some Collection',\n        label: 'some-collection',\n      },\n    ]\n    await expect(async () => {\n      await sanitizeFields({\n        config,\n        fields,\n        validRelationships: [],\n      })\n    }).rejects.toThrow(MissingFieldType)\n  })\n  it('should throw on invalid field name', async () => {\n    const fields: Field[] = [\n      {\n        name: 'some.collection',\n        type: 'text',\n        label: 'some.collection',\n      },\n    ]\n    await expect(async () => {\n      await sanitizeFields({\n        config,\n        fields,\n        validRelationships: [],\n      })\n    }).rejects.toThrow(InvalidFieldName)\n  })\n\n  describe('auto-labeling', () => {\n    it('should populate label if missing', async () => {\n      const fields: Field[] = [\n        {\n          name: 'someField',\n          type: 'text',\n        },\n      ]\n      const sanitizedField = (\n        await sanitizeFields({\n          config,\n          fields,\n          validRelationships: [],\n        })\n      )[0] as TextField\n      expect(sanitizedField.name).toStrictEqual('someField')\n      expect(sanitizedField.label).toStrictEqual('Some Field')\n      expect(sanitizedField.type).toStrictEqual('text')\n    })\n    it('should allow auto-label override', async () => {\n      const fields: Field[] = [\n        {\n          name: 'someField',\n          type: 'text',\n          label: 'Do not label',\n        },\n      ]\n      const sanitizedField = (\n        await sanitizeFields({\n          config,\n          fields,\n          validRelationships: [],\n        })\n      )[0] as TextField\n      expect(sanitizedField.name).toStrictEqual('someField')\n      expect(sanitizedField.label).toStrictEqual('Do not label')\n      expect(sanitizedField.type).toStrictEqual('text')\n    })\n\n    describe('opt-out', () => {\n      it('should allow label opt-out', async () => {\n        const fields: Field[] = [\n          {\n            name: 'someField',\n            type: 'text',\n            label: false,\n          },\n        ]\n        const sanitizedField = (\n          await sanitizeFields({\n            config,\n            fields,\n            validRelationships: [],\n          })\n        )[0] as TextField\n        expect(sanitizedField.name).toStrictEqual('someField')\n        expect(sanitizedField.label).toStrictEqual(false)\n        expect(sanitizedField.type).toStrictEqual('text')\n      })\n\n      it('should allow label opt-out for arrays', async () => {\n        const arrayField: ArrayField = {\n          name: 'items',\n          type: 'array',\n          fields: [\n            {\n              name: 'itemName',\n              type: 'text',\n            },\n          ],\n          label: false,\n        }\n        const sanitizedField = (\n          await sanitizeFields({\n            config,\n            fields: [arrayField],\n            validRelationships: [],\n          })\n        )[0] as ArrayField\n        expect(sanitizedField.name).toStrictEqual('items')\n        expect(sanitizedField.label).toStrictEqual(false)\n        expect(sanitizedField.type).toStrictEqual('array')\n        expect(sanitizedField.labels).toBeUndefined()\n      })\n      it('should allow label opt-out for blocks', async () => {\n        const fields: Field[] = [\n          {\n            name: 'noLabelBlock',\n            type: 'blocks',\n            blocks: [\n              {\n                slug: 'number',\n                fields: [\n                  {\n                    name: 'testNumber',\n                    type: 'number',\n                  },\n                ],\n              },\n            ],\n            label: false,\n          },\n        ]\n        const sanitizedField = (\n          await sanitizeFields({\n            config,\n            fields,\n            validRelationships: [],\n          })\n        )[0] as BlocksField\n        expect(sanitizedField.name).toStrictEqual('noLabelBlock')\n        expect(sanitizedField.label).toStrictEqual(false)\n        expect(sanitizedField.type).toStrictEqual('blocks')\n        expect(sanitizedField.labels).toBeUndefined()\n      })\n    })\n\n    it('should label arrays with plural and singular', async () => {\n      const fields: Field[] = [\n        {\n          name: 'items',\n          type: 'array',\n          fields: [\n            {\n              name: 'itemName',\n              type: 'text',\n            },\n          ],\n        },\n      ]\n      const sanitizedField = (\n        await sanitizeFields({\n          config,\n          fields,\n          validRelationships: [],\n        })\n      )[0] as ArrayField\n      expect(sanitizedField.name).toStrictEqual('items')\n      expect(sanitizedField.label).toStrictEqual('Items')\n      expect(sanitizedField.type).toStrictEqual('array')\n      expect(sanitizedField.labels).toMatchObject({ plural: 'Items', singular: 'Item' })\n    })\n\n    it('should label blocks with plural and singular', async () => {\n      const fields: Field[] = [\n        {\n          name: 'specialBlock',\n          type: 'blocks',\n          blocks: [\n            {\n              slug: 'number',\n              fields: [{ name: 'testNumber', type: 'number' }],\n            },\n          ],\n        },\n      ]\n      const sanitizedField = (\n        await sanitizeFields({\n          config,\n          fields,\n          validRelationships: [],\n        })\n      )[0] as BlocksField\n      expect(sanitizedField.name).toStrictEqual('specialBlock')\n      expect(sanitizedField.label).toStrictEqual('Special Block')\n      expect(sanitizedField.type).toStrictEqual('blocks')\n      expect(sanitizedField.labels).toMatchObject({\n        plural: 'Special Blocks',\n        singular: 'Special Block',\n      })\n      expect((sanitizedField.blocks[0].fields[0] as NumberField).label).toStrictEqual('Test Number')\n    })\n  })\n\n  describe('relationships', () => {\n    it('should not throw on valid relationship', async () => {\n      const validRelationships = ['some-collection']\n      const fields: Field[] = [\n        {\n          name: 'My Relationship',\n          type: 'relationship',\n          label: 'my-relationship',\n          relationTo: 'some-collection',\n        },\n      ]\n      await expect(async () => {\n        await sanitizeFields({ config, fields, validRelationships })\n      }).not.toThrow()\n    })\n\n    it('should not throw on valid relationship - multiple', async () => {\n      const validRelationships = ['some-collection', 'another-collection']\n      const fields: Field[] = [\n        {\n          name: 'My Relationship',\n          type: 'relationship',\n          label: 'my-relationship',\n          relationTo: ['some-collection', 'another-collection'],\n        },\n      ]\n      await expect(async () => {\n        await sanitizeFields({ config, fields, validRelationships })\n      }).not.toThrow()\n    })\n\n    it('should not throw on valid relationship inside blocks', async () => {\n      const validRelationships = ['some-collection']\n      const relationshipBlock: Block = {\n        slug: 'relationshipBlock',\n        fields: [\n          {\n            name: 'My Relationship',\n            type: 'relationship',\n            label: 'my-relationship',\n            relationTo: 'some-collection',\n          },\n        ],\n      }\n      const fields: Field[] = [\n        {\n          name: 'layout',\n          type: 'blocks',\n          blocks: [relationshipBlock],\n          label: 'Layout Blocks',\n        },\n      ]\n      await expect(async () => {\n        await sanitizeFields({ config, fields, validRelationships })\n      }).not.toThrow()\n    })\n\n    it('should throw on invalid relationship', async () => {\n      const validRelationships = ['some-collection']\n      const fields: Field[] = [\n        {\n          name: 'My Relationship',\n          type: 'relationship',\n          label: 'my-relationship',\n          relationTo: 'not-valid',\n        },\n      ]\n      await expect(async () => {\n        await sanitizeFields({ config, fields, validRelationships })\n      }).rejects.toThrow(InvalidFieldRelationship)\n    })\n\n    it('should throw on invalid relationship - multiple', async () => {\n      const validRelationships = ['some-collection', 'another-collection']\n      const fields: Field[] = [\n        {\n          name: 'My Relationship',\n          type: 'relationship',\n          label: 'my-relationship',\n          relationTo: ['some-collection', 'not-valid'],\n        },\n      ]\n      await expect(async () => {\n        await sanitizeFields({ config, fields, validRelationships })\n      }).rejects.toThrow(InvalidFieldRelationship)\n    })\n\n    it('should throw on invalid relationship inside blocks', async () => {\n      const validRelationships = ['some-collection']\n      const relationshipBlock: Block = {\n        slug: 'relationshipBlock',\n        fields: [\n          {\n            name: 'My Relationship',\n            type: 'relationship',\n            label: 'my-relationship',\n            relationTo: 'not-valid',\n          },\n        ],\n      }\n      const fields: Field[] = [\n        {\n          name: 'layout',\n          type: 'blocks',\n          blocks: [relationshipBlock],\n          label: 'Layout Blocks',\n        },\n      ]\n      await expect(async () => {\n        await sanitizeFields({ config, fields, validRelationships })\n      }).rejects.toThrow(InvalidFieldRelationship)\n    })\n\n    it('should defaultValue of checkbox to false if required and undefined', async () => {\n      const fields: Field[] = [\n        {\n          name: 'My Checkbox',\n          type: 'checkbox',\n          required: true,\n        },\n      ]\n\n      const sanitizedField = (\n        await sanitizeFields({\n          config,\n          fields,\n          validRelationships: [],\n        })\n      )[0] as CheckboxField\n      expect(sanitizedField.defaultValue).toStrictEqual(false)\n    })\n\n    it('should return empty field array if no fields', async () => {\n      const sanitizedFields = await sanitizeFields({\n        config,\n        fields: [],\n        validRelationships: [],\n      })\n      expect(sanitizedFields).toStrictEqual([])\n    })\n  })\n})\n"],"names":["InvalidFieldName","InvalidFieldRelationship","MissingFieldType","sanitizeFields","describe","config","it","fields","name","label","expect","validRelationships","rejects","toThrow","type","sanitizedField","toStrictEqual","arrayField","labels","toBeUndefined","blocks","slug","toMatchObject","plural","singular","relationTo","not","relationshipBlock","required","defaultValue","sanitizedFields"],"mappings":"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"}

package/dist/fields/config/sanitizeJoinField.d.ts

@@ -0,0 +1,10 @@
+import type { SanitizedJoins } from '../../collections/config/types.js';
+import type { Config } from '../../config/types.js';
+import type { JoinField } from './types.js';
+export declare const sanitizeJoinField: ({ config, field, joinPath, joins, }: {
+    config: Config;
+    field: JoinField;
+    joinPath?: string;
+    joins?: SanitizedJoins;
+}) => void;
+//# sourceMappingURL=sanitizeJoinField.d.ts.map

package/dist/fields/config/sanitizeJoinField.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitizeJoinField.d.ts","sourceRoot":"","sources":["../../../src/fields/config/sanitizeJoinField.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,cAAc,EAAE,MAAM,mCAAmC,CAAA;AACtF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAA;AACnD,OAAO,KAAK,EAAE,SAAS,EAAkC,MAAM,YAAY,CAAA;AAK3E,eAAO,MAAM,iBAAiB,wCAK3B;IACD,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,SAAS,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,cAAc,CAAA;CACvB,SA2EA,CAAA"}