swagger-typescript-api 10.0.3 → 11.0.0--alpha

package/src/swagger-schema-resolver.js

@@ -0,0 +1,187 @@
+const { Configuration } = require("./configuration.js");
+const _ = require("lodash");
+const converter = require("swagger2openapi");
+const https = require("https");
+const axios = require("axios");
+const yaml = require("js-yaml");
+
+class SwaggerSchemaResolver {
+  /**
+   * @type {Configuration}
+   */
+  config;
+  /**
+   * @type {Logger}
+   */
+  logger;
+  /**
+   * @type {FileSystem}
+   */
+  fileSystem;
+
+  constructor(configuration, logger, fileSystem) {
+    this.config = configuration;
+    this.logger = logger;
+    this.fileSystem = fileSystem;
+  }
+
+  /**
+   *
+   * @returns {Promise<{usageSchema: Record<string, *>, originalSchema: Record<string, *>}>}
+   */
+  async create() {
+    const { spec, patch, input, url, disableStrictSSL, disableProxy, authorizationToken } = this.config;
+
+    if (this.config.spec) {
+      return await this.convertSwaggerObject(spec, { patch });
+    }
+
+    const swaggerSchemaFile = await this.fetchSwaggerSchemaFile(
+      input,
+      url,
+      disableStrictSSL,
+      disableProxy,
+      authorizationToken,
+    );
+    const swaggerSchemaObject = this.processSwaggerSchemaFile(swaggerSchemaFile);
+    return await this.convertSwaggerObject(swaggerSchemaObject, { patch });
+  }
+
+  /**
+   *
+   * @param swaggerSchema {Record<string, any>}
+   * @param converterOptions {{ patch?: boolean }}
+   * @returns {Promise<{ usageSchema: Record<string, any>, originalSchema: Record<string, any>}>}
+   */
+  convertSwaggerObject(swaggerSchema, converterOptions) {
+    return new Promise((resolve) => {
+      const result = _.cloneDeep(swaggerSchema);
+      result.info = _.merge(
+        {
+          title: "No title",
+          version: "",
+        },
+        result.info,
+      );
+
+      if (!result.openapi) {
+        result.paths = _.merge({}, result.paths);
+
+        converter.convertObj(
+          result,
+          {
+            ...converterOptions,
+            warnOnly: true,
+            refSiblings: "preserve",
+            rbname: "requestBodyName",
+          },
+          (err, options) => {
+            const parsedSwaggerSchema = _.get(err, "options.openapi", _.get(options, "openapi"));
+            if (!parsedSwaggerSchema && err) {
+              throw new Error(err);
+            }
+            this.config.update({ convertedFromSwagger2: true });
+            resolve({
+              usageSchema: parsedSwaggerSchema,
+              originalSchema: result,
+            });
+          },
+        );
+      } else {
+        resolve({
+          usageSchema: result,
+          originalSchema: _.cloneDeep(result),
+        });
+      }
+    });
+  }
+
+  fetchSwaggerSchemaFile(pathToSwagger, urlToSwagger, disableStrictSSL, disableProxy, authorizationToken) {
+    return new Promise((resolve, reject) => {
+      if (this.fileSystem.pathIsExist(pathToSwagger)) {
+        this.logger.log(`try to get swagger by path "${pathToSwagger}"`);
+        resolve(this.fileSystem.getFileContent(pathToSwagger));
+      } else {
+        this.logger.log(`try to get swagger by URL "${urlToSwagger}"`);
+        // setup options for Axios
+        const axiosOptions = {
+          maxContentLength: Infinity,
+          maxBodyLength: Infinity,
+        };
+        //
+        if (disableStrictSSL) {
+          axiosOptions.httpsAgent = new https.Agent({
+            rejectUnauthorized: false,
+          });
+        }
+        //
+        if (authorizationToken) {
+          axiosOptions.headers = {
+            Authorization: authorizationToken,
+          };
+        }
+        //
+        if (disableProxy) axiosOptions.proxy = false;
+        //
+        axios
+          .get(urlToSwagger, axiosOptions)
+          .then((res) => resolve(res.data))
+          .catch((error) => {
+            const message = `error while getting swagger by URL ${urlToSwagger}`;
+
+            this.logger.error(message, "response" in error ? error.response : error);
+
+            reject(message);
+          });
+      }
+    });
+  }
+
+  processSwaggerSchemaFile(file) {
+    if (typeof file !== "string") return file;
+
+    try {
+      return JSON.parse(file);
+    } catch (e) {
+      return yaml.load(file);
+    }
+  }
+
+  fixSwaggerSchema({ usageSchema, originalSchema }) {
+    const usagePaths = _.get(usageSchema, "paths");
+    const originalPaths = _.get(originalSchema, "paths");
+
+    // walk by routes
+    _.each(usagePaths, (usagePathObject, route) => {
+      const originalPathObject = _.get(originalPaths, route);
+
+      // walk by methods
+      _.each(usagePathObject, (usageRouteInfo, methodName) => {
+        const originalRouteInfo = _.get(originalPathObject, methodName);
+        const usageRouteParams = _.get(usageRouteInfo, "parameters", []);
+        const originalRouteParams = _.get(originalRouteInfo, "parameters", []);
+
+        usageRouteInfo.consumes = _.uniq(
+          _.compact([...(usageRouteInfo.consumes || []), ...(originalRouteInfo.consumes || [])]),
+        );
+        usageRouteInfo.produces = _.uniq(
+          _.compact([...(usageRouteInfo.produces || []), ...(originalRouteInfo.produces || [])]),
+        );
+
+        _.each(originalRouteParams, (originalRouteParam) => {
+          const existUsageParam = _.find(
+            usageRouteParams,
+            (param) => originalRouteParam.in === param.in && originalRouteParam.name === param.name,
+          );
+          if (!existUsageParam) {
+            usageRouteParams.push(originalRouteParam);
+          }
+        });
+      });
+    });
+  }
+}
+
+module.exports = {
+  SwaggerSchemaResolver,
+};

package/src/templates.js

@@ -1,155 +1,174 @@
+const { resolve } = require("path");
 const _ = require("lodash");
 const Eta = require("eta");
-const { getFileContent, pathIsExist } = require("./files");
-const { config } = require("./config");
-const { resolve } = require("path");
-const { logger } = require("./logger");
-
-const TEMPLATE_EXTENSIONS = [".eta", ".ejs"];
-
-/**
- * name - project template name,
- * fileName - template file name,
- */
-const TEMPLATE_INFOS = [
-  { name: "api", fileName: "api" },
-  { name: "dataContracts", fileName: "data-contracts" },
-  { name: "dataContractJsDoc", fileName: "data-contract-jsdoc" },
-  { name: "interfaceDataContract", fileName: "interface-data-contract" },
-  { name: "typeDataContract", fileName: "type-data-contract" },
-  { name: "enumDataContract", fileName: "enum-data-contract" },
-  { name: "objectFieldJsDoc", fileName: "object-field-jsdoc" },
-  { name: "httpClient", fileName: "http-client" },
-  { name: "routeTypes", fileName: "route-types" },
-  { name: "routeName", fileName: "route-name" },
-];
-
-const getTemplatePaths = ({ templates, modular }) => {
-  const baseTemplatesPath = resolve(__dirname, "../templates/base");
-  const defaultTemplatesPath = resolve(__dirname, "../templates/default");
-  const modularTemplatesPath = resolve(__dirname, "../templates/modular");
-  const originalTemplatesPath = modular ? modularTemplatesPath : defaultTemplatesPath;
-  const customTemplatesPath = templates ? resolve(process.cwd(), templates) : originalTemplatesPath;
-
-  return {
-    /** `templates/base` */
-    base: baseTemplatesPath,
-    /** `templates/default` */
-    default: defaultTemplatesPath,
-    /** `templates/modular` */
-    modular: modularTemplatesPath,
-    /** usage path if `--templates` option is not set */
-    original: originalTemplatesPath,
-    /** custom path to templates (`--templates`) */
-    custom: customTemplatesPath,
-  };
-};
+const path = require("path");
+
+class Templates {
+  /**
+   * @type {Configuration}
+   */
+  config;
+
+  /**
+   * @type {Logger}
+   */
+  logger;
+
+  /**
+   * @type {FileSystem}
+   */
+  fileSystem;
+
+  getRenderTemplateData;
+
+  constructor(config, logger, fileSystem, getRenderTemplateData) {
+    this.config = config;
+    this.logger = logger;
+    this.fileSystem = fileSystem;
+    this.getRenderTemplateData = getRenderTemplateData;
+  }
 
-const cropExtension = (path) =>
-  TEMPLATE_EXTENSIONS.reduce((path, ext) => (_.endsWith(path, ext) ? path.replace(ext, "") : path), path);
+  getTemplatePaths = ({ templates, modular }) => {
+    const baseTemplatesPath = resolve(__dirname, "../templates/base");
+    const defaultTemplatesPath = resolve(__dirname, "../templates/default");
+    const modularTemplatesPath = resolve(__dirname, "../templates/modular");
+    const originalTemplatesPath = modular ? modularTemplatesPath : defaultTemplatesPath;
+    const customTemplatesPath = templates ? resolve(process.cwd(), templates) : originalTemplatesPath;
+
+    return {
+      /** `templates/base` */
+      base: baseTemplatesPath,
+      /** `templates/default` */
+      default: defaultTemplatesPath,
+      /** `templates/modular` */
+      modular: modularTemplatesPath,
+      /** usage path if `--templates` option is not set */
+      original: originalTemplatesPath,
+      /** custom path to templates (`--templates`) */
+      custom: customTemplatesPath,
+    };
+  };
 
-const getTemplateFullPath = (path, fileName) => {
-  const raw = resolve(path, "./", cropExtension(fileName));
-  const pathVariants = TEMPLATE_EXTENSIONS.map((extension) => `${raw}${extension}`);
+  cropExtension = (path) =>
+    this.config.templateExtensions.reduce((path, ext) => (_.endsWith(path, ext) ? path.replace(ext, "") : path), path);
 
-  return pathVariants.find((variant) => !!pathIsExist(variant));
-};
+  getTemplateFullPath = (path, fileName) => {
+    const raw = resolve(path, "./", this.cropExtension(fileName));
+    const pathVariants = this.config.templateExtensions.map((extension) => `${raw}${extension}`);
 
-const getTemplate = ({ fileName, name, path }) => {
-  const { templatePaths } = config;
+    return pathVariants.find((variant) => !!this.fileSystem.pathIsExist(variant));
+  };
 
-  if (path) {
-    return getFileContent(path);
-  }
+  requireFnFromTemplate = (packageOrPath) => {
+    const isPath = _.startsWith(packageOrPath, "./") || _.startsWith(packageOrPath, "../");
 
-  if (!fileName) return "";
+    if (isPath) {
+      return require(path.resolve(this.config.templates, packageOrPath));
+    }
 
-  const customFullPath = getTemplateFullPath(templatePaths.custom, fileName);
-  let fileContent = customFullPath && getFileContent(customFullPath);
+    return require(packageOrPath);
+  };
 
-  if (!fileContent) {
-    const baseFullPath = getTemplateFullPath(templatePaths.base, fileName);
+  getTemplate = ({ fileName, name, path }) => {
+    const { templatePaths } = this.config;
 
-    if (baseFullPath) {
-      fileContent = getFileContent(baseFullPath);
-    } else {
-      logger.warn(
-        `${_.lowerCase(name)} template not found in ${customFullPath}`,
-        `\nCode generator will use the default template`,
-      );
+    if (path) {
+      return this.fileSystem.getFileContent(path);
     }
 
-    const originalFullPath = getTemplateFullPath(templatePaths.original, fileName);
+    if (!fileName) return "";
 
-    if (originalFullPath) {
-      fileContent = getFileContent(originalFullPath);
-    }
-  }
+    const customFullPath = this.getTemplateFullPath(templatePaths.custom, fileName);
+    let fileContent = customFullPath && this.fileSystem.getFileContent(customFullPath);
 
-  return fileContent;
-};
+    if (!fileContent) {
+      const baseFullPath = this.getTemplateFullPath(templatePaths.base, fileName);
 
-const getTemplates = ({ templatePaths }) => {
-  logger.log(`try to read templates from directory "${templatePaths.custom}"`);
+      if (baseFullPath) {
+        fileContent = this.fileSystem.getFileContent(baseFullPath);
+      } else {
+        this.logger.warn(
+          `${_.lowerCase(name)} template not found in ${customFullPath}`,
+          `\nCode generator will use the default template`,
+        );
+      }
 
-  const templatesMap = _.reduce(
-    TEMPLATE_INFOS,
-    (acc, { fileName, name }) => ({
-      ...acc,
-      [name]: getTemplate({ fileName, name }),
-    }),
-    {},
-  );
+      const originalFullPath = this.getTemplateFullPath(templatePaths.original, fileName);
 
-  return templatesMap;
-};
+      if (originalFullPath) {
+        fileContent = this.fileSystem.getFileContent(originalFullPath);
+      }
+    }
 
-const getTemplateContent = (path) => {
-  const foundTemplatePathKey = _.keys(config.templatePaths).find((key) => _.startsWith(path, `@${key}`));
+    return fileContent;
+  };
 
-  const findPathWithExt = (path) => {
-    const raw = cropExtension(path);
-    const pathVariants = TEMPLATE_EXTENSIONS.map((extension) => `${raw}${extension}`);
-    return pathVariants.find((variant) => pathIsExist(variant));
+  getTemplates = ({ templatePaths }) => {
+    this.logger.log(`try to read templates from directory "${templatePaths.custom}"`);
+
+    return _.reduce(
+      this.config.templateInfos,
+      (acc, { fileName, name }) => ({
+        ...acc,
+        [name]: this.getTemplate({ fileName, name }),
+      }),
+      {},
+    );
   };
 
-  const rawPath = resolve(_.replace(path, `@${foundTemplatePathKey}`, config.templatePaths[foundTemplatePathKey]));
-  const fixedPath = findPathWithExt(rawPath);
+  getTemplateContent = (path) => {
+    const foundTemplatePathKey = _.keys(this.config.templatePaths).find((key) => _.startsWith(path, `@${key}`));
 
-  if (fixedPath) {
-    return getFileContent(fixedPath);
-  }
+    const findPathWithExt = (path) => {
+      const raw = this.cropExtension(path);
+      const pathVariants = this.config.templateExtensions.map((extension) => `${raw}${extension}`);
+      return pathVariants.find((variant) => this.fileSystem.pathIsExist(variant));
+    };
 
-  const customPath = findPathWithExt(resolve(config.templatePaths.custom, path));
+    const rawPath = resolve(
+      _.replace(path, `@${foundTemplatePathKey}`, this.config.templatePaths[foundTemplatePathKey]),
+    );
+    const fixedPath = findPathWithExt(rawPath);
 
-  if (customPath) {
-    return getFileContent(customPath);
-  }
+    if (fixedPath) {
+      return this.fileSystem.getFileContent(fixedPath);
+    }
 
-  const originalPath = findPathWithExt(resolve(config.templatePaths.original, path));
+    const customPath = findPathWithExt(resolve(this.config.templatePaths.custom, path));
 
-  if (originalPath) {
-    return getFileContent(originalPath);
-  }
+    if (customPath) {
+      return this.fileSystem.getFileContent(customPath);
+    }
 
-  return "";
-};
+    const originalPath = findPathWithExt(resolve(this.config.templatePaths.original, path));
 
-const renderTemplate = (template, configuration, options) => {
-  if (!template) return "";
+    if (originalPath) {
+      return this.fileSystem.getFileContent(originalPath);
+    }
 
-  return Eta.render(template, configuration, {
-    async: false,
-    ...(options || {}),
-    includeFile: (path, payload, options) => {
-      return renderTemplate(getTemplateContent(path), payload, options);
-    },
-  });
-};
+    return "";
+  };
+
+  renderTemplate = (template, configuration, options) => {
+    if (!template) return "";
+
+    return Eta.render(
+      template,
+      {
+        ...this.getRenderTemplateData(),
+        ...configuration,
+      },
+      {
+        async: false,
+        ...(options || {}),
+        includeFile: (path, payload, options) => {
+          return this.renderTemplate(this.getTemplateContent(path), payload, options);
+        },
+      },
+    );
+  };
+}
 
 module.exports = {
-  getTemplate,
-  getTemplates,
-  getTemplatePaths,
-  renderTemplate,
+  Templates,
 };

package/src/translators/JavaScript.js

@@ -1,49 +1,49 @@
-const ts = require("typescript");
-
-function translate(fileName, content, options) {
-  const output = {};
-  const host = ts.createCompilerHost(options, true);
-  const fileNames = [fileName];
-  const originalSourceFileGet = host.getSourceFile.bind(host);
-  host.getSourceFile = (sourceFileName, languageVersion, onError, shouldCreateNewSourceFile) => {
-    if (sourceFileName !== fileName)
-      return originalSourceFileGet(sourceFileName, languageVersion, onError, shouldCreateNewSourceFile);
-
-    return ts.createSourceFile(sourceFileName, content, languageVersion, true, ts.ScriptKind.External);
-  };
-
-  host.writeFile = (fileName, contents) => {
-    output[fileName] = contents;
-  };
-
-  ts.createProgram(fileNames, options, host).emit();
-
-  return output;
-}
-
-module.exports = {
-  translate: (fileName, sourceTypeScript) => {
-    const translated = translate(fileName, sourceTypeScript, {
-      module: "ESNext",
-      noImplicitReturns: true,
-      alwaysStrict: true,
-      target: ts.ScriptTarget.ESNext,
-      declaration: true,
-      noImplicitAny: false,
-      sourceMap: false,
-      removeComments: false,
-      disableSizeLimit: true,
-      esModuleInterop: true,
-      emitDecoratorMetadata: true,
-      skipLibCheck: true,
-    });
-
-    const sourceFileName = fileName.replace(ts.Extension.Ts, ts.Extension.Js);
-    const declarationFileName = fileName.replace(ts.Extension.Ts, ts.Extension.Dts);
-
-    return {
-      sourceContent: translated[sourceFileName],
-      declarationContent: translated[declarationFileName],
-    };
-  },
-};
+const ts = require("typescript");
+
+function translate(fileName, content, options) {
+  const output = {};
+  const host = ts.createCompilerHost(options, true);
+  const fileNames = [fileName];
+  const originalSourceFileGet = host.getSourceFile.bind(host);
+  host.getSourceFile = (sourceFileName, languageVersion, onError, shouldCreateNewSourceFile) => {
+    if (sourceFileName !== fileName)
+      return originalSourceFileGet(sourceFileName, languageVersion, onError, shouldCreateNewSourceFile);
+
+    return ts.createSourceFile(sourceFileName, content, languageVersion, true, ts.ScriptKind.External);
+  };
+
+  host.writeFile = (fileName, contents) => {
+    output[fileName] = contents;
+  };
+
+  ts.createProgram(fileNames, options, host).emit();
+
+  return output;
+}
+
+module.exports = {
+  translate: (fileName, sourceTypeScript) => {
+    const translated = translate(fileName, sourceTypeScript, {
+      module: "ESNext",
+      noImplicitReturns: true,
+      alwaysStrict: true,
+      target: ts.ScriptTarget.ESNext,
+      declaration: true,
+      noImplicitAny: false,
+      sourceMap: false,
+      removeComments: false,
+      disableSizeLimit: true,
+      esModuleInterop: true,
+      emitDecoratorMetadata: true,
+      skipLibCheck: true,
+    });
+
+    const sourceFileName = fileName.replace(ts.Extension.Ts, ts.Extension.Js);
+    const declarationFileName = fileName.replace(ts.Extension.Ts, ts.Extension.Dts);
+
+    return {
+      sourceContent: translated[sourceFileName],
+      declarationContent: translated[declarationFileName],
+    };
+  },
+};

package/src/type-name.js

@@ -0,0 +1,79 @@
+const _ = require("lodash");
+
+class TypeName {
+  /** @type {Map<string, string>} */
+  formattedModelNamesMap = new Map();
+
+  /** @type {Configuration} */
+  config;
+
+  /** @type {Logger} */
+  logger;
+
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger;
+  }
+
+  /**
+   * @param name
+   * @param options {{ ignorePrefix?: boolean, ignoreSuffix?: boolean }}
+   * @return {string}
+   */
+  format = (name, options) => {
+    const typePrefix = options && options.ignorePrefix ? "" : this.config.typePrefix;
+    const typeSuffix = options && options.ignoreSuffix ? "" : this.config.typeSuffix;
+    const hashKey = `${typePrefix}_${name}_${typeSuffix}`;
+
+    if (typeof name !== "string") {
+      this.logger.warn("wrong name of the model name", name);
+      return name;
+    }
+
+    if (/^([A-Z_]{1,})$/g.test(name)) {
+      return _.compact([typePrefix, name, typeSuffix]).join("_");
+    }
+
+    if (this.formattedModelNamesMap.has(hashKey)) {
+      return this.formattedModelNamesMap.get(hashKey);
+    }
+
+    const fixedModelName = fixModelName(name);
+
+    const formattedModelName = _.replace(_.startCase(`${typePrefix}_${fixedModelName}_${typeSuffix}`), /\s/g, "");
+    const modelName = this.config.hooks.onFormatTypeName(formattedModelName, name) || formattedModelName;
+
+    this.formattedModelNamesMap.set(hashKey, modelName);
+
+    return modelName;
+  };
+
+  isValidName = isValidName;
+}
+
+const isValidName = (name) => /^([A-Za-z$_]{1,})$/g.test(name);
+
+const fixModelName = (name) => {
+  if (!isValidName(name)) {
+    if (!/^[a-zA-Z_$]/g.test(name)) {
+      name = `Type ${name}`;
+    }
+
+    // specific replaces for TSOA 3.x
+    if (name.includes("."))
+      name = name
+        .replace(/Exclude_keyof[A-Za-z]{1,}/g, (match) => "ExcludeKeys")
+        .replace(/%22\~AND\~%22/g, "And")
+        .replace(/%22\~OR\~%22/g, "Or")
+        .replace(/(\.?%22)|\./g, "_")
+        .replace(/__+$/, "");
+
+    if (name.includes("-")) name = _.startCase(name).replace(/ /g, "");
+  }
+
+  return name;
+};
+
+module.exports = {
+  TypeName,
+};