docusaurus-plugin-openapi-docs 1.5.1 → 1.6.0

package/lib/index.js

@@ -77,6 +77,8 @@ function pluginOpenAPIDocs(context, options) {
     let docPath = docData ? (docData.path ? docData.path : "docs") : undefined;
     async function generateApiDocs(options, pluginId) {
         let { specPath, outputDir, template, downloadUrl, sidebarOptions } = options;
+        // Remove trailing slash before proceeding
+        outputDir = outputDir.replace(/\/$/, "");
         // Override docPath if pluginId provided
         if (pluginId) {
             docData = getDocsPluginConfig(presetsPlugins, pluginId);
@@ -147,6 +149,9 @@ custom_edit_url: null
 {{#frontMatter.proxy}}
 proxy: {{{frontMatter.proxy}}}
 {{/frontMatter.proxy}}
+{{#frontMatter.hide_send_button}}
+hide_send_button: true
+{{/frontMatter.hide_send_button}}
 ---
 
 {{{markdown}}}

package/lib/markdown/createArrayBracket.d.ts

@@ -0,0 +1,2 @@
+export declare function createOpeningArrayBracket(): string;
+export declare function createClosingArrayBracket(): string;

package/lib/markdown/createArrayBracket.js

@@ -0,0 +1,37 @@
+"use strict";
+/* ============================================================================
+ * 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.
+ * ========================================================================== */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClosingArrayBracket = exports.createOpeningArrayBracket = void 0;
+const utils_1 = require("./utils");
+function createOpeningArrayBracket() {
+    return (0, utils_1.create)("li", {
+        children: (0, utils_1.create)("div", {
+            style: {
+                fontSize: "var(--ifm-code-font-size)",
+                opacity: "0.6",
+                marginLeft: "-.5rem",
+                paddingBottom: ".5rem",
+            },
+            children: ["Array ["],
+        }),
+    });
+}
+exports.createOpeningArrayBracket = createOpeningArrayBracket;
+function createClosingArrayBracket() {
+    return (0, utils_1.create)("li", {
+        children: (0, utils_1.create)("div", {
+            style: {
+                fontSize: "var(--ifm-code-font-size)",
+                opacity: "0.6",
+                marginLeft: "-.5rem",
+            },
+            children: ["]"],
+        }),
+    });
+}
+exports.createClosingArrayBracket = createClosingArrayBracket;

package/lib/markdown/createAuthentication.js

@@ -13,7 +13,7 @@ function createAuthentication(securitySchemes) {
     if (!securitySchemes || !Object.keys(securitySchemes).length)
         return "";
     const createAuthenticationTable = (securityScheme) => {
-        const { bearerFormat, flows, name, scheme, type } = securityScheme;
+        const { bearerFormat, flows, name, scheme, type, openIdConnectUrl } = securityScheme;
         const createSecuritySchemeTypeRow = () => (0, utils_1.create)("tr", {
             children: [
                 (0, utils_1.create)("th", { children: "Security Scheme Type:" }),
@@ -25,7 +25,7 @@ function createAuthentication(securitySchemes) {
                 const { authorizationUrl, tokenUrl, refreshUrl, scopes } = flowObj;
                 return (0, utils_1.create)("tr", {
                     children: [
-                        (0, utils_1.create)("th", { children: `${flowType} OAuth Flow:` }),
+                        (0, utils_1.create)("th", { children: `OAuth Flow (${flowType}):` }),
                         (0, utils_1.create)("td", {
                             children: [
                                 (0, utils_1.guard)(tokenUrl, () => (0, utils_1.create)("p", { children: `Token URL: ${tokenUrl}` })),
@@ -76,12 +76,12 @@ function createAuthentication(securitySchemes) {
                                             (0, utils_1.create)("td", { children: scheme }),
                                         ],
                                     }),
-                                    (0, utils_1.create)("tr", {
+                                    (0, utils_1.guard)(bearerFormat, () => (0, utils_1.create)("tr", {
                                         children: [
                                             (0, utils_1.create)("th", { children: "Bearer format:" }),
                                             (0, utils_1.create)("td", { children: bearerFormat }),
                                         ],
-                                    }),
+                                    })),
                                 ],
                             }),
                         }),
@@ -100,20 +100,51 @@ function createAuthentication(securitySchemes) {
                         }),
                     ],
                 });
+            case "openIdConnect":
+                return (0, utils_1.create)("div", {
+                    children: [
+                        (0, utils_1.create)("table", {
+                            children: (0, utils_1.create)("tbody", {
+                                children: [
+                                    createSecuritySchemeTypeRow(),
+                                    (0, utils_1.guard)(openIdConnectUrl, () => (0, utils_1.create)("tr", {
+                                        children: [
+                                            (0, utils_1.create)("th", { children: "OpenID Connect URL:" }),
+                                            (0, utils_1.create)("td", { children: openIdConnectUrl }),
+                                        ],
+                                    })),
+                                ],
+                            }),
+                        }),
+                    ],
+                });
             default:
                 return "";
         }
     };
-    const formatTabLabel = (str) => {
-        const formattedLabel = str
+    const formatTabLabel = (key, type, scheme) => {
+        const formattedLabel = key
             .replace(/(_|-)/g, " ")
             .trim()
             .replace(/\w\S*/g, (str) => str.charAt(0).toUpperCase() + str.substr(1))
             .replace(/([a-z])([A-Z])/g, "$1 $2")
             .replace(/([A-Z])([A-Z][a-z])/g, "$1 $2");
-        const isOAuth = formattedLabel.toLowerCase().includes("oauth2");
-        const isApiKey = formattedLabel.toLowerCase().includes("api");
-        return isOAuth ? "OAuth 2.0" : isApiKey ? "API Key" : formattedLabel;
+        const isOAuth = type === "oauth2";
+        const isApiKey = type === "apiKey";
+        const isHttpBasic = type === "http" && scheme === "basic";
+        const isHttpBearer = type === "http" && scheme === "bearer";
+        const isOpenId = type === "openIdConnect";
+        if (isOAuth)
+            return `OAuth 2.0: ${key}`;
+        if (isApiKey)
+            return `API Key: ${key}`;
+        if (isHttpBasic)
+            return "HTTP: Basic Auth";
+        if (isHttpBearer)
+            return "HTTP: Bearer Auth";
+        if (isOpenId)
+            return `OpenID Connect: ${key}`;
+        return formattedLabel;
     };
     return (0, utils_1.create)("div", {
         children: [
@@ -122,10 +153,11 @@ function createAuthentication(securitySchemes) {
                 id: "authentication",
                 style: { marginBottom: "1rem" },
             }),
-            (0, utils_1.create)("Tabs", {
-                children: Object.entries(securitySchemes).map(([schemeType, schemeObj]) => (0, utils_1.create)("TabItem", {
-                    label: formatTabLabel(schemeType),
-                    value: `${schemeType}`,
+            (0, utils_1.create)("SchemaTabs", {
+                className: "openapi-tabs__security-schemes",
+                children: Object.entries(securitySchemes).map(([schemeKey, schemeObj]) => (0, utils_1.create)("TabItem", {
+                    label: formatTabLabel(schemeKey, schemeObj.type, schemeObj.scheme),
+                    value: `${schemeKey}`,
                     children: [
                         (0, createDescription_1.createDescription)(schemeObj.description),
                         createAuthenticationTable(schemeObj),

package/lib/markdown/createRequestSchema.js

@@ -7,6 +7,7 @@
  * ========================================================================== */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRequestSchema = exports.mergeAllOf = void 0;
+const createArrayBracket_1 = require("./createArrayBracket");
 const createDescription_1 = require("./createDescription");
 const createDetails_1 = require("./createDetails");
 const createDetailsSummary_1 = require("./createDetailsSummary");
@@ -46,46 +47,55 @@ exports.mergeAllOf = mergeAllOf;
  */
 function createAnyOneOf(schema) {
     const type = schema.oneOf ? "oneOf" : "anyOf";
-    return (0, utils_1.create)("div", {
+    return (0, utils_1.create)("li", {
         children: [
-            (0, utils_1.create)("div", {
-                children: [
-                    (0, utils_1.create)("span", {
-                        className: "badge badge--info",
-                        children: type,
-                    }),
-                    (0, utils_1.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 (0, utils_1.create)("TabItem", {
-                                    label: label,
-                                    value: `${index}-item-properties`,
-                                    children: anyOneChildren,
-                                });
-                            }
-                            return undefined;
-                        }),
-                    }),
-                ],
+            (0, utils_1.create)("span", {
+                className: "badge badge--info",
+                children: type,
+            }),
+            (0, utils_1.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 (0, utils_1.create)("TabItem", {
+                                label: label,
+                                value: `${index}-item-properties`,
+                                children: [
+                                    (0, createArrayBracket_1.createOpeningArrayBracket)(),
+                                    anyOneChildren,
+                                    (0, createArrayBracket_1.createClosingArrayBracket)(),
+                                ]
+                                    .filter(Boolean)
+                                    .flat(),
+                            });
+                        }
+                        return (0, utils_1.create)("TabItem", {
+                            label: label,
+                            value: `${index}-item-properties`,
+                            children: anyOneChildren.filter(Boolean).flat(),
+                        });
+                    }
+                    return undefined;
+                }),
             }),
         ],
     });
@@ -188,15 +198,27 @@ function createAdditionalProperties(schema) {
 }
 // TODO: figure out how to handle array of objects
 function createItems(schema) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
     if (((_a = schema.items) === null || _a === void 0 ? void 0 : _a.properties) !== undefined) {
-        return createProperties(schema.items);
+        return [
+            (0, createArrayBracket_1.createOpeningArrayBracket)(),
+            createProperties(schema.items),
+            (0, createArrayBracket_1.createClosingArrayBracket)(),
+        ].flat();
     }
     if (((_b = schema.items) === null || _b === void 0 ? void 0 : _b.additionalProperties) !== undefined) {
-        return createAdditionalProperties(schema.items);
+        return [
+            (0, createArrayBracket_1.createOpeningArrayBracket)(),
+            createAdditionalProperties(schema.items),
+            (0, createArrayBracket_1.createClosingArrayBracket)(),
+        ].flat();
     }
     if (((_c = schema.items) === null || _c === void 0 ? void 0 : _c.oneOf) !== undefined || ((_d = schema.items) === null || _d === void 0 ? void 0 : _d.anyOf) !== undefined) {
-        return createAnyOneOf(schema.items);
+        return [
+            (0, createArrayBracket_1.createOpeningArrayBracket)(),
+            createAnyOneOf(schema.items),
+            (0, createArrayBracket_1.createClosingArrayBracket)(),
+        ].flat();
     }
     if (((_e = schema.items) === null || _e === void 0 ? void 0 : _e.allOf) !== undefined) {
         // TODO: figure out if and how we should pass merged required array
@@ -205,41 +227,54 @@ function createItems(schema) {
         if ((mergedSchemas.oneOf !== undefined ||
             mergedSchemas.anyOf !== undefined) &&
             mergedSchemas.properties) {
-            return (0, utils_1.create)("div", {
-                children: [
-                    createAnyOneOf(mergedSchemas),
-                    createProperties(mergedSchemas),
-                ],
-            });
+            return [
+                (0, createArrayBracket_1.createOpeningArrayBracket)(),
+                createAnyOneOf(mergedSchemas),
+                createProperties(mergedSchemas),
+                (0, createArrayBracket_1.createClosingArrayBracket)(),
+            ].flat();
         }
         // Handles only anyOf/oneOf
         if (mergedSchemas.oneOf !== undefined ||
             mergedSchemas.anyOf !== undefined) {
-            return (0, utils_1.create)("div", {
-                children: [createAnyOneOf(mergedSchemas)],
-            });
+            return [
+                (0, createArrayBracket_1.createOpeningArrayBracket)(),
+                createAnyOneOf(mergedSchemas),
+                (0, createArrayBracket_1.createClosingArrayBracket)(),
+            ].flat();
         }
         // Handles properties
         if (mergedSchemas.properties !== undefined) {
-            return (0, utils_1.create)("div", {
-                children: [createProperties(mergedSchemas)],
-            });
+            return [
+                (0, createArrayBracket_1.createOpeningArrayBracket)(),
+                createProperties(mergedSchemas),
+                (0, createArrayBracket_1.createClosingArrayBracket)(),
+            ].flat();
         }
     }
     if (((_g = schema.items) === null || _g === void 0 ? void 0 : _g.type) === "string" ||
         ((_h = schema.items) === null || _h === void 0 ? void 0 : _h.type) === "number" ||
         ((_j = schema.items) === null || _j === void 0 ? void 0 : _j.type) === "integer" ||
-        ((_k = schema.items) === null || _k === void 0 ? void 0 : _k.type) === "boolean") {
-        return createNodes(schema.items);
+        ((_k = schema.items) === null || _k === void 0 ? void 0 : _k.type) === "boolean" ||
+        ((_l = schema.items) === null || _l === void 0 ? void 0 : _l.type) === "object") {
+        return [
+            (0, createArrayBracket_1.createOpeningArrayBracket)(),
+            createNodes(schema.items),
+            (0, createArrayBracket_1.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 [
+        (0, createArrayBracket_1.createOpeningArrayBracket)(),
+        Object.entries(schema.items).map(([key, val]) => createEdges({
+            name: key,
+            schema: val,
+            required: Array.isArray(schema.required)
+                ? schema.required.includes(key)
+                : false,
+        })),
+        (0, createArrayBracket_1.createClosingArrayBracket)(),
+    ].flat();
 }
 /**
  * For handling discriminators that do not map to a same-level property
@@ -338,7 +373,7 @@ function createItems(schema) {
 //     }),
 //   });
 // }
-function createDetailsNode(name, schemaName, schema, required) {
+function createDetailsNode(name, schemaName, schema, required, nullable) {
     return (0, utils_1.create)("SchemaItem", {
         collapsible: true,
         className: "schemaItem",
@@ -352,6 +387,16 @@ function createDetailsNode(name, schemaName, schema, required) {
                                 style: { opacity: "0.6" },
                                 children: ` ${schemaName}`,
                             }),
+                            (0, utils_1.guard)((schema.nullable && schema.nullable === true) ||
+                                (nullable && nullable === true), () => [
+                                (0, utils_1.create)("strong", {
+                                    style: {
+                                        fontSize: "var(--ifm-code-font-size)",
+                                        color: "var(--openapi-nullable)",
+                                    },
+                                    children: " nullable",
+                                }),
+                            ]),
                             (0, utils_1.guard)(Array.isArray(required)
                                 ? required.includes(name)
                                 : required === true, () => [
@@ -454,24 +499,24 @@ function createEdges({ name, schema, required, discriminator, }) {
         return createPropertyDiscriminator(name, "string", schema, discriminator, required);
     }
     if (schema.oneOf !== undefined || schema.anyOf !== undefined) {
-        return createDetailsNode(name, schemaName, schema, required);
+        return createDetailsNode(name, schemaName, schema, required, schema.nullable);
     }
     if (schema.allOf !== undefined) {
         const { mergedSchemas, required, } = mergeAllOf(schema.allOf);
         const mergedSchemaName = (0, schema_1.getSchemaName)(mergedSchemas);
         if (mergedSchemas.oneOf !== undefined ||
             mergedSchemas.anyOf !== undefined) {
-            return createDetailsNode(name, mergedSchemaName, mergedSchemas, required);
+            return createDetailsNode(name, mergedSchemaName, mergedSchemas, required, schema.nullable);
         }
         if (mergedSchemas.properties !== undefined) {
-            return createDetailsNode(name, mergedSchemaName, mergedSchemas, required);
+            return createDetailsNode(name, mergedSchemaName, mergedSchemas, required, schema.nullable);
         }
         if (mergedSchemas.additionalProperties !== undefined) {
-            return createDetailsNode(name, mergedSchemaName, mergedSchemas, required);
+            return createDetailsNode(name, mergedSchemaName, mergedSchemas, required, schema.nullable);
         }
         // array of objects
         if (((_a = mergedSchemas.items) === null || _a === void 0 ? void 0 : _a.properties) !== undefined) {
-            return createDetailsNode(name, mergedSchemaName, mergedSchemas, required);
+            return createDetailsNode(name, mergedSchemaName, mergedSchemas, required, schema.nullable);
         }
         if (mergedSchemas.readOnly && mergedSchemas.readOnly === true) {
             return undefined;
@@ -480,25 +525,23 @@ function createEdges({ name, schema, required, discriminator, }) {
             collapsible: false,
             name,
             required: Array.isArray(required) ? required.includes(name) : required,
-            deprecated: mergedSchemas.deprecated,
-            schemaDescription: mergedSchemas.description,
             schemaName: schemaName,
             qualifierMessage: (0, schema_1.getQualifierMessage)(schema),
-            defaultValue: mergedSchemas.default,
+            schema: mergedSchemas,
         });
     }
     if (schema.properties !== undefined) {
-        return createDetailsNode(name, schemaName, schema, required);
+        return createDetailsNode(name, schemaName, schema, required, schema.nullable);
     }
     if (schema.additionalProperties !== undefined) {
-        return createDetailsNode(name, schemaName, schema, required);
+        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);
+        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);
+        return createDetailsNode(name, schemaName, schema, required, schema.nullable);
     }
     if (schema.readOnly && schema.readOnly === true) {
         return undefined;
@@ -508,39 +551,41 @@ function createEdges({ name, schema, required, discriminator, }) {
         collapsible: false,
         name,
         required: Array.isArray(required) ? required.includes(name) : required,
-        deprecated: schema.deprecated,
-        schemaDescription: schema.description,
         schemaName: schemaName,
         qualifierMessage: (0, schema_1.getQualifierMessage)(schema),
-        defaultValue: schema.default,
+        schema: schema,
     });
 }
 /**
  * Creates a hierarchical level of a schema tree. Nodes produce edges that can branch into sub-nodes with edges, recursively.
  */
 function createNodes(schema) {
+    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) {
         const { mergedSchemas } = mergeAllOf(schema.allOf);
         // 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
     if (schema.type !== undefined) {
@@ -566,9 +611,10 @@ function createNodes(schema) {
     }
     // Unknown node/schema type should return undefined
     // So far, haven't seen this hit in testing
-    return undefined;
+    return "any";
 }
 function createRequestSchema({ title, body, ...rest }) {
+    var _a;
     if (body === undefined ||
         body.content === undefined ||
         Object.keys(body).length === 0 ||
@@ -603,10 +649,6 @@ function createRequestSchema({ title, body, ...rest }) {
                                     style: { textAlign: "left" },
                                     children: [
                                         (0, utils_1.create)("strong", { children: `${title}` }),
-                                        (0, utils_1.guard)(firstBody.type === "array", (format) => (0, utils_1.create)("span", {
-                                            style: { opacity: "0.6" },
-                                            children: ` array`,
-                                        })),
                                         (0, utils_1.guard)(body.required && body.required === true, () => [
                                             (0, utils_1.create)("strong", {
                                                 style: {
@@ -641,7 +683,7 @@ function createRequestSchema({ title, body, ...rest }) {
         });
     }
     const randomFirstKey = Object.keys(body.content)[0];
-    const firstBody = body.content[randomFirstKey].schema;
+    const firstBody = (_a = body.content[randomFirstKey].schema) !== null && _a !== void 0 ? _a : body.content[randomFirstKey];
     if (firstBody === undefined) {
         return undefined;
     }