payload 3.0.0-beta.127 → 3.0.0-beta.129

package/dist/utilities/configToJSONSchema.js

@@ -82,13 +82,13 @@ function generateCollectionJoinsSchemas(collections) {
         };
         for(const collectionSlug in joins){
             for (const join of joins[collectionSlug]){
-                schema.properties[join.schemaPath] = {
+                schema.properties[join.joinPath] = {
                     type: 'string',
                     enum: [
                         collectionSlug
                     ]
                 };
-                schema.required.push(join.schemaPath);
+                schema.required.push(join.joinPath);
             }
         }
         if (Object.keys(schema.properties).length > 0) {
@@ -200,50 +200,128 @@ export function fieldsToJSONSchema(/**
             }
             let fieldSchema;
             switch(field.type){
-                case 'text':
-                    if (field.hasMany === true) {
+                case 'array':
+                    {
                         fieldSchema = {
                             type: withNullableJSONSchemaType('array', isRequired),
                             items: {
-                                type: 'string'
+                                type: 'object',
+                                additionalProperties: false,
+                                ...fieldsToJSONSchema(collectionIDFieldTypes, field.fields, interfaceNameDefinitions, config)
                             }
                         };
-                    } else {
+                        if (field.interfaceName) {
+                            interfaceNameDefinitions.set(field.interfaceName, fieldSchema);
+                            fieldSchema = {
+                                $ref: `#/definitions/${field.interfaceName}`
+                            };
+                        }
+                        break;
+                    }
+                case 'blocks':
+                    {
+                        // Check for a case where no blocks are provided.
+                        // We need to generate an empty array for this case, note that JSON schema 4 doesn't support empty arrays
+                        // so the best we can get is `unknown[]`
+                        const hasBlocks = Boolean(field.blocks.length);
                         fieldSchema = {
-                            type: withNullableJSONSchemaType('string', isRequired)
+                            type: withNullableJSONSchemaType('array', isRequired),
+                            items: hasBlocks ? {
+                                oneOf: field.blocks.map((block)=>{
+                                    const blockFieldSchemas = fieldsToJSONSchema(collectionIDFieldTypes, block.fields, interfaceNameDefinitions, config);
+                                    const blockSchema = {
+                                        type: 'object',
+                                        additionalProperties: false,
+                                        properties: {
+                                            ...blockFieldSchemas.properties,
+                                            blockType: {
+                                                const: block.slug
+                                            }
+                                        },
+                                        required: [
+                                            'blockType',
+                                            ...blockFieldSchemas.required
+                                        ]
+                                    };
+                                    if (block.interfaceName) {
+                                        interfaceNameDefinitions.set(block.interfaceName, blockSchema);
+                                        return {
+                                            $ref: `#/definitions/${block.interfaceName}`
+                                        };
+                                    }
+                                    return blockSchema;
+                                })
+                            } : {}
                         };
+                        break;
+                    }
+                case 'checkbox':
+                    {
+                        fieldSchema = {
+                            type: withNullableJSONSchemaType('boolean', isRequired)
+                        };
+                        break;
                     }
-                    break;
-                case 'textarea':
                 case 'code':
-                case 'email':
                 case 'date':
+                case 'email':
+                case 'textarea':
                     {
                         fieldSchema = {
                             type: withNullableJSONSchemaType('string', isRequired)
                         };
                         break;
                     }
-                case 'number':
+                case 'collapsible':
+                case 'row':
                     {
-                        if (field.hasMany === true) {
-                            fieldSchema = {
-                                type: withNullableJSONSchemaType('array', isRequired),
-                                items: {
-                                    type: 'number'
-                                }
-                            };
-                        } else {
+                        const childSchema = fieldsToJSONSchema(collectionIDFieldTypes, field.fields, interfaceNameDefinitions, config);
+                        Object.entries(childSchema.properties).forEach(([propName, propSchema])=>{
+                            fieldSchemas.set(propName, propSchema);
+                        });
+                        childSchema.required.forEach((propName)=>{
+                            requiredFieldNames.add(propName);
+                        });
+                        break;
+                    }
+                case 'group':
+                    {
+                        fieldSchema = {
+                            type: 'object',
+                            additionalProperties: false,
+                            ...fieldsToJSONSchema(collectionIDFieldTypes, field.fields, interfaceNameDefinitions, config)
+                        };
+                        if (field.interfaceName) {
+                            interfaceNameDefinitions.set(field.interfaceName, fieldSchema);
                             fieldSchema = {
-                                type: withNullableJSONSchemaType('number', isRequired)
+                                $ref: `#/definitions/${field.interfaceName}`
                             };
                         }
                         break;
                     }
-                case 'checkbox':
+                case 'join':
                     {
                         fieldSchema = {
-                            type: withNullableJSONSchemaType('boolean', isRequired)
+                            type: withNullableJSONSchemaType('object', false),
+                            additionalProperties: false,
+                            properties: {
+                                docs: {
+                                    type: withNullableJSONSchemaType('array', false),
+                                    items: {
+                                        oneOf: [
+                                            {
+                                                type: collectionIDFieldTypes[field.collection]
+                                            },
+                                            {
+                                                $ref: `#/definitions/${field.collection}`
+                                            }
+                                        ]
+                                    }
+                                },
+                                hasNextPage: {
+                                    type: withNullableJSONSchemaType('boolean', false)
+                                }
+                            }
                         };
                         break;
                     }
@@ -261,62 +339,19 @@ export function fieldsToJSONSchema(/**
                         };
                         break;
                     }
-                case 'richText':
-                    {
-                        if (!field?.editor) {
-                            throw new MissingEditorProp(field) // while we allow disabling editor functionality, you should not have any richText fields defined if you do not have an editor
-                            ;
-                        }
-                        if (typeof field.editor === 'function') {
-                            throw new Error('Attempted to access unsanitized rich text editor.');
-                        }
-                        if (field.editor.outputSchema) {
-                            fieldSchema = field.editor.outputSchema({
-                                collectionIDFieldTypes,
-                                config,
-                                field,
-                                interfaceNameDefinitions,
-                                isRequired
-                            });
-                        } else {
-                            // Maintain backwards compatibility with existing rich text editors
-                            fieldSchema = {
-                                type: withNullableJSONSchemaType('array', isRequired),
-                                items: {
-                                    type: 'object'
-                                }
-                            };
-                        }
-                        break;
-                    }
-                case 'radio':
-                    {
-                        fieldSchema = {
-                            type: withNullableJSONSchemaType('string', isRequired),
-                            enum: buildOptionEnums(field.options)
-                        };
-                        break;
-                    }
-                case 'select':
+                case 'number':
                     {
-                        const optionEnums = buildOptionEnums(field.options);
-                        if (field.hasMany) {
+                        if (field.hasMany === true) {
                             fieldSchema = {
                                 type: withNullableJSONSchemaType('array', isRequired),
                                 items: {
-                                    type: 'string'
+                                    type: 'number'
                                 }
                             };
-                            if (optionEnums?.length) {
-                                fieldSchema.items.enum = optionEnums;
-                            }
                         } else {
                             fieldSchema = {
-                                type: withNullableJSONSchemaType('string', isRequired)
+                                type: withNullableJSONSchemaType('number', isRequired)
                             };
-                            if (optionEnums?.length) {
-                                fieldSchema.enum = optionEnums;
-                            }
                         }
                         break;
                     }
@@ -337,34 +372,16 @@ export function fieldsToJSONSchema(/**
                         };
                         break;
                     }
-                case 'join':
+                case 'radio':
                     {
                         fieldSchema = {
-                            type: withNullableJSONSchemaType('object', false),
-                            additionalProperties: false,
-                            properties: {
-                                docs: {
-                                    type: withNullableJSONSchemaType('array', false),
-                                    items: {
-                                        oneOf: [
-                                            {
-                                                type: collectionIDFieldTypes[field.collection]
-                                            },
-                                            {
-                                                $ref: `#/definitions/${field.collection}`
-                                            }
-                                        ]
-                                    }
-                                },
-                                hasNextPage: {
-                                    type: withNullableJSONSchemaType('boolean', false)
-                                }
-                            }
+                            type: withNullableJSONSchemaType('string', isRequired),
+                            enum: buildOptionEnums(field.options)
                         };
                         break;
                     }
-                case 'upload':
                 case 'relationship':
+                case 'upload':
                     {
                         if (Array.isArray(field.relationTo)) {
                             if (field.hasMany) {
@@ -455,73 +472,57 @@ export function fieldsToJSONSchema(/**
                         }
                         break;
                     }
-                case 'blocks':
+                case 'richText':
                     {
-                        // Check for a case where no blocks are provided.
-                        // We need to generate an empty array for this case, note that JSON schema 4 doesn't support empty arrays
-                        // so the best we can get is `unknown[]`
-                        const hasBlocks = Boolean(field.blocks.length);
-                        fieldSchema = {
-                            type: withNullableJSONSchemaType('array', isRequired),
-                            items: hasBlocks ? {
-                                oneOf: field.blocks.map((block)=>{
-                                    const blockFieldSchemas = fieldsToJSONSchema(collectionIDFieldTypes, block.fields, interfaceNameDefinitions, config);
-                                    const blockSchema = {
-                                        type: 'object',
-                                        additionalProperties: false,
-                                        properties: {
-                                            ...blockFieldSchemas.properties,
-                                            blockType: {
-                                                const: block.slug
-                                            }
-                                        },
-                                        required: [
-                                            'blockType',
-                                            ...blockFieldSchemas.required
-                                        ]
-                                    };
-                                    if (block.interfaceName) {
-                                        interfaceNameDefinitions.set(block.interfaceName, blockSchema);
-                                        return {
-                                            $ref: `#/definitions/${block.interfaceName}`
-                                        };
-                                    }
-                                    return blockSchema;
-                                })
-                            } : {}
-                        };
+                        if (!field?.editor) {
+                            throw new MissingEditorProp(field) // while we allow disabling editor functionality, you should not have any richText fields defined if you do not have an editor
+                            ;
+                        }
+                        if (typeof field.editor === 'function') {
+                            throw new Error('Attempted to access unsanitized rich text editor.');
+                        }
+                        if (field.editor.outputSchema) {
+                            fieldSchema = field.editor.outputSchema({
+                                collectionIDFieldTypes,
+                                config,
+                                field,
+                                interfaceNameDefinitions,
+                                isRequired
+                            });
+                        } else {
+                            // Maintain backwards compatibility with existing rich text editors
+                            fieldSchema = {
+                                type: withNullableJSONSchemaType('array', isRequired),
+                                items: {
+                                    type: 'object'
+                                }
+                            };
+                        }
                         break;
                     }
-                case 'array':
+                case 'select':
                     {
-                        fieldSchema = {
-                            type: withNullableJSONSchemaType('array', isRequired),
-                            items: {
-                                type: 'object',
-                                additionalProperties: false,
-                                ...fieldsToJSONSchema(collectionIDFieldTypes, field.fields, interfaceNameDefinitions, config)
+                        const optionEnums = buildOptionEnums(field.options);
+                        if (field.hasMany) {
+                            fieldSchema = {
+                                type: withNullableJSONSchemaType('array', isRequired),
+                                items: {
+                                    type: 'string'
+                                }
+                            };
+                            if (optionEnums?.length) {
+                                fieldSchema.items.enum = optionEnums;
                             }
-                        };
-                        if (field.interfaceName) {
-                            interfaceNameDefinitions.set(field.interfaceName, fieldSchema);
+                        } else {
                             fieldSchema = {
-                                $ref: `#/definitions/${field.interfaceName}`
+                                type: withNullableJSONSchemaType('string', isRequired)
                             };
+                            if (optionEnums?.length) {
+                                fieldSchema.enum = optionEnums;
+                            }
                         }
                         break;
                     }
-                case 'row':
-                case 'collapsible':
-                    {
-                        const childSchema = fieldsToJSONSchema(collectionIDFieldTypes, field.fields, interfaceNameDefinitions, config);
-                        Object.entries(childSchema.properties).forEach(([propName, propSchema])=>{
-                            fieldSchemas.set(propName, propSchema);
-                        });
-                        childSchema.required.forEach((propName)=>{
-                            requiredFieldNames.add(propName);
-                        });
-                        break;
-                    }
                 case 'tabs':
                     {
                         field.tabs.forEach((tab)=>{
@@ -549,21 +550,20 @@ export function fieldsToJSONSchema(/**
                         });
                         break;
                     }
-                case 'group':
-                    {
+                case 'text':
+                    if (field.hasMany === true) {
                         fieldSchema = {
-                            type: 'object',
-                            additionalProperties: false,
-                            ...fieldsToJSONSchema(collectionIDFieldTypes, field.fields, interfaceNameDefinitions, config)
+                            type: withNullableJSONSchemaType('array', isRequired),
+                            items: {
+                                type: 'string'
+                            }
+                        };
+                    } else {
+                        fieldSchema = {
+                            type: withNullableJSONSchemaType('string', isRequired)
                         };
-                        if (field.interfaceName) {
-                            interfaceNameDefinitions.set(field.interfaceName, fieldSchema);
-                            fieldSchema = {
-                                $ref: `#/definitions/${field.interfaceName}`
-                            };
-                        }
-                        break;
                     }
+                    break;
                 default:
                     {
                         break;
@@ -638,15 +638,6 @@ export function fieldsToSelectJSONSchema({ fields }) {
     };
     for (const field of fields){
         switch(field.type){
-            case 'row':
-            case 'collapsible':
-                schema.properties = {
-                    ...schema.properties,
-                    ...fieldsToSelectJSONSchema({
-                        fields: field.fields
-                    }).properties
-                };
-                break;
             case 'array':
             case 'group':
                 schema.properties[field.name] = {
@@ -660,29 +651,6 @@ export function fieldsToSelectJSONSchema({ fields }) {
                     ]
                 };
                 break;
-            case 'tabs':
-                for (const tab of field.tabs){
-                    if (tabHasName(tab)) {
-                        schema.properties[tab.name] = {
-                            oneOf: [
-                                {
-                                    type: 'boolean'
-                                },
-                                fieldsToSelectJSONSchema({
-                                    fields: tab.fields
-                                })
-                            ]
-                        };
-                        continue;
-                    }
-                    schema.properties = {
-                        ...schema.properties,
-                        ...fieldsToSelectJSONSchema({
-                            fields: tab.fields
-                        }).properties
-                    };
-                }
-                break;
             case 'blocks':
                 {
                     const blocksSchema = {
@@ -712,6 +680,38 @@ export function fieldsToSelectJSONSchema({ fields }) {
                     };
                     break;
                 }
+            case 'collapsible':
+            case 'row':
+                schema.properties = {
+                    ...schema.properties,
+                    ...fieldsToSelectJSONSchema({
+                        fields: field.fields
+                    }).properties
+                };
+                break;
+            case 'tabs':
+                for (const tab of field.tabs){
+                    if (tabHasName(tab)) {
+                        schema.properties[tab.name] = {
+                            oneOf: [
+                                {
+                                    type: 'boolean'
+                                },
+                                fieldsToSelectJSONSchema({
+                                    fields: tab.fields
+                                })
+                            ]
+                        };
+                        continue;
+                    }
+                    schema.properties = {
+                        ...schema.properties,
+                        ...fieldsToSelectJSONSchema({
+                            fields: tab.fields
+                        }).properties
+                    };
+                }
+                break;
             default:
                 schema.properties[field.name] = {
                     type: 'boolean'
@@ -728,6 +728,46 @@ const fieldType = {
 const generateAuthFieldTypes = ({ type, loginWithUsername })=>{
     if (loginWithUsername) {
         switch(type){
+            case 'forgotOrUnlock':
+                {
+                    if (loginWithUsername.allowEmailLogin) {
+                        // allow email or username for unlock/forgot-password
+                        return {
+                            additionalProperties: false,
+                            oneOf: [
+                                {
+                                    additionalProperties: false,
+                                    properties: {
+                                        email: fieldType
+                                    },
+                                    required: [
+                                        'email'
+                                    ]
+                                },
+                                {
+                                    additionalProperties: false,
+                                    properties: {
+                                        username: fieldType
+                                    },
+                                    required: [
+                                        'username'
+                                    ]
+                                }
+                            ]
+                        };
+                    } else {
+                        // allow only username for unlock/forgot-password
+                        return {
+                            additionalProperties: false,
+                            properties: {
+                                username: fieldType
+                            },
+                            required: [
+                                'username'
+                            ]
+                        };
+                    }
+                }
             case 'login':
                 {
                     if (loginWithUsername.allowEmailLogin) {
@@ -798,46 +838,6 @@ const generateAuthFieldTypes = ({ type, loginWithUsername })=>{
                         required: requiredFields
                     };
                 }
-            case 'forgotOrUnlock':
-                {
-                    if (loginWithUsername.allowEmailLogin) {
-                        // allow email or username for unlock/forgot-password
-                        return {
-                            additionalProperties: false,
-                            oneOf: [
-                                {
-                                    additionalProperties: false,
-                                    properties: {
-                                        email: fieldType
-                                    },
-                                    required: [
-                                        'email'
-                                    ]
-                                },
-                                {
-                                    additionalProperties: false,
-                                    properties: {
-                                        username: fieldType
-                                    },
-                                    required: [
-                                        'username'
-                                    ]
-                                }
-                            ]
-                        };
-                    } else {
-                        // allow only username for unlock/forgot-password
-                        return {
-                            additionalProperties: false,
-                            properties: {
-                                username: fieldType
-                            },
-                            required: [
-                                'username'
-                            ]
-                        };
-                    }
-                }
         }
     }
     // default email (and password for login/register)