payload 1.15.6 → 2.0.0-beta.1

package/dist/fields/config/sanitize.js

@@ -1,39 +1,50 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const formatLabels_1 = require("../../utilities/formatLabels");
-const errors_1 = require("../../errors");
-const baseBlockFields_1 = require("../baseFields/baseBlockFields");
-const validations_1 = __importDefault(require("../validations"));
-const baseIDField_1 = require("../baseFields/baseIDField");
-const types_1 = require("./types");
-const withCondition_1 = __importDefault(require("../../admin/components/forms/withCondition"));
-const sanitizeFields = (fields, validRelationships) => {
-    if (!fields)
-        return [];
-    return fields.map((unsanitizedField) => {
-        var _a, _b;
-        const field = { ...unsanitizedField };
-        if (!field.type)
-            throw new errors_1.MissingFieldType(field);
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _withCondition = /*#__PURE__*/ _interop_require_default(require("../../admin/components/forms/withCondition"));
+const _errors = require("../../errors");
+const _formatLabels = require("../../utilities/formatLabels");
+const _baseBlockFields = require("../baseFields/baseBlockFields");
+const _baseIDField = require("../baseFields/baseIDField");
+const _validations = /*#__PURE__*/ _interop_require_default(require("../validations"));
+const _types = require("./types");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const sanitizeFields = ({ config, fields, validRelationships })=>{
+    if (!fields) return [];
+    return fields.map((unsanitizedField)=>{
+        const field = {
+            ...unsanitizedField
+        };
+        if (!field.type) throw new _errors.MissingFieldType(field);
         // assert that field names do not contain forbidden characters
-        if ((0, types_1.fieldAffectsData)(field) && field.name.includes('.')) {
-            throw new errors_1.InvalidFieldName(field, field.name);
+        if ((0, _types.fieldAffectsData)(field) && field.name.includes('.')) {
+            throw new _errors.InvalidFieldName(field, field.name);
         }
         // Auto-label
         if ('name' in field && field.name && typeof field.label !== 'object' && typeof field.label !== 'string' && field.label !== false) {
-            field.label = (0, formatLabels_1.toWords)(field.name);
+            field.label = (0, _formatLabels.toWords)(field.name);
         }
         if (field.type === 'checkbox' && typeof field.defaultValue === 'undefined' && field.required === true) {
             field.defaultValue = false;
         }
         if (field.type === 'relationship' || field.type === 'upload') {
-            const relationships = Array.isArray(field.relationTo) ? field.relationTo : [field.relationTo];
-            relationships.forEach((relationship) => {
+            const relationships = Array.isArray(field.relationTo) ? field.relationTo : [
+                field.relationTo
+            ];
+            relationships.forEach((relationship)=>{
                 if (!validRelationships.includes(relationship)) {
-                    throw new errors_1.InvalidFieldRelationship(field, relationship);
+                    throw new _errors.InvalidFieldRelationship(field, relationship);
                 }
             });
             if (field.type === 'relationship') {
@@ -48,59 +59,80 @@ const sanitizeFields = (fields, validRelationships) => {
             }
         }
         if (field.type === 'blocks' && field.blocks) {
-            field.blocks = field.blocks.map((block) => ({ ...block, fields: block.fields.concat(baseBlockFields_1.baseBlockFields) }));
+            field.blocks = field.blocks.map((block)=>({
+                    ...block,
+                    fields: block.fields.concat(_baseBlockFields.baseBlockFields)
+                }));
         }
         if (field.type === 'array' && field.fields) {
-            field.fields.push(baseIDField_1.baseIDField);
+            field.fields.push(_baseIDField.baseIDField);
         }
         if ((field.type === 'blocks' || field.type === 'array') && field.label) {
-            field.labels = field.labels || (0, formatLabels_1.formatLabels)(field.name);
+            field.labels = field.labels || (0, _formatLabels.formatLabels)(field.name);
         }
-        if ((0, types_1.fieldAffectsData)(field)) {
+        if ((0, _types.fieldAffectsData)(field)) {
+            if (field.localized && !config.localization) delete field.localized;
             if (typeof field.validate === 'undefined') {
-                const defaultValidate = validations_1.default[field.type];
+                const defaultValidate = _validations.default[field.type];
                 if (defaultValidate) {
-                    field.validate = (val, options) => defaultValidate(val, { ...field, ...options });
-                }
-                else {
-                    field.validate = () => true;
+                    field.validate = (val, options)=>defaultValidate(val, {
+                            ...field,
+                            ...options
+                        });
+                } else {
+                    field.validate = ()=>true;
                 }
             }
-            if (!field.hooks)
-                field.hooks = {};
-            if (!field.access)
-                field.access = {};
+            if (!field.hooks) field.hooks = {};
+            if (!field.access) field.access = {};
         }
         if (field.admin) {
-            if (field.admin.condition && ((_a = field.admin.components) === null || _a === void 0 ? void 0 : _a.Field)) {
-                field.admin.components.Field = (0, withCondition_1.default)((_b = field.admin.components) === null || _b === void 0 ? void 0 : _b.Field);
+            if (field.admin.condition && field.admin.components?.Field) {
+                field.admin.components.Field = (0, _withCondition.default)(field.admin.components?.Field);
             }
-        }
-        else {
+        } else {
             field.admin = {};
         }
-        if ('fields' in field && field.fields)
-            field.fields = sanitizeFields(field.fields, validRelationships);
+        if ('fields' in field && field.fields) {
+            field.fields = sanitizeFields({
+                config,
+                fields: field.fields,
+                validRelationships
+            });
+        }
         if (field.type === 'tabs') {
-            field.tabs = field.tabs.map((tab) => {
-                const unsanitizedTab = { ...tab };
-                if ((0, types_1.tabHasName)(tab) && typeof tab.label === 'undefined') {
-                    unsanitizedTab.label = (0, formatLabels_1.toWords)(tab.name);
+            field.tabs = field.tabs.map((tab)=>{
+                const unsanitizedTab = {
+                    ...tab
+                };
+                if ((0, _types.tabHasName)(tab) && typeof tab.label === 'undefined') {
+                    unsanitizedTab.label = (0, _formatLabels.toWords)(tab.name);
                 }
-                unsanitizedTab.fields = sanitizeFields(tab.fields, validRelationships);
+                unsanitizedTab.fields = sanitizeFields({
+                    config,
+                    fields: tab.fields,
+                    validRelationships
+                });
                 return unsanitizedTab;
             });
         }
         if ('blocks' in field && field.blocks) {
-            field.blocks = field.blocks.map((block) => {
-                const unsanitizedBlock = { ...block };
-                unsanitizedBlock.labels = !unsanitizedBlock.labels ? (0, formatLabels_1.formatLabels)(unsanitizedBlock.slug) : unsanitizedBlock.labels;
-                unsanitizedBlock.fields = sanitizeFields(block.fields, validRelationships);
+            field.blocks = field.blocks.map((block)=>{
+                const unsanitizedBlock = {
+                    ...block
+                };
+                unsanitizedBlock.labels = !unsanitizedBlock.labels ? (0, _formatLabels.formatLabels)(unsanitizedBlock.slug) : unsanitizedBlock.labels;
+                unsanitizedBlock.fields = sanitizeFields({
+                    config,
+                    fields: block.fields,
+                    validRelationships
+                });
                 return unsanitizedBlock;
             });
         }
         return field;
     });
 };
-exports.default = sanitizeFields;
-//# sourceMappingURL=sanitize.js.map
+const _default = sanitizeFields;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/fields/config/sanitize.ts"],"sourcesContent":["import type { Config } from '../../config/types'\nimport type { Field } from './types'\n\nimport withCondition from '../../admin/components/forms/withCondition'\nimport { InvalidFieldName, InvalidFieldRelationship, MissingFieldType } from '../../errors'\nimport { formatLabels, toWords } from '../../utilities/formatLabels'\nimport { baseBlockFields } from '../baseFields/baseBlockFields'\nimport { baseIDField } from '../baseFields/baseIDField'\nimport validations from '../validations'\nimport { fieldAffectsData, tabHasName } from './types'\n\ntype Args = {\n  config: Config\n  fields: Field[]\n  validRelationships: string[]\n}\n\nconst sanitizeFields = ({ config, fields, validRelationships }: Args): Field[] => {\n  if (!fields) return []\n\n  return fields.map((unsanitizedField) => {\n    const field: Field = { ...unsanitizedField }\n\n    if (!field.type) throw new MissingFieldType(field)\n\n    // assert that field names do not contain forbidden characters\n    if (fieldAffectsData(field) && field.name.includes('.')) {\n      throw new InvalidFieldName(field, field.name)\n    }\n\n    // Auto-label\n    if (\n      'name' in field &&\n      field.name &&\n      typeof field.label !== 'object' &&\n      typeof field.label !== 'string' &&\n      field.label !== false\n    ) {\n      field.label = toWords(field.name)\n    }\n\n    if (\n      field.type === 'checkbox' &&\n      typeof field.defaultValue === 'undefined' &&\n      field.required === true\n    ) {\n      field.defaultValue = false\n    }\n\n    if (field.type === 'relationship' || field.type === 'upload') {\n      const relationships = Array.isArray(field.relationTo) ? field.relationTo : [field.relationTo]\n      relationships.forEach((relationship: string) => {\n        if (!validRelationships.includes(relationship)) {\n          throw new InvalidFieldRelationship(field, relationship)\n        }\n      })\n\n      if (field.type === 'relationship') {\n        if (field.min && !field.minRows) {\n          console.warn(\n            `(payload): The \"min\" property is deprecated for the Relationship field \"${field.name}\" and will be removed in a future version. Please use \"minRows\" instead.`,\n          )\n        }\n        if (field.max && !field.maxRows) {\n          console.warn(\n            `(payload): The \"max\" property is deprecated for the Relationship field \"${field.name}\" and will be removed in a future version. Please use \"maxRows\" instead.`,\n          )\n        }\n        field.minRows = field.minRows || field.min\n        field.maxRows = field.maxRows || field.max\n      }\n    }\n\n    if (field.type === 'blocks' && field.blocks) {\n      field.blocks = field.blocks.map((block) => ({\n        ...block,\n        fields: block.fields.concat(baseBlockFields),\n      }))\n    }\n\n    if (field.type === 'array' && field.fields) {\n      field.fields.push(baseIDField)\n    }\n\n    if ((field.type === 'blocks' || field.type === 'array') && field.label) {\n      field.labels = field.labels || formatLabels(field.name)\n    }\n\n    if (fieldAffectsData(field)) {\n      if (field.localized && !config.localization) delete field.localized\n\n      if (typeof field.validate === 'undefined') {\n        const defaultValidate = validations[field.type]\n        if (defaultValidate) {\n          field.validate = (val, options) => defaultValidate(val, { ...field, ...options })\n        } else {\n          field.validate = () => true\n        }\n      }\n\n      if (!field.hooks) field.hooks = {}\n      if (!field.access) field.access = {}\n    }\n\n    if (field.admin) {\n      if (field.admin.condition && field.admin.components?.Field) {\n        field.admin.components.Field = withCondition(field.admin.components?.Field)\n      }\n    } else {\n      field.admin = {}\n    }\n\n    if ('fields' in field && field.fields) {\n      field.fields = sanitizeFields({\n        config,\n        fields: field.fields,\n        validRelationships,\n      })\n    }\n\n    if (field.type === 'tabs') {\n      field.tabs = field.tabs.map((tab) => {\n        const unsanitizedTab = { ...tab }\n        if (tabHasName(tab) && typeof tab.label === 'undefined') {\n          unsanitizedTab.label = toWords(tab.name)\n        }\n\n        unsanitizedTab.fields = sanitizeFields({\n          config,\n          fields: tab.fields,\n          validRelationships,\n        })\n\n        return unsanitizedTab\n      })\n    }\n\n    if ('blocks' in field && field.blocks) {\n      field.blocks = field.blocks.map((block) => {\n        const unsanitizedBlock = { ...block }\n        unsanitizedBlock.labels = !unsanitizedBlock.labels\n          ? formatLabels(unsanitizedBlock.slug)\n          : unsanitizedBlock.labels\n\n        unsanitizedBlock.fields = sanitizeFields({\n          config,\n          fields: block.fields,\n          validRelationships,\n        })\n\n        return unsanitizedBlock\n      })\n    }\n\n    return field\n  })\n}\n\nexport default sanitizeFields\n"],"names":["sanitizeFields","config","fields","validRelationships","map","unsanitizedField","field","type","MissingFieldType","fieldAffectsData","name","includes","InvalidFieldName","label","toWords","defaultValue","required","relationships","Array","isArray","relationTo","forEach","relationship","InvalidFieldRelationship","min","minRows","console","warn","max","maxRows","blocks","block","concat","baseBlockFields","push","baseIDField","labels","formatLabels","localized","localization","validate","defaultValidate","validations","val","options","hooks","access","admin","condition","components","Field","withCondition","tabs","tab","unsanitizedTab","tabHasName","unsanitizedBlock","slug"],"mappings":"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"}

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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"}

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

@@ -26,3 +26,4 @@ export declare const date: joi.ObjectSchema<any>;
 export declare const ui: joi.ObjectSchema<any>;
 declare const fieldSchema: joi.AlternativesSchema<any>;
 export default fieldSchema;
+//# sourceMappingURL=schema.d.ts.map