payload 4.0.0-internal.e16cf59 → 4.0.0-internal.e55ccef

package/dist/utilities/configToJSONSchema.js

@@ -1,10 +1,13 @@
+import { createHash } from 'crypto';
 import { MissingEditorProp } from '../errors/MissingEditorProp.js';
-import { fieldAffectsData } from '../fields/config/types.js';
+import { fieldAffectsData, fieldIsVirtual } from '../fields/config/types.js';
 import { generateJobsJSONSchemas } from '../queues/config/generateJobsJSONSchemas.js';
 import { flattenAllFields } from './flattenAllFields.js';
-import { formatNames } from './formatLabels.js';
+import { formatNames, toWords } from './formatLabels.js';
 import { getCollectionIDFieldTypes } from './getCollectionIDFieldTypes.js';
 import { optionsAreEqual } from './optionsAreEqual.js';
+// Virtual fields (computed) and join fields (derived from the inverse relationship) are read-only.
+const fieldIsInputExcluded = (field)=>field.type === 'join' || fieldIsVirtual(field);
 const fieldIsRequired = (field)=>{
     const isConditional = Boolean(field?.admin && field?.admin?.condition);
     if (isConditional) {
@@ -33,7 +36,7 @@ function generateEntitySchemas(entities) {
         ...entities
     ].reduce((acc, { slug })=>{
         acc[slug] = {
-            $ref: `#/definitions/${slug}`
+            $ref: `#/$defs/${slug}`
         };
         return acc;
     }, {});
@@ -49,7 +52,23 @@ function generateEntitySelectSchemas(entities) {
         ...entities
     ].reduce((acc, { slug })=>{
         acc[slug] = {
-            $ref: `#/definitions/${slug}_select`
+            $ref: `#/$defs/${slug}_select`
+        };
+        return acc;
+    }, {});
+    return {
+        type: 'object',
+        additionalProperties: false,
+        properties,
+        required: Object.keys(properties)
+    };
+}
+function generateEntityInputSchemas(entities) {
+    const properties = [
+        ...entities
+    ].reduce((acc, { slug })=>{
+        acc[slug] = {
+            $ref: `#/$defs/${slug}_input`
         };
         return acc;
     }, {});
@@ -120,7 +139,7 @@ function getAllowedWidgetWidths({ maxWidth, minWidth }) {
     }
     return widgetWidths.slice(minIndex, maxIndex + 1);
 }
-function generateWidgetSchemas({ collectionIDFieldTypes, config, i18n, interfaceNameDefinitions, opts = {} }) {
+function generateWidgetSchemas({ collectionIDFieldTypes, config, forceInlineBlocks, i18n, interfaceNameDefinitions, typeStringDefinitions }) {
     const widgets = config.admin?.dashboard?.widgets ?? [];
     const definitions = {};
     const properties = {};
@@ -132,9 +151,17 @@ function generateWidgetSchemas({ collectionIDFieldTypes, config, i18n, interface
         });
         let dataSchema;
         if (widget.fields?.length) {
-            const widgetFieldSchemas = fieldsToJSONSchema(collectionIDFieldTypes, flattenAllFields({
-                fields: widget.fields
-            }), interfaceNameDefinitions, config, i18n, opts);
+            const widgetFieldSchemas = fieldsToJSONSchema({
+                collectionIDFieldTypes,
+                config,
+                fields: flattenAllFields({
+                    fields: widget.fields
+                }),
+                forceInlineBlocks,
+                i18n,
+                interfaceNameDefinitions,
+                typeStringDefinitions
+            });
             dataSchema = {
                 type: 'object',
                 additionalProperties: false,
@@ -161,7 +188,7 @@ function generateWidgetSchemas({ collectionIDFieldTypes, config, i18n, interface
             ]
         };
         properties[widget.slug] = {
-            $ref: `#/definitions/${definition}`
+            $ref: `#/$defs/${definition}`
         };
     }
     return {
@@ -240,7 +267,7 @@ function generateAuthEntitySchemas(entities) {
         ...entities
     ].filter(({ auth })=>Boolean(auth)).map(({ slug })=>{
         return {
-            $ref: `#/definitions/${slug}`
+            $ref: `#/$defs/${slug}`
         };
     }, {});
     return {
@@ -299,17 +326,35 @@ function entityOrFieldToJsDocs({ entity, i18n }) {
     }
     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 = {}) {
+export function fieldsToJSONSchema({ collectionIDFieldTypes, config, fields, forceInlineBlocks, i18n, interfaceNameDefinitions, typeStringDefinitions, variant = 'output' }) {
     const requiredFieldNames = new Set();
+    // Registers a named-interface (group/tab/array/select) def and returns its `$ref` name. For input,
+    // shares the read-shaped def when byte-identical; otherwise registers an `Input`-suffixed twin so
+    // the write shape doesn't collide with the read one.
+    const registerNamedInterface = (name, schema)=>{
+        if (variant === 'input') {
+            const outputDef = interfaceNameDefinitions.get(name);
+            if (outputDef && JSON.stringify(outputDef) === JSON.stringify(schema)) {
+                return name;
+            }
+            const inputName = `${name}Input`;
+            interfaceNameDefinitions.set(inputName, schema);
+            return inputName;
+        }
+        interfaceNameDefinitions.set(name, schema);
+        return name;
+    };
     return {
         properties: Object.fromEntries(fields.reduce((fieldSchemas, field, index)=>{
+            if (variant === 'input' && fieldIsInputExcluded(field)) {
+                return fieldSchemas;
+            }
+            const hasDefaultValue = 'defaultValue' in field && field.defaultValue !== undefined;
+            // `isRequired` only controls nullability (a non-required field gets `| null`). It does not
+            // change between variants, so e.g. a defaulted field stays non-null on input.
             const isRequired = fieldAffectsData(field) && fieldIsRequired(field);
+            // `isOptionalOnInput` controls the `?`: on input, defaulted fields can be omitted.
+            const isOptionalOnInput = variant === 'input' && hasDefaultValue;
             const fieldDescription = entityOrFieldToJsDocs({
                 entity: field,
                 i18n
@@ -328,13 +373,21 @@ export function fieldsToJSONSchema(/**
                             items: {
                                 type: 'object',
                                 additionalProperties: false,
-                                ...fieldsToJSONSchema(collectionIDFieldTypes, field.flattenedFields, interfaceNameDefinitions, config, i18n, opts)
+                                ...fieldsToJSONSchema({
+                                    collectionIDFieldTypes,
+                                    config,
+                                    fields: field.flattenedFields,
+                                    forceInlineBlocks,
+                                    i18n,
+                                    interfaceNameDefinitions,
+                                    typeStringDefinitions,
+                                    variant
+                                })
                             }
                         };
                         if (field.interfaceName) {
-                            interfaceNameDefinitions.set(field.interfaceName, fieldSchema);
                             fieldSchema = {
-                                $ref: `#/definitions/${field.interfaceName}`
+                                $ref: `#/$defs/${registerNamedInterface(field.interfaceName, fieldSchema)}`
                             };
                         }
                         break;
@@ -344,25 +397,26 @@ export function fieldsToJSONSchema(/**
                         // 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);
+                        const hasBlocks = Boolean(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;
+                                oneOf: field.blocks.map((blockOrReference)=>{
+                                    const block = typeof blockOrReference === 'string' ? config?.blocks?.find((b)=>b.slug === blockOrReference) : blockOrReference;
+                                    if (!block) {
+                                        return {};
                                     }
-                                    const blockFieldSchemas = fieldsToJSONSchema(collectionIDFieldTypes, block.flattenedFields, interfaceNameDefinitions, config, i18n, opts);
+                                    const blockFieldSchemas = fieldsToJSONSchema({
+                                        collectionIDFieldTypes,
+                                        config,
+                                        fields: block.flattenedFields,
+                                        forceInlineBlocks,
+                                        i18n,
+                                        interfaceNameDefinitions,
+                                        typeStringDefinitions,
+                                        variant
+                                    });
                                     const blockSchema = {
                                         type: 'object',
                                         additionalProperties: false,
@@ -377,13 +431,9 @@ export function fieldsToJSONSchema(/**
                                             ...blockFieldSchemas.required
                                         ]
                                     };
-                                    if (!opts.forceInlineBlocks && block.interfaceName) {
-                                        interfaceNameDefinitions.set(block.interfaceName, blockSchema);
-                                        return {
-                                            $ref: `#/definitions/${block.interfaceName}`
-                                        };
-                                    }
-                                    return blockSchema;
+                                    return forceInlineBlocks ? blockSchema : {
+                                        $ref: `#/$defs/${registerBlockInterface(block, blockSchema, interfaceNameDefinitions, variant)}`
+                                    };
                                 })
                             } : {}
                         };
@@ -400,6 +450,7 @@ export function fieldsToJSONSchema(/**
                 case 'code':
                 case 'date':
                 case 'email':
+                case 'slug':
                 case 'textarea':
                     {
                         fieldSchema = {
@@ -415,12 +466,20 @@ export function fieldsToJSONSchema(/**
                                 ...baseFieldSchema,
                                 type: 'object',
                                 additionalProperties: false,
-                                ...fieldsToJSONSchema(collectionIDFieldTypes, field.flattenedFields, interfaceNameDefinitions, config, i18n, opts)
+                                ...fieldsToJSONSchema({
+                                    collectionIDFieldTypes,
+                                    config,
+                                    fields: field.flattenedFields,
+                                    forceInlineBlocks,
+                                    i18n,
+                                    interfaceNameDefinitions,
+                                    typeStringDefinitions,
+                                    variant
+                                })
                             };
                             if (field.interfaceName) {
-                                interfaceNameDefinitions.set(field.interfaceName, fieldSchema);
                                 fieldSchema = {
-                                    $ref: `#/definitions/${field.interfaceName}`
+                                    $ref: `#/$defs/${registerNamedInterface(field.interfaceName, fieldSchema)}`
                                 };
                             }
                         }
@@ -444,7 +503,7 @@ export function fieldsToJSONSchema(/**
                                                         type: collectionIDFieldTypes[collection]
                                                     },
                                                     {
-                                                        $ref: `#/definitions/${collection}`
+                                                        $ref: `#/$defs/${collection}`
                                                     }
                                                 ]
                                             }
@@ -462,7 +521,7 @@ export function fieldsToJSONSchema(/**
                                         type: collectionIDFieldTypes[field.collection]
                                     },
                                     {
-                                        $ref: `#/definitions/${field.collection}`
+                                        $ref: `#/$defs/${field.collection}`
                                     }
                                 ]
                             };
@@ -545,9 +604,8 @@ export function fieldsToJSONSchema(/**
                             enum: buildOptionEnums(field.options)
                         };
                         if (field.interfaceName) {
-                            interfaceNameDefinitions.set(field.interfaceName, fieldSchema);
                             fieldSchema = {
-                                $ref: `#/definitions/${field.interfaceName}`
+                                $ref: `#/$defs/${registerNamedInterface(field.interfaceName, fieldSchema)}`
                             };
                         }
                         break;
@@ -555,6 +613,19 @@ export function fieldsToJSONSchema(/**
                 case 'relationship':
                 case 'upload':
                     {
+                        // Read: an ID or the populated doc. Input: only the ID, so drop the `$ref`.
+                        const relationValueSchema = (relation)=>variant === 'input' ? {
+                                type: collectionIDFieldTypes[relation]
+                            } : {
+                                oneOf: [
+                                    {
+                                        type: collectionIDFieldTypes[relation]
+                                    },
+                                    {
+                                        $ref: `#/$defs/${relation}`
+                                    }
+                                ]
+                            };
                         if (Array.isArray(field.relationTo)) {
                             if (field.hasMany) {
                                 fieldSchema = {
@@ -569,16 +640,7 @@ export function fieldsToJSONSchema(/**
                                                     relationTo: {
                                                         const: relation
                                                     },
-                                                    value: {
-                                                        oneOf: [
-                                                            {
-                                                                type: collectionIDFieldTypes[relation]
-                                                            },
-                                                            {
-                                                                $ref: `#/definitions/${relation}`
-                                                            }
-                                                        ]
-                                                    }
+                                                    value: relationValueSchema(relation)
                                                 },
                                                 required: [
                                                     'value',
@@ -599,16 +661,7 @@ export function fieldsToJSONSchema(/**
                                                 relationTo: {
                                                     const: relation
                                                 },
-                                                value: {
-                                                    oneOf: [
-                                                        {
-                                                            type: collectionIDFieldTypes[relation]
-                                                        },
-                                                        {
-                                                            $ref: `#/definitions/${relation}`
-                                                        }
-                                                    ]
-                                                }
+                                                value: relationValueSchema(relation)
                                             },
                                             required: [
                                                 'value',
@@ -622,17 +675,24 @@ export function fieldsToJSONSchema(/**
                             fieldSchema = {
                                 ...baseFieldSchema,
                                 type: withNullableJSONSchemaType('array', isRequired),
-                                items: {
+                                items: variant === 'input' ? {
+                                    type: collectionIDFieldTypes[field.relationTo]
+                                } : {
                                     oneOf: [
                                         {
                                             type: collectionIDFieldTypes[field.relationTo]
                                         },
                                         {
-                                            $ref: `#/definitions/${field.relationTo}`
+                                            $ref: `#/$defs/${field.relationTo}`
                                         }
                                     ]
                                 }
                             };
+                        } else if (variant === 'input') {
+                            fieldSchema = {
+                                ...baseFieldSchema,
+                                type: withNullableJSONSchemaType(collectionIDFieldTypes[field.relationTo], isRequired)
+                            };
                         } else {
                             fieldSchema = {
                                 ...baseFieldSchema,
@@ -641,7 +701,7 @@ export function fieldsToJSONSchema(/**
                                         type: withNullableJSONSchemaType(collectionIDFieldTypes[field.relationTo], isRequired)
                                     },
                                     {
-                                        $ref: `#/definitions/${field.relationTo}`
+                                        $ref: `#/$defs/${field.relationTo}`
                                     }
                                 ]
                             };
@@ -657,16 +717,18 @@ export function fieldsToJSONSchema(/**
                         if (typeof field.editor === 'function') {
                             throw new Error('Attempted to access unsanitized rich text editor.');
                         }
-                        if (field.editor.outputSchema) {
+                        if (field.editor.jsonSchema) {
                             fieldSchema = {
                                 ...baseFieldSchema,
-                                ...field.editor.outputSchema({
+                                ...field.editor.jsonSchema({
                                     collectionIDFieldTypes,
                                     config,
                                     field,
                                     i18n,
                                     interfaceNameDefinitions,
-                                    isRequired
+                                    isRequired,
+                                    typeStringDefinitions,
+                                    variant
                                 })
                             };
                         } else {
@@ -694,7 +756,7 @@ export function fieldsToJSONSchema(/**
                         // only if the field's options match the global config
                         if (isTimezoneField && hasMatchingGlobalTimezones) {
                             fieldSchema = {
-                                $ref: `#/definitions/supportedTimezones`
+                                $ref: `#/$defs/supportedTimezones`
                             };
                         } else {
                             if (field.hasMany) {
@@ -719,9 +781,8 @@ export function fieldsToJSONSchema(/**
                                 }
                             }
                             if (field.interfaceName) {
-                                interfaceNameDefinitions.set(field.interfaceName, fieldSchema);
                                 fieldSchema = {
-                                    $ref: `#/definitions/${field.interfaceName}`
+                                    $ref: `#/$defs/${registerNamedInterface(field.interfaceName, fieldSchema)}`
                                 };
                             }
                             break;
@@ -734,12 +795,20 @@ export function fieldsToJSONSchema(/**
                             ...baseFieldSchema,
                             type: 'object',
                             additionalProperties: false,
-                            ...fieldsToJSONSchema(collectionIDFieldTypes, field.flattenedFields, interfaceNameDefinitions, config, i18n, opts)
+                            ...fieldsToJSONSchema({
+                                collectionIDFieldTypes,
+                                config,
+                                fields: field.flattenedFields,
+                                forceInlineBlocks,
+                                i18n,
+                                interfaceNameDefinitions,
+                                typeStringDefinitions,
+                                variant
+                            })
                         };
                         if (field.interfaceName) {
-                            interfaceNameDefinitions.set(field.interfaceName, fieldSchema);
                             fieldSchema = {
-                                $ref: `#/definitions/${field.interfaceName}`
+                                $ref: `#/$defs/${registerNamedInterface(field.interfaceName, fieldSchema)}`
                             };
                         }
                         break;
@@ -765,15 +834,16 @@ export function fieldsToJSONSchema(/**
                         break;
                     }
             }
-            if ('typescriptSchema' in field && field?.typescriptSchema?.length) {
-                for (const schema of field.typescriptSchema){
+            if ('jsonSchema' in field && field?.jsonSchema?.length) {
+                for (const schema of field.jsonSchema){
                     fieldSchema = schema({
-                        jsonSchema: fieldSchema
+                        jsonSchema: fieldSchema,
+                        variant
                     });
                 }
             }
             if (fieldSchema && fieldAffectsData(field)) {
-                if (isRequired && fieldSchema.required !== false) {
+                if (isRequired && !isOptionalOnInput && fieldSchema.required !== false) {
                     requiredFieldNames.add(field.name);
                 }
                 fieldSchemas.set(field.name, fieldSchema);
@@ -784,17 +854,21 @@ export function fieldsToJSONSchema(/**
     };
 }
 // This function is part of the public API and is exported through payload/utilities
-export function entityToJSONSchema(config, entity, interfaceNameDefinitions, defaultIDType, collectionIDFieldTypes, i18n, opts = {}) {
+export function entityToJSONSchema(config, entity, interfaceNameDefinitions, defaultIDType, typeStringDefinitions, collectionIDFieldTypes, i18n, forceInlineBlocks, variant = 'output') {
     if (!collectionIDFieldTypes) {
         collectionIDFieldTypes = getCollectionIDFieldTypes({
             config,
             defaultIDType
         });
     }
-    const title = entity.typescript?.interface ? entity.typescript.interface : formatNames(entity.slug).singular;
+    const isInput = variant === 'input';
+    const baseTitle = entity.typescript?.interface ? entity.typescript.interface : formatNames(entity.slug).singular;
+    const title = isInput ? `${baseTitle}Input` : baseTitle;
     let mutableFields = [
         ...entity.flattenedFields
     ];
+    // `required: true` keeps `id` non-null. On input it's made optional further below (it's dropped
+    // from `required`) so you can omit it or pass a custom ID, but it's still never `null`.
     const idField = {
         name: 'id',
         type: defaultIDType,
@@ -802,20 +876,18 @@ export function entityToJSONSchema(config, entity, interfaceNameDefinitions, def
     };
     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;
-        });
+        mutableFields = mutableFields.map((field)=>field === customIdField ? {
+                ...field,
+                required: true
+            } : field);
     } else {
         mutableFields.unshift(idField);
     }
-    // mark timestamp fields required
-    if ('timestamps' in entity && entity.timestamps !== false) {
+    if (isInput) {
+        // Timestamps are managed by Payload. `_status` remains because create/update accept it.
+        mutableFields = mutableFields.filter((field)=>field.name !== 'createdAt' && field.name !== 'updatedAt');
+    } else if ('timestamps' in entity && entity.timestamps !== false) {
+        // mark timestamp fields required
         mutableFields = mutableFields.map((field)=>{
             if (field.name === 'createdAt' || field.name === 'updatedAt') {
                 return {
@@ -833,9 +905,23 @@ export function entityToJSONSchema(config, entity, interfaceNameDefinitions, def
         });
     }
     const isAuthCollection = 'auth' in entity && entity.auth;
-    const fieldsSchema = fieldsToJSONSchema(collectionIDFieldTypes, mutableFields, interfaceNameDefinitions, config, i18n, opts);
-    // Add collection property to auth collections
-    if (isAuthCollection) {
+    const fieldsSchema = fieldsToJSONSchema({
+        collectionIDFieldTypes,
+        config,
+        fields: mutableFields,
+        forceInlineBlocks,
+        i18n,
+        interfaceNameDefinitions,
+        typeStringDefinitions,
+        variant
+    });
+    // On input, `id` is optional (omit it, or pass a custom ID). Removing it from `required` makes
+    // it optional without making it nullable.
+    if (isInput && Array.isArray(fieldsSchema.required)) {
+        fieldsSchema.required = fieldsSchema.required.filter((name)=>name !== 'id');
+    }
+    // The `User`-union discriminator (read-side, e.g. `req.user`); not part of create/update data.
+    if (isAuthCollection && !isInput) {
         fieldsSchema.properties = {
             ...fieldsSchema.properties,
             collection: {
@@ -865,6 +951,47 @@ export function entityToJSONSchema(config, entity, interfaceNameDefinitions, def
     }
     return jsonSchema;
 }
+/**
+ * Like {@link entityToJSONSchema}, but returns a standalone schema for one collection or global:
+ * the entity plus only the `$defs` it actually uses, so it resolves on its own rather than
+ * as part of the whole config schema.
+ *
+ * Relationship/upload `$ref`s to other collections are left in place - the caller handles those.
+ * (The `input` variant reduces relationships to IDs, so only rich-text node `$defs` still ref them.)
+ */ export function entityToStandaloneJSONSchema({ config, defaultIDType, entity, i18n, variant = 'output' }) {
+    const definitions = new Map();
+    // entityToJSONSchema fills `definitions` with everything the fields reference (node unions, blocks).
+    const schema = entityToJSONSchema(config, entity, definitions, defaultIDType, new Set(), undefined, i18n, true, variant);
+    // Timezone fields `$ref` supportedTimezones, which lives on the root config schema, so add it here.
+    const supportedTimezones = config.admin?.timezones?.supportedTimezones;
+    if (supportedTimezones?.length && schemaHasRef([
+        schema,
+        ...definitions.values()
+    ], '#/$defs/supportedTimezones')) {
+        definitions.set('supportedTimezones', timezonesToJSONSchema(supportedTimezones));
+    }
+    return {
+        $schema: 'https://json-schema.org/draft/2020-12/schema',
+        ...schema,
+        $defs: Object.fromEntries(definitions)
+    };
+}
+/**
+ * Recursive function that returns true if
+ * `node` has a `$ref` to `ref` somewhere inside it.
+ * */ function schemaHasRef(node, ref) {
+    if (Array.isArray(node)) {
+        return node.some((child)=>schemaHasRef(child, ref));
+    }
+    if (node && typeof node === 'object') {
+        const obj = node;
+        if (obj.$ref === ref) {
+            return true;
+        }
+        return Object.values(obj).some((value)=>schemaHasRef(value, ref));
+    }
+    return false;
+}
 export function fieldsToSelectJSONSchema({ config, fields, interfaceNameDefinitions }) {
     const schema = {
         type: 'object',
@@ -886,7 +1013,7 @@ export function fieldsToSelectJSONSchema({ config, fields, interfaceNameDefiniti
                         const definition = `${field.interfaceName}_select`;
                         interfaceNameDefinitions.set(definition, fieldSchema);
                         fieldSchema = {
-                            $ref: `#/definitions/${definition}`
+                            $ref: `#/$defs/${definition}`
                         };
                     }
                     schema.properties[field.name] = {
@@ -906,7 +1033,7 @@ export function fieldsToSelectJSONSchema({ config, fields, interfaceNameDefiniti
                         additionalProperties: false,
                         properties: {}
                     };
-                    for (const block of field.blockReferences ?? field.blocks){
+                    for (const block of field.blocks){
                         if (typeof block === 'string') {
                             continue; // TODO
                         }
@@ -919,7 +1046,7 @@ export function fieldsToSelectJSONSchema({ config, fields, interfaceNameDefiniti
                             const definition = `${block.interfaceName}_select`;
                             interfaceNameDefinitions.set(definition, blockSchema);
                             blockSchema = {
-                                $ref: `#/definitions/${definition}`
+                                $ref: `#/$defs/${definition}`
                             };
                         }
                         blocksSchema.properties[block.slug] = {
@@ -1121,7 +1248,7 @@ function generateAuthOperationSchemas(collections) {
     const properties = collections.reduce((acc, collection)=>{
         if (collection.auth) {
             acc[collection.slug] = {
-                $ref: `#/definitions/auth/${collection.slug}`
+                $ref: `#/$defs/auth/${collection.slug}`
             };
         }
         return acc;
@@ -1133,11 +1260,56 @@ function generateAuthOperationSchemas(collections) {
         required: Object.keys(properties)
     };
 }
+const hashBlockSchema = (schema)=>createHash('sha256').update(JSON.stringify(schema)).digest('hex').slice(0, 8).toUpperCase();
+/**
+ * Registers a block's schema as a top-level definition and returns its name.
+ *
+ * The name is the block's `interfaceName`, or a PascalCase form of its slug. If a different block
+ * already uses that name - whether it was auto-generated or an explicit `interfaceName` - this one
+ * gets a content-hash suffix (`Hero_3F2A1B0C`) so the two don't overwrite each other. Registering
+ * the same block shape again reuses its name.
+ *
+ * The `input` variant adds an `Input` suffix (`HeroInput`) - unless the read-shaped def is already
+ * registered with byte-identical content (a block with nothing that differs between input and
+ * output), in which case it's shared as-is rather than emitting a redundant twin.
+ */ export function registerBlockInterface(block, blockSchema, interfaceNameDefinitions, variant = 'output') {
+    const rawName = block.interfaceName ?? toWords(block.slug, true);
+    if (variant === 'input') {
+        const outputDef = interfaceNameDefinitions.get(rawName);
+        if (outputDef && hashBlockSchema(outputDef) === hashBlockSchema(blockSchema)) {
+            return rawName;
+        }
+    }
+    const baseName = variant === 'input' ? `${rawName}Input` : rawName;
+    const existing = interfaceNameDefinitions.get(baseName);
+    // The name is free - claim it.
+    if (!existing) {
+        interfaceNameDefinitions.set(baseName, blockSchema);
+        return baseName;
+    }
+    const hash = hashBlockSchema(blockSchema);
+    // The same block shape is already registered under this name, so reuse it.
+    if (hashBlockSchema(existing) === hash) {
+        return baseName;
+    }
+    // A different block already owns the name. Disambiguate this one with its hash.
+    blockSchema.description = `Multiple blocks resolve to the \`${baseName}\` interface with different fields, so a content hash is appended to keep the generated types stable and unambiguous. Set a unique \`interfaceName\` on the block to choose the name yourself. See https://payloadcms.com/docs/typescript/generating-types#block-interface-name-collisions`;
+    const uniqueName = `${baseName}_${hash}`;
+    interfaceNameDefinitions.set(uniqueName, blockSchema);
+    return uniqueName;
+}
 /**
  * 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
+ */ export function configToJSONSchema(config, defaultIDType, i18n, { forceInlineBlocks } = {}) {
+    // a mutable Map of top-level definitions in the generated JSON Schema.
+    // - `array`/`group`/named-`tab` fields are registered here when they set
+    //   `interfaceName` (otherwise they stay inline).
+    // - `block` configs always register here via `registerBlockInterface`, keyed by
+    //   `block.interfaceName` if set, else a PascalCase form of the slug (with a
+    //   content-hash suffix when two different blocks resolve to the same name).
     const interfaceNameDefinitions = new Map();
+    // a mutable Set for raw TS source to be appended to `payload-types.ts`.
+    const typeStringDefinitions = new Set();
     //  Used for relationship fields, to determine whether to use a string or number type for the ID.
     const collectionIDFieldTypes = getCollectionIDFieldTypes({
         config,
@@ -1155,8 +1327,12 @@ function generateAuthOperationSchemas(collections) {
                 entity: collection
             }))
     ];
+    const generateInputTypes = config.typescript?.generateInputTypes === true;
     const entityDefinitions = entities.reduce((acc, { type, entity })=>{
-        acc[entity.slug] = entityToJSONSchema(config, entity, interfaceNameDefinitions, defaultIDType, collectionIDFieldTypes, i18n, opts);
+        acc[entity.slug] = entityToJSONSchema(config, entity, interfaceNameDefinitions, defaultIDType, typeStringDefinitions, collectionIDFieldTypes, i18n, forceInlineBlocks);
+        if (generateInputTypes) {
+            acc[`${entity.slug}_input`] = entityToJSONSchema(config, entity, interfaceNameDefinitions, defaultIDType, typeStringDefinitions, collectionIDFieldTypes, i18n, forceInlineBlocks, 'input');
+        }
         const select = fieldsToSelectJSONSchema({
             config,
             fields: entity.flattenedFields,
@@ -1178,9 +1354,10 @@ function generateAuthOperationSchemas(collections) {
     const widgetSchemas = generateWidgetSchemas({
         collectionIDFieldTypes,
         config,
+        forceInlineBlocks,
         i18n,
         interfaceNameDefinitions,
-        opts
+        typeStringDefinitions
     });
     const authOperationDefinitions = [
         ...config.collections
@@ -1190,7 +1367,7 @@ function generateAuthOperationSchemas(collections) {
     }, {
         auth: {}
     });
-    const jobsSchemas = config.jobs ? generateJobsJSONSchemas(config, config.jobs, interfaceNameDefinitions, collectionIDFieldTypes, i18n) : {};
+    const jobsSchemas = config.jobs ? generateJobsJSONSchemas(config, config.jobs, interfaceNameDefinitions, collectionIDFieldTypes, typeStringDefinitions, i18n) : {};
     const blocksDefinition = {
         type: 'object',
         additionalProperties: false,
@@ -1199,7 +1376,15 @@ function generateAuthOperationSchemas(collections) {
     };
     if (config?.blocks?.length) {
         for (const block of config.blocks){
-            const blockFieldSchemas = fieldsToJSONSchema(collectionIDFieldTypes, block.flattenedFields, interfaceNameDefinitions, config, i18n, opts);
+            const blockFieldSchemas = fieldsToJSONSchema({
+                collectionIDFieldTypes,
+                config,
+                fields: block.flattenedFields,
+                forceInlineBlocks,
+                i18n,
+                interfaceNameDefinitions,
+                typeStringDefinitions
+            });
             const blockSchema = {
                 type: 'object',
                 additionalProperties: false,
@@ -1214,23 +1399,22 @@ function generateAuthOperationSchemas(collections) {
                     ...blockFieldSchemas.required
                 ]
             };
-            const interfaceName = block.interfaceName ?? block.slug;
-            interfaceNameDefinitions.set(interfaceName, blockSchema);
             blocksDefinition.properties[block.slug] = {
-                $ref: `#/definitions/${interfaceName}`
+                $ref: `#/$defs/${registerBlockInterface(block, blockSchema, interfaceNameDefinitions)}`
             };
             blocksDefinition.required.push(block.slug);
         }
     }
     let jsonSchema = {
-        additionalProperties: false,
-        definitions: {
+        $defs: {
             supportedTimezones: timezoneDefinitions,
             ...entityDefinitions,
             ...widgetSchemas.definitions,
             ...Object.fromEntries(interfaceNameDefinitions),
             ...authOperationDefinitions
         },
+        $schema: 'https://json-schema.org/draft/2020-12/schema',
+        additionalProperties: false,
         // 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: {
@@ -1245,6 +1429,10 @@ function generateAuthOperationSchemas(collections) {
             globalsSelect: generateEntitySelectSchemas(config.globals || []),
             locale: generateLocaleEntitySchemas(config.localization),
             widgets: widgetSchemas.schema,
+            ...generateInputTypes ? {
+                collectionsInput: generateEntityInputSchemas(config.collections || []),
+                globalsInput: generateEntityInputSchemas(config.globals || [])
+            } : {},
             ...config.typescript?.strictDraftTypes ? {
                 strictDraftTypes: {
                     type: 'boolean',
@@ -1261,6 +1449,10 @@ function generateAuthOperationSchemas(collections) {
             'collectionsSelect',
             'collectionsJoins',
             'globalsSelect',
+            ...generateInputTypes ? [
+                'collectionsInput',
+                'globalsInput'
+            ] : [],
             ...config.typescript?.strictDraftTypes ? [
                 'strictDraftTypes'
             ] : [],
@@ -1275,7 +1467,7 @@ function generateAuthOperationSchemas(collections) {
     };
     if (jobsSchemas.definitions?.size) {
         for (const [key, value] of jobsSchemas.definitions){
-            jsonSchema.definitions[key] = value;
+            jsonSchema.$defs[key] = value;
         }
     }
     if (jobsSchemas.properties) {
@@ -1299,7 +1491,10 @@ function generateAuthOperationSchemas(collections) {
             });
         }
     }
-    return jsonSchema;
+    return {
+        jsonSchema,
+        typeStringDefinitions
+    };
 }
 
 //# sourceMappingURL=configToJSONSchema.js.map