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

package/dist/packem_shared/initCommand-zE4VRDGW.mjs

@@ -1,63 +0,0 @@
-import { existsSync, realpathSync, writeFileSync } from 'node:fs';
-import { findUpSync, readJsonSync } from '@visulima/fs';
-
-const initCommand = (configName, packageJsonPath = process.cwd()) => {
-  if (existsSync(configName)) {
-    throw new Error("Config file already exists");
-  }
-  const packagePath = findUpSync("package.json", {
-    cwd: realpathSync(packageJsonPath)
-  });
-  let exportTemplate = "module.exports =";
-  if (packagePath) {
-    const packageJson = readJsonSync(packagePath);
-    console.info(`Found package.json at "${packagePath}"`);
-    if (packageJson.type === "module") {
-      console.info("Found package.json with type: module, using ES6 as export for the config file");
-      exportTemplate = "export default";
-    }
-  } else {
-    console.info("No package.json found");
-  }
-  writeFileSync(
-    configName,
-    `${exportTemplate} {
-  exclude: [
-    'coverage/**',
-    '.github/**',
-    'packages/*/test{,s}/**',
-    '**/*.d.ts',
-    'test{,s}/**',
-    'test{,-*}.{js,cjs,mjs,ts,tsx,jsx,yaml,yml}',
-    '**/*{.,-}test.{js,cjs,mjs,ts,tsx,jsx,yaml,yml}',
-    '**/__tests__/**',
-    '**/{ava,babel,nyc}.config.{js,cjs,mjs}',
-    '**/jest.config.{js,cjs,mjs,ts}',
-    '**/{karma,rollup,webpack}.config.js',
-    '**/.{eslint,mocha}rc.{js,cjs}',
-    '**/.{travis,yarnrc}.yml',
-    '**/{docker-compose,docker}.yml',
-    '**/.yamllint.{yaml,yml}',
-    '**/node_modules/**',
-    '**/pnpm-lock.yaml',
-    '**/pnpm-workspace.yaml',
-    '**/{package,package-lock}.json',
-    '**/yarn.lock',
-    '**/package.json5',
-    '**/.next/**',
-  ],
-  followSymlinks: false,
-  swaggerDefinition: {
-    openapi: '3.0.0',
-    info: {
-      title: 'API',
-      version: '1.0.0',
-    },
-  },
-};
-`
-  );
-  console.log(`Created "${configName}"`);
-};
-
-export { initCommand as default };

package/dist/packem_shared/jsDocumentCommentsToOpenApi-C7yMeXJ5.cjs

@@ -1,337 +0,0 @@
-'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;