@visulima/jsdoc-open-api 2.0.95 → 3.0.0-alpha.10

package/dist/packem_shared/jsDocumentCommentsToOpenApi-C7yMeXJ5.cjs

@@ -0,0 +1,337 @@
+'use strict';
+
+const commentParser = require('comment-parser');
+const mergeWith = require('lodash.mergewith');
+const customizer = require('./customizer-DDFwFqJl.cjs');
+
+const _interopDefaultCompat = e => e && typeof e === 'object' && 'default' in e ? e.default : e;
+
+const mergeWith__default = /*#__PURE__*/_interopDefaultCompat(mergeWith);
+
+const ARRAY_SUFFIX_REGEX = /\[\]$/;
+const DESCRIPTION_DASH_REGEX = /^- /u;
+const PARAM_SUFFIX_REGEX = /Param$/u;
+const OPEN_API_REGEX = /^(GET|PUT|POST|DELETE|OPTIONS|HEAD|PATCH|TRACE) \/.*$/;
+const fixSecurityObject = (thing) => {
+  if (thing.security) {
+    thing.security = Object.keys(thing.security).map((s) => {
+      return {
+        [s]: thing.security[s]
+      };
+    });
+  }
+};
+const primitiveTypes = /* @__PURE__ */ new Set(["array", "boolean", "integer", "number", "object", "string"]);
+const formatMap = {
+  binary: "string",
+  byte: "string",
+  date: "string",
+  "date-time": "string",
+  double: "number",
+  float: "number",
+  int32: "integer",
+  int64: "integer",
+  password: "string"
+};
+const parseDescription = (tag) => {
+  const rawType = tag.type;
+  const isArray = rawType.endsWith("[]");
+  const parsedType = rawType.replace(ARRAY_SUFFIX_REGEX, "");
+  const isPrimitive = primitiveTypes.has(parsedType);
+  const isFormat = Object.keys(formatMap).includes(parsedType);
+  let defaultValue;
+  if (tag.default) {
+    switch (parsedType) {
+      case "double":
+      case "float":
+      case "number": {
+        defaultValue = Number.parseFloat(tag.default);
+        break;
+      }
+      case "int32":
+      case "int64":
+      case "integer": {
+        defaultValue = Number.parseInt(tag.default, 10);
+        break;
+      }
+      default: {
+        defaultValue = tag.default;
+        break;
+      }
+    }
+  }
+  let rootType;
+  if (isPrimitive) {
+    rootType = { default: defaultValue, type: parsedType };
+  } else if (isFormat) {
+    rootType = {
+      default: defaultValue,
+      format: parsedType,
+      type: formatMap[parsedType]
+    };
+  } else {
+    rootType = { $ref: `#/components/schemas/${parsedType}` };
+  }
+  let schema = isArray ? {
+    items: {
+      ...rootType
+    },
+    type: "array"
+  } : {
+    ...rootType
+  };
+  if (parsedType === "") {
+    schema = void 0;
+  }
+  let description = tag.description.trim().replace(DESCRIPTION_DASH_REGEX, "");
+  if (description === "") {
+    description = void 0;
+  }
+  return {
+    description,
+    name: tag.name,
+    rawType,
+    required: !tag.optional,
+    schema
+  };
+};
+const tagsToObjects = (tags, _verbose) => tags.map((tag) => {
+  const parsedResponse = parseDescription(tag);
+  let nameAndDescription = "";
+  if (parsedResponse.name) {
+    nameAndDescription += parsedResponse.name;
+  }
+  if (parsedResponse.description) {
+    nameAndDescription += ` ${parsedResponse.description.trim()}`;
+  }
+  switch (tag.tag) {
+    case "bodyComponent": {
+      return {
+        requestBody: {
+          $ref: `#/components/requestBodies/${parsedResponse.rawType}`
+        }
+      };
+    }
+    case "bodyContent": {
+      return {
+        requestBody: {
+          content: {
+            [parsedResponse.name.replace(String.raw`*\/*`, "*/*")]: {
+              schema: parsedResponse.schema
+            }
+          }
+        }
+      };
+    }
+    case "bodyDescription": {
+      return { requestBody: { description: nameAndDescription } };
+    }
+    case "bodyExample": {
+      const [contentType, example] = parsedResponse.name.split(".");
+      return {
+        requestBody: {
+          content: {
+            [contentType]: {
+              examples: {
+                [example]: {
+                  $ref: `#/components/examples/${parsedResponse.rawType}`
+                }
+              }
+            }
+          }
+        }
+      };
+    }
+    case "bodyRequired": {
+      return { requestBody: { required: true } };
+    }
+    case "callback": {
+      return {
+        callbacks: {
+          [parsedResponse.name]: {
+            $ref: `#/components/callbacks/${parsedResponse.rawType}`
+          }
+        }
+      };
+    }
+    case "cookieParam":
+    case "headerParam":
+    case "pathParam":
+    case "queryParam": {
+      return {
+        parameters: [
+          {
+            description: parsedResponse.description,
+            in: tag.tag.replace(PARAM_SUFFIX_REGEX, ""),
+            name: parsedResponse.name,
+            required: parsedResponse.required,
+            schema: parsedResponse.schema
+          }
+        ]
+      };
+    }
+    case "deprecated": {
+      return { deprecated: true };
+    }
+    case "description":
+    case "operationId":
+    case "summary": {
+      return { [tag.tag]: nameAndDescription };
+    }
+    case "externalDocs": {
+      return {
+        externalDocs: {
+          description: parsedResponse.description,
+          url: parsedResponse.name
+        }
+      };
+    }
+    case "paramComponent": {
+      return {
+        parameters: [{ $ref: `#/components/parameters/${parsedResponse.rawType}` }]
+      };
+    }
+    case "response": {
+      return {
+        responses: {
+          [parsedResponse.name]: {
+            description: parsedResponse.description
+          }
+        }
+      };
+    }
+    case "responseComponent": {
+      return {
+        responses: {
+          [parsedResponse.name]: {
+            $ref: `#/components/responses/${parsedResponse.rawType}`
+          }
+        }
+      };
+    }
+    case "responseContent": {
+      const [status, contentType] = parsedResponse.name.split(".");
+      return {
+        responses: {
+          [status]: {
+            content: {
+              [contentType]: {
+                schema: parsedResponse.schema
+              }
+            }
+          }
+        }
+      };
+    }
+    case "responseExample": {
+      const [status, contentType, example] = parsedResponse.name.split(".");
+      return {
+        responses: {
+          [status]: {
+            content: {
+              [contentType]: {
+                examples: {
+                  [example]: {
+                    $ref: `#/components/examples/${parsedResponse.rawType}`
+                  }
+                }
+              }
+            }
+          }
+        }
+      };
+    }
+    case "responseHeader": {
+      const [status, header] = parsedResponse.name.split(".");
+      return {
+        responses: {
+          [status]: {
+            headers: {
+              [header]: {
+                description: parsedResponse.description,
+                schema: parsedResponse.schema
+              }
+            }
+          }
+        }
+      };
+    }
+    case "responseHeaderComponent": {
+      const [status, header] = parsedResponse.name.split(".");
+      return {
+        responses: {
+          [status]: {
+            headers: {
+              [header]: {
+                $ref: `#/components/headers/${parsedResponse.rawType}`
+              }
+            }
+          }
+        }
+      };
+    }
+    case "responseLink": {
+      const [status, link] = parsedResponse.name.split(".");
+      return {
+        responses: {
+          [status]: {
+            links: {
+              [link]: {
+                $ref: `#/components/links/${parsedResponse.rawType}`
+              }
+            }
+          }
+        }
+      };
+    }
+    case "security": {
+      const [security, scopeItem] = parsedResponse.name.split(".");
+      let scope = [];
+      if (scopeItem) {
+        scope = [scopeItem];
+      }
+      return {
+        security: { [security]: scope }
+      };
+    }
+    case "server": {
+      return {
+        servers: [
+          {
+            description: parsedResponse.description,
+            url: parsedResponse.name
+          }
+        ]
+      };
+    }
+    case "tag": {
+      return { tags: [nameAndDescription] };
+    }
+    default: {
+      return {};
+    }
+  }
+});
+const commentsToOpenApi = (fileContents, verbose) => {
+  const jsDocumentComments = commentParser.parse(fileContents, { spacing: "preserve" });
+  return jsDocumentComments.filter((comment) => OPEN_API_REGEX.test(comment.description.trim())).map((comment) => {
+    const loc = comment.tags.length + 1;
+    const result = mergeWith__default({}, ...tagsToObjects(comment.tags), customizer.customizer);
+    fixSecurityObject(result);
+    const [method, path] = comment.description.split(" ");
+    const pathsObject = {
+      [path.trim()]: {
+        [method.toLowerCase().trim()]: {
+          ...result
+        }
+      }
+    };
+    const spec = JSON.parse(JSON.stringify({ paths: pathsObject }));
+    return {
+      loc,
+      spec
+    };
+  });
+};
+
+module.exports = commentsToOpenApi;

package/dist/packem_shared/jsDocumentCommentsToOpenApi-DtrIZ2lK.mjs

@@ -0,0 +1,331 @@
+import { parse } from 'comment-parser';
+import mergeWith from 'lodash.mergewith';
+import { c as customizer } from './customizer-CoMXMU7a.mjs';
+
+const ARRAY_SUFFIX_REGEX = /\[\]$/;
+const DESCRIPTION_DASH_REGEX = /^- /u;
+const PARAM_SUFFIX_REGEX = /Param$/u;
+const OPEN_API_REGEX = /^(GET|PUT|POST|DELETE|OPTIONS|HEAD|PATCH|TRACE) \/.*$/;
+const fixSecurityObject = (thing) => {
+  if (thing.security) {
+    thing.security = Object.keys(thing.security).map((s) => {
+      return {
+        [s]: thing.security[s]
+      };
+    });
+  }
+};
+const primitiveTypes = /* @__PURE__ */ new Set(["array", "boolean", "integer", "number", "object", "string"]);
+const formatMap = {
+  binary: "string",
+  byte: "string",
+  date: "string",
+  "date-time": "string",
+  double: "number",
+  float: "number",
+  int32: "integer",
+  int64: "integer",
+  password: "string"
+};
+const parseDescription = (tag) => {
+  const rawType = tag.type;
+  const isArray = rawType.endsWith("[]");
+  const parsedType = rawType.replace(ARRAY_SUFFIX_REGEX, "");
+  const isPrimitive = primitiveTypes.has(parsedType);
+  const isFormat = Object.keys(formatMap).includes(parsedType);
+  let defaultValue;
+  if (tag.default) {
+    switch (parsedType) {
+      case "double":
+      case "float":
+      case "number": {
+        defaultValue = Number.parseFloat(tag.default);
+        break;
+      }
+      case "int32":
+      case "int64":
+      case "integer": {
+        defaultValue = Number.parseInt(tag.default, 10);
+        break;
+      }
+      default: {
+        defaultValue = tag.default;
+        break;
+      }
+    }
+  }
+  let rootType;
+  if (isPrimitive) {
+    rootType = { default: defaultValue, type: parsedType };
+  } else if (isFormat) {
+    rootType = {
+      default: defaultValue,
+      format: parsedType,
+      type: formatMap[parsedType]
+    };
+  } else {
+    rootType = { $ref: `#/components/schemas/${parsedType}` };
+  }
+  let schema = isArray ? {
+    items: {
+      ...rootType
+    },
+    type: "array"
+  } : {
+    ...rootType
+  };
+  if (parsedType === "") {
+    schema = void 0;
+  }
+  let description = tag.description.trim().replace(DESCRIPTION_DASH_REGEX, "");
+  if (description === "") {
+    description = void 0;
+  }
+  return {
+    description,
+    name: tag.name,
+    rawType,
+    required: !tag.optional,
+    schema
+  };
+};
+const tagsToObjects = (tags, _verbose) => tags.map((tag) => {
+  const parsedResponse = parseDescription(tag);
+  let nameAndDescription = "";
+  if (parsedResponse.name) {
+    nameAndDescription += parsedResponse.name;
+  }
+  if (parsedResponse.description) {
+    nameAndDescription += ` ${parsedResponse.description.trim()}`;
+  }
+  switch (tag.tag) {
+    case "bodyComponent": {
+      return {
+        requestBody: {
+          $ref: `#/components/requestBodies/${parsedResponse.rawType}`
+        }
+      };
+    }
+    case "bodyContent": {
+      return {
+        requestBody: {
+          content: {
+            [parsedResponse.name.replace(String.raw`*\/*`, "*/*")]: {
+              schema: parsedResponse.schema
+            }
+          }
+        }
+      };
+    }
+    case "bodyDescription": {
+      return { requestBody: { description: nameAndDescription } };
+    }
+    case "bodyExample": {
+      const [contentType, example] = parsedResponse.name.split(".");
+      return {
+        requestBody: {
+          content: {
+            [contentType]: {
+              examples: {
+                [example]: {
+                  $ref: `#/components/examples/${parsedResponse.rawType}`
+                }
+              }
+            }
+          }
+        }
+      };
+    }
+    case "bodyRequired": {
+      return { requestBody: { required: true } };
+    }
+    case "callback": {
+      return {
+        callbacks: {
+          [parsedResponse.name]: {
+            $ref: `#/components/callbacks/${parsedResponse.rawType}`
+          }
+        }
+      };
+    }
+    case "cookieParam":
+    case "headerParam":
+    case "pathParam":
+    case "queryParam": {
+      return {
+        parameters: [
+          {
+            description: parsedResponse.description,
+            in: tag.tag.replace(PARAM_SUFFIX_REGEX, ""),
+            name: parsedResponse.name,
+            required: parsedResponse.required,
+            schema: parsedResponse.schema
+          }
+        ]
+      };
+    }
+    case "deprecated": {
+      return { deprecated: true };
+    }
+    case "description":
+    case "operationId":
+    case "summary": {
+      return { [tag.tag]: nameAndDescription };
+    }
+    case "externalDocs": {
+      return {
+        externalDocs: {
+          description: parsedResponse.description,
+          url: parsedResponse.name
+        }
+      };
+    }
+    case "paramComponent": {
+      return {
+        parameters: [{ $ref: `#/components/parameters/${parsedResponse.rawType}` }]
+      };
+    }
+    case "response": {
+      return {
+        responses: {
+          [parsedResponse.name]: {
+            description: parsedResponse.description
+          }
+        }
+      };
+    }
+    case "responseComponent": {
+      return {
+        responses: {
+          [parsedResponse.name]: {
+            $ref: `#/components/responses/${parsedResponse.rawType}`
+          }
+        }
+      };
+    }
+    case "responseContent": {
+      const [status, contentType] = parsedResponse.name.split(".");
+      return {
+        responses: {
+          [status]: {
+            content: {
+              [contentType]: {
+                schema: parsedResponse.schema
+              }
+            }
+          }
+        }
+      };
+    }
+    case "responseExample": {
+      const [status, contentType, example] = parsedResponse.name.split(".");
+      return {
+        responses: {
+          [status]: {
+            content: {
+              [contentType]: {
+                examples: {
+                  [example]: {
+                    $ref: `#/components/examples/${parsedResponse.rawType}`
+                  }
+                }
+              }
+            }
+          }
+        }
+      };
+    }
+    case "responseHeader": {
+      const [status, header] = parsedResponse.name.split(".");
+      return {
+        responses: {
+          [status]: {
+            headers: {
+              [header]: {
+                description: parsedResponse.description,
+                schema: parsedResponse.schema
+              }
+            }
+          }
+        }
+      };
+    }
+    case "responseHeaderComponent": {
+      const [status, header] = parsedResponse.name.split(".");
+      return {
+        responses: {
+          [status]: {
+            headers: {
+              [header]: {
+                $ref: `#/components/headers/${parsedResponse.rawType}`
+              }
+            }
+          }
+        }
+      };
+    }
+    case "responseLink": {
+      const [status, link] = parsedResponse.name.split(".");
+      return {
+        responses: {
+          [status]: {
+            links: {
+              [link]: {
+                $ref: `#/components/links/${parsedResponse.rawType}`
+              }
+            }
+          }
+        }
+      };
+    }
+    case "security": {
+      const [security, scopeItem] = parsedResponse.name.split(".");
+      let scope = [];
+      if (scopeItem) {
+        scope = [scopeItem];
+      }
+      return {
+        security: { [security]: scope }
+      };
+    }
+    case "server": {
+      return {
+        servers: [
+          {
+            description: parsedResponse.description,
+            url: parsedResponse.name
+          }
+        ]
+      };
+    }
+    case "tag": {
+      return { tags: [nameAndDescription] };
+    }
+    default: {
+      return {};
+    }
+  }
+});
+const commentsToOpenApi = (fileContents, verbose) => {
+  const jsDocumentComments = parse(fileContents, { spacing: "preserve" });
+  return jsDocumentComments.filter((comment) => OPEN_API_REGEX.test(comment.description.trim())).map((comment) => {
+    const loc = comment.tags.length + 1;
+    const result = mergeWith({}, ...tagsToObjects(comment.tags), customizer);
+    fixSecurityObject(result);
+    const [method, path] = comment.description.split(" ");
+    const pathsObject = {
+      [path.trim()]: {
+        [method.toLowerCase().trim()]: {
+          ...result
+        }
+      }
+    };
+    const spec = JSON.parse(JSON.stringify({ paths: pathsObject }));
+    return {
+      loc,
+      spec
+    };
+  });
+};
+
+export { commentsToOpenApi as default };

package/dist/packem_shared/parseFile-BE-sKiRK.mjs

@@ -0,0 +1,35 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import yaml from 'yaml';
+import yamlLoc from './yamlLoc-C7iHWvdq.mjs';
+
+const ALLOWED_KEYS = /* @__PURE__ */ new Set(["components", "externalDocs", "info", "openapi", "paths", "security", "servers", "tags"]);
+class ParseError extends Error {
+  filePath;
+}
+const parseFile = (file, commentsToOpenApi, verbose) => {
+  const fileContent = readFileSync(file, { encoding: "utf8" });
+  const extension = path.extname(file);
+  if (extension === ".yaml" || extension === ".yml") {
+    const spec = yaml.parse(fileContent);
+    const invalidKeys = Object.keys(spec).filter((key) => !ALLOWED_KEYS.has(key));
+    if (invalidKeys.length > 0) {
+      const error = new ParseError(`Unexpected keys: ${invalidKeys.join(", ")}`);
+      error.filePath = file;
+      throw error;
+    }
+    if (Object.keys(spec).some((key) => ALLOWED_KEYS.has(key))) {
+      const loc = yamlLoc(fileContent);
+      return [{ loc, spec }];
+    }
+    return [];
+  }
+  try {
+    return commentsToOpenApi(fileContent, verbose);
+  } catch (error) {
+    error.filePath = file;
+    throw error;
+  }
+};
+
+export { parseFile as default };