payload 4.0.0-internal.c2b57ce → 4.0.0-internal.cd69eef

package/dist/utilities/configToJSONSchema.spec.js

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { sanitizeConfig } from '../config/sanitize.js';
-import { configToJSONSchema } from './configToJSONSchema.js';
+import { configToJSONSchema, entityToStandaloneJSONSchema } from './configToJSONSchema.js';
 describe('configToJSONSchema', ()=>{
     it('should handle optional arrays with required fields', async ()=>{
         // @ts-expect-error
@@ -21,13 +21,14 @@ describe('configToJSONSchema', ()=>{
                             ]
                         }
                     ],
-                    timestamps: false
+                    timestamps: false,
+                    versions: false
                 }
             ]
         };
         const sanitizedConfig = await sanitizeConfig(config);
-        const schema = configToJSONSchema(sanitizedConfig, 'text');
-        expect(schema?.definitions?.test).toStrictEqual({
+        const { jsonSchema: schema } = configToJSONSchema(sanitizedConfig, 'text');
+        expect(schema?.$defs?.test).toStrictEqual({
             type: 'object',
             additionalProperties: false,
             properties: {
@@ -65,6 +66,362 @@ describe('configToJSONSchema', ()=>{
             title: 'Test'
         });
     });
+    it('should generate separate input types when generateInputTypes is enabled', async ()=>{
+        // @ts-expect-error partial config
+        const config = {
+            collections: [
+                {
+                    slug: 'authors',
+                    fields: [
+                        {
+                            name: 'name',
+                            type: 'text'
+                        }
+                    ]
+                },
+                {
+                    slug: 'categories',
+                    fields: [
+                        {
+                            name: 'title',
+                            type: 'text'
+                        }
+                    ]
+                },
+                {
+                    slug: 'posts',
+                    fields: [
+                        {
+                            name: 'title',
+                            type: 'text',
+                            required: true
+                        },
+                        {
+                            name: 'status',
+                            type: 'select',
+                            defaultValue: 'draft',
+                            options: [
+                                'draft',
+                                'published'
+                            ],
+                            required: true
+                        },
+                        {
+                            name: 'author',
+                            type: 'relationship',
+                            relationTo: 'authors'
+                        },
+                        {
+                            name: 'categories',
+                            type: 'relationship',
+                            hasMany: true,
+                            relationTo: 'categories'
+                        }
+                    ]
+                }
+            ],
+            typescript: {
+                generateInputTypes: true
+            }
+        };
+        const sanitizedConfig = await sanitizeConfig(config);
+        const { jsonSchema: schema } = configToJSONSchema(sanitizedConfig, 'text');
+        // Output (read) shape is unchanged: relationships may be populated, managed fields are present,
+        // and a required field with a defaultValue stays required.
+        const postsOutput = schema?.$defs?.posts;
+        expect(postsOutput.title).toBe('Post');
+        expect(postsOutput.properties.author).toStrictEqual({
+            oneOf: [
+                {
+                    type: [
+                        'string',
+                        'null'
+                    ]
+                },
+                {
+                    $ref: '#/$defs/authors'
+                }
+            ]
+        });
+        expect(postsOutput.properties.categories).toStrictEqual({
+            type: [
+                'array',
+                'null'
+            ],
+            items: {
+                oneOf: [
+                    {
+                        type: 'string'
+                    },
+                    {
+                        $ref: '#/$defs/categories'
+                    }
+                ]
+            }
+        });
+        expect(postsOutput.required).toStrictEqual([
+            'id',
+            'title',
+            'status',
+            'updatedAt',
+            'createdAt'
+        ]);
+        // Input (write) shape: relationships are ID-only, the defaultValue field is optional, `id` is
+        // optional, and createdAt/updatedAt are dropped. `id` and the defaulted `status` are optional
+        // but NOT nullable - nullability follows the read shape, where they're non-null.
+        expect(schema?.$defs?.posts_input).toStrictEqual({
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                id: {
+                    type: 'string'
+                },
+                title: {
+                    type: 'string'
+                },
+                status: {
+                    type: 'string',
+                    enum: [
+                        'draft',
+                        'published'
+                    ]
+                },
+                author: {
+                    type: [
+                        'string',
+                        'null'
+                    ]
+                },
+                categories: {
+                    type: [
+                        'array',
+                        'null'
+                    ],
+                    items: {
+                        type: 'string'
+                    }
+                }
+            },
+            required: [
+                'title'
+            ],
+            title: 'PostInput'
+        });
+        // The Config type exposes input shapes under `collectionsInput`.
+        expect(schema?.properties?.collectionsInput?.properties?.posts).toStrictEqual({
+            $ref: '#/$defs/posts_input'
+        });
+    });
+    it('should keep _status in the input schema for draft-enabled entities', async ()=>{
+        // @ts-expect-error partial config
+        const config = {
+            collections: [
+                {
+                    slug: 'posts',
+                    fields: [
+                        {
+                            name: 'title',
+                            type: 'text',
+                            required: true
+                        }
+                    ],
+                    versions: {
+                        drafts: true
+                    }
+                }
+            ]
+        };
+        const sanitizedConfig = await sanitizeConfig(config);
+        const entity = sanitizedConfig.collections[0];
+        const schema = entityToStandaloneJSONSchema({
+            config: sanitizedConfig,
+            defaultIDType: 'text',
+            entity,
+            variant: 'input'
+        });
+        expect(schema.properties?._status).toMatchObject({
+            enum: [
+                'draft',
+                'published'
+            ]
+        });
+        expect(schema.required).not.toContain('_status');
+        expect(schema.properties?.createdAt).toBeUndefined();
+        expect(schema.properties?.updatedAt).toBeUndefined();
+    });
+    it('should skip input types by default and generate them when enabled', async ()=>{
+        // @ts-expect-error partial config
+        const offByDefault = {
+            collections: [
+                {
+                    slug: 'posts',
+                    fields: [
+                        {
+                            name: 'title',
+                            type: 'text'
+                        }
+                    ]
+                }
+            ]
+        };
+        const { jsonSchema: defaultSchema } = configToJSONSchema(await sanitizeConfig(offByDefault), 'text');
+        expect(defaultSchema?.$defs?.posts_input).toBeUndefined();
+        expect(defaultSchema?.properties?.collectionsInput).toBeUndefined();
+        // @ts-expect-error partial config
+        const enabled = {
+            collections: [
+                {
+                    slug: 'posts',
+                    fields: [
+                        {
+                            name: 'title',
+                            type: 'text'
+                        }
+                    ]
+                }
+            ],
+            typescript: {
+                generateInputTypes: true
+            }
+        };
+        const { jsonSchema: enabledSchema } = configToJSONSchema(await sanitizeConfig(enabled), 'text');
+        expect(enabledSchema?.$defs?.posts_input).toBeDefined();
+        expect(enabledSchema?.properties?.collectionsInput).toBeDefined();
+    });
+    it('should generate Input-suffixed definitions for named interfaces and blocks', async ()=>{
+        // @ts-expect-error partial config
+        const config = {
+            collections: [
+                {
+                    slug: 'authors',
+                    fields: [
+                        {
+                            name: 'name',
+                            type: 'text'
+                        }
+                    ]
+                },
+                {
+                    slug: 'pages',
+                    fields: [
+                        {
+                            name: 'meta',
+                            type: 'group',
+                            interfaceName: 'Meta',
+                            fields: [
+                                {
+                                    name: 'author',
+                                    type: 'relationship',
+                                    relationTo: 'authors'
+                                }
+                            ]
+                        },
+                        {
+                            name: 'layout',
+                            type: 'blocks',
+                            blocks: [
+                                {
+                                    slug: 'hero',
+                                    fields: [
+                                        {
+                                            name: 'heading',
+                                            type: 'text',
+                                            required: true
+                                        },
+                                        {
+                                            name: 'cta',
+                                            type: 'relationship',
+                                            relationTo: 'authors'
+                                        }
+                                    ]
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
+            typescript: {
+                generateInputTypes: true
+            }
+        };
+        const sanitizedConfig = await sanitizeConfig(config);
+        const { jsonSchema: schema } = configToJSONSchema(sanitizedConfig, 'text');
+        // Read-shaped named interface keeps the populated-doc union...
+        expect((schema?.$defs?.Meta).properties.author).toStrictEqual({
+            oneOf: [
+                {
+                    type: [
+                        'string',
+                        'null'
+                    ]
+                },
+                {
+                    $ref: '#/$defs/authors'
+                }
+            ]
+        });
+        // ...and a separate `Input` definition is ID-only, so the two don't collide.
+        expect((schema?.$defs?.MetaInput).properties.author).toStrictEqual({
+            type: [
+                'string',
+                'null'
+            ]
+        });
+        // Blocks get the same treatment: read-shaped `Hero`, write-shaped `HeroInput`.
+        const heroInput = schema?.$defs?.HeroInput;
+        expect(heroInput.properties.cta).toStrictEqual({
+            type: [
+                'string',
+                'null'
+            ]
+        });
+        expect(heroInput.required).toStrictEqual([
+            'blockType',
+            'heading'
+        ]);
+        expect((schema?.$defs?.Hero).properties.cta).toStrictEqual({
+            oneOf: [
+                {
+                    type: [
+                        'string',
+                        'null'
+                    ]
+                },
+                {
+                    $ref: '#/$defs/authors'
+                }
+            ]
+        });
+    });
+    it('passes the variant to field-level jsonSchema transforms', async ()=>{
+        // @ts-expect-error partial config
+        const config = {
+            collections: [
+                {
+                    slug: 'posts',
+                    fields: [
+                        {
+                            name: 'custom',
+                            type: 'text',
+                            jsonSchema: [
+                                ({ jsonSchema, variant })=>({
+                                        ...jsonSchema,
+                                        description: variant
+                                    })
+                            ]
+                        }
+                    ]
+                }
+            ],
+            typescript: {
+                generateInputTypes: true
+            }
+        };
+        const sanitizedConfig = await sanitizeConfig(config);
+        const { jsonSchema: schema } = configToJSONSchema(sanitizedConfig, 'text');
+        expect((schema?.$defs?.posts).properties.custom.description).toBe('output');
+        expect((schema?.$defs?.posts_input).properties.custom.description).toBe('input');
+    });
     it('should handle block fields with no blocks', async ()=>{
         // @ts-expect-error
         const config = {
@@ -103,7 +460,7 @@ describe('configToJSONSchema', ()=>{
                             type: 'blocks',
                             blocks: [
                                 {
-                                    slug: 'test',
+                                    slug: 'testRequired',
                                     fields: [
                                         {
                                             name: 'field',
@@ -115,13 +472,14 @@ describe('configToJSONSchema', ()=>{
                             ]
                         }
                     ],
-                    timestamps: false
+                    timestamps: false,
+                    versions: false
                 }
             ]
         };
         const sanitizedConfig = await sanitizeConfig(config);
-        const schema = configToJSONSchema(sanitizedConfig, 'text');
-        expect(schema?.definitions?.test).toStrictEqual({
+        const { jsonSchema: schema } = configToJSONSchema(sanitizedConfig, 'text');
+        expect(schema?.$defs?.test).toStrictEqual({
             type: 'object',
             additionalProperties: false,
             properties: {
@@ -147,34 +505,7 @@ describe('configToJSONSchema', ()=>{
                     items: {
                         oneOf: [
                             {
-                                type: 'object',
-                                additionalProperties: false,
-                                properties: {
-                                    id: {
-                                        type: [
-                                            'string',
-                                            'null'
-                                        ]
-                                    },
-                                    blockName: {
-                                        type: [
-                                            'string',
-                                            'null'
-                                        ]
-                                    },
-                                    blockType: {
-                                        const: 'test'
-                                    },
-                                    field: {
-                                        type: [
-                                            'string',
-                                            'null'
-                                        ]
-                                    }
-                                },
-                                required: [
-                                    'blockType'
-                                ]
+                                $ref: '#/$defs/Test'
                             }
                         ]
                     }
@@ -187,32 +518,7 @@ describe('configToJSONSchema', ()=>{
                     items: {
                         oneOf: [
                             {
-                                type: 'object',
-                                additionalProperties: false,
-                                properties: {
-                                    id: {
-                                        type: [
-                                            'string',
-                                            'null'
-                                        ]
-                                    },
-                                    blockName: {
-                                        type: [
-                                            'string',
-                                            'null'
-                                        ]
-                                    },
-                                    blockType: {
-                                        const: 'test'
-                                    },
-                                    field: {
-                                        type: 'string'
-                                    }
-                                },
-                                required: [
-                                    'blockType',
-                                    'field'
-                                ]
+                                $ref: '#/$defs/TestRequired'
                             }
                         ]
                     }
@@ -225,6 +531,89 @@ describe('configToJSONSchema', ()=>{
             title: 'Test'
         });
     });
+    it('keeps the first block interface name clean and content-hashes the colliding one', async ()=>{
+        // @ts-expect-error - partial config for testing
+        const config = {
+            collections: [
+                {
+                    slug: 'pages',
+                    fields: [
+                        {
+                            name: 'layout',
+                            type: 'blocks',
+                            blocks: [
+                                {
+                                    slug: 'hero',
+                                    fields: [
+                                        {
+                                            name: 'title',
+                                            type: 'text'
+                                        }
+                                    ]
+                                },
+                                {
+                                    slug: 'cta',
+                                    fields: [
+                                        {
+                                            name: 'label',
+                                            type: 'text'
+                                        }
+                                    ]
+                                }
+                            ]
+                        }
+                    ],
+                    timestamps: false,
+                    versions: false
+                },
+                {
+                    slug: 'posts',
+                    fields: [
+                        {
+                            name: 'layout',
+                            type: 'blocks',
+                            // Same slug `hero`, DIFFERENT fields → name collision with pages' hero.
+                            blocks: [
+                                {
+                                    slug: 'hero',
+                                    fields: [
+                                        {
+                                            name: 'heading',
+                                            type: 'text'
+                                        }
+                                    ]
+                                }
+                            ]
+                        }
+                    ],
+                    timestamps: false,
+                    versions: false
+                }
+            ]
+        };
+        const sanitizedConfig = await sanitizeConfig(config);
+        const { jsonSchema: schema } = configToJSONSchema(sanitizedConfig, 'text');
+        const defs = schema.$defs;
+        // The first `hero` keeps the clean name; the unique block is unaffected.
+        expect(defs.Hero).toBeDefined();
+        expect(defs.Cta).toBeDefined();
+        // Only the second, differently-shaped `hero` is disambiguated with a content hash.
+        const hashedHeroNames = Object.keys(defs).filter((k)=>/^Hero_[0-9A-F]{8}$/.test(k));
+        expect(hashedHeroNames).toHaveLength(1);
+        // The disambiguated interface carries the explanatory JSDoc note; the clean one does not.
+        expect(defs[hashedHeroNames[0]].description).toContain('content hash');
+        expect(defs.Hero.description).toBeUndefined();
+        // Each collection's block field references its own block's interface.
+        const refsOf = (slug)=>defs[slug].properties.layout.items.oneOf.map((r)=>r.$ref);
+        expect(refsOf('pages')).toContain('#/$defs/Hero');
+        expect(refsOf('pages')).toContain('#/$defs/Cta');
+        expect(refsOf('posts')).toStrictEqual([
+            `#/$defs/${hashedHeroNames[0]}`
+        ]);
+        // Hashing is deterministic: regenerating yields identical names.
+        const { jsonSchema: schema2 } = configToJSONSchema(sanitizedConfig, 'text');
+        expect(Object.keys(schema2.$defs).filter((k)=>/^Hero/.test(k)).sort()).toStrictEqual(Object.keys(defs).filter((k)=>/^Hero/.test(k)).sort());
+    });
     it('should handle tabs and named tabs with required fields', async ()=>{
         // @ts-expect-error
         const config = {
@@ -268,13 +657,14 @@ describe('configToJSONSchema', ()=>{
                             ]
                         }
                     ],
-                    timestamps: false
+                    timestamps: false,
+                    versions: false
                 }
             ]
         };
         const sanitizedConfig = await sanitizeConfig(config);
-        const schema = configToJSONSchema(sanitizedConfig, 'text');
-        expect(schema?.definitions?.test).toStrictEqual({
+        const { jsonSchema: schema } = configToJSONSchema(sanitizedConfig, 'text');
+        expect(schema?.$defs?.test).toStrictEqual({
             type: 'object',
             additionalProperties: false,
             properties: {
@@ -340,7 +730,7 @@ describe('configToJSONSchema', ()=>{
                         {
                             name: 'withCustom',
                             type: 'text',
-                            typescriptSchema: [
+                            jsonSchema: [
                                 ()=>customSchema
                             ]
                         },
@@ -356,13 +746,14 @@ describe('configToJSONSchema', ()=>{
                             }
                         }
                     ],
-                    timestamps: false
+                    timestamps: false,
+                    versions: false
                 }
             ]
         };
         const sanitizedConfig = await sanitizeConfig(config);
-        const schema = configToJSONSchema(sanitizedConfig, 'text');
-        expect(schema?.definitions?.test).toStrictEqual({
+        const { jsonSchema: schema } = configToJSONSchema(sanitizedConfig, 'text');
+        expect(schema?.$defs?.test).toStrictEqual({
             type: 'object',
             additionalProperties: false,
             properties: {
@@ -414,7 +805,8 @@ describe('configToJSONSchema', ()=>{
                             ]
                         }
                     ],
-                    timestamps: false
+                    timestamps: false,
+                    versions: false
                 }
             ]
         };
@@ -422,7 +814,7 @@ describe('configToJSONSchema', ()=>{
         const sanitizedConfig = await sanitizeConfig(config);
         expect(typeof sanitizedConfig?.blocks?.[0]?.fields?.[0]?.editor).toBe('object');
         expect(typeof sanitizedConfig.collections[0].fields[0]?.blocks?.[0]?.fields?.[0]?.editor).toBe('object');
-        const schema = configToJSONSchema(sanitizedConfig, 'text');
+        const { jsonSchema: schema } = configToJSONSchema(sanitizedConfig, 'text');
         const expectedBlockSchema = {
             type: 'object',
             additionalProperties: false,
@@ -456,7 +848,7 @@ describe('configToJSONSchema', ()=>{
                 'blockType'
             ]
         };
-        expect(schema?.definitions?.test).toStrictEqual({
+        expect(schema?.$defs?.test).toStrictEqual({
             type: 'object',
             additionalProperties: false,
             title: 'Test',
@@ -472,7 +864,7 @@ describe('configToJSONSchema', ()=>{
                     items: {
                         oneOf: [
                             {
-                                $ref: '#/definitions/SharedBlock'
+                                $ref: '#/$defs/SharedBlock'
                             }
                         ]
                     }
@@ -483,7 +875,100 @@ describe('configToJSONSchema', ()=>{
             ]
         });
         // The definition should still be registered for TypeScript type generation
-        expect(schema?.definitions?.SharedBlock).toStrictEqual(expectedBlockSchema);
+        expect(schema?.$defs?.SharedBlock).toStrictEqual(expectedBlockSchema);
+    });
+    it('content-hashes a colliding explicit interfaceName instead of overwriting it', async ()=>{
+        // Two different blocks both set `interfaceName: 'Hero'` - each must keep its own definition.
+        const config = {
+            collections: [
+                {
+                    slug: 'test',
+                    fields: [
+                        {
+                            name: 'blocksField',
+                            type: 'blocks',
+                            blocks: [
+                                {
+                                    slug: 'blockA',
+                                    fields: [
+                                        {
+                                            name: 'title',
+                                            type: 'text'
+                                        }
+                                    ],
+                                    interfaceName: 'Hero'
+                                },
+                                {
+                                    slug: 'blockB',
+                                    fields: [
+                                        {
+                                            name: 'subtitle',
+                                            type: 'number'
+                                        }
+                                    ],
+                                    interfaceName: 'Hero'
+                                }
+                            ]
+                        }
+                    ],
+                    timestamps: false,
+                    versions: false
+                }
+            ]
+        };
+        const sanitizedConfig = await sanitizeConfig(config);
+        const { jsonSchema } = configToJSONSchema(sanitizedConfig, 'text');
+        const defs = jsonSchema.$defs;
+        // Each differently-shaped block keeps its own interface (one clean, one hash-suffixed).
+        const heroNames = Object.keys(defs).filter((k)=>/^Hero(_[0-9A-F]{8})?$/.test(k));
+        expect(heroNames).toHaveLength(2);
+        // ...and they carry distinct field shapes (not a silent overwrite).
+        const shapeOf = (name)=>Object.keys(defs[name].properties).sort().join(',');
+        expect(shapeOf(heroNames[0])).not.toBe(shapeOf(heroNames[1]));
+    });
+    it('reuses one definition when the same block is registered more than once', async ()=>{
+        // Reusing one block across fields registers an identical schema each time, so it dedupes.
+        const heroBlock = {
+            slug: 'hero',
+            fields: [
+                {
+                    name: 'title',
+                    type: 'text'
+                }
+            ],
+            interfaceName: 'Hero'
+        };
+        const config = {
+            collections: [
+                {
+                    slug: 'test',
+                    fields: [
+                        {
+                            name: 'a',
+                            type: 'blocks',
+                            blocks: [
+                                heroBlock
+                            ]
+                        },
+                        {
+                            name: 'b',
+                            type: 'blocks',
+                            blocks: [
+                                heroBlock
+                            ]
+                        }
+                    ],
+                    timestamps: false,
+                    versions: false
+                }
+            ]
+        };
+        const sanitizedConfig = await sanitizeConfig(config);
+        const { jsonSchema } = configToJSONSchema(sanitizedConfig, 'text');
+        const heroNames = Object.keys(jsonSchema.$defs).filter((k)=>/^Hero(_[0-9A-F]{8})?$/.test(k));
+        expect(heroNames).toEqual([
+            'Hero'
+        ]);
     });
     it('should allow overriding required to false', async ()=>{
         // @ts-expect-error
@@ -497,7 +982,7 @@ describe('configToJSONSchema', ()=>{
                             type: 'text',
                             required: true,
                             defaultValue: 'test',
-                            typescriptSchema: [
+                            jsonSchema: [
                                 ()=>({
                                         type: 'string',
                                         required: false
@@ -505,14 +990,15 @@ describe('configToJSONSchema', ()=>{
                             ]
                         }
                     ],
-                    timestamps: false
+                    timestamps: false,
+                    versions: false
                 }
             ]
         };
         const sanitizedConfig = await sanitizeConfig(config);
-        const schema = configToJSONSchema(sanitizedConfig, 'text');
+        const { jsonSchema: schema } = configToJSONSchema(sanitizedConfig, 'text');
         // @ts-expect-error
-        expect(schema.definitions.test.properties.title.required).toStrictEqual(false);
+        expect(schema.$defs.test.properties.title.required).toStrictEqual(false);
     });
     it('should propagate forceInlineBlocks to nested fields (array, group, tab)', async ()=>{
         const namedBlock = {
@@ -558,34 +1044,119 @@ describe('configToJSONSchema', ()=>{
                             ]
                         }
                     ],
-                    timestamps: false
+                    timestamps: false,
+                    versions: false
                 }
             ]
         };
         const sanitizedConfig = await sanitizeConfig(config);
         // Without forceInlineBlocks: blocks field uses $ref
-        const schemaDefault = configToJSONSchema(sanitizedConfig, 'text');
-        const arrItemsDefault = schemaDefault.definitions.test.properties.arr.items;
+        const { jsonSchema: schemaDefault } = configToJSONSchema(sanitizedConfig, 'text');
+        const arrItemsDefault = schemaDefault.$defs.test.properties.arr.items;
         const arrBlocksDefault = arrItemsDefault.properties.blocks.items.oneOf[0];
         expect(arrBlocksDefault).toStrictEqual({
-            $ref: '#/definitions/MyBlock'
+            $ref: '#/$defs/MyBlock'
         });
         // With forceInlineBlocks: blocks field is inlined, no $ref
-        const schemaInline = configToJSONSchema(sanitizedConfig, 'text', undefined, {
+        const { jsonSchema: schemaInline } = configToJSONSchema(sanitizedConfig, 'text', undefined, {
             forceInlineBlocks: true
         });
-        const arrItemsInline = schemaInline.definitions.test.properties.arr.items;
+        const arrItemsInline = schemaInline.$defs.test.properties.arr.items;
         const arrBlocksInline = arrItemsInline.properties.blocks.items.oneOf[0];
         expect(arrBlocksInline).not.toHaveProperty('$ref');
         expect(arrBlocksInline.properties?.blockType).toStrictEqual({
             const: 'myBlock'
         });
-        const grpBlocksInline = schemaInline.definitions.test.properties.grp.properties.blocks.items.oneOf[0];
+        const grpBlocksInline = schemaInline.$defs.test.properties.grp.properties.blocks.items.oneOf[0];
         expect(grpBlocksInline).not.toHaveProperty('$ref');
         expect(grpBlocksInline.properties?.blockType).toStrictEqual({
             const: 'myBlock'
         });
     });
+    it('entityToStandaloneJSONSchema bundles only the definitions an entity references', async ()=>{
+        const sharedBlock = {
+            slug: 'sharedBlock',
+            interfaceName: 'SharedBlock',
+            fields: [
+                {
+                    name: 'title',
+                    type: 'text'
+                }
+            ]
+        };
+        // @ts-expect-error partial config
+        const config = {
+            admin: {
+                timezones: {
+                    supportedTimezones: [
+                        {
+                            label: 'UTC',
+                            value: 'UTC'
+                        },
+                        {
+                            label: 'New York',
+                            value: 'America/New_York'
+                        }
+                    ]
+                }
+            },
+            blocks: [
+                sharedBlock
+            ],
+            collections: [
+                {
+                    slug: 'with-refs',
+                    fields: [
+                        {
+                            name: 'layout',
+                            type: 'blocks',
+                            blocks: [
+                                'sharedBlock'
+                            ]
+                        },
+                        {
+                            name: 'when',
+                            type: 'date',
+                            timezone: true
+                        }
+                    ],
+                    timestamps: false,
+                    versions: false
+                },
+                {
+                    slug: 'other',
+                    fields: [
+                        {
+                            name: 'title',
+                            type: 'text'
+                        }
+                    ],
+                    timestamps: false,
+                    versions: false
+                }
+            ]
+        };
+        const sanitizedConfig = await sanitizeConfig(config);
+        const entity = sanitizedConfig.collections.find((collection)=>collection.slug === 'with-refs');
+        const schema = entityToStandaloneJSONSchema({
+            config: sanitizedConfig,
+            defaultIDType: 'text',
+            entity
+        });
+        // Has its own $schema, so it resolves on its own.
+        expect(schema.$schema).toBe('https://json-schema.org/draft/2020-12/schema');
+        // The block reference is resolved inline, so it can't dangle.
+        const layoutItems = schema.properties?.layout?.items;
+        const inlinedBlock = layoutItems?.oneOf?.[0] ?? {};
+        expect(inlinedBlock.properties?.blockType).toStrictEqual({
+            const: 'sharedBlock'
+        });
+        expect(inlinedBlock.properties?.title).toBeDefined();
+        // A timezone field pulls in supportedTimezones from the root config.
+        expect(schema.$defs?.supportedTimezones).toBeDefined();
+        // Doesn't pull in unrelated collections.
+        expect(schema.$defs?.other).toBeUndefined();
+    });
 });
 
 //# sourceMappingURL=configToJSONSchema.spec.js.map