docusaurus-plugin-openapi-docs 2.2.1 → 2.2.3

package/README.md

@@ -50,7 +50,7 @@ Key Features:
 Run the following to bootstrap a Docsaurus v3 site (classic theme) with `docusaurus-openapi-docs`:
 
 ```bash
-npx create-docusaurus@3.4.0 my-website --package-manager yarn
+npx create-docusaurus@2.4.3 my-website --package-manager yarn
 ```
 
 > When prompted to select a template choose `Git repository`.

package/lib/index.js

@@ -375,6 +375,15 @@ custom_edit_url: null
                 downloadUrl: metadata.downloadUrl,
             });
         }
+        if (!fs_1.default.existsSync(outputDir)) {
+            try {
+                fs_1.default.mkdirSync(outputDir, { recursive: true });
+                console.log(chalk_1.default.green(`Successfully created "${outputDir}"`));
+            }
+            catch (err) {
+                console.error(chalk_1.default.red(`Failed to create "${outputDir}"`), chalk_1.default.yellow(err));
+            }
+        }
         const versionsJson = JSON.stringify(versionsArray, null, 2);
         try {
             fs_1.default.writeFileSync(`${outputDir}/versions.json`, versionsJson, "utf8");

package/lib/markdown/createSchema.js

@@ -67,6 +67,12 @@ function createAnyOneOf(schema) {
                         ? anyOneSchema.title
                         : `MOD${index + 1}`;
                     const anyOneChildren = [];
+                    if (anyOneSchema.type === "object" &&
+                        !anyOneSchema.properties &&
+                        !anyOneSchema.allOf &&
+                        !anyOneSchema.items) {
+                        anyOneChildren.push(createNodes(anyOneSchema, SCHEMA_TYPE));
+                    }
                     if (anyOneSchema.properties !== undefined) {
                         anyOneChildren.push(createProperties(anyOneSchema));
                         delete anyOneSchema.properties;
@@ -434,8 +440,9 @@ function createPropertyDiscriminator(name, schemaName, schema, discriminator, re
     if (schema === undefined) {
         return undefined;
     }
+    // render as a simple property if there's no mapping
     if (discriminator.mapping === undefined) {
-        return undefined;
+        return createEdges({ name, schema, required });
     }
     return (0, utils_1.create)("div", {
         className: "openapi-discriminator__item openapi-schema__list-item",
@@ -510,6 +517,19 @@ function createEdges({ name, schema, required, discriminator, }) {
     if (schema.oneOf !== undefined || schema.anyOf !== undefined) {
         return createAnyOneOfProperty(name, schemaName, schema, required, schema.nullable);
     }
+    if (schema.properties !== undefined) {
+        return createDetailsNode(name, schemaName, schema, required, schema.nullable);
+    }
+    if (schema.additionalProperties !== undefined) {
+        return createDetailsNode(name, schemaName, schema, required, schema.nullable);
+    }
+    // array of objects
+    if (((_a = schema.items) === null || _a === void 0 ? void 0 : _a.properties) !== undefined) {
+        return createDetailsNode(name, schemaName, schema, required, schema.nullable);
+    }
+    if (((_b = schema.items) === null || _b === void 0 ? void 0 : _b.anyOf) !== undefined || ((_c = schema.items) === null || _c === void 0 ? void 0 : _c.oneOf) !== undefined) {
+        return createDetailsNode(name, schemaName, schema, required, schema.nullable);
+    }
     if (schema.allOf !== undefined) {
         const { mergedSchemas } = mergeAllOf(schema.allOf);
         if (SCHEMA_TYPE === "request") {
@@ -534,7 +554,7 @@ function createEdges({ name, schema, required, discriminator, }) {
             return createDetailsNode(name, mergedSchemaName, mergedSchemas, required, schema.nullable);
         }
         // array of objects
-        if (((_a = mergedSchemas.items) === null || _a === void 0 ? void 0 : _a.properties) !== undefined) {
+        if (((_d = mergedSchemas.items) === null || _d === void 0 ? void 0 : _d.properties) !== undefined) {
             return createDetailsNode(name, mergedSchemaName, mergedSchemas, required, schema.nullable);
         }
         return (0, utils_1.create)("SchemaItem", {
@@ -546,19 +566,6 @@ function createEdges({ name, schema, required, discriminator, }) {
             schema: mergedSchemas,
         });
     }
-    if (schema.properties !== undefined) {
-        return createDetailsNode(name, schemaName, schema, required, schema.nullable);
-    }
-    if (schema.additionalProperties !== undefined) {
-        return createDetailsNode(name, schemaName, schema, required, schema.nullable);
-    }
-    // array of objects
-    if (((_b = schema.items) === null || _b === void 0 ? void 0 : _b.properties) !== undefined) {
-        return createDetailsNode(name, schemaName, schema, required, schema.nullable);
-    }
-    if (((_c = schema.items) === null || _c === void 0 ? void 0 : _c.anyOf) !== undefined || ((_d = schema.items) === null || _d === void 0 ? void 0 : _d.oneOf) !== undefined) {
-        return createDetailsNode(name, schemaName, schema, required, schema.nullable);
-    }
     // primitives and array of non-objects
     return (0, utils_1.create)("SchemaItem", {
         collapsible: false,
@@ -591,13 +598,6 @@ function createNodes(schema, schemaType) {
     if (schema.oneOf !== undefined || schema.anyOf !== undefined) {
         nodes.push(createAnyOneOf(schema));
     }
-    if (schema.allOf !== undefined) {
-        const { mergedSchemas } = mergeAllOf(schema.allOf);
-        // allOf seems to always result in properties
-        if (mergedSchemas.properties !== undefined) {
-            nodes.push(createProperties(mergedSchemas));
-        }
-    }
     if (schema.properties !== undefined) {
         nodes.push(createProperties(schema));
     }
@@ -608,6 +608,13 @@ function createNodes(schema, schemaType) {
     if (schema.items !== undefined) {
         nodes.push(createItems(schema));
     }
+    if (schema.allOf !== undefined) {
+        const { mergedSchemas } = mergeAllOf(schema.allOf);
+        // allOf seems to always result in properties
+        if (mergedSchemas.properties !== undefined) {
+            nodes.push(createProperties(mergedSchemas));
+        }
+    }
     if (nodes.length && nodes.length > 0) {
         return nodes.filter(Boolean).flat();
     }

package/lib/markdown/createSchema.test.js

@@ -32,43 +32,261 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const prettier = __importStar(require("prettier"));
 const createSchema_1 = require("./createSchema");
 describe("createNodes", () => {
-    it("should create readable MODs for oneOf primitive properties", () => {
-        const schema = {
-            "x-tags": ["clown"],
-            type: "object",
-            properties: {
-                oneOfProperty: {
-                    oneOf: [
-                        {
-                            type: "object",
-                            properties: {
-                                noseLength: {
-                                    type: "number",
+    describe("oneOf", () => {
+        it("should create readable MODs for oneOf primitive properties", async () => {
+            const schema = {
+                "x-tags": ["clown"],
+                type: "object",
+                properties: {
+                    oneOfProperty: {
+                        oneOf: [
+                            {
+                                type: "object",
+                                properties: {
+                                    noseLength: {
+                                        type: "number",
+                                    },
                                 },
+                                required: ["noseLength"],
+                                description: "Clown's nose length",
+                            },
+                            {
+                                type: "array",
+                                items: {
+                                    type: "string",
+                                },
+                                description: "Array of strings",
+                            },
+                            {
+                                type: "boolean",
+                            },
+                            {
+                                type: "number",
+                            },
+                            {
+                                type: "string",
+                            },
+                        ],
+                    },
+                },
+            };
+            expect(await Promise.all((0, createSchema_1.createNodes)(schema, "request").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
+        });
+    });
+    describe("allOf", () => {
+        it("should render same-level properties with allOf", async () => {
+            const schema = {
+                allOf: [
+                    {
+                        type: "object",
+                        properties: {
+                            allOfProp1: {
+                                type: "string",
+                            },
+                            allOfProp2: {
+                                type: "string",
                             },
-                            required: ["noseLength"],
-                            description: "Clown's nose length",
                         },
-                        {
-                            type: "array",
-                            items: {
+                    },
+                ],
+                properties: {
+                    parentProp1: {
+                        type: "string",
+                    },
+                    parentProp2: {
+                        type: "string",
+                    },
+                },
+            };
+            expect(await Promise.all((0, createSchema_1.createNodes)(schema, "response").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
+        });
+        it("should correctly merge nested properties from multiple allOf schemas", async () => {
+            const schema = {
+                allOf: [
+                    {
+                        type: "object",
+                        properties: {
+                            outerProp1: {
+                                type: "object",
+                                properties: {
+                                    innerProp1: {
+                                        type: "string",
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    {
+                        type: "object",
+                        properties: {
+                            outerProp2: {
+                                type: "object",
+                                properties: {
+                                    innerProp2: {
+                                        type: "number",
+                                    },
+                                },
+                            },
+                        },
+                    },
+                ],
+            };
+            expect(await Promise.all((0, createSchema_1.createNodes)(schema, "response").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
+        });
+        it("should correctly handle shared required properties across allOf schemas", async () => {
+            const schema = {
+                allOf: [
+                    {
+                        type: "object",
+                        properties: {
+                            sharedProp: {
                                 type: "string",
                             },
-                            description: "Array of strings",
                         },
-                        {
-                            type: "boolean",
+                        required: ["sharedProp"],
+                    },
+                    {
+                        type: "object",
+                        properties: {
+                            anotherProp: {
+                                type: "number",
+                            },
                         },
-                        {
-                            type: "number",
+                        required: ["anotherProp"],
+                    },
+                ],
+            };
+            expect(await Promise.all((0, createSchema_1.createNodes)(schema, "response").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
+        });
+        // Could not resolve values for path:"properties.conflictingProp.type". They are probably incompatible. Values:
+        // "string"
+        // "number"
+        // eslint-disable-next-line jest/no-commented-out-tests
+        // it("should handle conflicting properties in allOf schemas", async () => {
+        //   const schema: SchemaObject = {
+        //     allOf: [
+        //       {
+        //         type: "object",
+        //         properties: {
+        //           conflictingProp: {
+        //             type: "string",
+        //           },
+        //         },
+        //       },
+        //       {
+        //         type: "object",
+        //         properties: {
+        //           conflictingProp: {
+        //             type: "number",
+        //           },
+        //         },
+        //       },
+        //     ],
+        //   };
+        //   expect(
+        //     await Promise.all(
+        //       createNodes(schema, "response").map(
+        //         async (md: any) => await prettier.format(md, { parser: "babel" })
+        //       )
+        //     )
+        //   ).toMatchSnapshot();
+        // });
+        // Could not resolve values for path:"type". They are probably incompatible. Values:
+        // "object"
+        // "array"
+        // eslint-disable-next-line jest/no-commented-out-tests
+        // it("should handle mixed data types in allOf schemas", async () => {
+        //   const schema: SchemaObject = {
+        //     allOf: [
+        //       {
+        //         type: "object",
+        //         properties: {
+        //           mixedTypeProp1: {
+        //             type: "string",
+        //           },
+        //         },
+        //       },
+        //       {
+        //         type: "array",
+        //         items: {
+        //           type: "number",
+        //         },
+        //       },
+        //     ],
+        //   };
+        //   expect(
+        //     await Promise.all(
+        //       createNodes(schema, "response").map(
+        //         async (md: any) => await prettier.format(md, { parser: "babel" })
+        //       )
+        //     )
+        //   ).toMatchSnapshot();
+        // });
+        it("should correctly deep merge properties in allOf schemas", async () => {
+            const schema = {
+                allOf: [
+                    {
+                        type: "object",
+                        properties: {
+                            deepProp: {
+                                type: "object",
+                                properties: {
+                                    innerProp1: {
+                                        type: "string",
+                                    },
+                                },
+                            },
                         },
-                        {
-                            type: "string",
+                    },
+                    {
+                        type: "object",
+                        properties: {
+                            deepProp: {
+                                type: "object",
+                                properties: {
+                                    innerProp2: {
+                                        type: "number",
+                                    },
+                                },
+                            },
                         },
-                    ],
-                },
-            },
-        };
-        expect((0, createSchema_1.createNodes)(schema, "request").map((md) => prettier.format(md, { parser: "babel" }))).toMatchSnapshot();
+                    },
+                ],
+            };
+            expect(await Promise.all((0, createSchema_1.createNodes)(schema, "response").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
+        });
+        // eslint-disable-next-line jest/no-commented-out-tests
+        // it("should handle discriminator with allOf schemas", async () => {
+        //   const schema: SchemaObject = {
+        //     allOf: [
+        //       {
+        //         type: "object",
+        //         discriminator: {
+        //           propertyName: "type",
+        //         },
+        //         properties: {
+        //           type: {
+        //             type: "string",
+        //           },
+        //         },
+        //       },
+        //       {
+        //         type: "object",
+        //         properties: {
+        //           specificProp: {
+        //             type: "string",
+        //           },
+        //         },
+        //       },
+        //     ],
+        //   };
+        //   expect(
+        //     await Promise.all(
+        //       createNodes(schema, "response").map(
+        //         async (md: any) => await prettier.format(md, { parser: "babel" })
+        //       )
+        //     )
+        //   ).toMatchSnapshot();
+        // });
     });
 });

package/lib/markdown/createStatusCodes.js

@@ -118,8 +118,9 @@ function createResponseExamples(responseExamples, mimeType) {
                 value: `${exampleName}`,
                 children: [
                     (0, utils_2.guard)(exampleValue.summary, (summary) => [
-                        (0, utils_1.create)("Markdown", {
-                            children: ` ${summary}`,
+                        (0, utils_1.create)("div", {
+                            children: `${summary}`,
+                            className: "openapi-example__summary",
                         }),
                     ]),
                     (0, utils_1.create)("ResponseSamples", {
@@ -134,8 +135,9 @@ function createResponseExamples(responseExamples, mimeType) {
             value: `${exampleName}`,
             children: [
                 (0, utils_2.guard)(exampleValue.summary, (summary) => [
-                    (0, utils_1.create)("Markdown", {
-                        children: ` ${summary}`,
+                    (0, utils_1.create)("div", {
+                        children: `${summary}`,
+                        className: "openapi-example__summary",
                     }),
                 ]),
                 (0, utils_1.create)("ResponseSamples", {
@@ -161,8 +163,9 @@ function createResponseExample(responseExample, mimeType) {
             value: `Example`,
             children: [
                 (0, utils_2.guard)(responseExample.summary, (summary) => [
-                    (0, utils_1.create)("Markdown", {
-                        children: ` ${summary}`,
+                    (0, utils_1.create)("div", {
+                        children: `${summary}`,
+                        className: "openapi-example__summary",
                     }),
                 ]),
                 (0, utils_1.create)("ResponseSamples", {
@@ -177,8 +180,9 @@ function createResponseExample(responseExample, mimeType) {
         value: `Example`,
         children: [
             (0, utils_2.guard)(responseExample.summary, (summary) => [
-                (0, utils_1.create)("Markdown", {
-                    children: ` ${summary}`,
+                (0, utils_1.create)("div", {
+                    children: `${summary}`,
+                    className: "openapi-example__summary",
                 }),
             ]),
             (0, utils_1.create)("ResponseSamples", {

package/lib/markdown/index.js

@@ -38,7 +38,7 @@ function createApiPageMD({ title, api: { deprecated, "x-deprecated-description":
         `import ResponseSamples from "@theme/ResponseSamples";\n`,
         `import SchemaItem from "@theme/SchemaItem";\n`,
         `import SchemaTabs from "@theme/SchemaTabs";\n`,
-        `import Markdown from "@theme/Markdown";\n`,
+        `import Heading from "@theme/Heading";\n`,
         `import OperationTabs from "@theme/OperationTabs";\n`,
         `import TabItem from "@theme/TabItem";\n\n`,
         (0, createHeading_1.createHeading)(title.replace(utils_1.lessThan, "<").replace(utils_1.greaterThan, ">")),

package/lib/openapi/createRequestExample.js

@@ -17,8 +17,8 @@ const primitives = {
     string: {
         default: () => "string",
         email: () => "user@example.com",
-        date: () => new Date().toISOString().substring(0, 10),
-        "date-time": () => new Date().toISOString(),
+        date: () => "2024-07-29",
+        "date-time": () => "2024-07-29T15:51:28.071Z",
         uuid: () => "3fa85f64-5717-4562-b3fc-2c963f66afa6",
         hostname: () => "example.com",
         ipv4: () => "198.51.100.42",

package/lib/openapi/createResponseExample.js

@@ -17,8 +17,8 @@ const primitives = {
     string: {
         default: () => "string",
         email: () => "user@example.com",
-        date: () => new Date().toISOString().substring(0, 10),
-        "date-time": () => new Date().toISOString(),
+        date: () => "2024-07-29",
+        "date-time": () => "2024-07-29T15:51:28.071Z",
         uuid: () => "3fa85f64-5717-4562-b3fc-2c963f66afa6",
         hostname: () => "example.com",
         ipv4: () => "198.51.100.42",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "docusaurus-plugin-openapi-docs",
   "description": "OpenAPI plugin for Docusaurus.",
-  "version": "2.2.1",
+  "version": "2.2.3",
   "license": "MIT",
   "keywords": [
     "openapi",
@@ -60,5 +60,5 @@
   "engines": {
     "node": ">=14"
   },
-  "gitHead": "73b212d18343aa7a35ede5136f5353f06b89d25f"
+  "gitHead": "59298da210f1720615ac258f7b6b386a3e01ecbd"
 }

package/src/index.ts

@@ -536,6 +536,18 @@ custom_edit_url: null
       });
     }
 
+    if (!fs.existsSync(outputDir)) {
+      try {
+        fs.mkdirSync(outputDir, { recursive: true });
+        console.log(chalk.green(`Successfully created "${outputDir}"`));
+      } catch (err) {
+        console.error(
+          chalk.red(`Failed to create "${outputDir}"`),
+          chalk.yellow(err)
+        );
+      }
+    }
+
     const versionsJson = JSON.stringify(versionsArray, null, 2);
     try {
       fs.writeFileSync(`${outputDir}/versions.json`, versionsJson, "utf8");

package/src/markdown/__snapshots__/createSchema.test.ts.snap

@@ -1,6 +1,151 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`createNodes should create readable MODs for oneOf primitive properties 1`] = `
+exports[`createNodes allOf should correctly deep merge properties in allOf schemas 1`] = `
+Array [
+  "<SchemaItem collapsible={true} className={\\"schemaItem\\"}>
+  <details style={{}} className={\\"openapi-markdown__details\\"}>
+    <summary style={{}}>
+      <span className={\\"openapi-schema__container\\"}>
+        <strong className={\\"openapi-schema__property\\"}>deepProp</strong>
+        <span className={\\"openapi-schema__name\\"}> object</span>
+      </span>
+    </summary>
+    <div style={{ marginLeft: \\"1rem\\" }}>
+      <SchemaItem
+        collapsible={false}
+        name={\\"innerProp1\\"}
+        required={false}
+        schemaName={\\"string\\"}
+        qualifierMessage={undefined}
+        schema={{ type: \\"string\\" }}
+      ></SchemaItem>
+      <SchemaItem
+        collapsible={false}
+        name={\\"innerProp2\\"}
+        required={false}
+        schemaName={\\"number\\"}
+        qualifierMessage={undefined}
+        schema={{ type: \\"number\\" }}
+      ></SchemaItem>
+    </div>
+  </details>
+</SchemaItem>;
+",
+]
+`;
+
+exports[`createNodes allOf should correctly handle shared required properties across allOf schemas 1`] = `
+Array [
+  "<SchemaItem
+  collapsible={false}
+  name={\\"sharedProp\\"}
+  required={true}
+  schemaName={\\"string\\"}
+  qualifierMessage={undefined}
+  schema={{ type: \\"string\\" }}
+></SchemaItem>;
+",
+  "<SchemaItem
+  collapsible={false}
+  name={\\"anotherProp\\"}
+  required={true}
+  schemaName={\\"number\\"}
+  qualifierMessage={undefined}
+  schema={{ type: \\"number\\" }}
+></SchemaItem>;
+",
+]
+`;
+
+exports[`createNodes allOf should correctly merge nested properties from multiple allOf schemas 1`] = `
+Array [
+  "<SchemaItem collapsible={true} className={\\"schemaItem\\"}>
+  <details style={{}} className={\\"openapi-markdown__details\\"}>
+    <summary style={{}}>
+      <span className={\\"openapi-schema__container\\"}>
+        <strong className={\\"openapi-schema__property\\"}>outerProp1</strong>
+        <span className={\\"openapi-schema__name\\"}> object</span>
+      </span>
+    </summary>
+    <div style={{ marginLeft: \\"1rem\\" }}>
+      <SchemaItem
+        collapsible={false}
+        name={\\"innerProp1\\"}
+        required={false}
+        schemaName={\\"string\\"}
+        qualifierMessage={undefined}
+        schema={{ type: \\"string\\" }}
+      ></SchemaItem>
+    </div>
+  </details>
+</SchemaItem>;
+",
+  "<SchemaItem collapsible={true} className={\\"schemaItem\\"}>
+  <details style={{}} className={\\"openapi-markdown__details\\"}>
+    <summary style={{}}>
+      <span className={\\"openapi-schema__container\\"}>
+        <strong className={\\"openapi-schema__property\\"}>outerProp2</strong>
+        <span className={\\"openapi-schema__name\\"}> object</span>
+      </span>
+    </summary>
+    <div style={{ marginLeft: \\"1rem\\" }}>
+      <SchemaItem
+        collapsible={false}
+        name={\\"innerProp2\\"}
+        required={false}
+        schemaName={\\"number\\"}
+        qualifierMessage={undefined}
+        schema={{ type: \\"number\\" }}
+      ></SchemaItem>
+    </div>
+  </details>
+</SchemaItem>;
+",
+]
+`;
+
+exports[`createNodes allOf should render same-level properties with allOf 1`] = `
+Array [
+  "<SchemaItem
+  collapsible={false}
+  name={\\"parentProp1\\"}
+  required={false}
+  schemaName={\\"string\\"}
+  qualifierMessage={undefined}
+  schema={{ type: \\"string\\" }}
+></SchemaItem>;
+",
+  "<SchemaItem
+  collapsible={false}
+  name={\\"parentProp2\\"}
+  required={false}
+  schemaName={\\"string\\"}
+  qualifierMessage={undefined}
+  schema={{ type: \\"string\\" }}
+></SchemaItem>;
+",
+  "<SchemaItem
+  collapsible={false}
+  name={\\"allOfProp1\\"}
+  required={false}
+  schemaName={\\"string\\"}
+  qualifierMessage={undefined}
+  schema={{ type: \\"string\\" }}
+></SchemaItem>;
+",
+  "<SchemaItem
+  collapsible={false}
+  name={\\"allOfProp2\\"}
+  required={false}
+  schemaName={\\"string\\"}
+  qualifierMessage={undefined}
+  schema={{ type: \\"string\\" }}
+></SchemaItem>;
+",
+]
+`;
+
+exports[`createNodes oneOf should create readable MODs for oneOf primitive properties 1`] = `
 Array [
   "<SchemaItem collapsible={true} className={\\"schemaItem\\"}>
   <details style={{}} className={\\"openapi-markdown__details\\"}>

package/src/markdown/createSchema.test.ts

@@ -11,47 +11,305 @@ import { createNodes } from "./createSchema";
 import { SchemaObject } from "../openapi/types";
 
 describe("createNodes", () => {
-  it("should create readable MODs for oneOf primitive properties", () => {
-    const schema: SchemaObject = {
-      "x-tags": ["clown"],
-      type: "object",
-      properties: {
-        oneOfProperty: {
-          oneOf: [
-            {
-              type: "object",
-              properties: {
-                noseLength: {
-                  type: "number",
+  describe("oneOf", () => {
+    it("should create readable MODs for oneOf primitive properties", async () => {
+      const schema: SchemaObject = {
+        "x-tags": ["clown"],
+        type: "object",
+        properties: {
+          oneOfProperty: {
+            oneOf: [
+              {
+                type: "object",
+                properties: {
+                  noseLength: {
+                    type: "number",
+                  },
+                },
+                required: ["noseLength"],
+                description: "Clown's nose length",
+              },
+              {
+                type: "array",
+                items: {
+                  type: "string",
+                },
+                description: "Array of strings",
+              },
+              {
+                type: "boolean",
+              },
+              {
+                type: "number",
+              },
+              {
+                type: "string",
+              },
+            ],
+          },
+        },
+      };
+      expect(
+        await Promise.all(
+          createNodes(schema, "request").map(
+            async (md: any) => await prettier.format(md, { parser: "babel" })
+          )
+        )
+      ).toMatchSnapshot();
+    });
+  });
+
+  describe("allOf", () => {
+    it("should render same-level properties with allOf", async () => {
+      const schema: SchemaObject = {
+        allOf: [
+          {
+            type: "object",
+            properties: {
+              allOfProp1: {
+                type: "string",
+              },
+              allOfProp2: {
+                type: "string",
+              },
+            },
+          },
+        ],
+        properties: {
+          parentProp1: {
+            type: "string",
+          },
+          parentProp2: {
+            type: "string",
+          },
+        },
+      };
+
+      expect(
+        await Promise.all(
+          createNodes(schema, "response").map(
+            async (md: any) => await prettier.format(md, { parser: "babel" })
+          )
+        )
+      ).toMatchSnapshot();
+    });
+
+    it("should correctly merge nested properties from multiple allOf schemas", async () => {
+      const schema: SchemaObject = {
+        allOf: [
+          {
+            type: "object",
+            properties: {
+              outerProp1: {
+                type: "object",
+                properties: {
+                  innerProp1: {
+                    type: "string",
+                  },
                 },
               },
-              required: ["noseLength"],
-              description: "Clown's nose length",
             },
-            {
-              type: "array",
-              items: {
+          },
+          {
+            type: "object",
+            properties: {
+              outerProp2: {
+                type: "object",
+                properties: {
+                  innerProp2: {
+                    type: "number",
+                  },
+                },
+              },
+            },
+          },
+        ],
+      };
+
+      expect(
+        await Promise.all(
+          createNodes(schema, "response").map(
+            async (md: any) => await prettier.format(md, { parser: "babel" })
+          )
+        )
+      ).toMatchSnapshot();
+    });
+
+    it("should correctly handle shared required properties across allOf schemas", async () => {
+      const schema: SchemaObject = {
+        allOf: [
+          {
+            type: "object",
+            properties: {
+              sharedProp: {
                 type: "string",
               },
-              description: "Array of strings",
             },
-            {
-              type: "boolean",
+            required: ["sharedProp"],
+          },
+          {
+            type: "object",
+            properties: {
+              anotherProp: {
+                type: "number",
+              },
             },
-            {
-              type: "number",
+            required: ["anotherProp"],
+          },
+        ],
+      };
+
+      expect(
+        await Promise.all(
+          createNodes(schema, "response").map(
+            async (md: any) => await prettier.format(md, { parser: "babel" })
+          )
+        )
+      ).toMatchSnapshot();
+    });
+
+    // Could not resolve values for path:"properties.conflictingProp.type". They are probably incompatible. Values:
+    // "string"
+    // "number"
+    // eslint-disable-next-line jest/no-commented-out-tests
+    // it("should handle conflicting properties in allOf schemas", async () => {
+    //   const schema: SchemaObject = {
+    //     allOf: [
+    //       {
+    //         type: "object",
+    //         properties: {
+    //           conflictingProp: {
+    //             type: "string",
+    //           },
+    //         },
+    //       },
+    //       {
+    //         type: "object",
+    //         properties: {
+    //           conflictingProp: {
+    //             type: "number",
+    //           },
+    //         },
+    //       },
+    //     ],
+    //   };
+
+    //   expect(
+    //     await Promise.all(
+    //       createNodes(schema, "response").map(
+    //         async (md: any) => await prettier.format(md, { parser: "babel" })
+    //       )
+    //     )
+    //   ).toMatchSnapshot();
+    // });
+
+    // Could not resolve values for path:"type". They are probably incompatible. Values:
+    // "object"
+    // "array"
+    // eslint-disable-next-line jest/no-commented-out-tests
+    // it("should handle mixed data types in allOf schemas", async () => {
+    //   const schema: SchemaObject = {
+    //     allOf: [
+    //       {
+    //         type: "object",
+    //         properties: {
+    //           mixedTypeProp1: {
+    //             type: "string",
+    //           },
+    //         },
+    //       },
+    //       {
+    //         type: "array",
+    //         items: {
+    //           type: "number",
+    //         },
+    //       },
+    //     ],
+    //   };
+
+    //   expect(
+    //     await Promise.all(
+    //       createNodes(schema, "response").map(
+    //         async (md: any) => await prettier.format(md, { parser: "babel" })
+    //       )
+    //     )
+    //   ).toMatchSnapshot();
+    // });
+
+    it("should correctly deep merge properties in allOf schemas", async () => {
+      const schema: SchemaObject = {
+        allOf: [
+          {
+            type: "object",
+            properties: {
+              deepProp: {
+                type: "object",
+                properties: {
+                  innerProp1: {
+                    type: "string",
+                  },
+                },
+              },
             },
-            {
-              type: "string",
+          },
+          {
+            type: "object",
+            properties: {
+              deepProp: {
+                type: "object",
+                properties: {
+                  innerProp2: {
+                    type: "number",
+                  },
+                },
+              },
             },
-          ],
-        },
-      },
-    };
-    expect(
-      createNodes(schema, "request").map((md: any) =>
-        prettier.format(md, { parser: "babel" })
-      )
-    ).toMatchSnapshot();
+          },
+        ],
+      };
+
+      expect(
+        await Promise.all(
+          createNodes(schema, "response").map(
+            async (md: any) => await prettier.format(md, { parser: "babel" })
+          )
+        )
+      ).toMatchSnapshot();
+    });
+
+    // eslint-disable-next-line jest/no-commented-out-tests
+    // it("should handle discriminator with allOf schemas", async () => {
+    //   const schema: SchemaObject = {
+    //     allOf: [
+    //       {
+    //         type: "object",
+    //         discriminator: {
+    //           propertyName: "type",
+    //         },
+    //         properties: {
+    //           type: {
+    //             type: "string",
+    //           },
+    //         },
+    //       },
+    //       {
+    //         type: "object",
+    //         properties: {
+    //           specificProp: {
+    //             type: "string",
+    //           },
+    //         },
+    //       },
+    //     ],
+    //   };
+
+    //   expect(
+    //     await Promise.all(
+    //       createNodes(schema, "response").map(
+    //         async (md: any) => await prettier.format(md, { parser: "babel" })
+    //       )
+    //     )
+    //   ).toMatchSnapshot();
+    // });
   });
 });

package/src/markdown/createSchema.ts

@@ -73,6 +73,15 @@ function createAnyOneOf(schema: SchemaObject): any {
             : `MOD${index + 1}`;
           const anyOneChildren = [];
 
+          if (
+            anyOneSchema.type === "object" &&
+            !anyOneSchema.properties &&
+            !anyOneSchema.allOf &&
+            !anyOneSchema.items
+          ) {
+            anyOneChildren.push(createNodes(anyOneSchema, SCHEMA_TYPE));
+          }
+
           if (anyOneSchema.properties !== undefined) {
             anyOneChildren.push(createProperties(anyOneSchema));
             delete anyOneSchema.properties;
@@ -526,8 +535,9 @@ function createPropertyDiscriminator(
     return undefined;
   }
 
+  // render as a simple property if there's no mapping
   if (discriminator.mapping === undefined) {
-    return undefined;
+    return createEdges({ name, schema, required });
   }
 
   return create("div", {
@@ -617,6 +627,7 @@ function createEdges({
   }
 
   const schemaName = getSchemaName(schema);
+
   if (discriminator !== undefined && discriminator.propertyName === name) {
     return createPropertyDiscriminator(
       name,
@@ -637,6 +648,47 @@ function createEdges({
     );
   }
 
+  if (schema.properties !== undefined) {
+    return createDetailsNode(
+      name,
+      schemaName,
+      schema,
+      required,
+      schema.nullable
+    );
+  }
+
+  if (schema.additionalProperties !== undefined) {
+    return createDetailsNode(
+      name,
+      schemaName,
+      schema,
+      required,
+      schema.nullable
+    );
+  }
+
+  // array of objects
+  if (schema.items?.properties !== undefined) {
+    return createDetailsNode(
+      name,
+      schemaName,
+      schema,
+      required,
+      schema.nullable
+    );
+  }
+
+  if (schema.items?.anyOf !== undefined || schema.items?.oneOf !== undefined) {
+    return createDetailsNode(
+      name,
+      schemaName,
+      schema,
+      required,
+      schema.nullable
+    );
+  }
+
   if (schema.allOf !== undefined) {
     const { mergedSchemas }: { mergedSchemas: SchemaObject } = mergeAllOf(
       schema.allOf
@@ -709,47 +761,6 @@ function createEdges({
     });
   }
 
-  if (schema.properties !== undefined) {
-    return createDetailsNode(
-      name,
-      schemaName,
-      schema,
-      required,
-      schema.nullable
-    );
-  }
-
-  if (schema.additionalProperties !== undefined) {
-    return createDetailsNode(
-      name,
-      schemaName,
-      schema,
-      required,
-      schema.nullable
-    );
-  }
-
-  // array of objects
-  if (schema.items?.properties !== undefined) {
-    return createDetailsNode(
-      name,
-      schemaName,
-      schema,
-      required,
-      schema.nullable
-    );
-  }
-
-  if (schema.items?.anyOf !== undefined || schema.items?.oneOf !== undefined) {
-    return createDetailsNode(
-      name,
-      schemaName,
-      schema,
-      required,
-      schema.nullable
-    );
-  }
-
   // primitives and array of non-objects
   return create("SchemaItem", {
     collapsible: false,
@@ -789,15 +800,6 @@ export function createNodes(
     nodes.push(createAnyOneOf(schema));
   }
 
-  if (schema.allOf !== undefined) {
-    const { mergedSchemas } = mergeAllOf(schema.allOf);
-
-    // allOf seems to always result in properties
-    if (mergedSchemas.properties !== undefined) {
-      nodes.push(createProperties(mergedSchemas));
-    }
-  }
-
   if (schema.properties !== undefined) {
     nodes.push(createProperties(schema));
   }
@@ -811,6 +813,15 @@ export function createNodes(
     nodes.push(createItems(schema));
   }
 
+  if (schema.allOf !== undefined) {
+    const { mergedSchemas } = mergeAllOf(schema.allOf);
+
+    // allOf seems to always result in properties
+    if (mergedSchemas.properties !== undefined) {
+      nodes.push(createProperties(mergedSchemas));
+    }
+  }
+
   if (nodes.length && nodes.length > 0) {
     return nodes.filter(Boolean).flat();
   }

package/src/markdown/createStatusCodes.ts

@@ -127,8 +127,9 @@ export function createResponseExamples(
           value: `${exampleName}`,
           children: [
             guard(exampleValue.summary, (summary) => [
-              create("Markdown", {
-                children: ` ${summary}`,
+              create("div", {
+                children: `${summary}`,
+                className: "openapi-example__summary",
               }),
             ]),
             create("ResponseSamples", {
@@ -143,8 +144,9 @@ export function createResponseExamples(
         value: `${exampleName}`,
         children: [
           guard(exampleValue.summary, (summary) => [
-            create("Markdown", {
-              children: ` ${summary}`,
+            create("div", {
+              children: `${summary}`,
+              className: "openapi-example__summary",
             }),
           ]),
           create("ResponseSamples", {
@@ -171,8 +173,9 @@ export function createResponseExample(responseExample: any, mimeType: string) {
       value: `Example`,
       children: [
         guard(responseExample.summary, (summary) => [
-          create("Markdown", {
-            children: ` ${summary}`,
+          create("div", {
+            children: `${summary}`,
+            className: "openapi-example__summary",
           }),
         ]),
         create("ResponseSamples", {
@@ -187,8 +190,9 @@ export function createResponseExample(responseExample: any, mimeType: string) {
     value: `Example`,
     children: [
       guard(responseExample.summary, (summary) => [
-        create("Markdown", {
-          children: ` ${summary}`,
+        create("div", {
+          children: `${summary}`,
+          className: "openapi-example__summary",
         }),
       ]),
       create("ResponseSamples", {

package/src/markdown/index.ts

@@ -76,7 +76,7 @@ export function createApiPageMD({
     `import ResponseSamples from "@theme/ResponseSamples";\n`,
     `import SchemaItem from "@theme/SchemaItem";\n`,
     `import SchemaTabs from "@theme/SchemaTabs";\n`,
-    `import Markdown from "@theme/Markdown";\n`,
+    `import Heading from "@theme/Heading";\n`,
     `import OperationTabs from "@theme/OperationTabs";\n`,
     `import TabItem from "@theme/TabItem";\n\n`,
     createHeading(title.replace(lessThan, "<").replace(greaterThan, ">")),

package/src/openapi/createRequestExample.ts

@@ -30,8 +30,8 @@ const primitives: Primitives = {
   string: {
     default: () => "string",
     email: () => "user@example.com",
-    date: () => new Date().toISOString().substring(0, 10),
-    "date-time": () => new Date().toISOString(),
+    date: () => "2024-07-29",
+    "date-time": () => "2024-07-29T15:51:28.071Z",
     uuid: () => "3fa85f64-5717-4562-b3fc-2c963f66afa6",
     hostname: () => "example.com",
     ipv4: () => "198.51.100.42",

package/src/openapi/createResponseExample.ts

@@ -30,8 +30,8 @@ const primitives: Primitives = {
   string: {
     default: () => "string",
     email: () => "user@example.com",
-    date: () => new Date().toISOString().substring(0, 10),
-    "date-time": () => new Date().toISOString(),
+    date: () => "2024-07-29",
+    "date-time": () => "2024-07-29T15:51:28.071Z",
     uuid: () => "3fa85f64-5717-4562-b3fc-2c963f66afa6",
     hostname: () => "example.com",
     ipv4: () => "198.51.100.42",