docusaurus-plugin-openapi-docs 1.1.2 → 1.1.3

package/src/markdown/schema.test.ts

@@ -17,19 +17,19 @@ describe("getQualifierMessage", () => {
   // minLength + maxLength
   //
   it("should render minLength", () => {
-    const expected = "**Possible values:** 1 ≤ length";
+    const expected = "**Possible values:** `non-empty`";
     const actual = getQualifierMessage({ minLength: 1 });
     expect(actual).toBe(expected);
   });
 
   it("should render maxLength", () => {
-    const expected = "**Possible values:** length ≤ 40";
+    const expected = "**Possible values:** `<= 40 characters`";
     const actual = getQualifierMessage({ maxLength: 40 });
     expect(actual).toBe(expected);
   });
 
   it("should render minLength and maxLength", () => {
-    const expected = "**Possible values:** 1 ≤ length ≤ 40";
+    const expected = "**Possible values:** `non-empty` and `<= 40 characters`";
     const actual = getQualifierMessage({ minLength: 1, maxLength: 40 });
     expect(actual).toBe(expected);
   });
@@ -46,7 +46,7 @@ describe("getQualifierMessage", () => {
 
   it("should render multiple string qualifiers", () => {
     const expected =
-      "**Possible values:** 1 ≤ length ≤ 40, Value must match regular expression `^[a-zA-Z0-9_-]*$`";
+      "**Possible values:** `non-empty` and `<= 40 characters`, Value must match regular expression `^[a-zA-Z0-9_-]*$`";
     const actual = getQualifierMessage({
       minLength: 1,
       maxLength: 40,
@@ -68,49 +68,49 @@ describe("getQualifierMessage", () => {
   // minimum + maximum + exclusiveMinimum + exclusiveMaximum
   //
   it("should render minimum", () => {
-    const expected = "**Possible values:** 1 ≤ value";
+    const expected = "**Possible values:** `>= 1`";
     const actual = getQualifierMessage({ minimum: 1 });
     expect(actual).toBe(expected);
   });
 
   it("should render maximum", () => {
-    const expected = "**Possible values:** value ≤ 40";
+    const expected = "**Possible values:** `<= 40`";
     const actual = getQualifierMessage({ maximum: 40 });
     expect(actual).toBe(expected);
   });
 
   it("should render numeric exclusiveMinimum", () => {
-    const expected = "**Possible values:** 1 < value";
+    const expected = "**Possible values:** `> 1`";
     const actual = getQualifierMessage({ exclusiveMinimum: 1 });
     expect(actual).toBe(expected);
   });
 
   it("should render numeric exclusiveMaximum", () => {
-    const expected = "**Possible values:** value < 40";
+    const expected = "**Possible values:** `< 40`";
     const actual = getQualifierMessage({ exclusiveMaximum: 40 });
     expect(actual).toBe(expected);
   });
 
   it("should render boolean exclusiveMinimum", () => {
-    const expected = "**Possible values:** 1 < value";
+    const expected = "**Possible values:** `> 1`";
     const actual = getQualifierMessage({ minimum: 1, exclusiveMinimum: true });
     expect(actual).toBe(expected);
   });
 
   it("should render boolean exclusiveMaximum", () => {
-    const expected = "**Possible values:** value < 40";
+    const expected = "**Possible values:** `< 40`";
     const actual = getQualifierMessage({ maximum: 40, exclusiveMaximum: true });
     expect(actual).toBe(expected);
   });
 
   it("should render minimum when exclusiveMinimum is false", () => {
-    const expected = "**Possible values:** 1 ≤ value";
+    const expected = "**Possible values:** `>= 1`";
     const actual = getQualifierMessage({ minimum: 1, exclusiveMinimum: false });
     expect(actual).toBe(expected);
   });
 
   it("should render maximum when exclusiveMaximum is false", () => {
-    const expected = "**Possible values:** value ≤ 40";
+    const expected = "**Possible values:** `<= 40`";
     const actual = getQualifierMessage({
       maximum: 40,
       exclusiveMaximum: false,
@@ -119,13 +119,13 @@ describe("getQualifierMessage", () => {
   });
 
   it("should render minimum and maximum", () => {
-    const expected = "**Possible values:** 1 ≤ value ≤ 40";
+    const expected = "**Possible values:** `>= 1` and `<= 40`";
     const actual = getQualifierMessage({ minimum: 1, maximum: 40 });
     expect(actual).toBe(expected);
   });
 
   it("should render boolean exclusiveMinimum and maximum", () => {
-    const expected = "**Possible values:** 1 < value ≤ 40";
+    const expected = "**Possible values:** `> 1` and `<= 40`";
     const actual = getQualifierMessage({
       minimum: 1,
       maximum: 40,
@@ -135,7 +135,7 @@ describe("getQualifierMessage", () => {
   });
 
   it("should render minimum and boolean exclusiveMaximum", () => {
-    const expected = "**Possible values:** 1 ≤ value < 40";
+    const expected = "**Possible values:** `>= 1` and `< 40`";
     const actual = getQualifierMessage({
       minimum: 1,
       maximum: 40,
@@ -145,7 +145,7 @@ describe("getQualifierMessage", () => {
   });
 
   it("should render numeric exclusiveMinimum and maximum", () => {
-    const expected = "**Possible values:** 1 < value ≤ 40";
+    const expected = "**Possible values:** `> 1` and `<= 40`";
     const actual = getQualifierMessage({
       exclusiveMinimum: 1,
       maximum: 40,
@@ -154,7 +154,7 @@ describe("getQualifierMessage", () => {
   });
 
   it("should render minimum and numeric exclusiveMaximum", () => {
-    const expected = "**Possible values:** 1 ≤ value < 40";
+    const expected = "**Possible values:** `>= 1` and `< 40`";
     const actual = getQualifierMessage({
       minimum: 1,
       exclusiveMaximum: 40,
@@ -163,7 +163,7 @@ describe("getQualifierMessage", () => {
   });
 
   it("should render numeric exclusiveMinimum and boolean exclusiveMaximum", () => {
-    const expected = "**Possible values:** 1 < value < 40";
+    const expected = "**Possible values:** `> 1` and `< 40`";
     const actual = getQualifierMessage({
       exclusiveMinimum: 1,
       maximum: 40,

package/src/markdown/schema.ts

@@ -64,7 +64,11 @@ export function getQualifierMessage(schema?: SchemaObject): string | undefined {
     return undefined;
   }
 
-  if (schema.items) {
+  if (
+    schema.items &&
+    schema.minItems === undefined &&
+    schema.maxItems === undefined
+  ) {
     return getQualifierMessage(schema.items);
   }
 
@@ -72,15 +76,38 @@ export function getQualifierMessage(schema?: SchemaObject): string | undefined {
 
   let qualifierGroups = [];
 
+  if (schema.items && schema.items.enum) {
+    if (schema.items.enum) {
+      qualifierGroups.push(
+        `[${schema.items.enum.map((e) => `\`${e}\``).join(", ")}]`
+      );
+    }
+  }
+
   if (schema.minLength || schema.maxLength) {
     let lengthQualifier = "";
-    if (schema.minLength) {
-      lengthQualifier += `${schema.minLength} ≤ `;
+    let minLength;
+    let maxLength;
+    if (schema.minLength && schema.minLength > 1) {
+      minLength = `\`>= ${schema.minLength} characters\``;
+    }
+    if (schema.minLength && schema.minLength === 1) {
+      minLength = `\`non-empty\``;
     }
-    lengthQualifier += "length";
     if (schema.maxLength) {
-      lengthQualifier += ` ≤ ${schema.maxLength}`;
+      maxLength = `\`<= ${schema.maxLength} characters\``;
+    }
+
+    if (minLength && !maxLength) {
+      lengthQualifier += minLength;
+    }
+    if (maxLength && !minLength) {
+      lengthQualifier += maxLength;
     }
+    if (minLength && maxLength) {
+      lengthQualifier += `${minLength} and ${maxLength}`;
+    }
+
     qualifierGroups.push(lengthQualifier);
   }
 
@@ -91,21 +118,33 @@ export function getQualifierMessage(schema?: SchemaObject): string | undefined {
     typeof schema.exclusiveMaximum === "number"
   ) {
     let minmaxQualifier = "";
+    let minimum;
+    let maximum;
     if (typeof schema.exclusiveMinimum === "number") {
-      minmaxQualifier += `${schema.exclusiveMinimum} < `;
+      minimum = `\`> ${schema.exclusiveMinimum}\``;
     } else if (schema.minimum && !schema.exclusiveMinimum) {
-      minmaxQualifier += `${schema.minimum} ≤ `;
+      minimum = `\`>= ${schema.minimum}\``;
     } else if (schema.minimum && schema.exclusiveMinimum === true) {
-      minmaxQualifier += `${schema.minimum} < `;
+      minimum = `\`> ${schema.minimum}\``;
     }
-    minmaxQualifier += "value";
     if (typeof schema.exclusiveMaximum === "number") {
-      minmaxQualifier += ` < ${schema.exclusiveMaximum}`;
+      maximum = `\`< ${schema.exclusiveMaximum}\``;
     } else if (schema.maximum && !schema.exclusiveMaximum) {
-      minmaxQualifier += ` ≤ ${schema.maximum}`;
+      maximum = `\`<= ${schema.maximum}\``;
     } else if (schema.maximum && schema.exclusiveMaximum === true) {
-      minmaxQualifier += ` < ${schema.maximum}`;
+      maximum = `\`< ${schema.maximum}\``;
+    }
+
+    if (minimum && !maximum) {
+      minmaxQualifier += minimum;
+    }
+    if (maximum && !minimum) {
+      minmaxQualifier += maximum;
     }
+    if (minimum && maximum) {
+      minmaxQualifier += `${minimum} and ${maximum}`;
+    }
+
     qualifierGroups.push(minmaxQualifier);
   }
 
@@ -115,16 +154,23 @@ export function getQualifierMessage(schema?: SchemaObject): string | undefined {
     );
   }
 
+  // Check if discriminator mapping
+  const discriminator = schema as any;
+  if (discriminator.mapping) {
+    const values = Object.keys(discriminator.mapping);
+    qualifierGroups.push(`[${values.map((e) => `\`${e}\``).join(", ")}]`);
+  }
+
   if (schema.enum) {
     qualifierGroups.push(`[${schema.enum.map((e) => `\`${e}\``).join(", ")}]`);
   }
 
   if (schema.minItems) {
-    qualifierGroups.push(`items >= ${schema.minItems}`);
+    qualifierGroups.push(`\`>= ${schema.minItems}\``);
   }
 
   if (schema.maxItems) {
-    qualifierGroups.push(`items <= ${schema.maxItems}`);
+    qualifierGroups.push(`\`<= ${schema.maxItems}\``);
   }
 
   if (qualifierGroups.length === 0) {

package/src/openapi/openapi.ts

@@ -13,7 +13,8 @@ import sdk from "@paloaltonetworks/postman-collection";
 import Collection from "@paloaltonetworks/postman-collection";
 import chalk from "chalk";
 import fs from "fs-extra";
-import { kebabCase } from "lodash";
+import cloneDeep from "lodash/cloneDeep";
+import kebabCase from "lodash/kebabCase";
 
 import { isURL } from "../index";
 import {
@@ -54,7 +55,7 @@ async function createPostmanCollection(
   openapiData: OpenApiObject
 ): Promise<Collection> {
   // Create copy of openapiData
-  const data = Object.assign({}, openapiData) as OpenApiObject;
+  const data = cloneDeep(openapiData) as OpenApiObject;
 
   // Including `servers` breaks postman, so delete all of them.
   delete data.servers;
@@ -102,7 +103,6 @@ function createItems(
           unversionedId: tagId,
           title: description ?? "",
           description: description ?? "",
-          slug: "/" + tagId,
           frontMatter: {},
           tag: {
             ...tag,
@@ -120,7 +120,6 @@ function createItems(
       unversionedId: infoId,
       title: openapiData.info.title,
       description: openapiData.info.description,
-      slug: "/" + infoId,
       frontMatter: {},
       securitySchemes: openapiData.components?.securitySchemes,
       info: {
@@ -129,6 +128,8 @@ function createItems(
           getTagDisplayName(tagName.name!, openapiData.tags ?? [])
         ),
         title: openapiData.info.title ?? "Introduction",
+        logo: openapiData.info["x-logo"]! as any,
+        darkLogo: openapiData.info["x-dark-logo"]! as any,
       },
     };
     items.push(infoPage);
@@ -184,7 +185,6 @@ function createItems(
         unversionedId: baseId,
         title: title,
         description: description ?? "",
-        slug: "/" + baseId,
         frontMatter: {},
         api: {
           ...defaults,

package/src/openapi/types.ts

@@ -42,6 +42,14 @@ export interface InfoObject {
   license?: LicenseObject;
   version: string;
   tags?: String[];
+  "x-logo"?: LogoObject;
+  "x-dark-logo"?: LogoObject;
+  logo?: LogoObject;
+  darkLogo?: LogoObject;
+}
+
+export interface LogoObject {
+  url?: string;
 }
 
 export interface ContactObject {

package/src/openapi/utils/loadAndResolveSpec.ts

@@ -14,6 +14,7 @@ import chalk from "chalk";
 import { convertObj } from "swagger2openapi";
 
 import { OpenApiObject } from "../types";
+import { OpenAPIParser } from "./services/OpenAPIParser";
 
 function serializer(replacer: any, cycleReplacer: any) {
   var stack: any = [],
@@ -26,6 +27,18 @@ function serializer(replacer: any, cycleReplacer: any) {
     };
 
   return function (key: any, value: any) {
+    // Resolve discriminator ref pointers
+    if (value?.discriminator !== undefined) {
+      const parser = new OpenAPIParser(stack[0]);
+      for (let [k, v] of Object.entries(value.discriminator.mapping)) {
+        const discriminator = k as string;
+        if (typeof v === "string" && v.charAt(0) === "#") {
+          const ref = v as string;
+          const resolvedRef = parser.byRef(ref);
+          value.discriminator.mapping[discriminator] = resolvedRef;
+        }
+      }
+    }
     if (stack.length > 0) {
       // @ts-ignore
       var thisPos = stack.indexOf(this);

package/src/sidebars/index.ts

@@ -5,6 +5,8 @@
  * LICENSE file in the root directory of this source tree.
  * ========================================================================== */
 
+import path from "path";
+
 import {
   ProcessedSidebar,
   SidebarItemCategory,
@@ -139,8 +141,8 @@ function groupByTags(
           type: "generated-index" as "generated-index",
           title: tag,
           slug: label
-            ? "/category/" + kebabCase(label) + "/" + kebabCase(tag)
-            : "/category/" + kebabCase(tag),
+            ? path.join("/category", basePath, kebabCase(label), kebabCase(tag))
+            : path.join("/category", basePath, kebabCase(tag)),
         } as SidebarItemCategoryLinkConfig;
       }
 

package/src/types.ts

@@ -76,7 +76,7 @@ export interface ApiMetadataBase {
   description: string;
   source: string; // @site aliased source => "@site/docs/folder/subFolder/subSubFolder/myDoc.md"
   sourceDirName: string; // relative to the versioned docs folder (can be ".") => "folder/subFolder/subSubFolder"
-  slug: string;
+  slug?: string;
   permalink: string;
   sidebarPosition?: number;
   frontMatter: Record<string, unknown>;