payload 4.0.0-internal.4cbdd50 → 4.0.0-internal.4e1f822

package/dist/utilities/configToJSONSchema.spec.js

@@ -2,7 +2,7 @@ import { describe, it, expect } from 'vitest';
 import { sanitizeConfig } from '../config/sanitize.js';
 import { configToJSONSchema, entityToStandaloneJSONSchema } from './configToJSONSchema.js';
 describe('configToJSONSchema', ()=>{
-    it('should handle optional arrays with required fields', async ()=>{
+    it('should handle optional arrays with required fields', ()=>{
         // @ts-expect-error
         const config = {
             collections: [
@@ -26,7 +26,7 @@ describe('configToJSONSchema', ()=>{
                 }
             ]
         };
-        const sanitizedConfig = await sanitizeConfig(config);
+        const sanitizedConfig = sanitizeConfig(config);
         const { jsonSchema: schema } = configToJSONSchema(sanitizedConfig, 'text');
         expect(schema?.$defs?.test).toStrictEqual({
             type: 'object',
@@ -66,7 +66,363 @@ describe('configToJSONSchema', ()=>{
             title: 'Test'
         });
     });
-    it('should handle block fields with no blocks', async ()=>{
+    it('should generate separate input types when generateInputTypes is enabled', ()=>{
+        // @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 = 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', ()=>{
+        // @ts-expect-error partial config
+        const config = {
+            collections: [
+                {
+                    slug: 'posts',
+                    fields: [
+                        {
+                            name: 'title',
+                            type: 'text',
+                            required: true
+                        }
+                    ],
+                    versions: {
+                        drafts: true
+                    }
+                }
+            ]
+        };
+        const sanitizedConfig = 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', ()=>{
+        // @ts-expect-error partial config
+        const offByDefault = {
+            collections: [
+                {
+                    slug: 'posts',
+                    fields: [
+                        {
+                            name: 'title',
+                            type: 'text'
+                        }
+                    ]
+                }
+            ]
+        };
+        const { jsonSchema: defaultSchema } = configToJSONSchema(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(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', ()=>{
+        // @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 = 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', ()=>{
+        // @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 = 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', ()=>{
         // @ts-expect-error
         const config = {
             collections: [
@@ -121,7 +477,7 @@ describe('configToJSONSchema', ()=>{
                 }
             ]
         };
-        const sanitizedConfig = await sanitizeConfig(config);
+        const sanitizedConfig = sanitizeConfig(config);
         const { jsonSchema: schema } = configToJSONSchema(sanitizedConfig, 'text');
         expect(schema?.$defs?.test).toStrictEqual({
             type: 'object',
@@ -175,7 +531,7 @@ describe('configToJSONSchema', ()=>{
             title: 'Test'
         });
     });
-    it('keeps the first block interface name clean and content-hashes the colliding one', async ()=>{
+    it('keeps the first block interface name clean and content-hashes the colliding one', ()=>{
         // @ts-expect-error - partial config for testing
         const config = {
             collections: [
@@ -235,7 +591,7 @@ describe('configToJSONSchema', ()=>{
                 }
             ]
         };
-        const sanitizedConfig = await sanitizeConfig(config);
+        const sanitizedConfig = sanitizeConfig(config);
         const { jsonSchema: schema } = configToJSONSchema(sanitizedConfig, 'text');
         const defs = schema.$defs;
         // The first `hero` keeps the clean name; the unique block is unaffected.
@@ -258,7 +614,7 @@ describe('configToJSONSchema', ()=>{
         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 ()=>{
+    it('should handle tabs and named tabs with required fields', ()=>{
         // @ts-expect-error
         const config = {
             collections: [
@@ -306,7 +662,7 @@ describe('configToJSONSchema', ()=>{
                 }
             ]
         };
-        const sanitizedConfig = await sanitizeConfig(config);
+        const sanitizedConfig = sanitizeConfig(config);
         const { jsonSchema: schema } = configToJSONSchema(sanitizedConfig, 'text');
         expect(schema?.$defs?.test).toStrictEqual({
             type: 'object',
@@ -354,7 +710,7 @@ describe('configToJSONSchema', ()=>{
             title: 'Test'
         });
     });
-    it('should handle custom typescript schema and JSON field schema', async ()=>{
+    it('should handle custom typescript schema and JSON field schema', ()=>{
         const customSchema = {
             type: 'object',
             properties: {
@@ -395,7 +751,7 @@ describe('configToJSONSchema', ()=>{
                 }
             ]
         };
-        const sanitizedConfig = await sanitizeConfig(config);
+        const sanitizedConfig = sanitizeConfig(config);
         const { jsonSchema: schema } = configToJSONSchema(sanitizedConfig, 'text');
         expect(schema?.$defs?.test).toStrictEqual({
             type: 'object',
@@ -413,7 +769,7 @@ describe('configToJSONSchema', ()=>{
             title: 'Test'
         });
     });
-    it('should handle same block object being referenced in both collection and config.blocks', async ()=>{
+    it('should handle same block object being referenced in both collection and config.blocks', ()=>{
         const sharedBlock = {
             slug: 'sharedBlock',
             interfaceName: 'SharedBlock',
@@ -455,7 +811,7 @@ describe('configToJSONSchema', ()=>{
             ]
         };
         // Ensure both rich text editor are sanitized
-        const sanitizedConfig = await sanitizeConfig(config);
+        const sanitizedConfig = 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 { jsonSchema: schema } = configToJSONSchema(sanitizedConfig, 'text');
@@ -521,7 +877,7 @@ describe('configToJSONSchema', ()=>{
         // The definition should still be registered for TypeScript type generation
         expect(schema?.$defs?.SharedBlock).toStrictEqual(expectedBlockSchema);
     });
-    it('content-hashes a colliding explicit interfaceName instead of overwriting it', async ()=>{
+    it('content-hashes a colliding explicit interfaceName instead of overwriting it', ()=>{
         // Two different blocks both set `interfaceName: 'Hero'` - each must keep its own definition.
         const config = {
             collections: [
@@ -560,7 +916,7 @@ describe('configToJSONSchema', ()=>{
                 }
             ]
         };
-        const sanitizedConfig = await sanitizeConfig(config);
+        const sanitizedConfig = sanitizeConfig(config);
         const { jsonSchema } = configToJSONSchema(sanitizedConfig, 'text');
         const defs = jsonSchema.$defs;
         // Each differently-shaped block keeps its own interface (one clean, one hash-suffixed).
@@ -570,7 +926,7 @@ describe('configToJSONSchema', ()=>{
         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 ()=>{
+    it('reuses one definition when the same block is registered more than once', ()=>{
         // Reusing one block across fields registers an identical schema each time, so it dedupes.
         const heroBlock = {
             slug: 'hero',
@@ -607,14 +963,14 @@ describe('configToJSONSchema', ()=>{
                 }
             ]
         };
-        const sanitizedConfig = await sanitizeConfig(config);
+        const sanitizedConfig = 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 ()=>{
+    it('should allow overriding required to false', ()=>{
         // @ts-expect-error
         const config = {
             collections: [
@@ -639,12 +995,12 @@ describe('configToJSONSchema', ()=>{
                 }
             ]
         };
-        const sanitizedConfig = await sanitizeConfig(config);
+        const sanitizedConfig = sanitizeConfig(config);
         const { jsonSchema: schema } = configToJSONSchema(sanitizedConfig, 'text');
         // @ts-expect-error
         expect(schema.$defs.test.properties.title.required).toStrictEqual(false);
     });
-    it('should propagate forceInlineBlocks to nested fields (array, group, tab)', async ()=>{
+    it('should propagate forceInlineBlocks to nested fields (array, group, tab)', ()=>{
         const namedBlock = {
             slug: 'myBlock',
             interfaceName: 'MyBlock',
@@ -693,7 +1049,7 @@ describe('configToJSONSchema', ()=>{
                 }
             ]
         };
-        const sanitizedConfig = await sanitizeConfig(config);
+        const sanitizedConfig = sanitizeConfig(config);
         // Without forceInlineBlocks: blocks field uses $ref
         const { jsonSchema: schemaDefault } = configToJSONSchema(sanitizedConfig, 'text');
         const arrItemsDefault = schemaDefault.$defs.test.properties.arr.items;
@@ -717,7 +1073,7 @@ describe('configToJSONSchema', ()=>{
             const: 'myBlock'
         });
     });
-    it('entityToStandaloneJSONSchema bundles only the definitions an entity references', async ()=>{
+    it('entityToStandaloneJSONSchema bundles only the definitions an entity references', ()=>{
         const sharedBlock = {
             slug: 'sharedBlock',
             interfaceName: 'SharedBlock',
@@ -780,7 +1136,7 @@ describe('configToJSONSchema', ()=>{
                 }
             ]
         };
-        const sanitizedConfig = await sanitizeConfig(config);
+        const sanitizedConfig = sanitizeConfig(config);
         const entity = sanitizedConfig.collections.find((collection)=>collection.slug === 'with-refs');
         const schema = entityToStandaloneJSONSchema({
             config: sanitizedConfig,