swagger-typescript-api 13.0.9 → 13.0.11

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

@@ -1,24 +0,0 @@
-import { NameResolver } from "../../util/name-resolver.js";
-
-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;
-    });
-  }
-}
-
-export { SpecificArgNameResolver };

package/src/schema-walker.js

@@ -1,91 +0,0 @@
-import _ from "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;
-  };
-}
-
-export { SchemaWalker };

package/src/swagger-schema-resolver.js

@@ -1,195 +0,0 @@
-import yaml from "js-yaml";
-import _ from "lodash";
-import converter from "swagger2openapi";
-import { Request } from "./util/request.js";
-
-class SwaggerSchemaResolver {
-  /**
-   * @type {CodeGenConfig}
-   */
-  config;
-  /**
-   * @type {Logger}
-   */
-  logger;
-  /**
-   * @type {FileSystem}
-   */
-  fileSystem;
-  /**
-   * @type {Request}
-   */
-  request;
-
-  constructor({ config, logger, fileSystem }) {
-    this.config = config;
-    this.logger = logger;
-    this.fileSystem = fileSystem;
-    this.request = new Request(config, logger);
-  }
-
-  /**
-   *
-   * @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),
-        });
-      }
-    });
-  }
-
-  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)) {
-      return this.getSwaggerSchemaByPath(pathToSwagger);
-    } else {
-      this.logger.log(`try to get swagger by URL "${urlToSwagger}"`);
-      return await this.request.download({
-        url: urlToSwagger,
-        disableStrictSSL,
-        authToken,
-        disableProxy,
-      });
-    }
-  }
-
-  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", []);
-
-        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,
-          );
-          if (!existUsageParam) {
-            usageRouteParams.push(originalRouteParam);
-          }
-        });
-      });
-    });
-  }
-}
-
-export { SwaggerSchemaResolver };

package/src/templates-worker.js

@@ -1,243 +0,0 @@
-import { resolve } from "node:path";
-import path from "node:path";
-import url from "node:url";
-import * as Eta from "eta";
-import _ from "lodash";
-
-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 __dirname = path.dirname(url.fileURLToPath(import.meta.url));
-    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,
-          );
-        },
-      },
-    );
-  };
-}
-
-export { TemplatesWorker };

package/src/translators/javascript.js

@@ -1,81 +0,0 @@
-import ts from "typescript";
-import { Translator } from "./translator.js";
-
-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),
-      },
-    ];
-  };
-}
-
-export { JavascriptTranslator };

package/src/translators/translator.js

@@ -1,33 +0,0 @@
-/**
- * @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");
-  }
-}
-
-export { Translator };