@depup/payload 3.79.1-depup.0

package/dist/utilities/configToJSONSchema.js

@@ -0,0 +1,1305 @@
+import { MissingEditorProp } from '../errors/MissingEditorProp.js';
+import { fieldAffectsData } from '../fields/config/types.js';
+import { generateJobsJSONSchemas } from '../queues/config/generateJobsJSONSchemas.js';
+import { flattenAllFields } from './flattenAllFields.js';
+import { formatNames } from './formatLabels.js';
+import { getCollectionIDFieldTypes } from './getCollectionIDFieldTypes.js';
+import { optionsAreEqual } from './optionsAreEqual.js';
+const fieldIsRequired = (field)=>{
+    const isConditional = Boolean(field?.admin && field?.admin?.condition);
+    if (isConditional) {
+        return false;
+    }
+    const isMarkedRequired = 'required' in field && field.required === true;
+    if (fieldAffectsData(field) && isMarkedRequired) {
+        return true;
+    }
+    // if any subfields are required, this field is required
+    if ('fields' in field && field.type !== 'array') {
+        return field.flattenedFields.some((subField)=>fieldIsRequired(subField));
+    }
+    return false;
+};
+function buildOptionEnums(options) {
+    return options.map((option)=>{
+        if (typeof option === 'object' && 'value' in option) {
+            return option.value;
+        }
+        return option;
+    });
+}
+function generateEntitySchemas(entities) {
+    const properties = [
+        ...entities
+    ].reduce((acc, { slug })=>{
+        acc[slug] = {
+            $ref: `#/definitions/${slug}`
+        };
+        return acc;
+    }, {});
+    return {
+        type: 'object',
+        additionalProperties: false,
+        properties,
+        required: Object.keys(properties)
+    };
+}
+function generateEntitySelectSchemas(entities) {
+    const properties = [
+        ...entities
+    ].reduce((acc, { slug })=>{
+        acc[slug] = {
+            $ref: `#/definitions/${slug}_select`
+        };
+        return acc;
+    }, {});
+    return {
+        type: 'object',
+        additionalProperties: false,
+        properties,
+        required: Object.keys(properties)
+    };
+}
+function generateCollectionJoinsSchemas(collections) {
+    const properties = [
+        ...collections
+    ].reduce((acc, { slug, joins, polymorphicJoins })=>{
+        const schema = {
+            type: 'object',
+            additionalProperties: false,
+            properties: {},
+            required: []
+        };
+        for(const collectionSlug in joins){
+            for (const join of joins[collectionSlug]){
+                ;
+                schema.properties[join.joinPath] = {
+                    type: 'string',
+                    enum: [
+                        collectionSlug
+                    ]
+                };
+                schema.required.push(join.joinPath);
+            }
+        }
+        for (const join of polymorphicJoins){
+            ;
+            schema.properties[join.joinPath] = {
+                type: 'string',
+                enum: join.field.collection
+            };
+            schema.required.push(join.joinPath);
+        }
+        if (Object.keys(schema.properties).length > 0) {
+            acc[slug] = schema;
+        }
+        return acc;
+    }, {});
+    return {
+        type: 'object',
+        additionalProperties: false,
+        properties,
+        required: Object.keys(properties)
+    };
+}
+const widgetWidths = [
+    'x-small',
+    'small',
+    'medium',
+    'large',
+    'x-large',
+    'full'
+];
+function getAllowedWidgetWidths({ maxWidth, minWidth }) {
+    const minIndex = minWidth ? widgetWidths.indexOf(minWidth) : 0;
+    const maxIndex = maxWidth ? widgetWidths.indexOf(maxWidth) : widgetWidths.length - 1;
+    if (minIndex === -1 || maxIndex === -1 || minIndex > maxIndex) {
+        return [
+            ...widgetWidths
+        ];
+    }
+    return widgetWidths.slice(minIndex, maxIndex + 1);
+}
+function generateWidgetSchemas({ collectionIDFieldTypes, config, i18n, interfaceNameDefinitions, opts = {} }) {
+    const widgets = config.admin?.dashboard?.widgets ?? [];
+    const definitions = {};
+    const properties = {};
+    for (const widget of widgets){
+        const definition = `${widget.slug}_widget`;
+        const widthEnum = getAllowedWidgetWidths({
+            maxWidth: widget.maxWidth,
+            minWidth: widget.minWidth
+        });
+        let dataSchema;
+        if (widget.fields?.length) {
+            const widgetFieldSchemas = fieldsToJSONSchema(collectionIDFieldTypes, flattenAllFields({
+                fields: widget.fields
+            }), interfaceNameDefinitions, config, i18n, opts);
+            dataSchema = {
+                type: 'object',
+                additionalProperties: false,
+                ...widgetFieldSchemas
+            };
+        } else {
+            dataSchema = {
+                type: 'object',
+                additionalProperties: true
+            };
+        }
+        definitions[definition] = {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                data: dataSchema,
+                width: {
+                    type: 'string',
+                    enum: widthEnum
+                }
+            },
+            required: [
+                'width'
+            ]
+        };
+        properties[widget.slug] = {
+            $ref: `#/definitions/${definition}`
+        };
+    }
+    return {
+        definitions,
+        schema: {
+            type: 'object',
+            additionalProperties: false,
+            properties,
+            required: Object.keys(properties)
+        }
+    };
+}
+function generateLocaleEntitySchemas(localization) {
+    if (localization && 'locales' in localization && localization?.locales) {
+        const localesFromConfig = localization?.locales;
+        const locales = [
+            ...localesFromConfig
+        ].map((locale)=>{
+            return locale.code;
+        }, []);
+        return {
+            type: 'string',
+            enum: locales
+        };
+    }
+    return {
+        type: 'null'
+    };
+}
+function generateFallbackLocaleEntitySchemas(localization) {
+    if (localization && 'localeCodes' in localization && localization?.localeCodes) {
+        const localeCodes = [
+            ...localization.localeCodes
+        ].map((localeCode)=>{
+            return localeCode;
+        }, []);
+        return {
+            oneOf: [
+                {
+                    type: 'string',
+                    enum: [
+                        'false',
+                        'none',
+                        'null'
+                    ]
+                },
+                {
+                    type: 'boolean',
+                    enum: [
+                        false
+                    ]
+                },
+                {
+                    type: 'null'
+                },
+                {
+                    type: 'string',
+                    enum: localeCodes
+                },
+                {
+                    type: 'array',
+                    items: {
+                        type: 'string',
+                        enum: localeCodes
+                    }
+                }
+            ]
+        };
+    }
+    return {
+        type: 'null'
+    };
+}
+function generateAuthEntitySchemas(entities) {
+    const properties = [
+        ...entities
+    ].filter(({ auth })=>Boolean(auth)).map(({ slug })=>{
+        return {
+            $ref: `#/definitions/${slug}`
+        };
+    }, {});
+    return {
+        oneOf: properties
+    };
+}
+/**
+ * Generates the JSON Schema for database configuration
+ *
+ * @example { db: idType: string }
+ */ function generateDbEntitySchema(config) {
+    const defaultIDType = config.db?.defaultIDType === 'number' ? {
+        type: 'number'
+    } : {
+        type: 'string'
+    };
+    return {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            defaultIDType
+        },
+        required: [
+            'defaultIDType'
+        ]
+    };
+}
+/**
+ * Returns a JSON Schema Type with 'null' added if the field is not required.
+ */ export function withNullableJSONSchemaType(fieldType, isRequired) {
+    const fieldTypes = [
+        fieldType
+    ];
+    if (isRequired) {
+        return fieldType;
+    }
+    fieldTypes.push('null');
+    return fieldTypes;
+}
+function entityOrFieldToJsDocs({ entity, i18n }) {
+    let description = undefined;
+    if (entity?.admin?.description) {
+        if (typeof entity?.admin?.description === 'string') {
+            description = entity?.admin?.description;
+        } else if (typeof entity?.admin?.description === 'object') {
+            if (entity?.admin?.description?.en) {
+                description = entity?.admin?.description?.en;
+            } else if (entity?.admin?.description?.[i18n.language]) {
+                description = entity?.admin?.description?.[i18n.language];
+            }
+        } else if (typeof entity?.admin?.description === 'function' && i18n) {
+        // do not evaluate description functions for generating JSDocs. The output of
+        // those can differ depending on where and when they are called, creating
+        // inconsistencies in the generated JSDocs.
+        }
+    }
+    return description;
+}
+export function fieldsToJSONSchema(/**
+   * Used for relationship fields, to determine whether to use a string or number type for the ID.
+   * While there is a default ID field type set by the db adapter, they can differ on a collection-level
+   * if they have custom ID fields.
+   */ collectionIDFieldTypes, fields, /**
+   * Allows you to define new top-level interfaces that can be re-used in the output schema.
+   */ interfaceNameDefinitions, config, i18n, opts = {}) {
+    const requiredFieldNames = new Set();
+    return {
+        properties: Object.fromEntries(fields.reduce((fieldSchemas, field, index)=>{
+            const isRequired = fieldAffectsData(field) && fieldIsRequired(field);
+            const fieldDescription = entityOrFieldToJsDocs({
+                entity: field,
+                i18n
+            });
+            const baseFieldSchema = {};
+            if (fieldDescription) {
+                baseFieldSchema.description = fieldDescription;
+            }
+            let fieldSchema;
+            switch(field.type){
+                case 'array':
+                    {
+                        fieldSchema = {
+                            ...baseFieldSchema,
+                            type: withNullableJSONSchemaType('array', isRequired),
+                            items: {
+                                type: 'object',
+                                additionalProperties: false,
+                                ...fieldsToJSONSchema(collectionIDFieldTypes, field.flattenedFields, interfaceNameDefinitions, config, i18n, opts)
+                            }
+                        };
+                        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.blockReferences ? field.blockReferences.length : field.blocks.length);
+                        fieldSchema = {
+                            ...baseFieldSchema,
+                            type: withNullableJSONSchemaType('array', isRequired),
+                            items: hasBlocks ? {
+                                oneOf: (field.blockReferences ?? field.blocks).map((block)=>{
+                                    if (typeof block === 'string') {
+                                        const resolvedBlock = config?.blocks?.find((b)=>b.slug === block);
+                                        if (!resolvedBlock) {
+                                            return {};
+                                        }
+                                        if (!opts.forceInlineBlocks) {
+                                            return {
+                                                $ref: `#/definitions/${resolvedBlock.interfaceName ?? resolvedBlock.slug}`
+                                            };
+                                        }
+                                        block = resolvedBlock;
+                                    }
+                                    const blockFieldSchemas = fieldsToJSONSchema(collectionIDFieldTypes, block.flattenedFields, interfaceNameDefinitions, config, i18n, opts);
+                                    const blockSchema = {
+                                        type: 'object',
+                                        additionalProperties: false,
+                                        properties: {
+                                            ...blockFieldSchemas.properties,
+                                            blockType: {
+                                                const: block.slug
+                                            }
+                                        },
+                                        required: [
+                                            'blockType',
+                                            ...blockFieldSchemas.required
+                                        ]
+                                    };
+                                    if (!opts.forceInlineBlocks && block.interfaceName) {
+                                        interfaceNameDefinitions.set(block.interfaceName, blockSchema);
+                                        return {
+                                            $ref: `#/definitions/${block.interfaceName}`
+                                        };
+                                    }
+                                    return blockSchema;
+                                })
+                            } : {}
+                        };
+                        break;
+                    }
+                case 'checkbox':
+                    {
+                        fieldSchema = {
+                            ...baseFieldSchema,
+                            type: withNullableJSONSchemaType('boolean', isRequired)
+                        };
+                        break;
+                    }
+                case 'code':
+                case 'date':
+                case 'email':
+                case 'textarea':
+                    {
+                        fieldSchema = {
+                            ...baseFieldSchema,
+                            type: withNullableJSONSchemaType('string', isRequired)
+                        };
+                        break;
+                    }
+                case 'group':
+                    {
+                        if (fieldAffectsData(field)) {
+                            fieldSchema = {
+                                ...baseFieldSchema,
+                                type: 'object',
+                                additionalProperties: false,
+                                ...fieldsToJSONSchema(collectionIDFieldTypes, field.flattenedFields, interfaceNameDefinitions, config, i18n, opts)
+                            };
+                            if (field.interfaceName) {
+                                interfaceNameDefinitions.set(field.interfaceName, fieldSchema);
+                                fieldSchema = {
+                                    $ref: `#/definitions/${field.interfaceName}`
+                                };
+                            }
+                        }
+                        break;
+                    }
+                case 'join':
+                    {
+                        let items;
+                        if (Array.isArray(field.collection)) {
+                            items = {
+                                oneOf: field.collection.map((collection)=>({
+                                        type: 'object',
+                                        additionalProperties: false,
+                                        properties: {
+                                            relationTo: {
+                                                const: collection
+                                            },
+                                            value: {
+                                                oneOf: [
+                                                    {
+                                                        type: collectionIDFieldTypes[collection]
+                                                    },
+                                                    {
+                                                        $ref: `#/definitions/${collection}`
+                                                    }
+                                                ]
+                                            }
+                                        },
+                                        required: [
+                                            'collectionSlug',
+                                            'value'
+                                        ]
+                                    }))
+                            };
+                        } else {
+                            items = {
+                                oneOf: [
+                                    {
+                                        type: collectionIDFieldTypes[field.collection]
+                                    },
+                                    {
+                                        $ref: `#/definitions/${field.collection}`
+                                    }
+                                ]
+                            };
+                        }
+                        fieldSchema = {
+                            ...baseFieldSchema,
+                            type: 'object',
+                            additionalProperties: false,
+                            properties: {
+                                docs: {
+                                    type: 'array',
+                                    items
+                                },
+                                hasNextPage: {
+                                    type: 'boolean'
+                                },
+                                totalDocs: {
+                                    type: 'number'
+                                }
+                            }
+                        };
+                        break;
+                    }
+                case 'json':
+                    {
+                        fieldSchema = field.jsonSchema?.schema || {
+                            ...baseFieldSchema,
+                            type: [
+                                'object',
+                                'array',
+                                'string',
+                                'number',
+                                'boolean',
+                                'null'
+                            ]
+                        };
+                        break;
+                    }
+                case 'number':
+                    {
+                        if (field.hasMany === true) {
+                            fieldSchema = {
+                                ...baseFieldSchema,
+                                type: withNullableJSONSchemaType('array', isRequired),
+                                items: {
+                                    type: 'number'
+                                }
+                            };
+                        } else {
+                            fieldSchema = {
+                                ...baseFieldSchema,
+                                type: withNullableJSONSchemaType('number', isRequired)
+                            };
+                        }
+                        break;
+                    }
+                case 'point':
+                    {
+                        fieldSchema = {
+                            ...baseFieldSchema,
+                            type: withNullableJSONSchemaType('array', isRequired),
+                            items: [
+                                {
+                                    type: 'number'
+                                },
+                                {
+                                    type: 'number'
+                                }
+                            ],
+                            maxItems: 2,
+                            minItems: 2
+                        };
+                        break;
+                    }
+                case 'radio':
+                    {
+                        fieldSchema = {
+                            ...baseFieldSchema,
+                            type: withNullableJSONSchemaType('string', isRequired),
+                            enum: buildOptionEnums(field.options)
+                        };
+                        if (field.interfaceName) {
+                            interfaceNameDefinitions.set(field.interfaceName, fieldSchema);
+                            fieldSchema = {
+                                $ref: `#/definitions/${field.interfaceName}`
+                            };
+                        }
+                        break;
+                    }
+                case 'relationship':
+                case 'upload':
+                    {
+                        if (Array.isArray(field.relationTo)) {
+                            if (field.hasMany) {
+                                fieldSchema = {
+                                    ...baseFieldSchema,
+                                    type: withNullableJSONSchemaType('array', isRequired),
+                                    items: {
+                                        oneOf: field.relationTo.map((relation)=>{
+                                            return {
+                                                type: 'object',
+                                                additionalProperties: false,
+                                                properties: {
+                                                    relationTo: {
+                                                        const: relation
+                                                    },
+                                                    value: {
+                                                        oneOf: [
+                                                            {
+                                                                type: collectionIDFieldTypes[relation]
+                                                            },
+                                                            {
+                                                                $ref: `#/definitions/${relation}`
+                                                            }
+                                                        ]
+                                                    }
+                                                },
+                                                required: [
+                                                    'value',
+                                                    'relationTo'
+                                                ]
+                                            };
+                                        })
+                                    }
+                                };
+                            } else {
+                                fieldSchema = {
+                                    ...baseFieldSchema,
+                                    oneOf: field.relationTo.map((relation)=>{
+                                        return {
+                                            type: withNullableJSONSchemaType('object', isRequired),
+                                            additionalProperties: false,
+                                            properties: {
+                                                relationTo: {
+                                                    const: relation
+                                                },
+                                                value: {
+                                                    oneOf: [
+                                                        {
+                                                            type: collectionIDFieldTypes[relation]
+                                                        },
+                                                        {
+                                                            $ref: `#/definitions/${relation}`
+                                                        }
+                                                    ]
+                                                }
+                                            },
+                                            required: [
+                                                'value',
+                                                'relationTo'
+                                            ]
+                                        };
+                                    })
+                                };
+                            }
+                        } else if (field.hasMany) {
+                            fieldSchema = {
+                                ...baseFieldSchema,
+                                type: withNullableJSONSchemaType('array', isRequired),
+                                items: {
+                                    oneOf: [
+                                        {
+                                            type: collectionIDFieldTypes[field.relationTo]
+                                        },
+                                        {
+                                            $ref: `#/definitions/${field.relationTo}`
+                                        }
+                                    ]
+                                }
+                            };
+                        } else {
+                            fieldSchema = {
+                                ...baseFieldSchema,
+                                oneOf: [
+                                    {
+                                        type: withNullableJSONSchemaType(collectionIDFieldTypes[field.relationTo], isRequired)
+                                    },
+                                    {
+                                        $ref: `#/definitions/${field.relationTo}`
+                                    }
+                                ]
+                            };
+                        }
+                        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 = {
+                                ...baseFieldSchema,
+                                ...field.editor.outputSchema({
+                                    collectionIDFieldTypes,
+                                    config,
+                                    field,
+                                    i18n,
+                                    interfaceNameDefinitions,
+                                    isRequired
+                                })
+                            };
+                        } else {
+                            // Maintain backwards compatibility with existing rich text editors
+                            fieldSchema = {
+                                ...baseFieldSchema,
+                                type: withNullableJSONSchemaType('array', isRequired),
+                                items: {
+                                    type: 'object'
+                                }
+                            };
+                        }
+                        break;
+                    }
+                case 'select':
+                    {
+                        const optionEnums = buildOptionEnums(field.options);
+                        // We get the previous field to check for a date in the case of a timezone select
+                        // This works because timezone selects are always inserted right after a date with 'timezone: true'
+                        const previousField = fields?.[index - 1];
+                        const isTimezoneField = previousField?.type === 'date' && previousField.timezone && field.name.includes('_tz');
+                        // Check if the timezone field's options match the global config's supported timezones
+                        const hasMatchingGlobalTimezones = isTimezoneField && config && optionsAreEqual(field.options, config.admin?.timezones?.supportedTimezones);
+                        // Timezone selects should reference the supportedTimezones definition
+                        // only if the field's options match the global config
+                        if (isTimezoneField && hasMatchingGlobalTimezones) {
+                            fieldSchema = {
+                                $ref: `#/definitions/supportedTimezones`
+                            };
+                        } else {
+                            if (field.hasMany) {
+                                fieldSchema = {
+                                    ...baseFieldSchema,
+                                    type: withNullableJSONSchemaType('array', isRequired),
+                                    items: {
+                                        type: 'string'
+                                    }
+                                };
+                                if (optionEnums?.length) {
+                                    ;
+                                    fieldSchema.items.enum = optionEnums;
+                                }
+                            } else {
+                                fieldSchema = {
+                                    ...baseFieldSchema,
+                                    type: withNullableJSONSchemaType('string', isRequired)
+                                };
+                                if (optionEnums?.length) {
+                                    fieldSchema.enum = optionEnums;
+                                }
+                            }
+                            if (field.interfaceName) {
+                                interfaceNameDefinitions.set(field.interfaceName, fieldSchema);
+                                fieldSchema = {
+                                    $ref: `#/definitions/${field.interfaceName}`
+                                };
+                            }
+                            break;
+                        }
+                        break;
+                    }
+                case 'tab':
+                    {
+                        fieldSchema = {
+                            ...baseFieldSchema,
+                            type: 'object',
+                            additionalProperties: false,
+                            ...fieldsToJSONSchema(collectionIDFieldTypes, field.flattenedFields, interfaceNameDefinitions, config, i18n, opts)
+                        };
+                        if (field.interfaceName) {
+                            interfaceNameDefinitions.set(field.interfaceName, fieldSchema);
+                            fieldSchema = {
+                                $ref: `#/definitions/${field.interfaceName}`
+                            };
+                        }
+                        break;
+                    }
+                case 'text':
+                    if (field.hasMany === true) {
+                        fieldSchema = {
+                            ...baseFieldSchema,
+                            type: withNullableJSONSchemaType('array', isRequired),
+                            items: {
+                                type: 'string'
+                            }
+                        };
+                    } else {
+                        fieldSchema = {
+                            ...baseFieldSchema,
+                            type: withNullableJSONSchemaType('string', isRequired)
+                        };
+                    }
+                    break;
+                default:
+                    {
+                        break;
+                    }
+            }
+            if ('typescriptSchema' in field && field?.typescriptSchema?.length) {
+                for (const schema of field.typescriptSchema){
+                    fieldSchema = schema({
+                        jsonSchema: fieldSchema
+                    });
+                }
+            }
+            if (fieldSchema && fieldAffectsData(field)) {
+                if (isRequired && fieldSchema.required !== false) {
+                    requiredFieldNames.add(field.name);
+                }
+                fieldSchemas.set(field.name, fieldSchema);
+            }
+            return fieldSchemas;
+        }, new Map())),
+        required: Array.from(requiredFieldNames)
+    };
+}
+// This function is part of the public API and is exported through payload/utilities
+export function entityToJSONSchema(config, entity, interfaceNameDefinitions, defaultIDType, collectionIDFieldTypes, i18n, opts = {}) {
+    if (!collectionIDFieldTypes) {
+        collectionIDFieldTypes = getCollectionIDFieldTypes({
+            config,
+            defaultIDType
+        });
+    }
+    const title = entity.typescript?.interface ? entity.typescript.interface : formatNames(entity.slug).singular;
+    let mutableFields = [
+        ...entity.flattenedFields
+    ];
+    const idField = {
+        name: 'id',
+        type: defaultIDType,
+        required: true
+    };
+    const customIdField = mutableFields.find((field)=>field.name === 'id');
+    if (customIdField && customIdField.type !== 'group' && customIdField.type !== 'tab') {
+        mutableFields = mutableFields.map((field)=>{
+            if (field === customIdField) {
+                return {
+                    ...field,
+                    required: true
+                };
+            }
+            return field;
+        });
+    } else {
+        mutableFields.unshift(idField);
+    }
+    // mark timestamp fields required
+    if ('timestamps' in entity && entity.timestamps !== false) {
+        mutableFields = mutableFields.map((field)=>{
+            if (field.name === 'createdAt' || field.name === 'updatedAt') {
+                return {
+                    ...field,
+                    required: true
+                };
+            }
+            return field;
+        });
+    }
+    if ('auth' in entity && entity.auth && (!entity.auth?.disableLocalStrategy || typeof entity.auth?.disableLocalStrategy === 'object' && entity.auth.disableLocalStrategy.enableFields)) {
+        mutableFields.push({
+            name: 'password',
+            type: 'text'
+        });
+    }
+    const isAuthCollection = 'auth' in entity && entity.auth;
+    const fieldsSchema = fieldsToJSONSchema(collectionIDFieldTypes, mutableFields, interfaceNameDefinitions, config, i18n, opts);
+    // Add collection property to auth collections
+    if (isAuthCollection) {
+        fieldsSchema.properties = {
+            ...fieldsSchema.properties,
+            collection: {
+                type: 'string',
+                enum: [
+                    entity.slug
+                ]
+            }
+        };
+        fieldsSchema.required = [
+            ...fieldsSchema.required || [],
+            'collection'
+        ];
+    }
+    const jsonSchema = {
+        type: 'object',
+        additionalProperties: false,
+        title,
+        ...fieldsSchema
+    };
+    const entityDescription = entityOrFieldToJsDocs({
+        entity,
+        i18n
+    });
+    if (entityDescription) {
+        jsonSchema.description = entityDescription;
+    }
+    return jsonSchema;
+}
+export function fieldsToSelectJSONSchema({ config, fields, interfaceNameDefinitions }) {
+    const schema = {
+        type: 'object',
+        additionalProperties: false,
+        properties: {}
+    };
+    for (const field of fields){
+        switch(field.type){
+            case 'array':
+            case 'group':
+            case 'tab':
+                {
+                    let fieldSchema = fieldsToSelectJSONSchema({
+                        config,
+                        fields: field.flattenedFields,
+                        interfaceNameDefinitions
+                    });
+                    if (field.interfaceName) {
+                        const definition = `${field.interfaceName}_select`;
+                        interfaceNameDefinitions.set(definition, fieldSchema);
+                        fieldSchema = {
+                            $ref: `#/definitions/${definition}`
+                        };
+                    }
+                    schema.properties[field.name] = {
+                        oneOf: [
+                            {
+                                type: 'boolean'
+                            },
+                            fieldSchema
+                        ]
+                    };
+                    break;
+                }
+            case 'blocks':
+                {
+                    const blocksSchema = {
+                        type: 'object',
+                        additionalProperties: false,
+                        properties: {}
+                    };
+                    for (const block of field.blockReferences ?? field.blocks){
+                        if (typeof block === 'string') {
+                            continue; // TODO
+                        }
+                        let blockSchema = fieldsToSelectJSONSchema({
+                            config,
+                            fields: block.flattenedFields,
+                            interfaceNameDefinitions
+                        });
+                        if (block.interfaceName) {
+                            const definition = `${block.interfaceName}_select`;
+                            interfaceNameDefinitions.set(definition, blockSchema);
+                            blockSchema = {
+                                $ref: `#/definitions/${definition}`
+                            };
+                        }
+                        blocksSchema.properties[block.slug] = {
+                            oneOf: [
+                                {
+                                    type: 'boolean'
+                                },
+                                blockSchema
+                            ]
+                        };
+                    }
+                    schema.properties[field.name] = {
+                        oneOf: [
+                            {
+                                type: 'boolean'
+                            },
+                            blocksSchema
+                        ]
+                    };
+                    break;
+                }
+            default:
+                schema.properties[field.name] = {
+                    type: 'boolean'
+                };
+                break;
+        }
+    }
+    return schema;
+}
+const fieldType = {
+    type: 'string',
+    required: false
+};
+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) {
+                        // allow username or email and require password for login
+                        return {
+                            additionalProperties: false,
+                            oneOf: [
+                                {
+                                    additionalProperties: false,
+                                    properties: {
+                                        email: fieldType,
+                                        password: fieldType
+                                    },
+                                    required: [
+                                        'email',
+                                        'password'
+                                    ]
+                                },
+                                {
+                                    additionalProperties: false,
+                                    properties: {
+                                        password: fieldType,
+                                        username: fieldType
+                                    },
+                                    required: [
+                                        'username',
+                                        'password'
+                                    ]
+                                }
+                            ]
+                        };
+                    } else {
+                        // allow only username and password for login
+                        return {
+                            additionalProperties: false,
+                            properties: {
+                                password: fieldType,
+                                username: fieldType
+                            },
+                            required: [
+                                'username',
+                                'password'
+                            ]
+                        };
+                    }
+                }
+            case 'register':
+                {
+                    const requiredFields = [
+                        'password'
+                    ];
+                    const properties = {
+                        password: fieldType,
+                        username: fieldType
+                    };
+                    if (loginWithUsername.requireEmail) {
+                        requiredFields.push('email');
+                    }
+                    if (loginWithUsername.requireUsername) {
+                        requiredFields.push('username');
+                    }
+                    if (loginWithUsername.requireEmail || loginWithUsername.allowEmailLogin) {
+                        properties.email = fieldType;
+                    }
+                    return {
+                        additionalProperties: false,
+                        properties,
+                        required: requiredFields
+                    };
+                }
+        }
+    }
+    // default email (and password for login/register)
+    return {
+        additionalProperties: false,
+        properties: {
+            email: fieldType,
+            password: fieldType
+        },
+        required: [
+            'email',
+            'password'
+        ]
+    };
+};
+export function authCollectionToOperationsJSONSchema(config) {
+    const loginWithUsername = config.auth?.loginWithUsername;
+    const loginUserFields = generateAuthFieldTypes({
+        type: 'login',
+        loginWithUsername
+    });
+    const forgotOrUnlockUserFields = generateAuthFieldTypes({
+        type: 'forgotOrUnlock',
+        loginWithUsername
+    });
+    const registerUserFields = generateAuthFieldTypes({
+        type: 'register',
+        loginWithUsername
+    });
+    const properties = {
+        forgotPassword: forgotOrUnlockUserFields,
+        login: loginUserFields,
+        registerFirstUser: registerUserFields,
+        unlock: forgotOrUnlockUserFields
+    };
+    return {
+        type: 'object',
+        additionalProperties: false,
+        properties,
+        required: Object.keys(properties),
+        title: `${formatNames(config.slug).singular}AuthOperations`
+    };
+}
+// Generates the JSON Schema for supported timezones
+export function timezonesToJSONSchema(supportedTimezones) {
+    return {
+        description: 'Supported timezones in IANA format.',
+        enum: supportedTimezones.map((timezone)=>typeof timezone === 'string' ? timezone : timezone.value)
+    };
+}
+function generateAuthOperationSchemas(collections) {
+    const properties = collections.reduce((acc, collection)=>{
+        if (collection.auth) {
+            acc[collection.slug] = {
+                $ref: `#/definitions/auth/${collection.slug}`
+            };
+        }
+        return acc;
+    }, {});
+    return {
+        type: 'object',
+        additionalProperties: false,
+        properties,
+        required: Object.keys(properties)
+    };
+}
+/**
+ * This is used for generating the TypeScript types (payload-types.ts) with the payload generate:types command.
+ */ export function configToJSONSchema(config, defaultIDType, i18n, opts = {}) {
+    // a mutable Map to store custom top-level `interfaceName` types. Fields with an `interfaceName` property will be moved to the top-level definitions here
+    const interfaceNameDefinitions = new Map();
+    //  Used for relationship fields, to determine whether to use a string or number type for the ID.
+    const collectionIDFieldTypes = getCollectionIDFieldTypes({
+        config,
+        defaultIDType: defaultIDType
+    });
+    // Collections and Globals have to be moved to the top-level definitions as well. Reason: The top-level type will be the `Config` type - we don't want all collection and global
+    // types to be inlined inside the `Config` type
+    const entities = [
+        ...config.globals.map((global)=>({
+                type: 'global',
+                entity: global
+            })),
+        ...config.collections.map((collection)=>({
+                type: 'collection',
+                entity: collection
+            }))
+    ];
+    const entityDefinitions = entities.reduce((acc, { type, entity })=>{
+        acc[entity.slug] = entityToJSONSchema(config, entity, interfaceNameDefinitions, defaultIDType, collectionIDFieldTypes, i18n, opts);
+        const select = fieldsToSelectJSONSchema({
+            config,
+            fields: entity.flattenedFields,
+            interfaceNameDefinitions
+        });
+        if (type === 'global') {
+            select.properties.globalType = {
+                type: 'boolean'
+            };
+        }
+        acc[`${entity.slug}_select`] = {
+            type: 'object',
+            additionalProperties: false,
+            ...select
+        };
+        return acc;
+    }, {});
+    const timezoneDefinitions = timezonesToJSONSchema(config.admin.timezones.supportedTimezones);
+    const widgetSchemas = generateWidgetSchemas({
+        collectionIDFieldTypes,
+        config,
+        i18n,
+        interfaceNameDefinitions,
+        opts
+    });
+    const authOperationDefinitions = [
+        ...config.collections
+    ].filter(({ auth })=>Boolean(auth)).reduce((acc, authCollection)=>{
+        acc.auth[authCollection.slug] = authCollectionToOperationsJSONSchema(authCollection);
+        return acc;
+    }, {
+        auth: {}
+    });
+    const jobsSchemas = config.jobs ? generateJobsJSONSchemas(config, config.jobs, interfaceNameDefinitions, collectionIDFieldTypes, i18n) : {};
+    const blocksDefinition = {
+        type: 'object',
+        additionalProperties: false,
+        properties: {},
+        required: []
+    };
+    if (config?.blocks?.length) {
+        for (const block of config.blocks){
+            const blockFieldSchemas = fieldsToJSONSchema(collectionIDFieldTypes, block.flattenedFields, interfaceNameDefinitions, config, i18n, opts);
+            const blockSchema = {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    ...blockFieldSchemas.properties,
+                    blockType: {
+                        const: block.slug
+                    }
+                },
+                required: [
+                    'blockType',
+                    ...blockFieldSchemas.required
+                ]
+            };
+            const interfaceName = block.interfaceName ?? block.slug;
+            interfaceNameDefinitions.set(interfaceName, blockSchema);
+            blocksDefinition.properties[block.slug] = {
+                $ref: `#/definitions/${interfaceName}`
+            };
+            blocksDefinition.required.push(block.slug);
+        }
+    }
+    let jsonSchema = {
+        additionalProperties: false,
+        definitions: {
+            supportedTimezones: timezoneDefinitions,
+            ...entityDefinitions,
+            ...widgetSchemas.definitions,
+            ...Object.fromEntries(interfaceNameDefinitions),
+            ...authOperationDefinitions
+        },
+        // These properties here will be very simple, as all the complexity is in the definitions. These are just the properties for the top-level `Config` type
+        type: 'object',
+        properties: {
+            auth: generateAuthOperationSchemas(config.collections),
+            blocks: blocksDefinition,
+            collections: generateEntitySchemas(config.collections || []),
+            collectionsJoins: generateCollectionJoinsSchemas(config.collections || []),
+            collectionsSelect: generateEntitySelectSchemas(config.collections || []),
+            db: generateDbEntitySchema(config),
+            fallbackLocale: generateFallbackLocaleEntitySchemas(config.localization),
+            globals: generateEntitySchemas(config.globals || []),
+            globalsSelect: generateEntitySelectSchemas(config.globals || []),
+            locale: generateLocaleEntitySchemas(config.localization),
+            widgets: widgetSchemas.schema,
+            ...config.typescript?.strictDraftTypes ? {
+                strictDraftTypes: {
+                    type: 'boolean',
+                    const: true
+                }
+            } : {},
+            user: generateAuthEntitySchemas(config.collections)
+        },
+        required: [
+            'user',
+            'locale',
+            'fallbackLocale',
+            'collections',
+            'collectionsSelect',
+            'collectionsJoins',
+            'globalsSelect',
+            ...config.typescript?.strictDraftTypes ? [
+                'strictDraftTypes'
+            ] : [],
+            'globals',
+            'auth',
+            'db',
+            'jobs',
+            'blocks',
+            'widgets'
+        ],
+        title: 'Config'
+    };
+    if (jobsSchemas.definitions?.size) {
+        for (const [key, value] of jobsSchemas.definitions){
+            jsonSchema.definitions[key] = value;
+        }
+    }
+    if (jobsSchemas.properties) {
+        jsonSchema.properties.jobs = {
+            type: 'object',
+            additionalProperties: false,
+            properties: jobsSchemas.properties,
+            required: [
+                'tasks',
+                'workflows'
+            ]
+        };
+    }
+    if (config?.typescript?.schema?.length) {
+        for (const schema of config.typescript.schema){
+            jsonSchema = schema({
+                collectionIDFieldTypes,
+                config,
+                i18n: i18n,
+                jsonSchema
+            });
+        }
+    }
+    return jsonSchema;
+}
+
+//# sourceMappingURL=configToJSONSchema.js.map