docusaurus-theme-openapi-docs 0.0.0-1000

package/src/theme/ApiExplorer/Request/index.tsx

@@ -0,0 +1,309 @@
+/* ============================================================================
+ * 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.
+ * ========================================================================== */
+
+// @ts-nocheck
+import React, { useState } from "react";
+
+import { useDoc } from "@docusaurus/plugin-content-docs/client";
+import Accept from "@theme/ApiExplorer/Accept";
+import Authorization from "@theme/ApiExplorer/Authorization";
+import Body from "@theme/ApiExplorer/Body";
+import buildPostmanRequest from "@theme/ApiExplorer/buildPostmanRequest";
+import ContentType from "@theme/ApiExplorer/ContentType";
+import ParamOptions from "@theme/ApiExplorer/ParamOptions";
+import {
+  setResponse,
+  setCode,
+  clearCode,
+  setHeaders,
+  clearHeaders,
+} from "@theme/ApiExplorer/Response/slice";
+import Server from "@theme/ApiExplorer/Server";
+import { useTypedDispatch, useTypedSelector } from "@theme/ApiItem/hooks";
+import { ParameterObject } from "docusaurus-plugin-openapi-docs/src/openapi/types";
+import { ApiItem } from "docusaurus-plugin-openapi-docs/src/types";
+import sdk from "postman-collection";
+import { FormProvider, useForm } from "react-hook-form";
+
+import makeRequest from "./makeRequest";
+
+function Request({ item }: { item: ApiItem }) {
+  const postman = new sdk.Request(item.postman);
+  const metadata = useDoc();
+  const { proxy, hide_send_button: hideSendButton } = metadata.frontMatter;
+
+  const pathParams = useTypedSelector((state: any) => state.params.path);
+  const queryParams = useTypedSelector((state: any) => state.params.query);
+  const cookieParams = useTypedSelector((state: any) => state.params.cookie);
+  const contentType = useTypedSelector((state: any) => state.contentType.value);
+  const headerParams = useTypedSelector((state: any) => state.params.header);
+  const body = useTypedSelector((state: any) => state.body);
+  const accept = useTypedSelector((state: any) => state.accept.value);
+  const acceptOptions = useTypedDispatch((state: any) => state.accept.options);
+  const authSelected = useTypedSelector((state: any) => state.auth.selected);
+  const server = useTypedSelector((state: any) => state.server.value);
+  const serverOptions = useTypedSelector((state: any) => state.server.options);
+  const auth = useTypedSelector((state: any) => state.auth);
+  const dispatch = useTypedDispatch();
+
+  const [expandAccept, setExpandAccept] = useState(true);
+  const [expandAuth, setExpandAuth] = useState(true);
+  const [expandBody, setExpandBody] = useState(true);
+  const [expandParams, setExpandParams] = useState(true);
+  const [expandServer, setExpandServer] = useState(true);
+
+  const allParams = [
+    ...pathParams,
+    ...queryParams,
+    ...cookieParams,
+    ...headerParams,
+  ];
+
+  const postmanRequest = buildPostmanRequest(postman, {
+    queryParams,
+    pathParams,
+    cookieParams,
+    contentType,
+    accept,
+    headerParams,
+    body,
+    server,
+    auth,
+  });
+
+  const delay = (ms: number) =>
+    new Promise((resolve) => setTimeout(resolve, ms));
+
+  const paramsObject = {
+    path: [] as ParameterObject[],
+    query: [] as ParameterObject[],
+    header: [] as ParameterObject[],
+    cookie: [] as ParameterObject[],
+  };
+
+  item.parameters?.forEach(
+    (param: { in: "path" | "query" | "header" | "cookie" }) => {
+      const paramType = param.in;
+      const paramsArray: ParameterObject[] = paramsObject[paramType];
+      paramsArray.push(param as ParameterObject);
+    }
+  );
+
+  const methods = useForm({ shouldFocusError: false });
+
+  const handleEventStream = async (res) => {
+    res.headers && dispatch(setHeaders(Object.fromEntries(res.headers)));
+    dispatch(setCode(res.status));
+
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let result = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      result += decoder.decode(value, { stream: true });
+      dispatch(setResponse(result));
+    }
+  };
+
+  const handleResponse = async (res) => {
+    dispatch(setResponse(await res.text()));
+    dispatch(setCode(res.status));
+    res.headers && dispatch(setHeaders(Object.fromEntries(res.headers)));
+  };
+
+  const onSubmit = async (data) => {
+    dispatch(setResponse("Fetching..."));
+    try {
+      await delay(1200);
+      const res = await makeRequest(postmanRequest, proxy, body);
+      if (res.headers.get("content-type")?.includes("text/event-stream")) {
+        await handleEventStream(res);
+      } else {
+        await handleResponse(res);
+      }
+    } catch (e: any) {
+      console.log(e);
+      dispatch(setResponse("Connection failed"));
+      dispatch(clearCode());
+      dispatch(clearHeaders());
+    }
+  };
+
+  const showServerOptions = serverOptions.length > 0;
+  const showAcceptOptions = acceptOptions.length > 1;
+  const showRequestBody = contentType !== undefined;
+  const showRequestButton = item.servers && !hideSendButton;
+  const showAuth = authSelected !== undefined;
+  const showParams = allParams.length > 0;
+  const requestBodyRequired = item.requestBody?.required;
+
+  if (
+    !showAcceptOptions &&
+    !showAuth &&
+    !showParams &&
+    !showRequestBody &&
+    !showServerOptions
+  ) {
+    return null;
+  }
+
+  const expandAllDetails = () => {
+    setExpandAccept(true);
+    setExpandAuth(true);
+    setExpandBody(true);
+    setExpandParams(true);
+    setExpandServer(true);
+  };
+
+  const collapseAllDetails = () => {
+    setExpandAccept(false);
+    setExpandAuth(false);
+    setExpandBody(false);
+    setExpandParams(false);
+    setExpandServer(false);
+  };
+
+  const allDetailsExpanded =
+    expandParams && expandBody && expandServer && expandAuth && expandAccept;
+
+  return (
+    <FormProvider {...methods}>
+      <form
+        className="openapi-explorer__request-form"
+        onSubmit={methods.handleSubmit(onSubmit)}
+      >
+        <div className="openapi-explorer__request-header-container">
+          <span className="openapi-explorer__request-title">Request </span>
+          {allDetailsExpanded ? (
+            <span
+              className="openapi-explorer__expand-details-btn"
+              onClick={collapseAllDetails}
+            >
+              Collapse all
+            </span>
+          ) : (
+            <span
+              className="openapi-explorer__expand-details-btn"
+              onClick={expandAllDetails}
+            >
+              Expand all
+            </span>
+          )}
+        </div>
+        <div className="openapi-explorer__details-outer-container">
+          {showServerOptions && item.method !== "event" && (
+            <details
+              open={expandServer}
+              className="openapi-explorer__details-container"
+            >
+              <summary
+                className="openapi-explorer__details-summary"
+                onClick={(e) => {
+                  e.preventDefault();
+                  setExpandServer(!expandServer);
+                }}
+              >
+                Base URL
+              </summary>
+              <Server />
+            </details>
+          )}
+          {showAuth && (
+            <details
+              open={expandAuth}
+              className="openapi-explorer__details-container"
+            >
+              <summary
+                className="openapi-explorer__details-summary"
+                onClick={(e) => {
+                  e.preventDefault();
+                  setExpandAuth(!expandAuth);
+                }}
+              >
+                Auth
+              </summary>
+              <Authorization />
+            </details>
+          )}
+          {showParams && (
+            <details
+              open={
+                expandParams || Object.keys(methods.formState.errors).length
+              }
+              className="openapi-explorer__details-container"
+            >
+              <summary
+                className="openapi-explorer__details-summary"
+                onClick={(e) => {
+                  e.preventDefault();
+                  setExpandParams(!expandParams);
+                }}
+              >
+                Parameters
+              </summary>
+              <ParamOptions />
+            </details>
+          )}
+          {showRequestBody && (
+            <details
+              open={expandBody}
+              className="openapi-explorer__details-container"
+            >
+              <summary
+                className="openapi-explorer__details-summary"
+                onClick={(e) => {
+                  e.preventDefault();
+                  setExpandBody(!expandBody);
+                }}
+              >
+                Body
+                {requestBodyRequired && (
+                  <span className="openapi-schema__required">
+                    &nbsp;required
+                  </span>
+                )}
+              </summary>
+              <>
+                <ContentType />
+                <Body
+                  jsonRequestBodyExample={item.jsonRequestBodyExample}
+                  requestBodyMetadata={item.requestBody}
+                  required={requestBodyRequired}
+                />
+              </>
+            </details>
+          )}
+          {showAcceptOptions && (
+            <details
+              open={expandAccept}
+              className="openapi-explorer__details-container"
+            >
+              <summary
+                className="openapi-explorer__details-summary"
+                onClick={(e) => {
+                  e.preventDefault();
+                  setExpandAccept(!expandAccept);
+                }}
+              >
+                Accept
+              </summary>
+              <Accept />
+            </details>
+          )}
+          {showRequestButton && item.method !== "event" && (
+            <button className="openapi-explorer__request-btn" type="submit">
+              Send API Request
+            </button>
+          )}
+        </div>
+      </form>
+    </FormProvider>
+  );
+}
+
+export default Request;

package/src/theme/ApiExplorer/Request/makeRequest.ts

@@ -0,0 +1,254 @@
+/* ============================================================================
+ * 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 { Body } from "@theme/ApiExplorer/Body/slice";
+import sdk from "postman-collection";
+
+function fetchWithtimeout(
+  url: string,
+  options: RequestInit,
+  timeout = 5000
+): any {
+  return Promise.race([
+    fetch(url, options),
+    new Promise((_, reject) =>
+      setTimeout(() => reject(new Error("Request timed out")), timeout)
+    ),
+  ]);
+}
+
+async function loadImage(content: Blob): Promise<string | ArrayBuffer | null> {
+  return new Promise((accept, reject) => {
+    const reader = new FileReader();
+
+    reader.onabort = () => {
+      console.log("file reading was aborted");
+      reject();
+    };
+
+    reader.onerror = () => {
+      console.log("file reading has failed");
+      reject();
+    };
+
+    reader.onload = () => {
+      // Do whatever you want with the file contents
+      const binaryStr = reader.result;
+      accept(binaryStr);
+    };
+    reader.readAsArrayBuffer(content);
+  });
+}
+
+async function makeRequest(
+  request: sdk.Request,
+  proxy: string | undefined,
+  _body: Body
+) {
+  const headers = request.toJSON().header;
+
+  let myHeaders = new Headers();
+  if (headers) {
+    headers.forEach((header: any) => {
+      if (header.key && header.value) {
+        myHeaders.append(header.key, header.value);
+      }
+    });
+  }
+
+  // The following code handles multiple files in the same formdata param.
+  // It removes the form data params where the src property is an array of filepath strings
+  // Splits that array into different form data params with src set as a single filepath string
+  // TODO:
+  // if (request.body && request.body.mode === 'formdata') {
+  //   let formdata = request.body.formdata,
+  //     formdataArray = [];
+  //   formdata.members.forEach((param) => {
+  //     let key = param.key,
+  //       type = param.type,
+  //       disabled = param.disabled,
+  //       contentType = param.contentType;
+  //     // check if type is file or text
+  //     if (type === 'file') {
+  //       // if src is not of type string we check for array(multiple files)
+  //       if (typeof param.src !== 'string') {
+  //         // if src is an array(not empty), iterate over it and add files as separate form fields
+  //         if (Array.isArray(param.src) && param.src.length) {
+  //           param.src.forEach((filePath) => {
+  //             addFormParam(
+  //               formdataArray,
+  //               key,
+  //               param.type,
+  //               filePath,
+  //               disabled,
+  //               contentType
+  //             );
+  //           });
+  //         }
+  //         // if src is not an array or string, or is an empty array, add a placeholder for file path(no files case)
+  //         else {
+  //           addFormParam(
+  //             formdataArray,
+  //             key,
+  //             param.type,
+  //             '/path/to/file',
+  //             disabled,
+  //             contentType
+  //           );
+  //         }
+  //       }
+  //       // if src is string, directly add the param with src as filepath
+  //       else {
+  //         addFormParam(
+  //           formdataArray,
+  //           key,
+  //           param.type,
+  //           param.src,
+  //           disabled,
+  //           contentType
+  //         );
+  //       }
+  //     }
+  //     // if type is text, directly add it to formdata array
+  //     else {
+  //       addFormParam(
+  //         formdataArray,
+  //         key,
+  //         param.type,
+  //         param.value,
+  //         disabled,
+  //         contentType
+  //       );
+  //     }
+  //   });
+  //   request.body.update({
+  //     mode: 'formdata',
+  //     formdata: formdataArray,
+  //   });
+  // }
+
+  const body = request.body?.toJSON();
+
+  let myBody: RequestInit["body"] = undefined;
+  if (body !== undefined && Object.keys(body).length > 0) {
+    switch (body.mode) {
+      case "urlencoded": {
+        myBody = new URLSearchParams();
+        if (Array.isArray(body.urlencoded)) {
+          for (const data of body.urlencoded) {
+            if (data.key && data.value) {
+              myBody.append(data.key, data.value);
+            }
+          }
+        }
+        break;
+      }
+      case "raw": {
+        myBody = (body.raw ?? "").toString();
+        break;
+      }
+      case "formdata": {
+        // The Content-Type header will be set automatically based on the type of body.
+        myHeaders.delete("Content-Type");
+
+        myBody = new FormData();
+        if (Array.isArray(request.body.formdata.members)) {
+          for (const data of request.body.formdata.members) {
+            if (data.key && data.value.content) {
+              myBody.append(data.key, data.value.content);
+            }
+            // handle generic key-value payload
+            if (data.key && typeof data.value === "string") {
+              myBody.append(data.key, data.value);
+            }
+          }
+        }
+        break;
+      }
+      case "file": {
+        if (_body.type === "raw" && _body.content?.type === "file") {
+          myBody = await loadImage(_body.content.value.content);
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+
+  const requestOptions: RequestInit = {
+    method: request.method,
+    headers: myHeaders,
+    body: myBody,
+  };
+
+  let finalUrl = request.url.toString();
+  if (proxy) {
+    // Ensure the proxy ends with a slash.
+    let normalizedProxy = proxy.replace(/\/$/, "") + "/";
+    finalUrl = normalizedProxy + request.url.toString();
+  }
+
+  return fetchWithtimeout(finalUrl, requestOptions).then((response: any) => {
+    const contentType = response.headers.get("content-type");
+    let fileExtension = "";
+
+    if (contentType) {
+      if (contentType.includes("application/pdf")) {
+        fileExtension = ".pdf";
+      } else if (contentType.includes("image/jpeg")) {
+        fileExtension = ".jpg";
+      } else if (contentType.includes("image/png")) {
+        fileExtension = ".png";
+      } else if (contentType.includes("image/gif")) {
+        fileExtension = ".gif";
+      } else if (contentType.includes("image/webp")) {
+        fileExtension = ".webp";
+      } else if (contentType.includes("video/mpeg")) {
+        fileExtension = ".mpeg";
+      } else if (contentType.includes("video/mp4")) {
+        fileExtension = ".mp4";
+      } else if (contentType.includes("audio/mpeg")) {
+        fileExtension = ".mp3";
+      } else if (contentType.includes("audio/ogg")) {
+        fileExtension = ".ogg";
+      } else if (contentType.includes("application/octet-stream")) {
+        fileExtension = ".bin";
+      } else if (contentType.includes("application/zip")) {
+        fileExtension = ".zip";
+      }
+
+      if (fileExtension) {
+        return response.blob().then((blob: any) => {
+          const url = window.URL.createObjectURL(blob);
+
+          const link = document.createElement("a");
+          link.href = url;
+          // Now the file name includes the extension
+          link.setAttribute("download", `file${fileExtension}`);
+
+          // These two lines are necessary to make the link click in Firefox
+          link.style.display = "none";
+          document.body.appendChild(link);
+
+          link.click();
+
+          // After link is clicked, it's safe to remove it.
+          setTimeout(() => document.body.removeChild(link), 0);
+
+          return response;
+        });
+      } else {
+        return response;
+      }
+    }
+
+    return response;
+  });
+}
+
+export default makeRequest;

package/src/theme/ApiExplorer/Response/_Response.scss

@@ -0,0 +1,121 @@
+.openapi-explorer__response-container {
+  background-color: var(--ifm-pre-background);
+  border-radius: var(--openapi-card-border-radius);
+  border: 1px solid var(--openapi-explorer-border-color);
+  box-shadow:
+    0 2px 3px hsla(222, 8%, 43%, 0.1),
+    0 8px 16px -10px hsla(222, 8%, 43%, 0.2);
+  color: var(--ifm-pre-color);
+  line-height: var(--ifm-pre-line-height);
+  margin-bottom: var(--ifm-spacing-vertical);
+  margin-top: 0;
+  overflow: auto;
+  transition: 300ms;
+
+  &:hover {
+    box-shadow:
+      0 0 0 2px rgba(38, 53, 61, 0.15),
+      0 2px 3px hsla(222, 8%, 43%, 0.15),
+      0 16px 16px -10px hsla(222, 8%, 43%, 0.2);
+  }
+
+  .openapi-explorer__code-block code {
+    padding-top: 0;
+  }
+}
+
+.openapi-explorer__response-title-container {
+  display: flex;
+  justify-content: space-between;
+  border-bottom: 1px solid var(--openapi-explorer-border-color);
+  margin: 0;
+  padding: 0.75rem var(--ifm-pre-padding);
+  text-transform: uppercase;
+  font-size: 12px;
+  font-weight: bold;
+}
+
+.openapi-explorer__response-placeholder-message {
+  font-size: 12px;
+  padding: 1.25rem;
+  margin-bottom: 0;
+  text-align: center;
+}
+
+.openapi-explorer__response-clear-btn {
+  &:hover {
+    cursor: pointer;
+  }
+}
+
+.openapi-explorer__loading-container {
+  width: 100%;
+  display: flex;
+  justify-content: center;
+}
+
+.openapi-response__dot::before {
+  margin-right: 0.2rem;
+  margin-bottom: 0.15rem;
+  content: "⬤";
+  color: var(--ifm-color-primary);
+  font-size: 8px;
+}
+
+.openapi-response__dot--danger::before {
+  color: var(--ifm-color-danger);
+}
+
+.openapi-response__dot--success::before {
+  color: var(--ifm-color-success);
+}
+
+.openapi-response__dot--info::before {
+  color: var(--ifm-color-info);
+}
+
+.openapi-response__status-code {
+  margin-left: -1rem;
+}
+
+.openapi-response__status-headers {
+  margin-left: -1rem;
+}
+
+/* loading spinner */
+.openapi-response__lds-ring {
+  display: inline-block;
+  position: relative;
+  width: 80px;
+  height: 80px;
+}
+.openapi-response__lds-ring div {
+  box-sizing: border-box;
+  display: block;
+  position: absolute;
+  width: 64px;
+  height: 64px;
+  margin: 8px;
+  border: 5px solid #dfc;
+  border-radius: 50%;
+  animation: openapi-response__lds-ring 1.2s cubic-bezier(0.5, 0, 0.5, 1)
+    infinite;
+  border-color: var(--ifm-color-primary) transparent transparent transparent;
+}
+.openapi-response__lds-ring div:nth-child(1) {
+  animation-delay: -0.45s;
+}
+.openapi-response__lds-ring div:nth-child(2) {
+  animation-delay: -0.3s;
+}
+.openapi-response__lds-ring div:nth-child(3) {
+  animation-delay: -0.15s;
+}
+@keyframes openapi-response__lds-ring {
+  0% {
+    transform: rotate(0deg);
+  }
+  100% {
+    transform: rotate(360deg);
+  }
+}