payload 3.0.0-alpha.9 → 3.0.0-beta.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/fields/config/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AAEzD,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAEpE,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAAC,KAAK,EAAE,QAAQ,GAAG,cAAc,GAAG,OAAO,GAAG,UAAU,CAAC,CAAA;AAE7F,MAAM,MAAM,yBAAyB,GACjC,QAAQ,GACR,eAAe,GACf,OAAO,GACP,MAAM,IAAI,CAAC,SAAS,EAAE,QAAQ,GAAG,cAAc,GAAG,OAAO,GAAG,UAAU,CAAC,CAAA;AAE3E,MAAM,MAAM,8BAA8B,GAAG,MAAM,IAAI,CACrD,SAAS,CAAC,OAAO,CAAC,EAClB,YAAY,GAAG,WAAW,GAAG,aAAa,CAC3C,CAAA;AAED,eAAO,MAAM,uBAAuB,iCAGjC;IACD,KAAK,EAAE,KAAK,CAAA;IACZ,CAAC,EAAE,SAAS,CAAA;CACb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuEA,CAAA;AAED,eAAO,MAAM,wBAAwB,mBAGlC;IACD,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,CAAC,EAAE,SAAS,CAAA;CACb,KAAG,KAAK,EAAkE,CAAA"}

package/dist/fields/config/client.js

@@ -0,0 +1,79 @@
+export const createClientFieldConfig = ({ field: incomingField, t })=>{
+    const field = {
+        ...incomingField
+    };
+    const serverOnlyFieldProperties = [
+        'hooks',
+        'access',
+        'validate',
+        'defaultValue',
+        'label',
+        'filterOptions',
+        'editor'
+    ];
+    serverOnlyFieldProperties.forEach((key)=>{
+        if (key in field) {
+            delete field[key];
+        }
+    });
+    if ('options' in field && Array.isArray(field.options)) {
+        field.options = field.options.map((option)=>{
+            if (typeof option === 'object' && typeof option.label === 'function') {
+                return {
+                    label: option.label({
+                        t
+                    }),
+                    value: option.value
+                };
+            }
+            return option;
+        });
+    }
+    if ('fields' in field) {
+        field.fields = createClientFieldConfigs({
+            fields: field.fields,
+            t
+        });
+    }
+    if ('blocks' in field) {
+        field.blocks = field.blocks.map((block)=>{
+            const sanitized = {
+                ...block
+            };
+            sanitized.fields = createClientFieldConfigs({
+                fields: sanitized.fields,
+                t
+            });
+            return sanitized;
+        });
+    }
+    if ('tabs' in field) {
+        // @ts-expect-error
+        field.tabs = field.tabs.map((tab)=>createClientFieldConfig({
+                field: tab,
+                t
+            }));
+    }
+    if ('admin' in field) {
+        field.admin = {
+            ...field.admin
+        };
+        const serverOnlyFieldAdminProperties = [
+            'components',
+            'condition',
+            'description'
+        ];
+        serverOnlyFieldAdminProperties.forEach((key)=>{
+            if (key in field.admin) {
+                delete field.admin[key];
+            }
+        });
+    }
+    return field;
+};
+export const createClientFieldConfigs = ({ fields, t })=>fields.map((field)=>createClientFieldConfig({
+            field,
+            t
+        }));
+
+//# sourceMappingURL=client.js.map

package/dist/fields/config/client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/fields/config/client.ts"],"sourcesContent":["import type { TFunction } from '@payloadcms/translations'\n\nimport type { Field, FieldBase } from '../../fields/config/types.js'\n\nexport type ClientFieldConfig = Omit<Field, 'access' | 'defaultValue' | 'hooks' | 'validate'>\n\nexport type ServerOnlyFieldProperties =\n  | 'editor' // This is a `richText` only property\n  | 'filterOptions' // This is a `relationship` and `upload` only property\n  | 'label'\n  | keyof Pick<FieldBase, 'access' | 'defaultValue' | 'hooks' | 'validate'>\n\nexport type ServerOnlyFieldAdminProperties = keyof Pick<\n  FieldBase['admin'],\n  'components' | 'condition' | 'description'\n>\n\nexport const createClientFieldConfig = ({\n  field: incomingField,\n  t,\n}: {\n  field: Field\n  t: TFunction\n}) => {\n  const field = { ...incomingField }\n\n  const serverOnlyFieldProperties: Partial<ServerOnlyFieldProperties>[] = [\n    'hooks',\n    'access',\n    'validate',\n    'defaultValue',\n    'label',\n    'filterOptions', // This is a `relationship` and `upload` only property\n    'editor', // This is a `richText` only property\n    // `fields`\n    // `blocks`\n    // `tabs`\n    // `admin`\n    // are all handled separately\n  ]\n\n  serverOnlyFieldProperties.forEach((key) => {\n    if (key in field) {\n      delete field[key]\n    }\n  })\n\n  if ('options' in field && Array.isArray(field.options)) {\n    field.options = field.options.map((option) => {\n      if (typeof option === 'object' && typeof option.label === 'function') {\n        return {\n          label: option.label({ t }),\n          value: option.value,\n        }\n      }\n\n      return option\n    })\n  }\n\n  if ('fields' in field) {\n    field.fields = createClientFieldConfigs({ fields: field.fields, t })\n  }\n\n  if ('blocks' in field) {\n    field.blocks = field.blocks.map((block) => {\n      const sanitized = { ...block }\n      sanitized.fields = createClientFieldConfigs({ fields: sanitized.fields, t })\n      return sanitized\n    })\n  }\n\n  if ('tabs' in field) {\n    // @ts-expect-error\n    field.tabs = field.tabs.map((tab) => createClientFieldConfig({ field: tab, t }))\n  }\n\n  if ('admin' in field) {\n    field.admin = { ...field.admin }\n\n    const serverOnlyFieldAdminProperties: Partial<ServerOnlyFieldAdminProperties>[] = [\n      'components',\n      'condition',\n      'description',\n    ]\n\n    serverOnlyFieldAdminProperties.forEach((key) => {\n      if (key in field.admin) {\n        delete field.admin[key]\n      }\n    })\n  }\n\n  return field\n}\n\nexport const createClientFieldConfigs = ({\n  fields,\n  t,\n}: {\n  fields: Field[]\n  t: TFunction\n}): Field[] => fields.map((field) => createClientFieldConfig({ field, t }))\n"],"names":["createClientFieldConfig","field","incomingField","t","serverOnlyFieldProperties","forEach","key","Array","isArray","options","map","option","label","value","fields","createClientFieldConfigs","blocks","block","sanitized","tabs","tab","admin","serverOnlyFieldAdminProperties"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAiBA,OAAO,MAAMA,0BAA0B,CAAC,EACtCC,OAAOC,aAAa,EACpBC,CAAC,EAIF;IACC,MAAMF,QAAQ;QAAE,GAAGC,aAAa;IAAC;IAEjC,MAAME,4BAAkE;QACtE;QACA;QACA;QACA;QACA;QACA;QACA;KAMD;IAEDA,0BAA0BC,OAAO,CAAC,CAACC;QACjC,IAAIA,OAAOL,OAAO;YAChB,OAAOA,KAAK,CAACK,IAAI;QACnB;IACF;IAEA,IAAI,aAAaL,SAASM,MAAMC,OAAO,CAACP,MAAMQ,OAAO,GAAG;QACtDR,MAAMQ,OAAO,GAAGR,MAAMQ,OAAO,CAACC,GAAG,CAAC,CAACC;YACjC,IAAI,OAAOA,WAAW,YAAY,OAAOA,OAAOC,KAAK,KAAK,YAAY;gBACpE,OAAO;oBACLA,OAAOD,OAAOC,KAAK,CAAC;wBAAET;oBAAE;oBACxBU,OAAOF,OAAOE,KAAK;gBACrB;YACF;YAEA,OAAOF;QACT;IACF;IAEA,IAAI,YAAYV,OAAO;QACrBA,MAAMa,MAAM,GAAGC,yBAAyB;YAAED,QAAQb,MAAMa,MAAM;YAAEX;QAAE;IACpE;IAEA,IAAI,YAAYF,OAAO;QACrBA,MAAMe,MAAM,GAAGf,MAAMe,MAAM,CAACN,GAAG,CAAC,CAACO;YAC/B,MAAMC,YAAY;gBAAE,GAAGD,KAAK;YAAC;YAC7BC,UAAUJ,MAAM,GAAGC,yBAAyB;gBAAED,QAAQI,UAAUJ,MAAM;gBAAEX;YAAE;YAC1E,OAAOe;QACT;IACF;IAEA,IAAI,UAAUjB,OAAO;QACnB,mBAAmB;QACnBA,MAAMkB,IAAI,GAAGlB,MAAMkB,IAAI,CAACT,GAAG,CAAC,CAACU,MAAQpB,wBAAwB;gBAAEC,OAAOmB;gBAAKjB;YAAE;IAC/E;IAEA,IAAI,WAAWF,OAAO;QACpBA,MAAMoB,KAAK,GAAG;YAAE,GAAGpB,MAAMoB,KAAK;QAAC;QAE/B,MAAMC,iCAA4E;YAChF;YACA;YACA;SACD;QAEDA,+BAA+BjB,OAAO,CAAC,CAACC;YACtC,IAAIA,OAAOL,MAAMoB,KAAK,EAAE;gBACtB,OAAOpB,MAAMoB,KAAK,CAACf,IAAI;YACzB;QACF;IACF;IAEA,OAAOL;AACT,EAAC;AAED,OAAO,MAAMc,2BAA2B,CAAC,EACvCD,MAAM,EACNX,CAAC,EAIF,GAAcW,OAAOJ,GAAG,CAAC,CAACT,QAAUD,wBAAwB;YAAEC;YAAOE;QAAE,IAAG"}

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

@@ -1,15 +1,21 @@
-import type { Config } from '../../config/types';
-import type { Field } from './types';
+import type { Config } from '../../config/types.js';
+import type { Field } from './types.js';
 type Args = {
     config: Config;
     existingFieldNames?: Set<string>;
     fields: Field[];
+    /**
+     * If true, a richText field will require an editor property to be set, as the sanitizeFields function will not add it from the payload config if not present.
+     *
+     * @default false
+     */
+    requireFieldLevelRichTextEditor?: boolean;
     /**
      * If not null, will validate that upload and relationship fields do not relate to a collection that is not in this array.
      * This validation will be skipped if validRelationships is null.
      */
     validRelationships: null | string[];
 };
-export declare const sanitizeFields: ({ config, existingFieldNames, fields, validRelationships, }: Args) => Field[];
+export declare const sanitizeFields: ({ config, existingFieldNames, fields, requireFieldLevelRichTextEditor, validRelationships, }: Args) => Field[];
 export {};
 //# sourceMappingURL=sanitize.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../../src/fields/config/sanitize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAChD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAcpC,KAAK,IAAI,GAAG;IACV,MAAM,EAAE,MAAM,CAAA;IACd,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAChC,MAAM,EAAE,KAAK,EAAE,CAAA;IACf;;;OAGG;IACH,kBAAkB,EAAE,IAAI,GAAG,MAAM,EAAE,CAAA;CACpC,CAAA;AAED,eAAO,MAAM,cAAc,gEAKxB,IAAI,KAAG,KAAK,EAyJd,CAAA"}
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../../src/fields/config/sanitize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAA;AACnD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAgBvC,KAAK,IAAI,GAAG;IACV,MAAM,EAAE,MAAM,CAAA;IACd,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAChC,MAAM,EAAE,KAAK,EAAE,CAAA;IACf;;;;OAIG;IACH,+BAA+B,CAAC,EAAE,OAAO,CAAA;IACzC;;;OAGG;IACH,kBAAkB,EAAE,IAAI,GAAG,MAAM,EAAE,CAAA;CACpC,CAAA;AAED,eAAO,MAAM,cAAc,iGAMxB,IAAI,KAAG,KAAK,EAkKd,CAAA"}

package/dist/fields/config/sanitize.js

@@ -1,42 +1,33 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "sanitizeFields", {
-    enumerable: true,
-    get: function() {
-        return sanitizeFields;
-    }
-});
-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, existingFieldNames = new Set(), fields, validRelationships })=>{
+import MissingEditorProp from '../../errors/MissingEditorProp.js';
+import { DuplicateFieldName, InvalidFieldName, InvalidFieldRelationship, MissingFieldType } from '../../errors/index.js';
+import { formatLabels, toWords } from '../../utilities/formatLabels.js';
+import { baseBlockFields } from '../baseFields/baseBlockFields.js';
+import { baseIDField } from '../baseFields/baseIDField.js';
+import { setDefaultBeforeDuplicate } from '../setDefaultBeforeDuplicate.js';
+import validations from '../validations.js';
+import { fieldAffectsData, tabHasName } from './types.js';
+export const sanitizeFields = ({ config, existingFieldNames = new Set(), fields, requireFieldLevelRichTextEditor = false, validRelationships })=>{
     if (!fields) return [];
     return fields.map((unsanitizedField)=>{
         const field = {
             ...unsanitizedField
         };
-        if (!field.type) throw new _errors.MissingFieldType(field);
+        if (!field.type) throw new MissingFieldType(field);
         // assert that field names do not contain forbidden characters
-        if ((0, _types.fieldAffectsData)(field) && field.name.includes('.')) {
-            throw new _errors.InvalidFieldName(field, field.name);
+        if (fieldAffectsData(field) && field.name.includes('.')) {
+            throw new InvalidFieldName(field, field.name);
         }
         // Make sure that the richText field has an editor
-        if (field.type === 'richText' && !field.editor && config.editor) {
-            field.editor = config.editor;
+        if (field.type === 'richText' && !field.editor) {
+            if (config.editor && !requireFieldLevelRichTextEditor) {
+                field.editor = config.editor;
+            } else {
+                throw new MissingEditorProp(field);
+            }
         }
         // Auto-label
         if ('name' in field && field.name && typeof field.label !== 'object' && typeof field.label !== 'string' && field.label !== false) {
-            field.label = (0, _formatLabels.toWords)(field.name);
+            field.label = toWords(field.name);
         }
         if (field.type === 'checkbox' && typeof field.defaultValue === 'undefined' && field.required === true) {
             field.defaultValue = false;
@@ -48,7 +39,7 @@ const sanitizeFields = ({ config, existingFieldNames = new Set(), fields, validR
                 ];
                 relationships.forEach((relationship)=>{
                     if (!validRelationships.includes(relationship)) {
-                        throw new _errors.InvalidFieldRelationship(field, relationship);
+                        throw new InvalidFieldRelationship(field, relationship);
                     }
                 });
             }
@@ -66,27 +57,27 @@ const sanitizeFields = ({ config, existingFieldNames = new Set(), fields, validR
         if (field.type === 'blocks' && field.blocks) {
             field.blocks = field.blocks.map((block)=>({
                     ...block,
-                    fields: block.fields.concat(_baseBlockFields.baseBlockFields)
+                    fields: block.fields.concat(baseBlockFields)
                 }));
         }
         if (field.type === 'array' && field.fields) {
-            field.fields.push(_baseIDField.baseIDField);
+            field.fields.push(baseIDField);
         }
         if ((field.type === 'blocks' || field.type === 'array') && field.label) {
-            field.labels = field.labels || (0, _formatLabels.formatLabels)(field.name);
+            field.labels = field.labels || formatLabels(field.name);
         }
-        if ((0, _types.fieldAffectsData)(field)) {
+        if (fieldAffectsData(field)) {
             if (existingFieldNames.has(field.name)) {
-                throw new _errors.DuplicateFieldName(field.name);
+                throw new DuplicateFieldName(field.name);
             } else if (![
-                'id',
-                'blockName'
+                'blockName',
+                'id'
             ].includes(field.name)) {
                 existingFieldNames.add(field.name);
             }
             if (field.localized && !config.localization) delete field.localized;
             if (typeof field.validate === 'undefined') {
-                const defaultValidate = _validations.default[field.type];
+                const defaultValidate = validations[field.type];
                 if (defaultValidate) {
                     field.validate = (val, options)=>defaultValidate(val, {
                             ...field,
@@ -98,6 +89,7 @@ const sanitizeFields = ({ config, existingFieldNames = new Set(), fields, validR
             }
             if (!field.hooks) field.hooks = {};
             if (!field.access) field.access = {};
+            setDefaultBeforeDuplicate(field);
         }
         if (!field.admin) {
             field.admin = {};
@@ -105,8 +97,9 @@ const sanitizeFields = ({ config, existingFieldNames = new Set(), fields, validR
         if ('fields' in field && field.fields) {
             field.fields = sanitizeFields({
                 config,
-                existingFieldNames: (0, _types.fieldAffectsData)(field) ? new Set() : existingFieldNames,
+                existingFieldNames: fieldAffectsData(field) ? new Set() : existingFieldNames,
                 fields: field.fields,
+                requireFieldLevelRichTextEditor,
                 validRelationships
             });
         }
@@ -115,13 +108,14 @@ const sanitizeFields = ({ config, existingFieldNames = new Set(), fields, validR
                 const unsanitizedTab = {
                     ...tab
                 };
-                if ((0, _types.tabHasName)(tab) && typeof tab.label === 'undefined') {
-                    unsanitizedTab.label = (0, _formatLabels.toWords)(tab.name);
+                if (tabHasName(tab) && typeof tab.label === 'undefined') {
+                    unsanitizedTab.label = toWords(tab.name);
                 }
                 unsanitizedTab.fields = sanitizeFields({
                     config,
-                    existingFieldNames: (0, _types.tabHasName)(tab) ? new Set() : existingFieldNames,
+                    existingFieldNames: tabHasName(tab) ? new Set() : existingFieldNames,
                     fields: tab.fields,
+                    requireFieldLevelRichTextEditor,
                     validRelationships
                 });
                 return unsanitizedTab;
@@ -132,12 +126,13 @@ const sanitizeFields = ({ config, existingFieldNames = new Set(), fields, validR
                 const unsanitizedBlock = {
                     ...block
                 };
-                unsanitizedBlock.labels = !unsanitizedBlock.labels ? (0, _formatLabels.formatLabels)(unsanitizedBlock.slug) : unsanitizedBlock.labels;
+                unsanitizedBlock.labels = !unsanitizedBlock.labels ? formatLabels(unsanitizedBlock.slug) : unsanitizedBlock.labels;
                 unsanitizedBlock.fields = sanitizeFields({
                     config,
+                    existingFieldNames: new Set(),
                     fields: block.fields,
-                    validRelationships,
-                    existingFieldNames: new Set()
+                    requireFieldLevelRichTextEditor,
+                    validRelationships
                 });
                 return unsanitizedBlock;
             });
@@ -146,4 +141,4 @@ const sanitizeFields = ({ config, existingFieldNames = new Set(), fields, validR
     });
 };
 
-//# 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 {\n  DuplicateFieldName,\n  InvalidFieldName,\n  InvalidFieldRelationship,\n  MissingFieldType,\n} 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  existingFieldNames?: Set<string>\n  fields: Field[]\n  /**\n   * If not null, will validate that upload and relationship fields do not relate to a collection that is not in this array.\n   * This validation will be skipped if validRelationships is null.\n   */\n  validRelationships: null | string[]\n}\n\nexport const sanitizeFields = ({\n  config,\n  existingFieldNames = new Set(),\n  fields,\n  validRelationships,\n}: 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    // Make sure that the richText field has an editor\n    if (field.type === 'richText' && !field.editor && config.editor) {\n      field.editor = config.editor\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      if (validRelationships) {\n        const relationships = Array.isArray(field.relationTo)\n          ? field.relationTo\n          : [field.relationTo]\n        relationships.forEach((relationship: string) => {\n          if (!validRelationships.includes(relationship)) {\n            throw new InvalidFieldRelationship(field, relationship)\n          }\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 (existingFieldNames.has(field.name)) {\n        throw new DuplicateFieldName(field.name)\n      } else if (!['id', 'blockName'].includes(field.name)) {\n        existingFieldNames.add(field.name)\n      }\n\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      field.admin = {}\n    }\n\n    if ('fields' in field && field.fields) {\n      field.fields = sanitizeFields({\n        config,\n        existingFieldNames: fieldAffectsData(field) ? new Set() : existingFieldNames,\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          existingFieldNames: tabHasName(tab) ? new Set() : existingFieldNames,\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          existingFieldNames: new Set(),\n        })\n\n        return unsanitizedBlock\n      })\n    }\n\n    return field\n  })\n}\n"],"names":["sanitizeFields","config","existingFieldNames","Set","fields","validRelationships","map","unsanitizedField","field","type","MissingFieldType","fieldAffectsData","name","includes","InvalidFieldName","editor","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","has","DuplicateFieldName","add","localized","localization","validate","defaultValidate","validations","val","options","hooks","access","admin","tabs","tab","unsanitizedTab","tabHasName","unsanitizedBlock","slug"],"mappings":"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"}
+//# sourceMappingURL=sanitize.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/fields/config/sanitize.ts"],"sourcesContent":["import type { Config } from '../../config/types.js'\nimport type { Field } from './types.js'\n\nimport MissingEditorProp from '../../errors/MissingEditorProp.js'\nimport {\n  DuplicateFieldName,\n  InvalidFieldName,\n  InvalidFieldRelationship,\n  MissingFieldType,\n} from '../../errors/index.js'\nimport { formatLabels, toWords } from '../../utilities/formatLabels.js'\nimport { baseBlockFields } from '../baseFields/baseBlockFields.js'\nimport { baseIDField } from '../baseFields/baseIDField.js'\nimport { setDefaultBeforeDuplicate } from '../setDefaultBeforeDuplicate.js'\nimport validations from '../validations.js'\nimport { fieldAffectsData, tabHasName } from './types.js'\n\ntype Args = {\n  config: Config\n  existingFieldNames?: Set<string>\n  fields: Field[]\n  /**\n   * If true, a richText field will require an editor property to be set, as the sanitizeFields function will not add it from the payload config if not present.\n   *\n   * @default false\n   */\n  requireFieldLevelRichTextEditor?: boolean\n  /**\n   * If not null, will validate that upload and relationship fields do not relate to a collection that is not in this array.\n   * This validation will be skipped if validRelationships is null.\n   */\n  validRelationships: null | string[]\n}\n\nexport const sanitizeFields = ({\n  config,\n  existingFieldNames = new Set(),\n  fields,\n  requireFieldLevelRichTextEditor = false,\n  validRelationships,\n}: 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    // Make sure that the richText field has an editor\n    if (field.type === 'richText' && !field.editor) {\n      if (config.editor && !requireFieldLevelRichTextEditor) {\n        field.editor = config.editor\n      } else {\n        throw new MissingEditorProp(field)\n      }\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      if (validRelationships) {\n        const relationships = Array.isArray(field.relationTo)\n          ? field.relationTo\n          : [field.relationTo]\n        relationships.forEach((relationship: string) => {\n          if (!validRelationships.includes(relationship)) {\n            throw new InvalidFieldRelationship(field, relationship)\n          }\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 (existingFieldNames.has(field.name)) {\n        throw new DuplicateFieldName(field.name)\n      } else if (!['blockName', 'id'].includes(field.name)) {\n        existingFieldNames.add(field.name)\n      }\n\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      setDefaultBeforeDuplicate(field)\n    }\n\n    if (!field.admin) {\n      field.admin = {}\n    }\n\n    if ('fields' in field && field.fields) {\n      field.fields = sanitizeFields({\n        config,\n        existingFieldNames: fieldAffectsData(field) ? new Set() : existingFieldNames,\n        fields: field.fields,\n        requireFieldLevelRichTextEditor,\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          existingFieldNames: tabHasName(tab) ? new Set() : existingFieldNames,\n          fields: tab.fields,\n          requireFieldLevelRichTextEditor,\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          existingFieldNames: new Set(),\n          fields: block.fields,\n          requireFieldLevelRichTextEditor,\n          validRelationships,\n        })\n\n        return unsanitizedBlock\n      })\n    }\n\n    return field\n  })\n}\n"],"names":["MissingEditorProp","DuplicateFieldName","InvalidFieldName","InvalidFieldRelationship","MissingFieldType","formatLabels","toWords","baseBlockFields","baseIDField","setDefaultBeforeDuplicate","validations","fieldAffectsData","tabHasName","sanitizeFields","config","existingFieldNames","Set","fields","requireFieldLevelRichTextEditor","validRelationships","map","unsanitizedField","field","type","name","includes","editor","label","defaultValue","required","relationships","Array","isArray","relationTo","forEach","relationship","min","minRows","console","warn","max","maxRows","blocks","block","concat","push","labels","has","add","localized","localization","validate","defaultValidate","val","options","hooks","access","admin","tabs","tab","unsanitizedTab","unsanitizedBlock","slug"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

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

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _errors = require("../../errors");
-const _sanitize = require("./sanitize");
+import { InvalidFieldName, InvalidFieldRelationship, MissingFieldType } from '../../errors';
+import { sanitizeFields } from './sanitize';
 const dummyConfig = {
     collections: [],
     db: ()=>({})
@@ -21,12 +17,12 @@ describe('sanitizeFields', ()=>{
         expect(()=>{
             // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-ignore
-            (0, _sanitize.sanitizeFields)({
+            sanitizeFields({
                 config: dummyConfig,
                 fields,
                 validRelationships: []
             });
-        }).toThrow(_errors.MissingFieldType);
+        }).toThrow(MissingFieldType);
     });
     it('should throw on invalid field name', ()=>{
         const fields = [
@@ -37,12 +33,12 @@ describe('sanitizeFields', ()=>{
             }
         ];
         expect(()=>{
-            (0, _sanitize.sanitizeFields)({
+            sanitizeFields({
                 config: dummyConfig,
                 fields,
                 validRelationships: []
             });
-        }).toThrow(_errors.InvalidFieldName);
+        }).toThrow(InvalidFieldName);
     });
     describe('auto-labeling', ()=>{
         it('should populate label if missing', ()=>{
@@ -52,7 +48,7 @@ describe('sanitizeFields', ()=>{
                     type: 'text'
                 }
             ];
-            const sanitizedField = (0, _sanitize.sanitizeFields)({
+            const sanitizedField = sanitizeFields({
                 config: dummyConfig,
                 fields,
                 validRelationships: []
@@ -69,7 +65,7 @@ describe('sanitizeFields', ()=>{
                     type: 'text'
                 }
             ];
-            const sanitizedField = (0, _sanitize.sanitizeFields)({
+            const sanitizedField = sanitizeFields({
                 config: dummyConfig,
                 fields,
                 validRelationships: []
@@ -87,7 +83,7 @@ describe('sanitizeFields', ()=>{
                         type: 'text'
                     }
                 ];
-                const sanitizedField = (0, _sanitize.sanitizeFields)({
+                const sanitizedField = sanitizeFields({
                     config: dummyConfig,
                     fields,
                     validRelationships: []
@@ -108,7 +104,7 @@ describe('sanitizeFields', ()=>{
                     name: 'items',
                     type: 'array'
                 };
-                const sanitizedField = (0, _sanitize.sanitizeFields)({
+                const sanitizedField = sanitizeFields({
                     config: dummyConfig,
                     fields: [
                         arrayField
@@ -139,7 +135,7 @@ describe('sanitizeFields', ()=>{
                         type: 'blocks'
                     }
                 ];
-                const sanitizedField = (0, _sanitize.sanitizeFields)({
+                const sanitizedField = sanitizeFields({
                     config: dummyConfig,
                     fields,
                     validRelationships: []
@@ -163,7 +159,7 @@ describe('sanitizeFields', ()=>{
                     type: 'array'
                 }
             ];
-            const sanitizedField = (0, _sanitize.sanitizeFields)({
+            const sanitizedField = sanitizeFields({
                 config: dummyConfig,
                 fields,
                 validRelationships: []
@@ -194,7 +190,7 @@ describe('sanitizeFields', ()=>{
                     type: 'blocks'
                 }
             ];
-            const sanitizedField = (0, _sanitize.sanitizeFields)({
+            const sanitizedField = sanitizeFields({
                 config: dummyConfig,
                 fields,
                 validRelationships: []
@@ -223,7 +219,7 @@ describe('sanitizeFields', ()=>{
                 }
             ];
             expect(()=>{
-                (0, _sanitize.sanitizeFields)({
+                sanitizeFields({
                     config: dummyConfig,
                     fields,
                     validRelationships
@@ -247,7 +243,7 @@ describe('sanitizeFields', ()=>{
                 }
             ];
             expect(()=>{
-                (0, _sanitize.sanitizeFields)({
+                sanitizeFields({
                     config: dummyConfig,
                     fields,
                     validRelationships
@@ -280,7 +276,7 @@ describe('sanitizeFields', ()=>{
                 }
             ];
             expect(()=>{
-                (0, _sanitize.sanitizeFields)({
+                sanitizeFields({
                     config: dummyConfig,
                     fields,
                     validRelationships
@@ -300,12 +296,12 @@ describe('sanitizeFields', ()=>{
                 }
             ];
             expect(()=>{
-                (0, _sanitize.sanitizeFields)({
+                sanitizeFields({
                     config: dummyConfig,
                     fields,
                     validRelationships
                 });
-            }).toThrow(_errors.InvalidFieldRelationship);
+            }).toThrow(InvalidFieldRelationship);
         });
         it('should throw on invalid relationship - multiple', ()=>{
             const validRelationships = [
@@ -324,12 +320,12 @@ describe('sanitizeFields', ()=>{
                 }
             ];
             expect(()=>{
-                (0, _sanitize.sanitizeFields)({
+                sanitizeFields({
                     config: dummyConfig,
                     fields,
                     validRelationships
                 });
-            }).toThrow(_errors.InvalidFieldRelationship);
+            }).toThrow(InvalidFieldRelationship);
         });
         it('should throw on invalid relationship inside blocks', ()=>{
             const validRelationships = [
@@ -357,12 +353,12 @@ describe('sanitizeFields', ()=>{
                 }
             ];
             expect(()=>{
-                (0, _sanitize.sanitizeFields)({
+                sanitizeFields({
                     config: dummyConfig,
                     fields,
                     validRelationships
                 });
-            }).toThrow(_errors.InvalidFieldRelationship);
+            }).toThrow(InvalidFieldRelationship);
         });
         it('should defaultValue of checkbox to false if required and undefined', ()=>{
             const fields = [
@@ -372,7 +368,7 @@ describe('sanitizeFields', ()=>{
                     type: 'checkbox'
                 }
             ];
-            const sanitizedField = (0, _sanitize.sanitizeFields)({
+            const sanitizedField = sanitizeFields({
                 config: dummyConfig,
                 fields,
                 validRelationships: []
@@ -380,7 +376,7 @@ describe('sanitizeFields', ()=>{
             expect(sanitizedField.defaultValue).toStrictEqual(false);
         });
         it('should return empty field array if no fields', ()=>{
-            const sanitizedFields = (0, _sanitize.sanitizeFields)({
+            const sanitizedFields = sanitizeFields({
                 config: dummyConfig,
                 fields: [],
                 validRelationships: []
@@ -390,4 +386,4 @@ describe('sanitizeFields', ()=>{
     });
 });
 
-//# 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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"}
+//# sourceMappingURL=sanitize.spec.js.map