@visulima/jsdoc-open-api 3.0.0-alpha.9 → 3.0.1

package/dist/packem_shared/jsDocumentCommentsToOpenApi-DtrIZ2lK.mjs

@@ -1,331 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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 };

package/dist/packem_shared/parseFile-Dk7Bw7lt.cjs

@@ -1,42 +0,0 @@
-'use strict';
-
-const node_fs = require('node:fs');
-const path = require('node:path');
-const yaml = require('yaml');
-const yamlLoc = require('./yamlLoc-CEvBiR4K.cjs');
-
-const _interopDefaultCompat = e => e && typeof e === 'object' && 'default' in e ? e.default : e;
-
-const path__default = /*#__PURE__*/_interopDefaultCompat(path);
-const yaml__default = /*#__PURE__*/_interopDefaultCompat(yaml);
-
-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 = node_fs.readFileSync(file, { encoding: "utf8" });
-  const extension = path__default.extname(file);
-  if (extension === ".yaml" || extension === ".yml") {
-    const spec = yaml__default.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;
-  }
-};
-
-module.exports = parseFile;

package/dist/packem_shared/swaggerJsDocumentCommentsToOpenApi-B7g9rVr5.mjs

@@ -1,131 +0,0 @@
-import { parse } from 'comment-parser';
-import mergeWith from 'lodash.mergewith';
-import yaml from 'yaml';
-import { c as customizer } from './customizer-CoMXMU7a.mjs';
-
-const mergeDeep = (first, second) => mergeWith({}, first, second, (a, b) => {
-  if (b === null) {
-    return a;
-  }
-  return void 0;
-});
-const hasEmptyProperty = (object) => Object.keys(object).map((key) => object[key]).every((keyObject) => typeof keyObject === "object" && Object.keys(keyObject).every((key) => !(key in keyObject)));
-const isTagPresentInTags = (tag, tags) => tags.some((targetTag) => tag.name === targetTag.name);
-const getSwaggerVersionFromSpec = (tag) => {
-  switch (tag.tag) {
-    case "asyncapi": {
-      return "v4";
-    }
-    case "openapi": {
-      return "v3";
-    }
-    case "swagger": {
-      return "v2";
-    }
-    default: {
-      return "v2";
-    }
-  }
-};
-
-const organizeSwaggerObject = (swaggerObject, annotation, property) => {
-  if (property === "x-webhooks") {
-    swaggerObject[property] = annotation[property];
-  }
-  if (property.startsWith("x-")) {
-    return;
-  }
-  const commonProperties = [
-    "components",
-    "consumes",
-    "produces",
-    "paths",
-    "schemas",
-    "securityDefinitions",
-    "responses",
-    "parameters",
-    "definitions",
-    "channels"
-  ];
-  if (commonProperties.includes(property)) {
-    Object.keys(annotation[property]).forEach((definition) => {
-      swaggerObject[property][definition] = mergeDeep(swaggerObject[property][definition], annotation[property][definition]);
-    });
-  } else if (property === "tags") {
-    const { tags } = annotation;
-    if (Array.isArray(tags)) {
-      tags.forEach((tag) => {
-        if (!isTagPresentInTags(tag, swaggerObject.tags)) {
-          swaggerObject.tags.push(tag);
-        }
-      });
-    } else if (!isTagPresentInTags(tags, swaggerObject.tags)) {
-      swaggerObject.tags.push(tags);
-    }
-  } else if (property === "security") {
-    const { security } = annotation;
-    swaggerObject.security = security;
-  } else if (property.startsWith("/")) {
-    swaggerObject.paths[property] = mergeDeep(swaggerObject.paths[property], annotation[property]);
-  }
-};
-
-const specificationTemplate = {
-  v2: ["paths", "definitions", "responses", "parameters", "securityDefinitions"],
-  v3: ["paths", "definitions", "responses", "parameters", "securityDefinitions", "components"],
-  v4: ["components", "channels"]
-};
-const tagsToObjects = (specs, verbose) => specs.map((spec) => {
-  const hasContent = spec.description !== "" || spec.name.startsWith("/") || spec.name.endsWith(":");
-  if ((spec.tag === "openapi" || spec.tag === "swagger" || spec.tag === "asyncapi") && hasContent) {
-    let yamlContent = spec.description;
-    if (spec.name.startsWith("/") || spec.name.endsWith(":")) {
-      yamlContent = yamlContent.trim() === "" ? spec.name : `${spec.name}
-${yamlContent}`;
-    }
-    const parsed = yaml.parseDocument(yamlContent);
-    if (parsed.errors.length > 0) {
-      parsed.errors.forEach((error) => {
-        error.annotation = yamlContent;
-      });
-      let errorString = "Error parsing YAML in @openapi spec:";
-      errorString += verbose ? parsed.errors.map((error) => `${error.toString()}
-Imbedded within:
-\`\`\`
-  ${error.annotation?.replaceAll("\n", "\n  ")}
-\`\`\``).join("\n") : parsed.errors.map((error) => error.toString()).join("\n");
-      throw new Error(errorString);
-    }
-    const parsedDocument = parsed.toJSON();
-    const specification = {
-      tags: []
-    };
-    specificationTemplate[getSwaggerVersionFromSpec(spec)].forEach((property) => {
-      specification[property] = specification[property] ?? {};
-    });
-    Object.keys(parsedDocument).forEach((property) => {
-      organizeSwaggerObject(specification, parsedDocument, property);
-    });
-    return specification;
-  }
-  return {};
-});
-const commentsToOpenApi = (fileContents, verbose) => {
-  const jsDocumentComments = parse(fileContents, { spacing: "preserve" });
-  return jsDocumentComments.map((comment) => {
-    const loc = comment.tags.length + 1;
-    const result = mergeWith({}, ...tagsToObjects(comment.tags, verbose), customizer);
-    ["definitions", "responses", "parameters", "securityDefinitions", "components", "tags"].forEach((property) => {
-      if (result[property] !== void 0 && hasEmptyProperty(result[property])) {
-        delete result[property];
-      }
-    });
-    const spec = JSON.parse(JSON.stringify(result));
-    return {
-      loc,
-      spec
-    };
-  });
-};
-
-export { commentsToOpenApi as default };

package/dist/packem_shared/swaggerJsDocumentCommentsToOpenApi-BuB7eE94.cjs

@@ -1,138 +0,0 @@
-'use strict';
-
-const commentParser = require('comment-parser');
-const mergeWith = require('lodash.mergewith');
-const yaml = require('yaml');
-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 yaml__default = /*#__PURE__*/_interopDefaultCompat(yaml);
-
-const mergeDeep = (first, second) => mergeWith__default({}, first, second, (a, b) => {
-  if (b === null) {
-    return a;
-  }
-  return void 0;
-});
-const hasEmptyProperty = (object) => Object.keys(object).map((key) => object[key]).every((keyObject) => typeof keyObject === "object" && Object.keys(keyObject).every((key) => !(key in keyObject)));
-const isTagPresentInTags = (tag, tags) => tags.some((targetTag) => tag.name === targetTag.name);
-const getSwaggerVersionFromSpec = (tag) => {
-  switch (tag.tag) {
-    case "asyncapi": {
-      return "v4";
-    }
-    case "openapi": {
-      return "v3";
-    }
-    case "swagger": {
-      return "v2";
-    }
-    default: {
-      return "v2";
-    }
-  }
-};
-
-const organizeSwaggerObject = (swaggerObject, annotation, property) => {
-  if (property === "x-webhooks") {
-    swaggerObject[property] = annotation[property];
-  }
-  if (property.startsWith("x-")) {
-    return;
-  }
-  const commonProperties = [
-    "components",
-    "consumes",
-    "produces",
-    "paths",
-    "schemas",
-    "securityDefinitions",
-    "responses",
-    "parameters",
-    "definitions",
-    "channels"
-  ];
-  if (commonProperties.includes(property)) {
-    Object.keys(annotation[property]).forEach((definition) => {
-      swaggerObject[property][definition] = mergeDeep(swaggerObject[property][definition], annotation[property][definition]);
-    });
-  } else if (property === "tags") {
-    const { tags } = annotation;
-    if (Array.isArray(tags)) {
-      tags.forEach((tag) => {
-        if (!isTagPresentInTags(tag, swaggerObject.tags)) {
-          swaggerObject.tags.push(tag);
-        }
-      });
-    } else if (!isTagPresentInTags(tags, swaggerObject.tags)) {
-      swaggerObject.tags.push(tags);
-    }
-  } else if (property === "security") {
-    const { security } = annotation;
-    swaggerObject.security = security;
-  } else if (property.startsWith("/")) {
-    swaggerObject.paths[property] = mergeDeep(swaggerObject.paths[property], annotation[property]);
-  }
-};
-
-const specificationTemplate = {
-  v2: ["paths", "definitions", "responses", "parameters", "securityDefinitions"],
-  v3: ["paths", "definitions", "responses", "parameters", "securityDefinitions", "components"],
-  v4: ["components", "channels"]
-};
-const tagsToObjects = (specs, verbose) => specs.map((spec) => {
-  const hasContent = spec.description !== "" || spec.name.startsWith("/") || spec.name.endsWith(":");
-  if ((spec.tag === "openapi" || spec.tag === "swagger" || spec.tag === "asyncapi") && hasContent) {
-    let yamlContent = spec.description;
-    if (spec.name.startsWith("/") || spec.name.endsWith(":")) {
-      yamlContent = yamlContent.trim() === "" ? spec.name : `${spec.name}
-${yamlContent}`;
-    }
-    const parsed = yaml__default.parseDocument(yamlContent);
-    if (parsed.errors.length > 0) {
-      parsed.errors.forEach((error) => {
-        error.annotation = yamlContent;
-      });
-      let errorString = "Error parsing YAML in @openapi spec:";
-      errorString += verbose ? parsed.errors.map((error) => `${error.toString()}
-Imbedded within:
-\`\`\`
-  ${error.annotation?.replaceAll("\n", "\n  ")}
-\`\`\``).join("\n") : parsed.errors.map((error) => error.toString()).join("\n");
-      throw new Error(errorString);
-    }
-    const parsedDocument = parsed.toJSON();
-    const specification = {
-      tags: []
-    };
-    specificationTemplate[getSwaggerVersionFromSpec(spec)].forEach((property) => {
-      specification[property] = specification[property] ?? {};
-    });
-    Object.keys(parsedDocument).forEach((property) => {
-      organizeSwaggerObject(specification, parsedDocument, property);
-    });
-    return specification;
-  }
-  return {};
-});
-const commentsToOpenApi = (fileContents, verbose) => {
-  const jsDocumentComments = commentParser.parse(fileContents, { spacing: "preserve" });
-  return jsDocumentComments.map((comment) => {
-    const loc = comment.tags.length + 1;
-    const result = mergeWith__default({}, ...tagsToObjects(comment.tags, verbose), customizer.customizer);
-    ["definitions", "responses", "parameters", "securityDefinitions", "components", "tags"].forEach((property) => {
-      if (result[property] !== void 0 && hasEmptyProperty(result[property])) {
-        delete result[property];
-      }
-    });
-    const spec = JSON.parse(JSON.stringify(result));
-    return {
-      loc,
-      spec
-    };
-  });
-};
-
-module.exports = commentsToOpenApi;