payload 1.15.6 → 2.0.0-beta.0

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

@@ -0,0 +1,398 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _errors = require("../../errors");
+const _sanitize = /*#__PURE__*/ _interop_require_default(require("./sanitize"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const dummyConfig = {
+    collections: [],
+    db: ()=>({})
+};
+describe('sanitizeFields', ()=>{
+    it('should throw on missing type field', ()=>{
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        const fields = [
+            {
+                label: 'some-collection',
+                name: 'Some Collection'
+            }
+        ];
+        expect(()=>{
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            (0, _sanitize.default)({
+                config: dummyConfig,
+                fields,
+                validRelationships: []
+            });
+        }).toThrow(_errors.MissingFieldType);
+    });
+    it('should throw on invalid field name', ()=>{
+        const fields = [
+            {
+                label: 'some.collection',
+                name: 'some.collection',
+                type: 'text'
+            }
+        ];
+        expect(()=>{
+            (0, _sanitize.default)({
+                config: dummyConfig,
+                fields,
+                validRelationships: []
+            });
+        }).toThrow(_errors.InvalidFieldName);
+    });
+    describe('auto-labeling', ()=>{
+        it('should populate label if missing', ()=>{
+            const fields = [
+                {
+                    name: 'someField',
+                    type: 'text'
+                }
+            ];
+            const sanitizedField = (0, _sanitize.default)({
+                config: dummyConfig,
+                fields,
+                validRelationships: []
+            })[0];
+            expect(sanitizedField.name).toStrictEqual('someField');
+            expect(sanitizedField.label).toStrictEqual('Some Field');
+            expect(sanitizedField.type).toStrictEqual('text');
+        });
+        it('should allow auto-label override', ()=>{
+            const fields = [
+                {
+                    label: 'Do not label',
+                    name: 'someField',
+                    type: 'text'
+                }
+            ];
+            const sanitizedField = (0, _sanitize.default)({
+                config: dummyConfig,
+                fields,
+                validRelationships: []
+            })[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', ()=>{
+                const fields = [
+                    {
+                        label: false,
+                        name: 'someField',
+                        type: 'text'
+                    }
+                ];
+                const sanitizedField = (0, _sanitize.default)({
+                    config: dummyConfig,
+                    fields,
+                    validRelationships: []
+                })[0];
+                expect(sanitizedField.name).toStrictEqual('someField');
+                expect(sanitizedField.label).toStrictEqual(false);
+                expect(sanitizedField.type).toStrictEqual('text');
+            });
+            it('should allow label opt-out for arrays', ()=>{
+                const arrayField = {
+                    fields: [
+                        {
+                            name: 'itemName',
+                            type: 'text'
+                        }
+                    ],
+                    label: false,
+                    name: 'items',
+                    type: 'array'
+                };
+                const sanitizedField = (0, _sanitize.default)({
+                    config: dummyConfig,
+                    fields: [
+                        arrayField
+                    ],
+                    validRelationships: []
+                })[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', ()=>{
+                const fields = [
+                    {
+                        blocks: [
+                            {
+                                fields: [
+                                    {
+                                        name: 'testNumber',
+                                        type: 'number'
+                                    }
+                                ],
+                                slug: 'number'
+                            }
+                        ],
+                        label: false,
+                        name: 'noLabelBlock',
+                        type: 'blocks'
+                    }
+                ];
+                const sanitizedField = (0, _sanitize.default)({
+                    config: dummyConfig,
+                    fields,
+                    validRelationships: []
+                })[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', ()=>{
+            const fields = [
+                {
+                    fields: [
+                        {
+                            name: 'itemName',
+                            type: 'text'
+                        }
+                    ],
+                    name: 'items',
+                    type: 'array'
+                }
+            ];
+            const sanitizedField = (0, _sanitize.default)({
+                config: dummyConfig,
+                fields,
+                validRelationships: []
+            })[0];
+            expect(sanitizedField.name).toStrictEqual('items');
+            expect(sanitizedField.label).toStrictEqual('Items');
+            expect(sanitizedField.type).toStrictEqual('array');
+            expect(sanitizedField.labels).toMatchObject({
+                plural: 'Items',
+                singular: 'Item'
+            });
+        });
+        it('should label blocks with plural and singular', ()=>{
+            const fields = [
+                {
+                    blocks: [
+                        {
+                            fields: [
+                                {
+                                    name: 'testNumber',
+                                    type: 'number'
+                                }
+                            ],
+                            slug: 'number'
+                        }
+                    ],
+                    name: 'specialBlock',
+                    type: 'blocks'
+                }
+            ];
+            const sanitizedField = (0, _sanitize.default)({
+                config: dummyConfig,
+                fields,
+                validRelationships: []
+            })[0];
+            expect(sanitizedField.name).toStrictEqual('specialBlock');
+            expect(sanitizedField.label).toStrictEqual('Special Block');
+            expect(sanitizedField.type).toStrictEqual('blocks');
+            expect(sanitizedField.labels).toMatchObject({
+                plural: 'Special Blocks',
+                singular: 'Special Block'
+            });
+            expect(sanitizedField.blocks[0].fields[0].label).toStrictEqual('Test Number');
+        });
+    });
+    describe('relationships', ()=>{
+        it('should not throw on valid relationship', ()=>{
+            const validRelationships = [
+                'some-collection'
+            ];
+            const fields = [
+                {
+                    label: 'my-relationship',
+                    name: 'My Relationship',
+                    relationTo: 'some-collection',
+                    type: 'relationship'
+                }
+            ];
+            expect(()=>{
+                (0, _sanitize.default)({
+                    config: dummyConfig,
+                    fields,
+                    validRelationships
+                });
+            }).not.toThrow();
+        });
+        it('should not throw on valid relationship - multiple', ()=>{
+            const validRelationships = [
+                'some-collection',
+                'another-collection'
+            ];
+            const fields = [
+                {
+                    label: 'my-relationship',
+                    name: 'My Relationship',
+                    relationTo: [
+                        'some-collection',
+                        'another-collection'
+                    ],
+                    type: 'relationship'
+                }
+            ];
+            expect(()=>{
+                (0, _sanitize.default)({
+                    config: dummyConfig,
+                    fields,
+                    validRelationships
+                });
+            }).not.toThrow();
+        });
+        it('should not throw on valid relationship inside blocks', ()=>{
+            const validRelationships = [
+                'some-collection'
+            ];
+            const relationshipBlock = {
+                fields: [
+                    {
+                        label: 'my-relationship',
+                        name: 'My Relationship',
+                        relationTo: 'some-collection',
+                        type: 'relationship'
+                    }
+                ],
+                slug: 'relationshipBlock'
+            };
+            const fields = [
+                {
+                    blocks: [
+                        relationshipBlock
+                    ],
+                    label: 'Layout Blocks',
+                    name: 'layout',
+                    type: 'blocks'
+                }
+            ];
+            expect(()=>{
+                (0, _sanitize.default)({
+                    config: dummyConfig,
+                    fields,
+                    validRelationships
+                });
+            }).not.toThrow();
+        });
+        it('should throw on invalid relationship', ()=>{
+            const validRelationships = [
+                'some-collection'
+            ];
+            const fields = [
+                {
+                    label: 'my-relationship',
+                    name: 'My Relationship',
+                    relationTo: 'not-valid',
+                    type: 'relationship'
+                }
+            ];
+            expect(()=>{
+                (0, _sanitize.default)({
+                    config: dummyConfig,
+                    fields,
+                    validRelationships
+                });
+            }).toThrow(_errors.InvalidFieldRelationship);
+        });
+        it('should throw on invalid relationship - multiple', ()=>{
+            const validRelationships = [
+                'some-collection',
+                'another-collection'
+            ];
+            const fields = [
+                {
+                    label: 'my-relationship',
+                    name: 'My Relationship',
+                    relationTo: [
+                        'some-collection',
+                        'not-valid'
+                    ],
+                    type: 'relationship'
+                }
+            ];
+            expect(()=>{
+                (0, _sanitize.default)({
+                    config: dummyConfig,
+                    fields,
+                    validRelationships
+                });
+            }).toThrow(_errors.InvalidFieldRelationship);
+        });
+        it('should throw on invalid relationship inside blocks', ()=>{
+            const validRelationships = [
+                'some-collection'
+            ];
+            const relationshipBlock = {
+                fields: [
+                    {
+                        label: 'my-relationship',
+                        name: 'My Relationship',
+                        relationTo: 'not-valid',
+                        type: 'relationship'
+                    }
+                ],
+                slug: 'relationshipBlock'
+            };
+            const fields = [
+                {
+                    blocks: [
+                        relationshipBlock
+                    ],
+                    label: 'Layout Blocks',
+                    name: 'layout',
+                    type: 'blocks'
+                }
+            ];
+            expect(()=>{
+                (0, _sanitize.default)({
+                    config: dummyConfig,
+                    fields,
+                    validRelationships
+                });
+            }).toThrow(_errors.InvalidFieldRelationship);
+        });
+        it('should defaultValue of checkbox to false if required and undefined', ()=>{
+            const fields = [
+                {
+                    name: 'My Checkbox',
+                    required: true,
+                    type: 'checkbox'
+                }
+            ];
+            const sanitizedField = (0, _sanitize.default)({
+                config: dummyConfig,
+                fields,
+                validRelationships: []
+            })[0];
+            expect(sanitizedField.defaultValue).toStrictEqual(false);
+        });
+        it('should return empty field array if no fields', ()=>{
+            const sanitizedFields = (0, _sanitize.default)({
+                config: dummyConfig,
+                fields: [],
+                validRelationships: []
+            });
+            expect(sanitizedFields).toStrictEqual([]);
+        });
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,{"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 { DatabaseAdapter } from '../..'\n\nconst dummyConfig: Config = {\n  collections: [],\n  db: () => ({}) as DatabaseAdapter,\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":["dummyConfig","collections","db","describe","it","fields","label","name","expect","sanitizeFields","config","validRelationships","toThrow","MissingFieldType","type","InvalidFieldName","sanitizedField","toStrictEqual","arrayField","labels","toBeUndefined","blocks","slug","toMatchObject","plural","singular","relationTo","not","relationshipBlock","InvalidFieldRelationship","required","defaultValue","sanitizedFields"],"mappings":"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"}