docusaurus-plugin-openapi-docs 0.0.0-beta.739 → 0.0.0-beta.741

package/lib/markdown/createSchema.js

@@ -11,6 +11,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNodes = exports.mergeAllOf = void 0;
 const clsx_1 = __importDefault(require("clsx"));
+const isEmpty_1 = __importDefault(require("lodash/isEmpty"));
 const createArrayBracket_1 = require("./createArrayBracket");
 const createDescription_1 = require("./createDescription");
 const createDetails_1 = require("./createDetails");
@@ -141,70 +142,52 @@ function createProperties(schema) {
  * For handling additionalProperties.
  */
 function createAdditionalProperties(schema) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    var _a;
     const additionalProperties = schema.additionalProperties;
-    const type = additionalProperties === null || additionalProperties === void 0 ? void 0 : additionalProperties.type;
+    if (!additionalProperties)
+        return [];
     // Handle free-form objects
-    if (String(additionalProperties) === "true" && schema.type === "object") {
+    if (additionalProperties === true || (0, isEmpty_1.default)(additionalProperties)) {
         return (0, utils_1.create)("SchemaItem", {
             name: "property name*",
             required: false,
             schemaName: "any",
-            qualifierMessage: (0, schema_1.getQualifierMessage)(schema.additionalProperties),
+            qualifierMessage: (0, schema_1.getQualifierMessage)(schema),
             schema: schema,
             collapsible: false,
             discriminator: false,
         });
     }
-    if ((type === "object" || type === "array") &&
-        ((additionalProperties === null || additionalProperties === void 0 ? void 0 : additionalProperties.properties) ||
-            (additionalProperties === null || additionalProperties === void 0 ? void 0 : additionalProperties.items) ||
-            (additionalProperties === null || additionalProperties === void 0 ? void 0 : additionalProperties.allOf) ||
-            (additionalProperties === null || additionalProperties === void 0 ? void 0 : additionalProperties.additionalProperties) ||
-            (additionalProperties === null || additionalProperties === void 0 ? void 0 : additionalProperties.oneOf) ||
-            (additionalProperties === null || additionalProperties === void 0 ? void 0 : additionalProperties.anyOf))) {
+    // objects, arrays, complex schemas
+    if (additionalProperties.properties ||
+        additionalProperties.items ||
+        additionalProperties.allOf ||
+        additionalProperties.additionalProperties ||
+        additionalProperties.oneOf ||
+        additionalProperties.anyOf) {
         const title = additionalProperties.title;
         const schemaName = (0, schema_1.getSchemaName)(additionalProperties);
         const required = (_a = schema.required) !== null && _a !== void 0 ? _a : false;
         return createDetailsNode("property name*", title !== null && title !== void 0 ? title : schemaName, additionalProperties, required, schema.nullable);
     }
-    if (((_b = schema.additionalProperties) === null || _b === void 0 ? void 0 : _b.type) === "string" ||
-        ((_c = schema.additionalProperties) === null || _c === void 0 ? void 0 : _c.type) === "object" ||
-        ((_d = schema.additionalProperties) === null || _d === void 0 ? void 0 : _d.type) === "boolean" ||
-        ((_e = schema.additionalProperties) === null || _e === void 0 ? void 0 : _e.type) === "integer" ||
-        ((_f = schema.additionalProperties) === null || _f === void 0 ? void 0 : _f.type) === "number") {
-        const additionalProperties = (_g = schema.additionalProperties) === null || _g === void 0 ? void 0 : _g.additionalProperties;
-        if (additionalProperties !== undefined) {
-            const type = (_j = (_h = schema.additionalProperties) === null || _h === void 0 ? void 0 : _h.additionalProperties) === null || _j === void 0 ? void 0 : _j.type;
-            const schemaName = (0, schema_1.getSchemaName)((_k = schema.additionalProperties) === null || _k === void 0 ? void 0 : _k.additionalProperties);
-            return (0, utils_1.create)("SchemaItem", {
-                name: "property name*",
-                required: false,
-                schemaName: schemaName !== null && schemaName !== void 0 ? schemaName : type,
-                qualifierMessage: (_l = schema.additionalProperties) !== null && _l !== void 0 ? _l : (0, schema_1.getQualifierMessage)(schema.additionalProperties),
-                schema: schema,
-                collapsible: false,
-                discriminator: false,
-            });
-        }
-        const schemaName = (0, schema_1.getSchemaName)(schema.additionalProperties);
+    // primitive types
+    if (additionalProperties.type === "string" ||
+        additionalProperties.type === "boolean" ||
+        additionalProperties.type === "integer" ||
+        additionalProperties.type === "number") {
+        const schemaName = (0, schema_1.getSchemaName)(additionalProperties);
         return (0, utils_1.create)("SchemaItem", {
             name: "property name*",
             required: false,
             schemaName: schemaName,
             qualifierMessage: (0, schema_1.getQualifierMessage)(schema),
-            schema: schema.additionalProperties,
+            schema: additionalProperties,
             collapsible: false,
             discriminator: false,
         });
     }
-    return Object.entries(schema.additionalProperties).map(([key, val]) => createEdges({
-        name: key,
-        schema: val,
-        required: Array.isArray(schema.required)
-            ? schema.required.includes(key)
-            : false,
-    }));
+    // unknown
+    return [];
 }
 /**
  * For handling items.
@@ -593,7 +576,10 @@ function createNodes(schema, schemaType) {
     }
     if (schema.allOf !== undefined) {
         const { mergedSchemas } = mergeAllOf(schema.allOf);
-        // allOf seems to always result in properties
+        if (mergedSchemas.oneOf !== undefined ||
+            mergedSchemas.anyOf !== undefined) {
+            nodes.push(createAnyOneOf(mergedSchemas));
+        }
         if (mergedSchemas.properties !== undefined) {
             nodes.push(createProperties(mergedSchemas));
         }

package/lib/markdown/createSchema.test.js

@@ -71,4 +71,80 @@ describe("createNodes", () => {
         };
         expect(await Promise.all((0, createSchema_1.createNodes)(schema, "request").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
     });
+    describe("additionalProperties", () => {
+        it.each([
+            [
+                {
+                    allOf: [
+                        {
+                            oneOf: [
+                                {
+                                    type: "object",
+                                    properties: {
+                                        type: {
+                                            type: "string",
+                                            enum: ["nose"],
+                                        },
+                                    },
+                                    required: ["type"],
+                                },
+                                {
+                                    type: "object",
+                                    properties: {
+                                        type: {
+                                            type: "string",
+                                            enum: ["mouth"],
+                                        },
+                                    },
+                                    required: ["type"],
+                                },
+                                {
+                                    type: "object",
+                                    properties: {
+                                        type: {
+                                            type: "string",
+                                            enum: ["eyes"],
+                                        },
+                                        default: {
+                                            type: "string",
+                                        },
+                                    },
+                                    required: ["type"],
+                                },
+                            ],
+                        },
+                        {
+                            type: "object",
+                            properties: {
+                                description: {
+                                    type: "string",
+                                    description: "Description of the body part.",
+                                },
+                            },
+                            required: ["description"],
+                        },
+                    ],
+                },
+            ],
+            [
+                {
+                    type: "array",
+                    items: { type: "object", properties: { a: "string", b: "number" } },
+                },
+            ],
+            [{ type: "string" }],
+            [{ type: "number" }],
+            [{ type: "integer" }],
+            [{ type: "boolean" }],
+            [false],
+            [true],
+            [{}],
+        ])("should handle additionalProperties: %p", async (additionalProperties) => {
+            const schema = {
+                type: "object",
+                additionalProperties,
+            };
+            expect(await Promise.all((0, createSchema_1.createNodes)(schema, "request").map(async (md) => await prettier.format(md, { parser: "babel" })))).toMatchSnapshot();
+        });
+    });
 });

package/lib/openapi/types.d.ts

@@ -269,7 +269,7 @@ export type SchemaObject = Omit<JSONSchema, "type" | "allOf" | "oneOf" | "anyOf"
     not?: SchemaObject;
     items?: SchemaObject;
     properties?: Map<SchemaObject>;
-    additionalProperties?: Map<SchemaObject>;
+    additionalProperties?: boolean | SchemaObject;
     nullable?: boolean;
     discriminator?: DiscriminatorObject;
     readOnly?: boolean;

package/lib/sidebars/index.js

@@ -55,7 +55,9 @@ function groupByTags(items, sidebarOptions, options, tags, docPath) {
             apiTags.push(tag.name);
         }
     });
-    apiTags = (0, uniq_1.default)(apiTags.concat(operationTags, schemaTags));
+    if (sidebarOptions.groupPathsBy !== "tagGroup") {
+        apiTags = (0, uniq_1.default)(apiTags.concat(operationTags, schemaTags));
+    }
     const basePath = docPath
         ? outputDir.split(docPath)[1].replace(/^\/+/g, "")
         : outputDir.slice(outputDir.indexOf("/", 1)).replace(/^\/+/g, "");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "docusaurus-plugin-openapi-docs",
   "description": "OpenAPI plugin for Docusaurus.",
-  "version": "0.0.0-beta.739",
+  "version": "0.0.0-beta.741",
   "license": "MIT",
   "keywords": [
     "openapi",
@@ -62,5 +62,5 @@
   "engines": {
     "node": ">=14"
   },
-  "gitHead": "95001f341b43305ba8ec1f280f70efd44f813753"
+  "gitHead": "58863e27abae4f8e870ff050b3bcb276bda49fb6"
 }

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

@@ -1,5 +1,226 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`createNodes additionalProperties should handle additionalProperties: {"allOf": [Array]} 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\\"}>property name*</strong>
+        <span className={\\"openapi-schema__name\\"}>object</span>
+      </span>
+    </summary>
+    <div style={{ marginLeft: \\"1rem\\" }}>
+      <div>
+        <span className={\\"badge badge--info\\"}>oneOf</span>
+        <SchemaTabs>
+          <TabItem label={\\"MOD1\\"} value={\\"0-item-properties\\"}>
+            <SchemaItem
+              collapsible={false}
+              name={\\"type\\"}
+              required={true}
+              schemaName={\\"string\\"}
+              qualifierMessage={\\"**Possible values:** [\`nose\`]\\"}
+              schema={{ type: \\"string\\", enum: [\\"nose\\"] }}
+            ></SchemaItem>
+          </TabItem>
+          <TabItem label={\\"MOD2\\"} value={\\"1-item-properties\\"}>
+            <SchemaItem
+              collapsible={false}
+              name={\\"type\\"}
+              required={true}
+              schemaName={\\"string\\"}
+              qualifierMessage={\\"**Possible values:** [\`mouth\`]\\"}
+              schema={{ type: \\"string\\", enum: [\\"mouth\\"] }}
+            ></SchemaItem>
+          </TabItem>
+          <TabItem label={\\"MOD3\\"} value={\\"2-item-properties\\"}>
+            <SchemaItem
+              collapsible={false}
+              name={\\"type\\"}
+              required={true}
+              schemaName={\\"string\\"}
+              qualifierMessage={\\"**Possible values:** [\`eyes\`]\\"}
+              schema={{ type: \\"string\\", enum: [\\"eyes\\"] }}
+            ></SchemaItem>
+            <SchemaItem
+              collapsible={false}
+              name={\\"default\\"}
+              required={false}
+              schemaName={\\"string\\"}
+              qualifierMessage={undefined}
+              schema={{ type: \\"string\\" }}
+            ></SchemaItem>
+          </TabItem>
+        </SchemaTabs>
+      </div>
+      <SchemaItem
+        collapsible={false}
+        name={\\"description\\"}
+        required={true}
+        schemaName={\\"string\\"}
+        qualifierMessage={undefined}
+        schema={{
+          type: \\"string\\",
+          description: \\"Description of the body part.\\",
+        }}
+      ></SchemaItem>
+    </div>
+  </details>
+</SchemaItem>;
+",
+]
+`;
+
+exports[`createNodes additionalProperties should handle additionalProperties: {"items": [Object], "type": "array"} 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\\"}>property name*</strong>
+        <span className={\\"openapi-schema__name\\"}>object[]</span>
+      </span>
+    </summary>
+    <div style={{ marginLeft: \\"1rem\\" }}>
+      <li>
+        <div
+          style={{
+            fontSize: \\"var(--ifm-code-font-size)\\",
+            opacity: \\"0.6\\",
+            marginLeft: \\"-.5rem\\",
+            paddingBottom: \\".5rem\\",
+          }}
+        >
+          Array [
+        </div>
+      </li>
+      <SchemaItem
+        collapsible={false}
+        name={\\"a\\"}
+        required={false}
+        schemaName={\\"\\"}
+        qualifierMessage={undefined}
+        schema={\\"string\\"}
+      ></SchemaItem>
+      <SchemaItem
+        collapsible={false}
+        name={\\"b\\"}
+        required={false}
+        schemaName={\\"\\"}
+        qualifierMessage={undefined}
+        schema={\\"number\\"}
+      ></SchemaItem>
+      <li>
+        <div
+          style={{
+            fontSize: \\"var(--ifm-code-font-size)\\",
+            opacity: \\"0.6\\",
+            marginLeft: \\"-.5rem\\",
+          }}
+        >
+          ]
+        </div>
+      </li>
+    </div>
+  </details>
+</SchemaItem>;
+",
+]
+`;
+
+exports[`createNodes additionalProperties should handle additionalProperties: {"type": "boolean"} 1`] = `
+Array [
+  "<SchemaItem
+  name={\\"property name*\\"}
+  required={false}
+  schemaName={\\"boolean\\"}
+  qualifierMessage={undefined}
+  schema={{ type: \\"boolean\\" }}
+  collapsible={false}
+  discriminator={false}
+></SchemaItem>;
+",
+]
+`;
+
+exports[`createNodes additionalProperties should handle additionalProperties: {"type": "integer"} 1`] = `
+Array [
+  "<SchemaItem
+  name={\\"property name*\\"}
+  required={false}
+  schemaName={\\"integer\\"}
+  qualifierMessage={undefined}
+  schema={{ type: \\"integer\\" }}
+  collapsible={false}
+  discriminator={false}
+></SchemaItem>;
+",
+]
+`;
+
+exports[`createNodes additionalProperties should handle additionalProperties: {"type": "number"} 1`] = `
+Array [
+  "<SchemaItem
+  name={\\"property name*\\"}
+  required={false}
+  schemaName={\\"number\\"}
+  qualifierMessage={undefined}
+  schema={{ type: \\"number\\" }}
+  collapsible={false}
+  discriminator={false}
+></SchemaItem>;
+",
+]
+`;
+
+exports[`createNodes additionalProperties should handle additionalProperties: {"type": "string"} 1`] = `
+Array [
+  "<SchemaItem
+  name={\\"property name*\\"}
+  required={false}
+  schemaName={\\"string\\"}
+  qualifierMessage={undefined}
+  schema={{ type: \\"string\\" }}
+  collapsible={false}
+  discriminator={false}
+></SchemaItem>;
+",
+]
+`;
+
+exports[`createNodes additionalProperties should handle additionalProperties: {} 1`] = `
+Array [
+  "<SchemaItem
+  name={\\"property name*\\"}
+  required={false}
+  schemaName={\\"any\\"}
+  qualifierMessage={undefined}
+  schema={{ type: \\"object\\", additionalProperties: {} }}
+  collapsible={false}
+  discriminator={false}
+></SchemaItem>;
+",
+]
+`;
+
+exports[`createNodes additionalProperties should handle additionalProperties: false 1`] = `Array []`;
+
+exports[`createNodes additionalProperties should handle additionalProperties: true 1`] = `
+Array [
+  "<SchemaItem
+  name={\\"property name*\\"}
+  required={false}
+  schemaName={\\"any\\"}
+  qualifierMessage={undefined}
+  schema={{ type: \\"object\\", additionalProperties: true }}
+  collapsible={false}
+  discriminator={false}
+></SchemaItem>;
+",
+]
+`;
+
 exports[`createNodes should create readable MODs for oneOf primitive properties 1`] = `
 Array [
   "<SchemaItem collapsible={true} className={\\"schemaItem\\"}>

package/src/markdown/createSchema.test.ts

@@ -56,4 +56,91 @@ describe("createNodes", () => {
       )
     ).toMatchSnapshot();
   });
+
+  describe("additionalProperties", () => {
+    it.each([
+      [
+        {
+          allOf: [
+            {
+              oneOf: [
+                {
+                  type: "object",
+                  properties: {
+                    type: {
+                      type: "string",
+                      enum: ["nose"],
+                    },
+                  },
+                  required: ["type"],
+                },
+                {
+                  type: "object",
+                  properties: {
+                    type: {
+                      type: "string",
+                      enum: ["mouth"],
+                    },
+                  },
+                  required: ["type"],
+                },
+                {
+                  type: "object",
+                  properties: {
+                    type: {
+                      type: "string",
+                      enum: ["eyes"],
+                    },
+                    default: {
+                      type: "string",
+                    },
+                  },
+                  required: ["type"],
+                },
+              ],
+            },
+            {
+              type: "object",
+              properties: {
+                description: {
+                  type: "string",
+                  description: "Description of the body part.",
+                },
+              },
+              required: ["description"],
+            },
+          ],
+        },
+      ],
+      [
+        {
+          type: "array",
+          items: { type: "object", properties: { a: "string", b: "number" } },
+        },
+      ],
+      [{ type: "string" }],
+      [{ type: "number" }],
+      [{ type: "integer" }],
+      [{ type: "boolean" }],
+      [false],
+      [true],
+      [{}],
+    ] as [SchemaObject["additionalProperties"]][])(
+      "should handle additionalProperties: %p",
+      async (additionalProperties) => {
+        const schema: SchemaObject = {
+          type: "object",
+          additionalProperties,
+        };
+
+        expect(
+          await Promise.all(
+            createNodes(schema, "request").map(
+              async (md: any) => await prettier.format(md, { parser: "babel" })
+            )
+          )
+        ).toMatchSnapshot();
+      }
+    );
+  });
 });

package/src/markdown/createSchema.ts

@@ -6,6 +6,7 @@
  * ========================================================================== */
 
 import clsx from "clsx";
+import isEmpty from "lodash/isEmpty";
 
 import {
   createClosingArrayBracket,
@@ -156,27 +157,29 @@ function createProperties(schema: SchemaObject) {
  */
 function createAdditionalProperties(schema: SchemaObject) {
   const additionalProperties = schema.additionalProperties;
-  const type: string | unknown = additionalProperties?.type;
+  if (!additionalProperties) return [];
+
   // Handle free-form objects
-  if (String(additionalProperties) === "true" && schema.type === "object") {
+  if (additionalProperties === true || isEmpty(additionalProperties)) {
     return create("SchemaItem", {
       name: "property name*",
       required: false,
       schemaName: "any",
-      qualifierMessage: getQualifierMessage(schema.additionalProperties),
+      qualifierMessage: getQualifierMessage(schema),
       schema: schema,
       collapsible: false,
       discriminator: false,
     });
   }
+
+  // objects, arrays, complex schemas
   if (
-    (type === "object" || type === "array") &&
-    (additionalProperties?.properties ||
-      additionalProperties?.items ||
-      additionalProperties?.allOf ||
-      additionalProperties?.additionalProperties ||
-      additionalProperties?.oneOf ||
-      additionalProperties?.anyOf)
+    additionalProperties.properties ||
+    additionalProperties.items ||
+    additionalProperties.allOf ||
+    additionalProperties.additionalProperties ||
+    additionalProperties.oneOf ||
+    additionalProperties.anyOf
   ) {
     const title = additionalProperties.title as string;
     const schemaName = getSchemaName(additionalProperties);
@@ -190,52 +193,27 @@ function createAdditionalProperties(schema: SchemaObject) {
     );
   }
 
+  // primitive types
   if (
-    (schema.additionalProperties?.type as string) === "string" ||
-    (schema.additionalProperties?.type as string) === "object" ||
-    (schema.additionalProperties?.type as string) === "boolean" ||
-    (schema.additionalProperties?.type as string) === "integer" ||
-    (schema.additionalProperties?.type as string) === "number"
+    additionalProperties.type === "string" ||
+    additionalProperties.type === "boolean" ||
+    additionalProperties.type === "integer" ||
+    additionalProperties.type === "number"
   ) {
-    const additionalProperties =
-      schema.additionalProperties?.additionalProperties;
-    if (additionalProperties !== undefined) {
-      const type = schema.additionalProperties?.additionalProperties?.type;
-      const schemaName = getSchemaName(
-        schema.additionalProperties?.additionalProperties!
-      );
-      return create("SchemaItem", {
-        name: "property name*",
-        required: false,
-        schemaName: schemaName ?? type,
-        qualifierMessage:
-          schema.additionalProperties ??
-          getQualifierMessage(schema.additionalProperties),
-        schema: schema,
-        collapsible: false,
-        discriminator: false,
-      });
-    }
-    const schemaName = getSchemaName(schema.additionalProperties!);
+    const schemaName = getSchemaName(additionalProperties);
     return create("SchemaItem", {
       name: "property name*",
       required: false,
       schemaName: schemaName,
       qualifierMessage: getQualifierMessage(schema),
-      schema: schema.additionalProperties,
+      schema: additionalProperties,
       collapsible: false,
       discriminator: false,
     });
   }
-  return Object.entries(schema.additionalProperties!).map(([key, val]) =>
-    createEdges({
-      name: key,
-      schema: val,
-      required: Array.isArray(schema.required)
-        ? schema.required.includes(key)
-        : false,
-    })
-  );
+
+  // unknown
+  return [];
 }
 
 /**
@@ -792,7 +770,13 @@ export function createNodes(
   if (schema.allOf !== undefined) {
     const { mergedSchemas } = mergeAllOf(schema.allOf);
 
-    // allOf seems to always result in properties
+    if (
+      mergedSchemas.oneOf !== undefined ||
+      mergedSchemas.anyOf !== undefined
+    ) {
+      nodes.push(createAnyOneOf(mergedSchemas));
+    }
+
     if (mergedSchemas.properties !== undefined) {
       nodes.push(createProperties(mergedSchemas));
     }

package/src/openapi/types.ts

@@ -341,7 +341,7 @@ export type SchemaObject = Omit<
   not?: SchemaObject;
   items?: SchemaObject;
   properties?: Map<SchemaObject>;
-  additionalProperties?: Map<SchemaObject>;
+  additionalProperties?: boolean | SchemaObject;
 
   // OpenAPI additions
   nullable?: boolean;

package/src/sidebars/index.ts

@@ -93,7 +93,10 @@ function groupByTags(
       apiTags.push(tag.name!);
     }
   });
-  apiTags = uniq(apiTags.concat(operationTags, schemaTags));
+
+  if (sidebarOptions.groupPathsBy !== "tagGroup") {
+    apiTags = uniq(apiTags.concat(operationTags, schemaTags));
+  }
 
   const basePath = docPath
     ? outputDir.split(docPath!)[1].replace(/^\/+/g, "")