docusaurus-plugin-openapi-docs 1.5.1 → 1.5.2

package/lib/markdown/createStatusCodes.js

@@ -110,12 +110,10 @@ function createResponseExamples(responseExamples, mimeType) {
         language = "xml";
     }
     return Object.entries(responseExamples).map(([exampleName, exampleValue]) => {
-        const camelToSpaceName = exampleName.replace(/([A-Z])/g, " $1");
-        let finalFormattedName = camelToSpaceName.charAt(0).toUpperCase() + camelToSpaceName.slice(1);
         if (typeof exampleValue.value === "object") {
             return (0, utils_1.create)("TabItem", {
-                label: `${finalFormattedName}`,
-                value: `${finalFormattedName}`,
+                label: `${exampleName}`,
+                value: `${exampleName}`,
                 children: [
                     (0, utils_2.guard)(exampleValue.summary, (summary) => [
                         (0, utils_1.create)("p", {
@@ -130,8 +128,8 @@ function createResponseExamples(responseExamples, mimeType) {
             });
         }
         return (0, utils_1.create)("TabItem", {
-            label: `${finalFormattedName}`,
-            value: `${finalFormattedName}`,
+            label: `${exampleName}`,
+            value: `${exampleName}`,
             children: [
                 (0, utils_2.guard)(exampleValue.summary, (summary) => [
                     (0, utils_1.create)("p", {

package/lib/openapi/createRequestExample.js

@@ -11,6 +11,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sampleRequestFromSchema = void 0;
 const chalk_1 = __importDefault(require("chalk"));
+const merge_1 = __importDefault(require("lodash/merge"));
 const createRequestSchema_1 = require("../markdown/createRequestSchema");
 const primitives = {
     string: {
@@ -60,15 +61,27 @@ function sampleRequestFromProp(name, prop, obj) {
 }
 const sampleRequestFromSchema = (schema = {}) => {
     try {
-        let { type, example, allOf, properties, items, oneOf, anyOf } = schema;
+        // deep copy schema before processing
+        let schemaCopy = JSON.parse(JSON.stringify(schema));
+        let { type, example, allOf, properties, items, oneOf, anyOf } = schemaCopy;
         if (example !== undefined) {
             return example;
         }
         if (oneOf) {
+            if (properties) {
+                const combinedSchemas = (0, merge_1.default)(schemaCopy, oneOf[0]);
+                delete combinedSchemas.oneOf;
+                return (0, exports.sampleRequestFromSchema)(combinedSchemas);
+            }
             // Just go with first schema
             return (0, exports.sampleRequestFromSchema)(oneOf[0]);
         }
         if (anyOf) {
+            if (properties) {
+                const combinedSchemas = (0, merge_1.default)(schemaCopy, anyOf[0]);
+                delete combinedSchemas.anyOf;
+                return (0, exports.sampleRequestFromSchema)(combinedSchemas);
+            }
             // Just go with first schema
             return (0, exports.sampleRequestFromSchema)(anyOf[0]);
         }
@@ -81,6 +94,11 @@ const sampleRequestFromSchema = (schema = {}) => {
                     }
                 }
             }
+            if (properties) {
+                const combinedSchemas = (0, merge_1.default)(schemaCopy, mergedSchemas);
+                delete combinedSchemas.allOf;
+                return (0, exports.sampleRequestFromSchema)(combinedSchemas);
+            }
             return (0, exports.sampleRequestFromSchema)(mergedSchemas);
         }
         if (!type) {
@@ -133,16 +151,17 @@ const sampleRequestFromSchema = (schema = {}) => {
             }
             return [(0, exports.sampleRequestFromSchema)(items)];
         }
-        if (schema.enum) {
-            if (schema.default) {
-                return schema.default;
+        if (schemaCopy.enum) {
+            if (schemaCopy.default) {
+                return schemaCopy.default;
             }
-            return normalizeArray(schema.enum)[0];
+            return normalizeArray(schemaCopy.enum)[0];
         }
-        if ((schema.readOnly && schema.readOnly === true) || schema.deprecated) {
+        if ((schema.readOnly && schema.readOnly === true) ||
+            schemaCopy.deprecated) {
             return undefined;
         }
-        return primitive(schema);
+        return primitive(schemaCopy);
     }
     catch (err) {
         console.error(chalk_1.default.yellow("WARNING: failed to create example from schema object:", err));

package/lib/openapi/createResponseExample.js

@@ -11,6 +11,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sampleResponseFromSchema = void 0;
 const chalk_1 = __importDefault(require("chalk"));
+const merge_1 = __importDefault(require("lodash/merge"));
 const createResponseSchema_1 = require("../markdown/createResponseSchema");
 const primitives = {
     string: {
@@ -60,7 +61,9 @@ function sampleResponseFromProp(name, prop, obj) {
 }
 const sampleResponseFromSchema = (schema = {}) => {
     try {
-        let { type, example, allOf, oneOf, anyOf, properties, items } = schema;
+        // deep copy schema before processing
+        let schemaCopy = JSON.parse(JSON.stringify(schema));
+        let { type, example, allOf, properties, items, oneOf, anyOf } = schemaCopy;
         if (example !== undefined) {
             return example;
         }
@@ -74,13 +77,28 @@ const sampleResponseFromSchema = (schema = {}) => {
                     }
                 }
             }
+            if (properties) {
+                const combinedSchemas = (0, merge_1.default)(schemaCopy, mergedSchemas);
+                delete combinedSchemas.allOf;
+                return (0, exports.sampleResponseFromSchema)(combinedSchemas);
+            }
             return (0, exports.sampleResponseFromSchema)(mergedSchemas);
         }
         if (oneOf) {
+            if (properties) {
+                const combinedSchemas = (0, merge_1.default)(schemaCopy, oneOf[0]);
+                delete combinedSchemas.oneOf;
+                return (0, exports.sampleResponseFromSchema)(combinedSchemas);
+            }
             // Just go with first schema
             return (0, exports.sampleResponseFromSchema)(oneOf[0]);
         }
         if (anyOf) {
+            if (properties) {
+                const combinedSchemas = (0, merge_1.default)(schemaCopy, anyOf[0]);
+                delete combinedSchemas.anyOf;
+                return (0, exports.sampleResponseFromSchema)(combinedSchemas);
+            }
             // Just go with first schema
             return (0, exports.sampleResponseFromSchema)(anyOf[0]);
         }
@@ -134,16 +152,17 @@ const sampleResponseFromSchema = (schema = {}) => {
             }
             return [(0, exports.sampleResponseFromSchema)(items)];
         }
-        if (schema.enum) {
-            if (schema.default) {
-                return schema.default;
+        if (schemaCopy.enum) {
+            if (schemaCopy.default) {
+                return schemaCopy.default;
             }
-            return normalizeArray(schema.enum)[0];
+            return normalizeArray(schemaCopy.enum)[0];
         }
-        if ((schema.writeOnly && schema.writeOnly === true) || schema.deprecated) {
+        if ((schemaCopy.writeOnly && schemaCopy.writeOnly === true) ||
+            schemaCopy.deprecated) {
             return undefined;
         }
-        return primitive(schema);
+        return primitive(schemaCopy);
     }
     catch (err) {
         console.error(chalk_1.default.yellow("WARNING: failed to create example from schema object:", err));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "docusaurus-plugin-openapi-docs",
   "description": "OpenAPI plugin for Docusaurus.",
-  "version": "1.5.1",
+  "version": "1.5.2",
   "license": "MIT",
   "keywords": [
     "openapi",
@@ -68,5 +68,5 @@
   "engines": {
     "node": ">=14"
   },
-  "gitHead": "11d2c2fdb2bc81048097b05bc65698777d54e456"
+  "gitHead": "fa3096190356c0161a8e255b9950857a7b131eef"
 }

package/src/markdown/createArrayBracket.ts

@@ -0,0 +1,35 @@
+/* ============================================================================
+ * Copyright (c) Palo Alto Networks
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ * ========================================================================== */
+
+import { create } from "./utils";
+
+export function createOpeningArrayBracket() {
+  return create("li", {
+    children: create("div", {
+      style: {
+        fontSize: "var(--ifm-code-font-size)",
+        opacity: "0.6",
+        marginLeft: "-.5rem",
+        paddingBottom: ".5rem",
+      },
+      children: ["Array ["],
+    }),
+  });
+}
+
+export function createClosingArrayBracket() {
+  return create("li", {
+    children: create("div", {
+      style: {
+        fontSize: "var(--ifm-code-font-size)",
+        opacity: "0.6",
+        marginLeft: "-.5rem",
+      },
+      children: ["]"],
+    }),
+  });
+}

package/src/markdown/createRequestSchema.ts

@@ -6,6 +6,10 @@
  * ========================================================================== */
 
 import { MediaTypeObject, SchemaObject } from "../openapi/types";
+import {
+  createClosingArrayBracket,
+  createOpeningArrayBracket,
+} from "./createArrayBracket";
 import { createDescription } from "./createDescription";
 import { createDetails } from "./createDetails";
 import { createDetailsSummary } from "./createDetailsSummary";
@@ -49,54 +53,62 @@ export function mergeAllOf(allOf: SchemaObject[]) {
  */
 function createAnyOneOf(schema: SchemaObject): any {
   const type = schema.oneOf ? "oneOf" : "anyOf";
-  return create("div", {
+  return create("li", {
     children: [
-      create("div", {
-        children: [
-          create("span", {
-            className: "badge badge--info",
-            children: type,
-          }),
-          create("SchemaTabs", {
-            children: schema[type]!.map((anyOneSchema, index) => {
-              const label = anyOneSchema.title
-                ? anyOneSchema.title
-                : `MOD${index + 1}`;
-              const anyOneChildren = [];
-
-              if (anyOneSchema.properties !== undefined) {
-                anyOneChildren.push(createProperties(anyOneSchema));
-              }
-
-              if (anyOneSchema.allOf !== undefined) {
-                anyOneChildren.push(createNodes(anyOneSchema));
-              }
-
-              if (anyOneSchema.items !== undefined) {
-                anyOneChildren.push(createItems(anyOneSchema));
-              }
-
-              if (
-                anyOneSchema.type === "string" ||
-                anyOneSchema.type === "number" ||
-                anyOneSchema.type === "integer" ||
-                anyOneSchema.type === "boolean"
-              ) {
-                anyOneChildren.push(createNodes(anyOneSchema));
-              }
-
-              if (anyOneChildren.length) {
-                return create("TabItem", {
-                  label: label,
-                  value: `${index}-item-properties`,
-                  children: anyOneChildren,
-                });
-              }
-
-              return undefined;
-            }),
-          }),
-        ],
+      create("span", {
+        className: "badge badge--info",
+        children: type,
+      }),
+      create("SchemaTabs", {
+        children: schema[type]!.map((anyOneSchema, index) => {
+          const label = anyOneSchema.title
+            ? anyOneSchema.title
+            : `MOD${index + 1}`;
+          const anyOneChildren = [];
+
+          if (anyOneSchema.properties !== undefined) {
+            anyOneChildren.push(createProperties(anyOneSchema));
+          }
+
+          if (anyOneSchema.allOf !== undefined) {
+            anyOneChildren.push(createNodes(anyOneSchema));
+          }
+
+          if (anyOneSchema.items !== undefined) {
+            anyOneChildren.push(createItems(anyOneSchema));
+          }
+
+          if (
+            anyOneSchema.type === "string" ||
+            anyOneSchema.type === "number" ||
+            anyOneSchema.type === "integer" ||
+            anyOneSchema.type === "boolean"
+          ) {
+            anyOneChildren.push(createNodes(anyOneSchema));
+          }
+          if (anyOneChildren.length) {
+            if (schema.type === "array") {
+              return create("TabItem", {
+                label: label,
+                value: `${index}-item-properties`,
+                children: [
+                  createOpeningArrayBracket(),
+                  anyOneChildren,
+                  createClosingArrayBracket(),
+                ]
+                  .filter(Boolean)
+                  .flat(),
+              });
+            }
+            return create("TabItem", {
+              label: label,
+              value: `${index}-item-properties`,
+              children: anyOneChildren.filter(Boolean).flat(),
+            });
+          }
+
+          return undefined;
+        }),
       }),
     ],
   });
@@ -147,11 +159,11 @@ function createAdditionalProperties(schema: SchemaObject) {
   // }
 
   if (
-    schema.additionalProperties?.type === "string" ||
-    schema.additionalProperties?.type === "object" ||
-    schema.additionalProperties?.type === "boolean" ||
-    schema.additionalProperties?.type === "integer" ||
-    schema.additionalProperties?.type === "number"
+    (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"
   ) {
     const type = schema.additionalProperties?.type;
     const additionalProperties =
@@ -219,15 +231,27 @@ function createAdditionalProperties(schema: SchemaObject) {
 // TODO: figure out how to handle array of objects
 function createItems(schema: SchemaObject) {
   if (schema.items?.properties !== undefined) {
-    return createProperties(schema.items);
+    return [
+      createOpeningArrayBracket(),
+      createProperties(schema.items),
+      createClosingArrayBracket(),
+    ].flat();
   }
 
   if (schema.items?.additionalProperties !== undefined) {
-    return createAdditionalProperties(schema.items);
+    return [
+      createOpeningArrayBracket(),
+      createAdditionalProperties(schema.items),
+      createClosingArrayBracket(),
+    ].flat();
   }
 
   if (schema.items?.oneOf !== undefined || schema.items?.anyOf !== undefined) {
-    return createAnyOneOf(schema.items!);
+    return [
+      createOpeningArrayBracket(),
+      createAnyOneOf(schema.items!),
+      createClosingArrayBracket(),
+    ].flat();
   }
 
   if (schema.items?.allOf !== undefined) {
@@ -244,12 +268,12 @@ function createItems(schema: SchemaObject) {
         mergedSchemas.anyOf !== undefined) &&
       mergedSchemas.properties
     ) {
-      return create("div", {
-        children: [
-          createAnyOneOf(mergedSchemas),
-          createProperties(mergedSchemas),
-        ],
-      });
+      return [
+        createOpeningArrayBracket(),
+        createAnyOneOf(mergedSchemas),
+        createProperties(mergedSchemas),
+        createClosingArrayBracket(),
+      ].flat();
     }
 
     // Handles only anyOf/oneOf
@@ -257,16 +281,20 @@ function createItems(schema: SchemaObject) {
       mergedSchemas.oneOf !== undefined ||
       mergedSchemas.anyOf !== undefined
     ) {
-      return create("div", {
-        children: [createAnyOneOf(mergedSchemas)],
-      });
+      return [
+        createOpeningArrayBracket(),
+        createAnyOneOf(mergedSchemas),
+        createClosingArrayBracket(),
+      ].flat();
     }
 
     // Handles properties
     if (mergedSchemas.properties !== undefined) {
-      return create("div", {
-        children: [createProperties(mergedSchemas)],
-      });
+      return [
+        createOpeningArrayBracket(),
+        createProperties(mergedSchemas),
+        createClosingArrayBracket(),
+      ].flat();
     }
   }
 
@@ -274,21 +302,30 @@ function createItems(schema: SchemaObject) {
     schema.items?.type === "string" ||
     schema.items?.type === "number" ||
     schema.items?.type === "integer" ||
-    schema.items?.type === "boolean"
+    schema.items?.type === "boolean" ||
+    schema.items?.type === "object"
   ) {
-    return createNodes(schema.items);
+    return [
+      createOpeningArrayBracket(),
+      createNodes(schema.items),
+      createClosingArrayBracket(),
+    ].flat();
   }
 
   // TODO: clean this up or eliminate it?
-  return Object.entries(schema.items!).map(([key, val]) =>
-    createEdges({
-      name: key,
-      schema: val,
-      required: Array.isArray(schema.required)
-        ? schema.required.includes(key)
-        : false,
-    })
-  );
+  return [
+    createOpeningArrayBracket(),
+    Object.entries(schema.items!).map(([key, val]) =>
+      createEdges({
+        name: key,
+        schema: val,
+        required: Array.isArray(schema.required)
+          ? schema.required.includes(key)
+          : false,
+      })
+    ),
+    createClosingArrayBracket(),
+  ].flat();
 }
 
 /**
@@ -414,6 +451,15 @@ function createDetailsNode(
                 style: { opacity: "0.6" },
                 children: ` ${schemaName}`,
               }),
+              guard(schema.nullable && schema.nullable === true, () => [
+                create("strong", {
+                  style: {
+                    fontSize: "var(--ifm-code-font-size)",
+                    color: "var(--openapi-nullable)",
+                  },
+                  children: " nullable",
+                }),
+              ]),
               guard(
                 Array.isArray(required)
                   ? required.includes(name)
@@ -597,11 +643,9 @@ function createEdges({
       collapsible: false,
       name,
       required: Array.isArray(required) ? required.includes(name) : required,
-      deprecated: mergedSchemas.deprecated,
-      schemaDescription: mergedSchemas.description,
       schemaName: schemaName,
       qualifierMessage: getQualifierMessage(schema),
-      defaultValue: mergedSchemas.default,
+      schema: mergedSchemas,
     });
   }
 
@@ -631,11 +675,9 @@ function createEdges({
     collapsible: false,
     name,
     required: Array.isArray(required) ? required.includes(name) : required,
-    deprecated: schema.deprecated,
-    schemaDescription: schema.description,
     schemaName: schemaName,
     qualifierMessage: getQualifierMessage(schema),
-    defaultValue: schema.default,
+    schema: schema,
   });
 }
 
@@ -643,12 +685,13 @@ function createEdges({
  * Creates a hierarchical level of a schema tree. Nodes produce edges that can branch into sub-nodes with edges, recursively.
  */
 function createNodes(schema: SchemaObject): any {
+  const nodes = [];
   // if (schema.discriminator !== undefined) {
   //   return createDiscriminator(schema);
   // }
 
   if (schema.oneOf !== undefined || schema.anyOf !== undefined) {
-    return createAnyOneOf(schema);
+    nodes.push(createAnyOneOf(schema));
   }
 
   if (schema.allOf !== undefined) {
@@ -656,21 +699,25 @@ function createNodes(schema: SchemaObject): any {
 
     // allOf seems to always result in properties
     if (mergedSchemas.properties !== undefined) {
-      return createProperties(mergedSchemas);
+      nodes.push(createProperties(mergedSchemas));
     }
   }
 
   if (schema.properties !== undefined) {
-    return createProperties(schema);
+    nodes.push(createProperties(schema));
   }
 
   if (schema.additionalProperties !== undefined) {
-    return createAdditionalProperties(schema);
+    nodes.push(createAdditionalProperties(schema));
   }
 
   // TODO: figure out how to handle array of objects
   if (schema.items !== undefined) {
-    return createItems(schema);
+    nodes.push(createItems(schema));
+  }
+
+  if (nodes.length && nodes.length > 0) {
+    return nodes.filter(Boolean).flat();
   }
 
   // primitive
@@ -758,12 +805,6 @@ export function createRequestSchema({ title, body, ...rest }: Props) {
                   style: { textAlign: "left" },
                   children: [
                     create("strong", { children: `${title}` }),
-                    guard(firstBody.type === "array", (format) =>
-                      create("span", {
-                        style: { opacity: "0.6" },
-                        children: ` array`,
-                      })
-                    ),
                     guard(body.required && body.required === true, () => [
                       create("strong", {
                         style: {