@depup/payload 3.79.1-depup.0

package/dist/utilities/configToJSONSchema.spec.js

@@ -0,0 +1,591 @@
+import { describe, it, expect } from 'vitest';
+import { sanitizeConfig } from '../config/sanitize.js';
+import { configToJSONSchema } from './configToJSONSchema.js';
+describe('configToJSONSchema', ()=>{
+    it('should handle optional arrays with required fields', async ()=>{
+        // @ts-expect-error
+        const config = {
+            collections: [
+                {
+                    slug: 'test',
+                    fields: [
+                        {
+                            name: 'someRequiredField',
+                            type: 'array',
+                            fields: [
+                                {
+                                    name: 'someRequiredField',
+                                    type: 'text',
+                                    required: true
+                                }
+                            ]
+                        }
+                    ],
+                    timestamps: false
+                }
+            ]
+        };
+        const sanitizedConfig = await sanitizeConfig(config);
+        const schema = configToJSONSchema(sanitizedConfig, 'text');
+        expect(schema?.definitions?.test).toStrictEqual({
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                id: {
+                    type: 'string'
+                },
+                someRequiredField: {
+                    type: [
+                        'array',
+                        'null'
+                    ],
+                    items: {
+                        type: 'object',
+                        additionalProperties: false,
+                        properties: {
+                            id: {
+                                type: [
+                                    'string',
+                                    'null'
+                                ]
+                            },
+                            someRequiredField: {
+                                type: 'string'
+                            }
+                        },
+                        required: [
+                            'someRequiredField'
+                        ]
+                    }
+                }
+            },
+            required: [
+                'id'
+            ],
+            title: 'Test'
+        });
+    });
+    it('should handle block fields with no blocks', async ()=>{
+        // @ts-expect-error
+        const config = {
+            collections: [
+                {
+                    slug: 'test',
+                    fields: [
+                        {
+                            name: 'blockField',
+                            type: 'blocks',
+                            blocks: []
+                        },
+                        {
+                            name: 'blockFieldRequired',
+                            type: 'blocks',
+                            blocks: [],
+                            required: true
+                        },
+                        {
+                            name: 'blockFieldWithFields',
+                            type: 'blocks',
+                            blocks: [
+                                {
+                                    slug: 'test',
+                                    fields: [
+                                        {
+                                            name: 'field',
+                                            type: 'text'
+                                        }
+                                    ]
+                                }
+                            ]
+                        },
+                        {
+                            name: 'blockFieldWithFieldsRequired',
+                            type: 'blocks',
+                            blocks: [
+                                {
+                                    slug: 'test',
+                                    fields: [
+                                        {
+                                            name: 'field',
+                                            type: 'text',
+                                            required: true
+                                        }
+                                    ]
+                                }
+                            ]
+                        }
+                    ],
+                    timestamps: false
+                }
+            ]
+        };
+        const sanitizedConfig = await sanitizeConfig(config);
+        const schema = configToJSONSchema(sanitizedConfig, 'text');
+        expect(schema?.definitions?.test).toStrictEqual({
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                id: {
+                    type: 'string'
+                },
+                blockField: {
+                    type: [
+                        'array',
+                        'null'
+                    ],
+                    items: {}
+                },
+                blockFieldRequired: {
+                    type: 'array',
+                    items: {}
+                },
+                blockFieldWithFields: {
+                    type: [
+                        'array',
+                        'null'
+                    ],
+                    items: {
+                        oneOf: [
+                            {
+                                type: 'object',
+                                additionalProperties: false,
+                                properties: {
+                                    id: {
+                                        type: [
+                                            'string',
+                                            'null'
+                                        ]
+                                    },
+                                    blockName: {
+                                        type: [
+                                            'string',
+                                            'null'
+                                        ]
+                                    },
+                                    blockType: {
+                                        const: 'test'
+                                    },
+                                    field: {
+                                        type: [
+                                            'string',
+                                            'null'
+                                        ]
+                                    }
+                                },
+                                required: [
+                                    'blockType'
+                                ]
+                            }
+                        ]
+                    }
+                },
+                blockFieldWithFieldsRequired: {
+                    type: [
+                        'array',
+                        'null'
+                    ],
+                    items: {
+                        oneOf: [
+                            {
+                                type: 'object',
+                                additionalProperties: false,
+                                properties: {
+                                    id: {
+                                        type: [
+                                            'string',
+                                            'null'
+                                        ]
+                                    },
+                                    blockName: {
+                                        type: [
+                                            'string',
+                                            'null'
+                                        ]
+                                    },
+                                    blockType: {
+                                        const: 'test'
+                                    },
+                                    field: {
+                                        type: 'string'
+                                    }
+                                },
+                                required: [
+                                    'blockType',
+                                    'field'
+                                ]
+                            }
+                        ]
+                    }
+                }
+            },
+            required: [
+                'id',
+                'blockFieldRequired'
+            ],
+            title: 'Test'
+        });
+    });
+    it('should handle tabs and named tabs with required fields', async ()=>{
+        // @ts-expect-error
+        const config = {
+            collections: [
+                {
+                    slug: 'test',
+                    fields: [
+                        {
+                            type: 'tabs',
+                            tabs: [
+                                {
+                                    fields: [
+                                        {
+                                            name: 'fieldInUnnamedTab',
+                                            type: 'text'
+                                        }
+                                    ],
+                                    label: 'unnamedTab'
+                                },
+                                {
+                                    name: 'namedTab',
+                                    fields: [
+                                        {
+                                            name: 'fieldInNamedTab',
+                                            type: 'text'
+                                        }
+                                    ],
+                                    label: 'namedTab'
+                                },
+                                {
+                                    name: 'namedTabWithRequired',
+                                    fields: [
+                                        {
+                                            name: 'fieldInNamedTab',
+                                            type: 'text',
+                                            required: true
+                                        }
+                                    ],
+                                    label: 'namedTabWithRequired'
+                                }
+                            ]
+                        }
+                    ],
+                    timestamps: false
+                }
+            ]
+        };
+        const sanitizedConfig = await sanitizeConfig(config);
+        const schema = configToJSONSchema(sanitizedConfig, 'text');
+        expect(schema?.definitions?.test).toStrictEqual({
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                id: {
+                    type: 'string'
+                },
+                fieldInUnnamedTab: {
+                    type: [
+                        'string',
+                        'null'
+                    ]
+                },
+                namedTab: {
+                    type: 'object',
+                    additionalProperties: false,
+                    properties: {
+                        fieldInNamedTab: {
+                            type: [
+                                'string',
+                                'null'
+                            ]
+                        }
+                    },
+                    required: []
+                },
+                namedTabWithRequired: {
+                    type: 'object',
+                    additionalProperties: false,
+                    properties: {
+                        fieldInNamedTab: {
+                            type: 'string'
+                        }
+                    },
+                    required: [
+                        'fieldInNamedTab'
+                    ]
+                }
+            },
+            required: [
+                'id',
+                'namedTabWithRequired'
+            ],
+            title: 'Test'
+        });
+    });
+    it('should handle custom typescript schema and JSON field schema', async ()=>{
+        const customSchema = {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'number'
+                },
+                required: [
+                    'id'
+                ]
+            }
+        };
+        const config = {
+            collections: [
+                {
+                    slug: 'test',
+                    fields: [
+                        {
+                            name: 'withCustom',
+                            type: 'text',
+                            typescriptSchema: [
+                                ()=>customSchema
+                            ]
+                        },
+                        {
+                            name: 'jsonWithSchema',
+                            type: 'json',
+                            jsonSchema: {
+                                fileMatch: [
+                                    'a://b/foo.json'
+                                ],
+                                schema: customSchema,
+                                uri: 'a://b/foo.json'
+                            }
+                        }
+                    ],
+                    timestamps: false
+                }
+            ]
+        };
+        const sanitizedConfig = await sanitizeConfig(config);
+        const schema = configToJSONSchema(sanitizedConfig, 'text');
+        expect(schema?.definitions?.test).toStrictEqual({
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                id: {
+                    type: 'string'
+                },
+                jsonWithSchema: customSchema,
+                withCustom: customSchema
+            },
+            required: [
+                'id'
+            ],
+            title: 'Test'
+        });
+    });
+    it('should handle same block object being referenced in both collection and config.blocks', async ()=>{
+        const sharedBlock = {
+            slug: 'sharedBlock',
+            interfaceName: 'SharedBlock',
+            fields: [
+                {
+                    name: 'richText',
+                    type: 'richText',
+                    editor: ()=>{
+                        // stub rich text editor
+                        return {
+                            CellComponent: '',
+                            FieldComponent: '',
+                            validate: ()=>true
+                        };
+                    }
+                }
+            ]
+        };
+        // @ts-expect-error
+        const config = {
+            blocks: [
+                sharedBlock
+            ],
+            collections: [
+                {
+                    slug: 'test',
+                    fields: [
+                        {
+                            name: 'someBlockField',
+                            type: 'blocks',
+                            blocks: [
+                                sharedBlock
+                            ]
+                        }
+                    ],
+                    timestamps: false
+                }
+            ]
+        };
+        // Ensure both rich text editor are sanitized
+        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 expectedBlockSchema = {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                id: {
+                    type: [
+                        'string',
+                        'null'
+                    ]
+                },
+                blockName: {
+                    type: [
+                        'string',
+                        'null'
+                    ]
+                },
+                blockType: {
+                    const: 'sharedBlock'
+                },
+                richText: {
+                    type: [
+                        'array',
+                        'null'
+                    ],
+                    items: {
+                        type: 'object'
+                    }
+                }
+            },
+            required: [
+                'blockType'
+            ]
+        };
+        expect(schema?.definitions?.test).toStrictEqual({
+            type: 'object',
+            additionalProperties: false,
+            title: 'Test',
+            properties: {
+                id: {
+                    type: 'string'
+                },
+                someBlockField: {
+                    type: [
+                        'array',
+                        'null'
+                    ],
+                    items: {
+                        oneOf: [
+                            {
+                                $ref: '#/definitions/SharedBlock'
+                            }
+                        ]
+                    }
+                }
+            },
+            required: [
+                'id'
+            ]
+        });
+        // The definition should still be registered for TypeScript type generation
+        expect(schema?.definitions?.SharedBlock).toStrictEqual(expectedBlockSchema);
+    });
+    it('should allow overriding required to false', async ()=>{
+        // @ts-expect-error
+        const config = {
+            collections: [
+                {
+                    slug: 'test',
+                    fields: [
+                        {
+                            name: 'title',
+                            type: 'text',
+                            required: true,
+                            defaultValue: 'test',
+                            typescriptSchema: [
+                                ()=>({
+                                        type: 'string',
+                                        required: false
+                                    })
+                            ]
+                        }
+                    ],
+                    timestamps: false
+                }
+            ]
+        };
+        const sanitizedConfig = await sanitizeConfig(config);
+        const schema = configToJSONSchema(sanitizedConfig, 'text');
+        // @ts-expect-error
+        expect(schema.definitions.test.properties.title.required).toStrictEqual(false);
+    });
+    it('should propagate forceInlineBlocks to nested fields (array, group, tab)', async ()=>{
+        const namedBlock = {
+            slug: 'myBlock',
+            interfaceName: 'MyBlock',
+            fields: [
+                {
+                    name: 'text',
+                    type: 'text'
+                }
+            ]
+        };
+        // @ts-expect-error
+        const config = {
+            collections: [
+                {
+                    slug: 'test',
+                    fields: [
+                        {
+                            name: 'arr',
+                            type: 'array',
+                            fields: [
+                                {
+                                    name: 'blocks',
+                                    type: 'blocks',
+                                    blocks: [
+                                        namedBlock
+                                    ]
+                                }
+                            ]
+                        },
+                        {
+                            name: 'grp',
+                            type: 'group',
+                            fields: [
+                                {
+                                    name: 'blocks',
+                                    type: 'blocks',
+                                    blocks: [
+                                        namedBlock
+                                    ]
+                                }
+                            ]
+                        }
+                    ],
+                    timestamps: 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 arrBlocksDefault = arrItemsDefault.properties.blocks.items.oneOf[0];
+        expect(arrBlocksDefault).toStrictEqual({
+            $ref: '#/definitions/MyBlock'
+        });
+        // With forceInlineBlocks: blocks field is inlined, no $ref
+        const schemaInline = configToJSONSchema(sanitizedConfig, 'text', undefined, {
+            forceInlineBlocks: true
+        });
+        const arrItemsInline = schemaInline.definitions.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];
+        expect(grpBlocksInline).not.toHaveProperty('$ref');
+        expect(grpBlocksInline.properties?.blockType).toStrictEqual({
+            const: 'myBlock'
+        });
+    });
+});
+
+//# sourceMappingURL=configToJSONSchema.spec.js.map

package/dist/utilities/configToJSONSchema.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/configToJSONSchema.spec.ts"],"sourcesContent":["import type { JSONSchema4 } from 'json-schema'\nimport { describe, it, expect } from 'vitest'\n\nimport type { Config } from '../config/types.js'\n\nimport { sanitizeConfig } from '../config/sanitize.js'\nimport { configToJSONSchema } from './configToJSONSchema.js'\nimport type { Block, BlocksField, RichTextField } from '../fields/config/types.js'\n\ndescribe('configToJSONSchema', () => {\n  it('should handle optional arrays with required fields', async () => {\n    // @ts-expect-error\n    const config: Config = {\n      collections: [\n        {\n          slug: 'test',\n          fields: [\n            {\n              name: 'someRequiredField',\n              type: 'array',\n              fields: [\n                {\n                  name: 'someRequiredField',\n                  type: 'text',\n                  required: true,\n                },\n              ],\n            },\n          ],\n          timestamps: false,\n        },\n      ],\n    }\n\n    const sanitizedConfig = await sanitizeConfig(config)\n    const schema = configToJSONSchema(sanitizedConfig, 'text')\n\n    expect(schema?.definitions?.test).toStrictEqual({\n      type: 'object',\n      additionalProperties: false,\n      properties: {\n        id: {\n          type: 'string',\n        },\n        someRequiredField: {\n          type: ['array', 'null'],\n          items: {\n            type: 'object',\n            additionalProperties: false,\n            properties: {\n              id: {\n                type: ['string', 'null'],\n              },\n              someRequiredField: {\n                type: 'string',\n              },\n            },\n            required: ['someRequiredField'],\n          },\n        },\n      },\n      required: ['id'],\n      title: 'Test',\n    })\n  })\n\n  it('should handle block fields with no blocks', async () => {\n    // @ts-expect-error\n    const config: Config = {\n      collections: [\n        {\n          slug: 'test',\n          fields: [\n            {\n              name: 'blockField',\n              type: 'blocks',\n              blocks: [],\n            },\n            {\n              name: 'blockFieldRequired',\n              type: 'blocks',\n              blocks: [],\n              required: true,\n            },\n            {\n              name: 'blockFieldWithFields',\n              type: 'blocks',\n              blocks: [\n                {\n                  slug: 'test',\n                  fields: [\n                    {\n                      name: 'field',\n                      type: 'text',\n                    },\n                  ],\n                },\n              ],\n            },\n            {\n              name: 'blockFieldWithFieldsRequired',\n              type: 'blocks',\n              blocks: [\n                {\n                  slug: 'test',\n                  fields: [\n                    {\n                      name: 'field',\n                      type: 'text',\n                      required: true,\n                    },\n                  ],\n                },\n              ],\n            },\n          ],\n          timestamps: false,\n        },\n      ],\n    }\n\n    const sanitizedConfig = await sanitizeConfig(config)\n    const schema = configToJSONSchema(sanitizedConfig, 'text')\n\n    expect(schema?.definitions?.test).toStrictEqual({\n      type: 'object',\n      additionalProperties: false,\n      properties: {\n        id: {\n          type: 'string',\n        },\n        blockField: {\n          type: ['array', 'null'],\n          items: {},\n        },\n        blockFieldRequired: {\n          type: 'array',\n          items: {},\n        },\n        blockFieldWithFields: {\n          type: ['array', 'null'],\n          items: {\n            oneOf: [\n              {\n                type: 'object',\n                additionalProperties: false,\n                properties: {\n                  id: {\n                    type: ['string', 'null'],\n                  },\n                  blockName: {\n                    type: ['string', 'null'],\n                  },\n                  blockType: {\n                    const: 'test',\n                  },\n                  field: {\n                    type: ['string', 'null'],\n                  },\n                },\n                required: ['blockType'],\n              },\n            ],\n          },\n        },\n        blockFieldWithFieldsRequired: {\n          type: ['array', 'null'],\n          items: {\n            oneOf: [\n              {\n                type: 'object',\n                additionalProperties: false,\n                properties: {\n                  id: {\n                    type: ['string', 'null'],\n                  },\n                  blockName: {\n                    type: ['string', 'null'],\n                  },\n                  blockType: {\n                    const: 'test',\n                  },\n                  field: {\n                    type: 'string',\n                  },\n                },\n                required: ['blockType', 'field'],\n              },\n            ],\n          },\n        },\n      },\n      required: ['id', 'blockFieldRequired'],\n      title: 'Test',\n    })\n  })\n\n  it('should handle tabs and named tabs with required fields', async () => {\n    // @ts-expect-error\n    const config: Config = {\n      collections: [\n        {\n          slug: 'test',\n          fields: [\n            {\n              type: 'tabs',\n              tabs: [\n                {\n                  fields: [\n                    {\n                      name: 'fieldInUnnamedTab',\n                      type: 'text',\n                    },\n                  ],\n                  label: 'unnamedTab',\n                },\n                {\n                  name: 'namedTab',\n                  fields: [\n                    {\n                      name: 'fieldInNamedTab',\n                      type: 'text',\n                    },\n                  ],\n                  label: 'namedTab',\n                },\n                {\n                  name: 'namedTabWithRequired',\n                  fields: [\n                    {\n                      name: 'fieldInNamedTab',\n                      type: 'text',\n                      required: true,\n                    },\n                  ],\n                  label: 'namedTabWithRequired',\n                },\n              ],\n            },\n          ],\n          timestamps: false,\n        },\n      ],\n    }\n\n    const sanitizedConfig = await sanitizeConfig(config)\n    const schema = configToJSONSchema(sanitizedConfig, 'text')\n\n    expect(schema?.definitions?.test).toStrictEqual({\n      type: 'object',\n      additionalProperties: false,\n      properties: {\n        id: {\n          type: 'string',\n        },\n        fieldInUnnamedTab: {\n          type: ['string', 'null'],\n        },\n        namedTab: {\n          type: 'object',\n          additionalProperties: false,\n          properties: {\n            fieldInNamedTab: {\n              type: ['string', 'null'],\n            },\n          },\n          required: [],\n        },\n        namedTabWithRequired: {\n          type: 'object',\n          additionalProperties: false,\n          properties: {\n            fieldInNamedTab: {\n              type: 'string',\n            },\n          },\n          required: ['fieldInNamedTab'],\n        },\n      },\n      required: ['id', 'namedTabWithRequired'],\n      title: 'Test',\n    })\n  })\n\n  it('should handle custom typescript schema and JSON field schema', async () => {\n    const customSchema: JSONSchema4 = {\n      type: 'object',\n      properties: {\n        id: {\n          type: 'number',\n        },\n        required: ['id'],\n      },\n    }\n\n    const config: Partial<Config> = {\n      collections: [\n        {\n          slug: 'test',\n          fields: [\n            {\n              name: 'withCustom',\n              type: 'text',\n              typescriptSchema: [() => customSchema],\n            },\n            {\n              name: 'jsonWithSchema',\n              type: 'json',\n              jsonSchema: {\n                fileMatch: ['a://b/foo.json'],\n                schema: customSchema,\n                uri: 'a://b/foo.json',\n              },\n            },\n          ],\n          timestamps: false,\n        },\n      ],\n    }\n\n    const sanitizedConfig = await sanitizeConfig(config as Config)\n    const schema = configToJSONSchema(sanitizedConfig, 'text')\n\n    expect(schema?.definitions?.test).toStrictEqual({\n      type: 'object',\n      additionalProperties: false,\n      properties: {\n        id: {\n          type: 'string',\n        },\n        jsonWithSchema: customSchema,\n        withCustom: customSchema,\n      },\n      required: ['id'],\n      title: 'Test',\n    })\n  })\n\n  it('should handle same block object being referenced in both collection and config.blocks', async () => {\n    const sharedBlock: Block = {\n      slug: 'sharedBlock',\n      interfaceName: 'SharedBlock',\n      fields: [\n        {\n          name: 'richText',\n          type: 'richText',\n          editor: () => {\n            // stub rich text editor\n            return {\n              CellComponent: '',\n              FieldComponent: '',\n              validate: () => true,\n            }\n          },\n        },\n      ],\n    }\n\n    // @ts-expect-error\n    const config: Config = {\n      blocks: [sharedBlock],\n      collections: [\n        {\n          slug: 'test',\n          fields: [\n            {\n              name: 'someBlockField',\n              type: 'blocks',\n              blocks: [sharedBlock],\n            },\n          ],\n          timestamps: false,\n        },\n      ],\n    }\n\n    // Ensure both rich text editor are sanitized\n    const sanitizedConfig = await sanitizeConfig(config)\n    expect(typeof (sanitizedConfig?.blocks?.[0]?.fields?.[0] as RichTextField)?.editor).toBe(\n      'object',\n    )\n    expect(\n      typeof (\n        (sanitizedConfig.collections[0].fields[0] as BlocksField)?.blocks?.[0]\n          ?.fields?.[0] as RichTextField\n      )?.editor,\n    ).toBe('object')\n\n    const schema = configToJSONSchema(sanitizedConfig, 'text')\n\n    const expectedBlockSchema = {\n      type: 'object',\n      additionalProperties: false,\n      properties: {\n        id: { type: ['string', 'null'] },\n        blockName: { type: ['string', 'null'] },\n        blockType: { const: 'sharedBlock' },\n        richText: { type: ['array', 'null'], items: { type: 'object' } },\n      },\n      required: ['blockType'],\n    }\n\n    expect(schema?.definitions?.test).toStrictEqual({\n      type: 'object',\n      additionalProperties: false,\n      title: 'Test',\n      properties: {\n        id: {\n          type: 'string',\n        },\n        someBlockField: {\n          type: ['array', 'null'],\n          items: {\n            oneOf: [\n              {\n                $ref: '#/definitions/SharedBlock',\n              },\n            ],\n          },\n        },\n      },\n      required: ['id'],\n    })\n\n    // The definition should still be registered for TypeScript type generation\n    expect(schema?.definitions?.SharedBlock).toStrictEqual(expectedBlockSchema)\n  })\n\n  it('should allow overriding required to false', async () => {\n    // @ts-expect-error\n    const config: Config = {\n      collections: [\n        {\n          slug: 'test',\n          fields: [\n            {\n              name: 'title',\n              type: 'text',\n              required: true,\n              defaultValue: 'test',\n              typescriptSchema: [\n                () => ({\n                  type: 'string',\n                  required: false,\n                }),\n              ],\n            },\n          ],\n          timestamps: false,\n        },\n      ],\n    }\n\n    const sanitizedConfig = await sanitizeConfig(config)\n    const schema = configToJSONSchema(sanitizedConfig, 'text')\n\n    // @ts-expect-error\n    expect(schema.definitions.test.properties.title.required).toStrictEqual(false)\n  })\n\n  it('should propagate forceInlineBlocks to nested fields (array, group, tab)', async () => {\n    const namedBlock: Block = {\n      slug: 'myBlock',\n      interfaceName: 'MyBlock',\n      fields: [{ name: 'text', type: 'text' }],\n    }\n\n    // @ts-expect-error\n    const config: Config = {\n      collections: [\n        {\n          slug: 'test',\n          fields: [\n            {\n              name: 'arr',\n              type: 'array',\n              fields: [{ name: 'blocks', type: 'blocks', blocks: [namedBlock] }],\n            },\n            {\n              name: 'grp',\n              type: 'group',\n              fields: [{ name: 'blocks', type: 'blocks', blocks: [namedBlock] }],\n            },\n          ],\n          timestamps: false,\n        },\n      ],\n    }\n\n    const sanitizedConfig = await sanitizeConfig(config)\n\n    // Without forceInlineBlocks: blocks field uses $ref\n    const schemaDefault = configToJSONSchema(sanitizedConfig, 'text')\n    const arrItemsDefault = schemaDefault.definitions!.test.properties!.arr.items as JSONSchema4\n    const arrBlocksDefault = (arrItemsDefault.properties!.blocks.items as JSONSchema4).oneOf![0]\n    expect(arrBlocksDefault).toStrictEqual({ $ref: '#/definitions/MyBlock' })\n\n    // With forceInlineBlocks: blocks field is inlined, no $ref\n    const schemaInline = configToJSONSchema(sanitizedConfig, 'text', undefined, {\n      forceInlineBlocks: true,\n    })\n    const arrItemsInline = schemaInline.definitions!.test.properties!.arr.items as JSONSchema4\n    const arrBlocksInline = (arrItemsInline.properties!.blocks.items as JSONSchema4).oneOf![0]\n    expect(arrBlocksInline).not.toHaveProperty('$ref')\n    expect(arrBlocksInline.properties?.blockType).toStrictEqual({ const: 'myBlock' })\n\n    const grpBlocksInline = (\n      schemaInline.definitions!.test.properties!.grp.properties!.blocks.items as JSONSchema4\n    ).oneOf![0]\n    expect(grpBlocksInline).not.toHaveProperty('$ref')\n    expect(grpBlocksInline.properties?.blockType).toStrictEqual({ const: 'myBlock' })\n  })\n})\n"],"names":["describe","it","expect","sanitizeConfig","configToJSONSchema","config","collections","slug","fields","name","type","required","timestamps","sanitizedConfig","schema","definitions","test","toStrictEqual","additionalProperties","properties","id","someRequiredField","items","title","blocks","blockField","blockFieldRequired","blockFieldWithFields","oneOf","blockName","blockType","const","field","blockFieldWithFieldsRequired","tabs","label","fieldInUnnamedTab","namedTab","fieldInNamedTab","namedTabWithRequired","customSchema","typescriptSchema","jsonSchema","fileMatch","uri","jsonWithSchema","withCustom","sharedBlock","interfaceName","editor","CellComponent","FieldComponent","validate","toBe","expectedBlockSchema","richText","someBlockField","$ref","SharedBlock","defaultValue","namedBlock","schemaDefault","arrItemsDefault","arr","arrBlocksDefault","schemaInline","undefined","forceInlineBlocks","arrItemsInline","arrBlocksInline","not","toHaveProperty","grpBlocksInline","grp"],"mappings":"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"}

package/dist/utilities/createArrayFromCommaDelineated.d.ts

@@ -0,0 +1,2 @@
+export declare function createArrayFromCommaDelineated(input: string): string[];
+//# sourceMappingURL=createArrayFromCommaDelineated.d.ts.map

package/dist/utilities/createArrayFromCommaDelineated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createArrayFromCommaDelineated.d.ts","sourceRoot":"","sources":["../../src/utilities/createArrayFromCommaDelineated.ts"],"names":[],"mappings":"AAAA,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAMtE"}

package/dist/utilities/createArrayFromCommaDelineated.js

@@ -0,0 +1,8 @@
+export function createArrayFromCommaDelineated(input) {
+    if (Array.isArray(input)) {
+        return input;
+    }
+    return input.split(',');
+}
+
+//# sourceMappingURL=createArrayFromCommaDelineated.js.map

package/dist/utilities/createArrayFromCommaDelineated.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/createArrayFromCommaDelineated.ts"],"sourcesContent":["export function createArrayFromCommaDelineated(input: string): string[] {\n  if (Array.isArray(input)) {\n    return input\n  }\n\n  return input.split(',')\n}\n"],"names":["createArrayFromCommaDelineated","input","Array","isArray","split"],"mappings":"AAAA,OAAO,SAASA,+BAA+BC,KAAa;IAC1D,IAAIC,MAAMC,OAAO,CAACF,QAAQ;QACxB,OAAOA;IACT;IAEA,OAAOA,MAAMG,KAAK,CAAC;AACrB"}

package/dist/utilities/createLocalReq.d.ts

@@ -0,0 +1,15 @@
+import type { Payload, RequestContext, TypedLocale, TypedUser } from '../index.js';
+import type { PayloadRequest } from '../types/index.js';
+export type CreateLocalReqOptions = {
+    context?: RequestContext;
+    depth?: number;
+    fallbackLocale?: false | TypedLocale;
+    locale?: string;
+    req?: Partial<PayloadRequest>;
+    urlSuffix?: string;
+    user?: TypedUser;
+};
+type CreateLocalReq = (options: CreateLocalReqOptions, payload: Payload) => Promise<PayloadRequest>;
+export declare const createLocalReq: CreateLocalReq;
+export {};
+//# sourceMappingURL=createLocalReq.d.ts.map