swagger-typescript-api 12.0.4 → 13.0.0

package/src/schema-routes/util/specific-arg-name-resolver.js

@@ -0,0 +1,26 @@
+const { NameResolver } = require('../../util/name-resolver');
+
+class SpecificArgNameResolver extends NameResolver {
+  counter = 1;
+  /**
+   * @param {CodeGenConfig} config;
+   * @param {Logger} logger;
+   * @param {string[]} reservedNames
+   */
+  constructor(config, logger, reservedNames) {
+    super(config, logger, reservedNames, (variants) => {
+      const generatedVariant =
+        (variants[0] && `${variants[0]}${this.counter++}`) ||
+        `${this.config.specificArgNameResolverName}${this.counter++}`;
+      this.logger.debug(
+        'generated fallback type name for specific arg - ',
+        generatedVariant,
+      );
+      return generatedVariant;
+    });
+  }
+}
+
+module.exports = {
+  SpecificArgNameResolver,
+};

package/src/schema-walker.js

@@ -0,0 +1,93 @@
+const _ = require('lodash');
+
+// TODO: WIP
+// this class will be needed to walk by schema everywhere
+class SchemaWalker {
+  /** @type {Logger} */
+  logger;
+  /** @type {CodeGenConfig} */
+  config;
+  /** @type {SwaggerSchemaResolver} */
+  swaggerSchemaResolver;
+  /** @type {Map<string, Record<string, any>>} */
+  schemas = new Map();
+  /** @type {Map<string, Record<string, any>>} */
+  caches = new Map();
+
+  constructor({ config, logger }) {
+    this.logger = logger;
+    this.config = config;
+  }
+
+  /**
+   * @param name {string}
+   * @param schema {Record<string, any>}
+   */
+  addSchema = (name, schema) => {
+    this.schemas.set(name, _.cloneDeep(schema));
+  };
+
+  /**
+   * @param ref {string}
+   * @returns {any}
+   */
+  findByRef = (ref) => {
+    this.logger.debug('try to resolve ref by path', ref);
+
+    if (this.caches.has(ref)) {
+      return this.caches.get(ref);
+    }
+
+    const schemas = Array.from(this.schemas.values());
+    if (this._isLocalRef(ref)) {
+      for (const schema of schemas) {
+        const refData = this._getRefDataFromSchema(schema, ref);
+        if (refData) {
+          return refData;
+        }
+      }
+    } else if (this._isRemoteRef(ref)) {
+      this.logger.debug('remote refs not supported', ref);
+      return null;
+    } else {
+      const [address, path] = path.split('#');
+      let swaggerSchemaObject;
+
+      if (this.schemas.has(address)) {
+        swaggerSchemaObject = this.schemas.get(address);
+      } else {
+        const pathToSchema = path.resolve(process.cwd(), address);
+        const swaggerSchemaFile =
+          this.swaggerSchemaResolver.getSwaggerSchemaByPath(pathToSchema);
+        swaggerSchemaObject =
+          this.swaggerSchemaResolver.processSwaggerSchemaFile(
+            swaggerSchemaFile,
+          );
+        this.schemas.set(address, swaggerSchemaObject);
+      }
+
+      return this._getRefDataFromSchema(swaggerSchemaObject, path);
+    }
+  };
+
+  _isLocalRef = (ref) => {
+    return ref.startsWith('#');
+  };
+
+  _isRemoteRef = (ref) => {
+    return ref.startsWith('http://') || ref.startsWith('https://');
+  };
+
+  _getRefDataFromSchema = (schema, ref) => {
+    const path = ref.replace('#', '').split('/');
+    const refData = _.get(schema, path);
+    if (refData) {
+      this.caches.set(ref, refData);
+    }
+    return refData;
+  };
+}
+
+module.exports = {
+  SchemaWalker,
+};

package/src/swagger-schema-resolver.js

@@ -1,7 +1,7 @@
-const _ = require("lodash");
-const converter = require("swagger2openapi");
-const yaml = require("js-yaml");
-const { Request } = require("./util/request");
+const _ = require('lodash');
+const converter = require('swagger2openapi');
+const yaml = require('js-yaml');
+const { Request } = require('./util/request');
 
 class SwaggerSchemaResolver {
   /**
@@ -21,7 +21,7 @@ class SwaggerSchemaResolver {
    */
   request;
 
-  constructor(config, logger, fileSystem) {
+  constructor({ config, logger, fileSystem }) {
     this.config = config;
     this.logger = logger;
     this.fileSystem = fileSystem;
@@ -33,7 +33,15 @@ class SwaggerSchemaResolver {
    * @returns {Promise<{usageSchema: Record<string, *>, originalSchema: Record<string, *>}>}
    */
   async create() {
-    const { spec, patch, input, url, disableStrictSSL, disableProxy, authorizationToken } = this.config;
+    const {
+      spec,
+      patch,
+      input,
+      url,
+      disableStrictSSL,
+      disableProxy,
+      authorizationToken,
+    } = this.config;
 
     if (this.config.spec) {
       return await this.convertSwaggerObject(spec, { patch });
@@ -46,7 +54,8 @@ class SwaggerSchemaResolver {
       disableProxy,
       authorizationToken,
     );
-    const swaggerSchemaObject = this.processSwaggerSchemaFile(swaggerSchemaFile);
+    const swaggerSchemaObject =
+      this.processSwaggerSchemaFile(swaggerSchemaFile);
     return await this.convertSwaggerObject(swaggerSchemaObject, { patch });
   }
 
@@ -61,8 +70,8 @@ class SwaggerSchemaResolver {
       const result = _.cloneDeep(swaggerSchema);
       result.info = _.merge(
         {
-          title: "No title",
-          version: "",
+          title: 'No title',
+          version: '',
         },
         result.info,
       );
@@ -75,11 +84,15 @@ class SwaggerSchemaResolver {
           {
             ...converterOptions,
             warnOnly: true,
-            refSiblings: "preserve",
-            rbname: "requestBodyName",
+            refSiblings: 'preserve',
+            rbname: 'requestBodyName',
           },
           (err, options) => {
-            const parsedSwaggerSchema = _.get(err, "options.openapi", _.get(options, "openapi"));
+            const parsedSwaggerSchema = _.get(
+              err,
+              'options.openapi',
+              _.get(options, 'openapi'),
+            );
             if (!parsedSwaggerSchema && err) {
               throw new Error(err);
             }
@@ -99,10 +112,20 @@ class SwaggerSchemaResolver {
     });
   }
 
-  async fetchSwaggerSchemaFile(pathToSwagger, urlToSwagger, disableStrictSSL, disableProxy, authToken) {
+  getSwaggerSchemaByPath = (pathToSwagger) => {
+    this.logger.log(`try to get swagger by path "${pathToSwagger}"`);
+    return this.fileSystem.getFileContent(pathToSwagger);
+  };
+
+  async fetchSwaggerSchemaFile(
+    pathToSwagger,
+    urlToSwagger,
+    disableStrictSSL,
+    disableProxy,
+    authToken,
+  ) {
     if (this.fileSystem.pathIsExist(pathToSwagger)) {
-      this.logger.log(`try to get swagger by path "${pathToSwagger}"`);
-      return this.fileSystem.getFileContent(pathToSwagger);
+      return this.getSwaggerSchemaByPath(pathToSwagger);
     } else {
       this.logger.log(`try to get swagger by URL "${urlToSwagger}"`);
       return await this.request.download({
@@ -115,7 +138,7 @@ class SwaggerSchemaResolver {
   }
 
   processSwaggerSchemaFile(file) {
-    if (typeof file !== "string") return file;
+    if (typeof file !== 'string') return file;
 
     try {
       return JSON.parse(file);
@@ -125,8 +148,8 @@ class SwaggerSchemaResolver {
   }
 
   fixSwaggerSchema({ usageSchema, originalSchema }) {
-    const usagePaths = _.get(usageSchema, "paths");
-    const originalPaths = _.get(originalSchema, "paths");
+    const usagePaths = _.get(usageSchema, 'paths');
+    const originalPaths = _.get(originalSchema, 'paths');
 
     // walk by routes
     _.each(usagePaths, (usagePathObject, route) => {
@@ -135,20 +158,30 @@ class SwaggerSchemaResolver {
       // 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 || [])]),
-        );
+        const usageRouteParams = _.get(usageRouteInfo, 'parameters', []);
+        const originalRouteParams = _.get(originalRouteInfo, 'parameters', []);
+
+        if (typeof usageRouteInfo === 'object') {
+          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,
+            (param) =>
+              originalRouteParam.in === param.in &&
+              originalRouteParam.name === param.name,
           );
           if (!existUsageParam) {
             usageRouteParams.push(originalRouteParam);

package/src/templates-worker.js

@@ -0,0 +1,240 @@
+const { resolve } = require('path');
+const _ = require('lodash');
+const Eta = require('eta');
+const path = require('path');
+
+class TemplatesWorker {
+  /**
+   * @type {CodeGenConfig}
+   */
+  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;
+  }
+
+  /**
+   *
+   * @param config {CodeGenConfig}
+   * @returns {CodeGenConfig.templatePaths}
+   */
+  getTemplatePaths = (config) => {
+    const baseTemplatesPath = resolve(__dirname, '../templates/base');
+    const defaultTemplatesPath = resolve(__dirname, '../templates/default');
+    const modularTemplatesPath = resolve(__dirname, '../templates/modular');
+    const originalTemplatesPath = config.modular
+      ? modularTemplatesPath
+      : defaultTemplatesPath;
+    const customTemplatesPath =
+      (config.templates && resolve(process.cwd(), config.templates)) || null;
+
+    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,
+    };
+  };
+
+  cropExtension = (path) =>
+    this.config.templateExtensions.reduce(
+      (path, ext) => (_.endsWith(path, ext) ? path.replace(ext, '') : path),
+      path,
+    );
+
+  getTemplateFullPath = (path, fileName) => {
+    const raw = resolve(path, './', this.cropExtension(fileName));
+    const pathVariants = this.config.templateExtensions.map(
+      (extension) => `${raw}${extension}`,
+    );
+
+    return pathVariants.find(
+      (variant) => !!this.fileSystem.pathIsExist(variant),
+    );
+  };
+
+  requireFnFromTemplate = (packageOrPath) => {
+    const isPath =
+      _.startsWith(packageOrPath, './') || _.startsWith(packageOrPath, '../');
+
+    if (isPath) {
+      return require(path.resolve(
+        this.config.templatePaths.custom || this.config.templatePaths.original,
+        packageOrPath,
+      ));
+    }
+
+    return require(packageOrPath);
+  };
+
+  getTemplate = ({ fileName, name, path }) => {
+    const { templatePaths } = this.config;
+
+    if (path) {
+      return this.fileSystem.getFileContent(path);
+    }
+
+    if (!fileName) return '';
+
+    const customFullPath =
+      templatePaths.custom &&
+      this.getTemplateFullPath(templatePaths.custom, fileName);
+    let fileContent =
+      customFullPath && this.fileSystem.getFileContent(customFullPath);
+
+    if (fileContent) {
+      this.logger.log(
+        `"${_.lowerCase(name)}" template found in "${templatePaths.custom}"`,
+      );
+      return fileContent;
+    }
+
+    const baseFullPath = this.getTemplateFullPath(templatePaths.base, fileName);
+
+    if (baseFullPath) {
+      fileContent = this.fileSystem.getFileContent(baseFullPath);
+    } else {
+      if (templatePaths.custom) {
+        this.logger.warn(
+          `"${_.lowerCase(name)}" template not found in "${
+            templatePaths.custom
+          }"`,
+          `\nCode generator will use the default template`,
+        );
+      } else {
+        this.logger.log(
+          `Code generator will use the default template for "${_.lowerCase(
+            name,
+          )}"`,
+        );
+      }
+    }
+
+    const originalFullPath = this.getTemplateFullPath(
+      templatePaths.original,
+      fileName,
+    );
+
+    if (originalFullPath) {
+      fileContent = this.fileSystem.getFileContent(originalFullPath);
+    }
+
+    return fileContent;
+  };
+
+  getTemplates = ({ templatePaths }) => {
+    if (templatePaths.custom) {
+      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 }),
+      }),
+      {},
+    );
+  };
+
+  findTemplateWithExt = (path) => {
+    const raw = this.cropExtension(path);
+    const pathVariants = this.config.templateExtensions.map(
+      (extension) => `${raw}${extension}`,
+    );
+    return pathVariants.find((variant) => this.fileSystem.pathIsExist(variant));
+  };
+
+  getTemplateContent = (path) => {
+    const foundTemplatePathKey = _.keys(this.config.templatePaths).find((key) =>
+      _.startsWith(path, `@${key}`),
+    );
+
+    const rawPath = resolve(
+      _.replace(
+        path,
+        `@${foundTemplatePathKey}`,
+        this.config.templatePaths[foundTemplatePathKey],
+      ),
+    );
+    const fixedPath = this.findTemplateWithExt(rawPath);
+
+    if (fixedPath) {
+      return this.fileSystem.getFileContent(fixedPath);
+    }
+
+    const customPath =
+      this.config.templatePaths.custom &&
+      this.findTemplateWithExt(resolve(this.config.templatePaths.custom, path));
+
+    if (customPath) {
+      return this.fileSystem.getFileContent(customPath);
+    }
+
+    const originalPath = this.findTemplateWithExt(
+      resolve(this.config.templatePaths.original, path),
+    );
+
+    if (originalPath) {
+      return this.fileSystem.getFileContent(originalPath);
+    }
+
+    return '';
+  };
+
+  /**
+   * @param template
+   * @param configuration
+   * @param options
+   * @returns {Promise<string|string|void>}
+   */
+  renderTemplate = (template, configuration, options) => {
+    if (!template) return '';
+
+    return Eta.render(
+      template,
+      {
+        ...this.getRenderTemplateData(),
+        ...configuration,
+      },
+      {
+        async: false,
+        ...(options || {}),
+        includeFile: (path, configuration, options) => {
+          return this.renderTemplate(
+            this.getTemplateContent(path),
+            configuration,
+            options,
+          );
+        },
+      },
+    );
+  };
+}
+
+module.exports = {
+  TemplatesWorker,
+};

package/src/translators/javascript.js

@@ -0,0 +1,83 @@
+const ts = require('typescript');
+const { Translator } = require('./translator');
+
+class JavascriptTranslator extends Translator {
+  /**
+   * @param {TranslatorIO} input
+   * @returns {Record<string, string>}
+   */
+  compileTSCode = (input) => {
+    const fileNameFull = `${input.fileName}${input.fileExtension}`;
+    const output = {};
+    const host = ts.createCompilerHost(this.config.compilerTsConfig, true);
+    const fileNames = [fileNameFull];
+    const originalSourceFileGet = host.getSourceFile.bind(host);
+    host.getSourceFile = (
+      sourceFileName,
+      languageVersion,
+      onError,
+      shouldCreateNewSourceFile,
+    ) => {
+      if (sourceFileName !== fileNameFull)
+        return originalSourceFileGet(
+          sourceFileName,
+          languageVersion,
+          onError,
+          shouldCreateNewSourceFile,
+        );
+
+      return ts.createSourceFile(
+        sourceFileName,
+        input.fileContent,
+        languageVersion,
+        true,
+        ts.ScriptKind.TS,
+      );
+    };
+
+    host.writeFile = (fileName, contents) => {
+      output[fileName] = contents;
+    };
+
+    ts.createProgram(fileNames, this.config.compilerTsConfig, host).emit();
+
+    return output;
+  };
+
+  translate = async (input) => {
+    const compiled = this.compileTSCode(input);
+
+    const jsFileName = `${input.fileName}${ts.Extension.Js}`;
+    const dtsFileName = `${input.fileName}${ts.Extension.Dts}`;
+    const sourceContent = compiled[jsFileName];
+    const tsImportRows = input.fileContent
+      .split('\n')
+      .filter((line) => line.startsWith('import '));
+    const declarationContent = compiled[dtsFileName]
+      .split('\n')
+      .map((line) => {
+        if (line.startsWith('import ')) {
+          return tsImportRows.shift();
+        }
+        return line;
+      })
+      .join('\n');
+
+    return [
+      {
+        fileName: input.fileName,
+        fileExtension: ts.Extension.Js,
+        fileContent: await this.codeFormatter.formatCode(sourceContent),
+      },
+      {
+        fileName: input.fileName,
+        fileExtension: ts.Extension.Dts,
+        fileContent: await this.codeFormatter.formatCode(declarationContent),
+      },
+    ];
+  };
+}
+
+module.exports = {
+  JavascriptTranslator,
+};

package/src/translators/translator.js

@@ -0,0 +1,35 @@
+/**
+ * @typedef {{ fileName: string, fileExtension: string, fileContent: string }} TranslatorIO
+ */
+
+class Translator {
+  /** @type {Logger} */
+  logger;
+  /** @type {CodeGenConfig} */
+  config;
+  /** @type {CodeFormatter} */
+  codeFormatter;
+
+  /**
+   * @param codeGenProcess
+   */
+  constructor(codeGenProcess) {
+    this.logger = codeGenProcess.logger;
+    this.config = codeGenProcess.config;
+    this.codeFormatter = codeGenProcess.codeFormatter;
+  }
+
+  /**
+   *
+   * @param input {TranslatorIO}
+   * @return {Promise<TranslatorIO[]>}
+   */
+  // eslint-disable-next-line no-unused-vars
+  translate(input) {
+    throw new Error('not implemented');
+  }
+}
+
+module.exports = {
+  Translator,
+};