docusaurus-plugin-openapi-docs 0.0.0-361 → 0.0.0-366

package/src/openapi/utils/loadAndBundleSpec.ts

@@ -0,0 +1,62 @@
+/* ============================================================================
+ * 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 type { Source, Document } from "@redocly/openapi-core";
+import { bundle } from "@redocly/openapi-core/lib/bundle";
+import type { ResolvedConfig } from "@redocly/openapi-core/lib/config";
+import { Config } from "@redocly/openapi-core/lib/config/config";
+import { convertObj } from "swagger2openapi";
+
+import { OpenAPISpec } from "./types";
+
+export async function loadAndBundleSpec(
+  specUrlOrObject: object | string
+): Promise<OpenAPISpec> {
+  const config = new Config({} as ResolvedConfig);
+  const bundleOpts = {
+    config,
+    base: process.cwd(),
+  };
+
+  if (typeof specUrlOrObject === "object" && specUrlOrObject !== null) {
+    bundleOpts["doc"] = {
+      source: { absoluteRef: "" } as Source,
+      parsed: specUrlOrObject,
+    } as Document;
+  } else {
+    bundleOpts["ref"] = specUrlOrObject;
+  }
+
+  // Force dereference ?
+  // bundleOpts["dereference"] = true;
+
+  const {
+    bundle: { parsed },
+  } = await bundle(bundleOpts);
+  return parsed.swagger !== undefined ? convertSwagger2OpenAPI(parsed) : parsed;
+}
+
+export function convertSwagger2OpenAPI(spec: any): Promise<OpenAPISpec> {
+  console.warn(
+    "[ReDoc Compatibility mode]: Converting OpenAPI 2.0 to OpenAPI 3.0"
+  );
+  return new Promise<OpenAPISpec>((resolve, reject) =>
+    convertObj(
+      spec,
+      { patch: true, warnOnly: true, text: "{}", anchors: true },
+      (err, res) => {
+        // TODO: log any warnings
+        if (err) {
+          return reject(err);
+        }
+        resolve(res && (res.openapi as any));
+      }
+    )
+  );
+}

package/src/openapi/utils/types.ts

@@ -0,0 +1,303 @@
+/* ============================================================================
+ * 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.
+ * ========================================================================== */
+
+type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+
+export interface OpenAPISpec {
+  openapi: string;
+  info: OpenAPIInfo;
+  servers?: OpenAPIServer[];
+  paths: OpenAPIPaths;
+  components?: OpenAPIComponents;
+  security?: OpenAPISecurityRequirement[];
+  tags?: OpenAPITag[];
+  externalDocs?: OpenAPIExternalDocumentation;
+  "x-webhooks"?: OpenAPIPaths;
+  webhooks?: OpenAPIPaths;
+}
+
+export interface OpenAPIInfo {
+  title: string;
+  version: string;
+
+  description?: string;
+  summary?: string;
+  termsOfService?: string;
+  contact?: OpenAPIContact;
+  license?: OpenAPILicense;
+}
+
+export interface OpenAPIServer {
+  url: string;
+  description?: string;
+  variables?: { [name: string]: OpenAPIServerVariable };
+}
+
+export interface OpenAPIServerVariable {
+  enum?: string[];
+  default: string;
+  description?: string;
+}
+
+export interface OpenAPIPaths {
+  [path: string]: OpenAPIPath;
+}
+export interface OpenAPIRef {
+  $ref: string;
+}
+
+export type Referenced<T> = OpenAPIRef | T;
+
+export interface OpenAPIPath {
+  summary?: string;
+  description?: string;
+  get?: OpenAPIOperation;
+  put?: OpenAPIOperation;
+  post?: OpenAPIOperation;
+  delete?: OpenAPIOperation;
+  options?: OpenAPIOperation;
+  head?: OpenAPIOperation;
+  patch?: OpenAPIOperation;
+  trace?: OpenAPIOperation;
+  servers?: OpenAPIServer[];
+  parameters?: Array<Referenced<OpenAPIParameter>>;
+  $ref?: string;
+}
+
+export interface OpenAPIXCodeSample {
+  lang: string;
+  label?: string;
+  source: string;
+}
+
+export interface OpenAPIOperation {
+  tags?: string[];
+  summary?: string;
+  description?: string;
+  externalDocs?: OpenAPIExternalDocumentation;
+  operationId?: string;
+  parameters?: Array<Referenced<OpenAPIParameter>>;
+  requestBody?: Referenced<OpenAPIRequestBody>;
+  responses: OpenAPIResponses;
+  callbacks?: { [name: string]: Referenced<OpenAPICallback> };
+  deprecated?: boolean;
+  security?: OpenAPISecurityRequirement[];
+  servers?: OpenAPIServer[];
+  "x-codeSamples"?: OpenAPIXCodeSample[];
+  "x-code-samples"?: OpenAPIXCodeSample[]; // deprecated
+}
+
+export interface OpenAPIParameter {
+  name: string;
+  in?: OpenAPIParameterLocation;
+  description?: string;
+  required?: boolean;
+  deprecated?: boolean;
+  allowEmptyValue?: boolean;
+  style?: OpenAPIParameterStyle;
+  explode?: boolean;
+  allowReserved?: boolean;
+  schema?: Referenced<OpenAPISchema>;
+  example?: any;
+  examples?: { [media: string]: Referenced<OpenAPIExample> };
+  content?: { [media: string]: OpenAPIMediaType };
+  encoding?: Record<string, OpenAPIEncoding>;
+  const?: any;
+}
+
+export interface OpenAPIExample {
+  value: any;
+  summary?: string;
+  description?: string;
+  externalValue?: string;
+}
+
+export interface OpenAPISchema {
+  $ref?: string;
+  type?: string | string[];
+  properties?: { [name: string]: OpenAPISchema };
+  patternProperties?: { [name: string]: OpenAPISchema };
+  additionalProperties?: boolean | OpenAPISchema;
+  unevaluatedProperties?: boolean | OpenAPISchema;
+  description?: string;
+  default?: any;
+  items?: OpenAPISchema | OpenAPISchema[] | boolean;
+  required?: string[];
+  readOnly?: boolean;
+  writeOnly?: boolean;
+  deprecated?: boolean;
+  format?: string;
+  externalDocs?: OpenAPIExternalDocumentation;
+  discriminator?: OpenAPIDiscriminator;
+  nullable?: boolean;
+  oneOf?: OpenAPISchema[];
+  anyOf?: OpenAPISchema[];
+  allOf?: OpenAPISchema[];
+  not?: OpenAPISchema;
+
+  title?: string;
+  multipleOf?: number;
+  maximum?: number;
+  exclusiveMaximum?: boolean | number;
+  minimum?: number;
+  exclusiveMinimum?: boolean | number;
+  maxLength?: number;
+  minLength?: number;
+  pattern?: string;
+  maxItems?: number;
+  minItems?: number;
+  uniqueItems?: boolean;
+  maxProperties?: number;
+  minProperties?: number;
+  enum?: any[];
+  example?: any;
+
+  if?: OpenAPISchema;
+  else?: OpenAPISchema;
+  then?: OpenAPISchema;
+  examples?: any[];
+  const?: string;
+  contentEncoding?: string;
+  contentMediaType?: string;
+  prefixItems?: OpenAPISchema[];
+  additionalItems?: OpenAPISchema | boolean;
+}
+
+export interface OpenAPIDiscriminator {
+  propertyName: string;
+  mapping?: { [name: string]: string };
+  "x-explicitMappingOnly"?: boolean;
+}
+
+export interface OpenAPIMediaType {
+  schema?: Referenced<OpenAPISchema>;
+  example?: any;
+  examples?: { [name: string]: Referenced<OpenAPIExample> };
+  encoding?: { [field: string]: OpenAPIEncoding };
+}
+
+export interface OpenAPIEncoding {
+  contentType: string;
+  headers?: { [name: string]: Referenced<OpenAPIHeader> };
+  style: OpenAPIParameterStyle;
+  explode: boolean;
+  allowReserved: boolean;
+}
+
+export type OpenAPIParameterLocation = "query" | "header" | "path" | "cookie";
+export type OpenAPIParameterStyle =
+  | "matrix"
+  | "label"
+  | "form"
+  | "simple"
+  | "spaceDelimited"
+  | "pipeDelimited"
+  | "deepObject";
+
+export interface OpenAPIRequestBody {
+  description?: string;
+  required?: boolean;
+  content: { [mime: string]: OpenAPIMediaType };
+
+  "x-examples"?: {
+    [mime: string]: { [name: string]: Referenced<OpenAPIExample> };
+  };
+  "x-example"?: { [mime: string]: any };
+}
+
+export interface OpenAPIResponses {
+  [code: string]: Referenced<OpenAPIResponse>;
+}
+
+export interface OpenAPIResponse
+  extends Pick<OpenAPIRequestBody, "description" | "x-examples" | "x-example"> {
+  headers?: { [name: string]: Referenced<OpenAPIHeader> };
+  links?: { [name: string]: Referenced<OpenAPILink> };
+  content?: { [mime: string]: OpenAPIMediaType };
+}
+
+export interface OpenAPILink {
+  $ref?: string;
+}
+
+export type OpenAPIHeader = Omit<OpenAPIParameter, "in" | "name">;
+
+export interface OpenAPICallback {
+  [name: string]: OpenAPIPath;
+}
+
+export interface OpenAPIComponents {
+  schemas?: { [name: string]: Referenced<OpenAPISchema> };
+  responses?: { [name: string]: Referenced<OpenAPIResponse> };
+  parameters?: { [name: string]: Referenced<OpenAPIParameter> };
+  examples?: { [name: string]: Referenced<OpenAPIExample> };
+  requestBodies?: { [name: string]: Referenced<OpenAPIRequestBody> };
+  headers?: { [name: string]: Referenced<OpenAPIHeader> };
+  securitySchemes?: { [name: string]: Referenced<OpenAPISecurityScheme> };
+  links?: { [name: string]: Referenced<OpenAPILink> };
+  callbacks?: { [name: string]: Referenced<OpenAPICallback> };
+}
+
+export interface OpenAPISecurityRequirement {
+  [name: string]: string[];
+}
+
+export interface OpenAPISecurityScheme {
+  type: "apiKey" | "http" | "oauth2" | "openIdConnect";
+  description?: string;
+  name?: string;
+  in?: "query" | "header" | "cookie";
+  scheme?: string;
+  bearerFormat: string;
+  flows: {
+    implicit?: {
+      refreshUrl?: string;
+      scopes: Record<string, string>;
+      authorizationUrl: string;
+    };
+    password?: {
+      refreshUrl?: string;
+      scopes: Record<string, string>;
+      tokenUrl: string;
+    };
+    clientCredentials?: {
+      refreshUrl?: string;
+      scopes: Record<string, string>;
+      tokenUrl: string;
+    };
+    authorizationCode?: {
+      refreshUrl?: string;
+      scopes: Record<string, string>;
+      tokenUrl: string;
+    };
+  };
+  openIdConnectUrl?: string;
+}
+
+export interface OpenAPITag {
+  name: string;
+  description?: string;
+  externalDocs?: OpenAPIExternalDocumentation;
+  "x-displayName"?: string;
+}
+
+export interface OpenAPIExternalDocumentation {
+  description?: string;
+  url: string;
+}
+
+export interface OpenAPIContact {
+  name?: string;
+  url?: string;
+  email?: string;
+}
+
+export interface OpenAPILicense {
+  name: string;
+  url?: string;
+  identifier?: string;
+}

package/src/types.ts

@@ -48,6 +48,8 @@ export interface ApiMetadataBase {
   //
   id: string; // TODO legacy versioned id => try to remove
   unversionedId: string; // TODO new unversioned id => try to rename to "id"
+  infoId?: string;
+  infoPath?: string;
   title: string;
   description: string;
   source: string; // @site aliased source => "@site/docs/folder/subFolder/subSubFolder/myDoc.md"
@@ -80,6 +82,9 @@ export interface InfoPageMetadata extends ApiMetadataBase {
   type: "info";
   info: ApiInfo;
   markdown?: string;
+  securitySchemes?: {
+    [key: string]: SecuritySchemeObject;
+  };
 }
 
 export interface TagPageMetadata extends ApiMetadataBase {

package/src/openapi/__fixtures__/examples/yogurtstore/_category_.json

@@ -1,4 +0,0 @@
-{
-  "label": "Foods",
-  "collapsed": true
-}

package/src/openapi/__fixtures__/examples/yogurtstore/froyo.yaml

@@ -1,13 +0,0 @@
-openapi: 3.0.3
-info:
-  title: Frozen Yogurt Example
-  version: 1.0.0
-  description: Sample description.
-paths:
-  /flavors:
-    get:
-      summary: List All Flavors
-      description: Froyo's the best!
-      responses:
-        200:
-          description: OK

package/src/openapi/__fixtures__/examples/yogurtstore/nested/nested.yaml

@@ -1,13 +0,0 @@
-openapi: 3.0.3
-info:
-  title: Nested Folder Example
-  version: 1.0.0
-  description: Sample description.
-paths:
-  /flavors:
-    get:
-      summary: List All
-      description: All
-      responses:
-        200:
-          description: OK