docusaurus-plugin-openapi-docs 0.0.0-429 → 0.0.0-433

package/src/markdown/createResponseSchema.ts

@@ -10,6 +10,7 @@ import { createDescription } from "./createDescription";
 import { createDetails } from "./createDetails";
 import { createDetailsSummary } from "./createDetailsSummary";
 import {
+  createExampleFromSchema,
   createResponseExample,
   createResponseExamples,
 } from "./createStatusCodes";
@@ -290,106 +291,106 @@ function createItems(schema: SchemaObject) {
 /**
  * For handling discriminators that do not map to a same-level property
  */
-function createDiscriminator(schema: SchemaObject) {
-  const discriminator = schema.discriminator;
-  const propertyName = discriminator?.propertyName;
-  const propertyType = "string"; // should always be string
-  const mapping: any = discriminator?.mapping;
-
-  // Explicit mapping is required since we can't support implicit
-  if (mapping === undefined) {
-    return undefined;
-  }
-
-  // Attempt to get the property description we want to display
-  // TODO: how to make it predictable when handling allOf
-  let propertyDescription;
-  const firstMappingSchema = mapping[Object.keys(mapping)[0]];
-  if (firstMappingSchema.properties !== undefined) {
-    propertyDescription =
-      firstMappingSchema.properties![propertyName!].description;
-  }
-  if (firstMappingSchema.allOf !== undefined) {
-    const { mergedSchemas }: { mergedSchemas: SchemaObject } = mergeAllOf(
-      firstMappingSchema.allOf
-    );
-    if (mergedSchemas.properties !== undefined) {
-      propertyDescription =
-        mergedSchemas.properties[propertyName!]?.description;
-    }
-  }
-
-  if (propertyDescription === undefined) {
-    if (
-      schema.properties !== undefined &&
-      schema.properties![propertyName!] !== undefined
-    ) {
-      propertyDescription = schema.properties![propertyName!].description;
-    }
-  }
-
-  return create("div", {
-    className: "discriminatorItem",
-    children: create("div", {
-      children: [
-        create("strong", {
-          style: { paddingLeft: "1rem" },
-          children: propertyName,
-        }),
-        guard(propertyType, (name) =>
-          create("span", {
-            style: { opacity: "0.6" },
-            children: ` ${propertyType}`,
-          })
-        ),
-        guard(getQualifierMessage(schema.discriminator as any), (message) =>
-          create("div", {
-            style: {
-              paddingLeft: "1rem",
-            },
-            children: createDescription(message),
-          })
-        ),
-        guard(propertyDescription, (description) =>
-          create("div", {
-            style: {
-              paddingLeft: "1rem",
-            },
-            children: createDescription(description),
-          })
-        ),
-        create("DiscriminatorTabs", {
-          children: Object.keys(mapping!).map((key, index) => {
-            if (mapping[key].allOf !== undefined) {
-              const { mergedSchemas }: { mergedSchemas: SchemaObject } =
-                mergeAllOf(mapping[key].allOf);
-              // Cleanup duplicate property from mapping schema
-              delete mergedSchemas.properties![propertyName!];
-              mapping[key] = mergedSchemas;
-            }
-
-            if (mapping[key].properties !== undefined) {
-              // Cleanup duplicate property from mapping schema
-              delete mapping[key].properties![propertyName!];
-            }
-
-            const label = key;
-            return create("TabItem", {
-              label: label,
-              value: `${index}-item-discriminator`,
-              children: [
-                create("div", {
-                  style: { marginLeft: "-4px" },
-                  children: createNodes(mapping[key]),
-                }),
-              ],
-            });
-          }),
-        }),
-      ],
-    }),
-  });
-}
+// function createDiscriminator(schema: SchemaObject) {
+//   const discriminator = schema.discriminator;
+//   const propertyName = discriminator?.propertyName;
+//   const propertyType = "string"; // should always be string
+//   const mapping: any = discriminator?.mapping;
+
+//   // Explicit mapping is required since we can't support implicit
+//   if (mapping === undefined) {
+//     return undefined;
+//   }
+
+//   // Attempt to get the property description we want to display
+//   // TODO: how to make it predictable when handling allOf
+//   let propertyDescription;
+//   const firstMappingSchema = mapping[Object.keys(mapping)[0]];
+//   if (firstMappingSchema.properties !== undefined) {
+//     propertyDescription =
+//       firstMappingSchema.properties![propertyName!].description;
+//   }
+//   if (firstMappingSchema.allOf !== undefined) {
+//     const { mergedSchemas }: { mergedSchemas: SchemaObject } = mergeAllOf(
+//       firstMappingSchema.allOf
+//     );
+//     if (mergedSchemas.properties !== undefined) {
+//       propertyDescription =
+//         mergedSchemas.properties[propertyName!]?.description;
+//     }
+//   }
+
+//   if (propertyDescription === undefined) {
+//     if (
+//       schema.properties !== undefined &&
+//       schema.properties![propertyName!] !== undefined
+//     ) {
+//       propertyDescription = schema.properties![propertyName!].description;
+//     }
+//   }
+
+//   return create("div", {
+//     className: "discriminatorItem",
+//     children: create("div", {
+//       children: [
+//         create("strong", {
+//           style: { paddingLeft: "1rem" },
+//           children: propertyName,
+//         }),
+//         guard(propertyType, (name) =>
+//           create("span", {
+//             style: { opacity: "0.6" },
+//             children: ` ${propertyType}`,
+//           })
+//         ),
+//         guard(getQualifierMessage(schema.discriminator as any), (message) =>
+//           create("div", {
+//             style: {
+//               paddingLeft: "1rem",
+//             },
+//             children: createDescription(message),
+//           })
+//         ),
+//         guard(propertyDescription, (description) =>
+//           create("div", {
+//             style: {
+//               paddingLeft: "1rem",
+//             },
+//             children: createDescription(description),
+//           })
+//         ),
+//         create("DiscriminatorTabs", {
+//           children: Object.keys(mapping!).map((key, index) => {
+//             if (mapping[key].allOf !== undefined) {
+//               const { mergedSchemas }: { mergedSchemas: SchemaObject } =
+//                 mergeAllOf(mapping[key].allOf);
+//               // Cleanup duplicate property from mapping schema
+//               delete mergedSchemas.properties![propertyName!];
+//               mapping[key] = mergedSchemas;
+//             }
+
+//             if (mapping[key].properties !== undefined) {
+//               // Cleanup duplicate property from mapping schema
+//               delete mapping[key].properties![propertyName!];
+//             }
+
+//             const label = key;
+//             return create("TabItem", {
+//               label: label,
+//               value: `${index}-item-discriminator`,
+//               children: [
+//                 create("div", {
+//                   style: { marginLeft: "-4px" },
+//                   children: createNodes(mapping[key]),
+//                 }),
+//               ],
+//             });
+//           }),
+//         }),
+//       ],
+//     }),
+//   });
+// }
 
 function createDetailsNode(
   name: string,
@@ -628,9 +629,9 @@ 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 {
-  if (schema.discriminator !== undefined) {
-    return createDiscriminator(schema);
-  }
+  // if (schema.discriminator !== undefined) {
+  //   return createDiscriminator(schema);
+  // }
 
   if (schema.oneOf !== undefined || schema.anyOf !== undefined) {
     return createAnyOneOf(schema);
@@ -748,7 +749,7 @@ export function createResponseSchema({ title, body, ...rest }: Props) {
               groupId: "schema-tabs",
               children: [
                 firstBody &&
-                  create("TabTtem", {
+                  create("TabItem", {
                     label: `${title}`,
                     value: `${title}`,
                     children: [
@@ -803,8 +804,11 @@ export function createResponseSchema({ title, body, ...rest }: Props) {
                       }),
                     ],
                   }),
-                responseExamples && createResponseExamples(responseExamples),
-                responseExample && createResponseExample(responseExample),
+                firstBody && createExampleFromSchema(firstBody, mimeType),
+                responseExamples &&
+                  createResponseExamples(responseExamples, mimeType),
+                responseExample &&
+                  createResponseExample(responseExample, mimeType),
               ],
             }),
           ],

package/src/markdown/createStatusCodes.ts

@@ -5,6 +5,9 @@
  * LICENSE file in the root directory of this source tree.
  * ========================================================================== */
 
+import format from "xml-formatter";
+
+import { sampleResponseFromSchema } from "../openapi/createResponseExample";
 import { ApiItem } from "../types";
 import { createDescription } from "./createDescription";
 import { createDetails } from "./createDetails";
@@ -13,6 +16,43 @@ import { createResponseSchema } from "./createResponseSchema";
 import { create } from "./utils";
 import { guard } from "./utils";
 
+export default function json2xml(o: any, tab: any) {
+  var toXml = function (v: any, name: string, ind: any) {
+      var xml = "";
+      if (v instanceof Array) {
+        for (var i = 0, n = v.length; i < n; i++)
+          xml += ind + toXml(v[i], name, ind + "\t") + "\n";
+      } else if (typeof v == "object") {
+        var hasChild = false;
+        xml += ind + "<" + name;
+        for (var m in v) {
+          if (m.charAt(0) === "@")
+            xml += " " + m.substr(1) + '="' + v[m].toString() + '"';
+          else hasChild = true;
+        }
+        xml += hasChild ? ">" : "/>";
+        if (hasChild) {
+          for (var m2 in v) {
+            if (m2 === "#text") xml += v[m2];
+            else if (m2 === "#cdata") xml += "<![CDATA[" + v[m2] + "]]>";
+            else if (m2.charAt(0) !== "@") xml += toXml(v[m2], m2, ind + "\t");
+          }
+          xml +=
+            (xml.charAt(xml.length - 1) === "\n" ? ind : "") +
+            "</" +
+            name +
+            ">";
+        }
+      } else {
+        xml += ind + "<" + name + ">" + v.toString() + "</" + name + ">";
+      }
+      return xml;
+    },
+    xml = "";
+  for (var m3 in o) xml += toXml(o[m3], m3, "");
+  return tab ? xml.replace(/\t/g, tab) : xml.replace(/\t|\n/g, "");
+}
+
 interface Props {
   responses: ApiItem["responses"];
 }
@@ -67,7 +107,17 @@ function createResponseHeaders(responseHeaders: any) {
   );
 }
 
-export function createResponseExamples(responseExamples: any) {
+export function createResponseExamples(
+  responseExamples: any,
+  mimeType: string
+) {
+  let language = "shell";
+  if (mimeType.endsWith("json")) {
+    language = "json";
+  }
+  if (mimeType.endsWith("xml")) {
+    language = "xml";
+  }
   return Object.entries(responseExamples).map(
     ([exampleName, exampleValue]: any) => {
       const camelToSpaceName = exampleName.replace(/([A-Z])/g, " $1");
@@ -81,6 +131,7 @@ export function createResponseExamples(responseExamples: any) {
           children: [
             create("ResponseSamples", {
               responseExample: JSON.stringify(exampleValue.value, null, 2),
+              language: language,
             }),
           ],
         });
@@ -91,6 +142,7 @@ export function createResponseExamples(responseExamples: any) {
         children: [
           create("ResponseSamples", {
             responseExample: exampleValue.value,
+            language: language,
           }),
         ],
       });
@@ -98,7 +150,14 @@ export function createResponseExamples(responseExamples: any) {
   );
 }
 
-export function createResponseExample(responseExample: any) {
+export function createResponseExample(responseExample: any, mimeType: string) {
+  let language = "shell";
+  if (mimeType.endsWith("json")) {
+    language = "json";
+  }
+  if (mimeType.endsWith("xml")) {
+    language = "xml";
+  }
   if (typeof responseExample === "object") {
     return create("TabItem", {
       label: `Example`,
@@ -106,6 +165,7 @@ export function createResponseExample(responseExample: any) {
       children: [
         create("ResponseSamples", {
           responseExample: JSON.stringify(responseExample, null, 2),
+          language: language,
         }),
       ],
     });
@@ -116,11 +176,69 @@ export function createResponseExample(responseExample: any) {
     children: [
       create("ResponseSamples", {
         responseExample: responseExample,
+        language: language,
       }),
     ],
   });
 }
 
+export function createExampleFromSchema(schema: any, mimeType: string) {
+  const responseExample = sampleResponseFromSchema(schema);
+  if (mimeType.endsWith("xml")) {
+    let responseExampleObject;
+    try {
+      responseExampleObject = JSON.parse(JSON.stringify(responseExample));
+    } catch {
+      return undefined;
+    }
+
+    if (typeof responseExampleObject === "object") {
+      let xmlExample;
+      try {
+        xmlExample = format(json2xml(responseExampleObject, ""), {
+          indentation: "  ",
+          lineSeparator: "\n",
+          collapseContent: true,
+        });
+      } catch {
+        const xmlExampleWithRoot = { root: responseExampleObject };
+        try {
+          xmlExample = format(json2xml(xmlExampleWithRoot, ""), {
+            indentation: "  ",
+            lineSeparator: "\n",
+            collapseContent: true,
+          });
+        } catch {
+          xmlExample = json2xml(responseExampleObject, "");
+        }
+      }
+      return create("TabItem", {
+        label: `Example (from schema)`,
+        value: `Example (from schema)`,
+        children: [
+          create("ResponseSamples", {
+            responseExample: xmlExample,
+            language: "xml",
+          }),
+        ],
+      });
+    }
+  }
+  if (typeof responseExample === "object") {
+    return create("TabItem", {
+      label: `Example (from schema)`,
+      value: `Example (from schema)`,
+      children: [
+        create("ResponseSamples", {
+          responseExample: JSON.stringify(responseExample, null, 2),
+          language: "json",
+        }),
+      ],
+    });
+  }
+  return undefined;
+}
+
 export function createStatusCodes({ responses }: Props) {
   if (responses === undefined) {
     return undefined;
@@ -147,8 +265,8 @@ export function createStatusCodes({ responses }: Props) {
               }),
               responseHeaders &&
                 createDetails({
-                  "data-collaposed": false,
-                  open: true,
+                  "data-collaposed": true,
+                  open: false,
                   style: { textAlign: "left", marginBottom: "1rem" },
                   children: [
                     createDetailsSummary({

package/src/openapi/{createExample.ts → createRequestExample.ts}

@@ -51,14 +51,48 @@ const primitives: Primitives = {
   array: {},
 };
 
-export const sampleFromSchema = (schema: SchemaObject = {}): any => {
+function sampleRequestFromProp(name: string, prop: any, obj: any): any {
+  // Handle resolved circular props
+  if (typeof prop === "object" && Object.keys(prop).length === 0) {
+    obj[name] = prop;
+    return obj;
+  }
+
+  // TODO: handle discriminators
+
+  if (prop.oneOf) {
+    obj[name] = sampleRequestFromSchema(prop.oneOf[0]);
+  } else if (prop.anyOf) {
+    obj[name] = sampleRequestFromSchema(prop.anyOf[0]);
+  } else if (prop.allOf) {
+    const { mergedSchemas }: { mergedSchemas: SchemaObject } = mergeAllOf(
+      prop.allOf
+    );
+    sampleRequestFromProp(name, mergedSchemas, obj);
+  } else {
+    obj[name] = sampleRequestFromSchema(prop);
+  }
+  return obj;
+}
+
+export const sampleRequestFromSchema = (schema: SchemaObject = {}): any => {
   try {
-    let { type, example, allOf, properties, items } = schema;
+    let { type, example, allOf, properties, items, oneOf, anyOf } = schema;
 
     if (example !== undefined) {
       return example;
     }
 
+    if (oneOf) {
+      // Just go with first schema
+      return sampleRequestFromSchema(oneOf[0]);
+    }
+
+    if (anyOf) {
+      // Just go with first schema
+      return sampleRequestFromSchema(anyOf[0]);
+    }
+
     if (allOf) {
       const { mergedSchemas }: { mergedSchemas: SchemaObject } =
         mergeAllOf(allOf);
@@ -69,7 +103,7 @@ export const sampleFromSchema = (schema: SchemaObject = {}): any => {
           }
         }
       }
-      return sampleFromSchema(mergedSchemas);
+      return sampleRequestFromSchema(mergedSchemas);
     }
 
     if (!type) {
@@ -104,21 +138,23 @@ export const sampleFromSchema = (schema: SchemaObject = {}): any => {
         if (prop.deprecated) {
           continue;
         }
-        obj[name] = sampleFromSchema(prop);
+
+        // Resolve schema from prop recursively
+        obj = sampleRequestFromProp(name, prop, obj);
       }
       return obj;
     }
 
     if (type === "array") {
       if (Array.isArray(items?.anyOf)) {
-        return items?.anyOf.map((item) => sampleFromSchema(item));
+        return items?.anyOf.map((item) => sampleRequestFromSchema(item));
       }
 
       if (Array.isArray(items?.oneOf)) {
-        return items?.oneOf.map((item) => sampleFromSchema(item));
+        return items?.oneOf.map((item) => sampleRequestFromSchema(item));
       }
 
-      return [sampleFromSchema(items)];
+      return [sampleRequestFromSchema(items)];
     }
 
     if (schema.enum) {