swagger-typescript-api 12.0.4 → 13.0.0

package/templates/modular/procedure-call.ejs

@@ -1,100 +1,100 @@
-<%
-const { utils, route, config } = it;
-const { requestBodyInfo, responseBodyInfo, specificArgNameResolver } = route;
-const { _, getInlineParseContent, getParseContent, parseSchema, getComponentByRef, require } = utils;
-const { parameters, path, method, payload, query, formData, security, requestParams } = route.request;
-const { type, errorType, contentTypes } = route.response;
-const { HTTP_CLIENT, RESERVED_REQ_PARAMS_ARG_NAMES } = config.constants;
-const routeDocs = includeFile("@base/route-docs", { config, route, utils });
-const queryName = (query && query.name) || "query";
-const pathParams = _.values(parameters);
-const pathParamsNames = _.map(pathParams, "name");
-
-const isFetchTemplate = config.httpClientType === HTTP_CLIENT.FETCH;
-
-const requestConfigParam = {
-    name: specificArgNameResolver.resolve(RESERVED_REQ_PARAMS_ARG_NAMES),
-    optional: true,
-    type: "RequestParams",
-    defaultValue: "{}",
-}
-
-const argToTmpl = ({ name, optional, type, defaultValue }) => `${name}${!defaultValue && optional ? '?' : ''}: ${type}${defaultValue ? ` = ${defaultValue}` : ''}`;
-
-const rawWrapperArgs = config.extractRequestParams ?
-    _.compact([
-        requestParams && {
-          name: pathParams.length ? `{ ${_.join(pathParamsNames, ", ")}, ...${queryName} }` : queryName,
-          optional: false,
-          type: getInlineParseContent(requestParams),
-        },
-        ...(!requestParams ? pathParams : []),
-        payload,
-        requestConfigParam,
-    ]) :
-    _.compact([
-        ...pathParams,
-        query,
-        payload,
-        requestConfigParam,
-    ])
-
-const wrapperArgs = _
-    // Sort by optionality
-    .sortBy(rawWrapperArgs, [o => o.optional])
-    .map(argToTmpl)
-    .join(', ')
-
-// RequestParams["type"]
-const requestContentKind = {
-    "JSON": "ContentType.Json",
-    "URL_ENCODED": "ContentType.UrlEncoded",
-    "FORM_DATA": "ContentType.FormData",
-    "TEXT": "ContentType.Text",
-}
-// RequestParams["format"]
-const responseContentKind = {
-    "JSON": '"json"',
-    "IMAGE": '"blob"',
-    "FORM_DATA": isFetchTemplate ? '"formData"' : '"document"'
-}
-
-const bodyTmpl = _.get(payload, "name") || null;
-const queryTmpl = (query != null && queryName) || null;
-const bodyContentKindTmpl = requestContentKind[requestBodyInfo.contentKind] || null;
-const responseFormatTmpl = responseContentKind[responseBodyInfo.success && responseBodyInfo.success.schema && responseBodyInfo.success.schema.contentKind] || null;
-const securityTmpl = security ? 'true' : null;
-
-const describeReturnType = () => {
-    if (!config.toJS) return "";
-
-    switch(config.httpClientType) {
-        case HTTP_CLIENT.AXIOS: {
-          return `Promise<AxiosResponse<${type}>>`
-        }
-        default: {
-          return `Promise<HttpResponse<${type}, ${errorType}>`
-        }
-    }
-}
-
-%>
-/**
-<%~ routeDocs.description %>
-
- *<% /* Here you can add some other JSDoc tags */ %>
-
-<%~ routeDocs.lines %>
-
- */
-<%~ route.routeName.usage %> = (<%~ wrapperArgs %>)<%~ config.toJS ? `: ${describeReturnType()}` : "" %> =>
-    <%~ config.singleHttpClient ? 'this.http.request' : 'this.request' %><<%~ type %>, <%~ errorType %>>({
-        path: `<%~ path %>`,
-        method: '<%~ _.upperCase(method) %>',
-        <%~ queryTmpl ? `query: ${queryTmpl},` : '' %>
-        <%~ bodyTmpl ? `body: ${bodyTmpl},` : '' %>
-        <%~ securityTmpl ? `secure: ${securityTmpl},` : '' %>
-        <%~ bodyContentKindTmpl ? `type: ${bodyContentKindTmpl},` : '' %>
-        <%~ responseFormatTmpl ? `format: ${responseFormatTmpl},` : '' %>
-        ...<%~ _.get(requestConfigParam, "name") %>,
-    })
+<%
+const { utils, route, config } = it;
+const { requestBodyInfo, responseBodyInfo, specificArgNameResolver } = route;
+const { _, getInlineParseContent, getParseContent, parseSchema, getComponentByRef, require } = utils;
+const { parameters, path, method, payload, query, formData, security, requestParams } = route.request;
+const { type, errorType, contentTypes } = route.response;
+const { HTTP_CLIENT, RESERVED_REQ_PARAMS_ARG_NAMES } = config.constants;
+const routeDocs = includeFile("@base/route-docs", { config, route, utils });
+const queryName = (query && query.name) || "query";
+const pathParams = _.values(parameters);
+const pathParamsNames = _.map(pathParams, "name");
+
+const isFetchTemplate = config.httpClientType === HTTP_CLIENT.FETCH;
+
+const requestConfigParam = {
+    name: specificArgNameResolver.resolve(RESERVED_REQ_PARAMS_ARG_NAMES),
+    optional: true,
+    type: "RequestParams",
+    defaultValue: "{}",
+}
+
+const argToTmpl = ({ name, optional, type, defaultValue }) => `${name}${!defaultValue && optional ? '?' : ''}: ${type}${defaultValue ? ` = ${defaultValue}` : ''}`;
+
+const rawWrapperArgs = config.extractRequestParams ?
+    _.compact([
+        requestParams && {
+          name: pathParams.length ? `{ ${_.join(pathParamsNames, ", ")}, ...${queryName} }` : queryName,
+          optional: false,
+          type: getInlineParseContent(requestParams),
+        },
+        ...(!requestParams ? pathParams : []),
+        payload,
+        requestConfigParam,
+    ]) :
+    _.compact([
+        ...pathParams,
+        query,
+        payload,
+        requestConfigParam,
+    ])
+
+const wrapperArgs = _
+    // Sort by optionality
+    .sortBy(rawWrapperArgs, [o => o.optional])
+    .map(argToTmpl)
+    .join(', ')
+
+// RequestParams["type"]
+const requestContentKind = {
+    "JSON": "ContentType.Json",
+    "URL_ENCODED": "ContentType.UrlEncoded",
+    "FORM_DATA": "ContentType.FormData",
+    "TEXT": "ContentType.Text",
+}
+// RequestParams["format"]
+const responseContentKind = {
+    "JSON": '"json"',
+    "IMAGE": '"blob"',
+    "FORM_DATA": isFetchTemplate ? '"formData"' : '"document"'
+}
+
+const bodyTmpl = _.get(payload, "name") || null;
+const queryTmpl = (query != null && queryName) || null;
+const bodyContentKindTmpl = requestContentKind[requestBodyInfo.contentKind] || null;
+const responseFormatTmpl = responseContentKind[responseBodyInfo.success && responseBodyInfo.success.schema && responseBodyInfo.success.schema.contentKind] || null;
+const securityTmpl = security ? 'true' : null;
+
+const describeReturnType = () => {
+    if (!config.toJS) return "";
+
+    switch(config.httpClientType) {
+        case HTTP_CLIENT.AXIOS: {
+          return `Promise<AxiosResponse<${type}>>`
+        }
+        default: {
+          return `Promise<HttpResponse<${type}, ${errorType}>`
+        }
+    }
+}
+
+%>
+/**
+<%~ routeDocs.description %>
+
+ *<% /* Here you can add some other JSDoc tags */ %>
+
+<%~ routeDocs.lines %>
+
+ */
+<%~ route.routeName.usage %> = (<%~ wrapperArgs %>)<%~ config.toJS ? `: ${describeReturnType()}` : "" %> =>
+    <%~ config.singleHttpClient ? 'this.http.request' : 'this.request' %><<%~ type %>, <%~ errorType %>>({
+        path: `<%~ path %>`,
+        method: '<%~ _.upperCase(method) %>',
+        <%~ queryTmpl ? `query: ${queryTmpl},` : '' %>
+        <%~ bodyTmpl ? `body: ${bodyTmpl},` : '' %>
+        <%~ securityTmpl ? `secure: ${securityTmpl},` : '' %>
+        <%~ bodyContentKindTmpl ? `type: ${bodyContentKindTmpl},` : '' %>
+        <%~ responseFormatTmpl ? `format: ${responseFormatTmpl},` : '' %>
+        ...<%~ _.get(requestConfigParam, "name") %>,
+    })

package/templates/modular/route-types.ejs

@@ -1,18 +1,18 @@
-<%
-const { utils, config, route, modelTypes } = it;
-const { _, pascalCase } = utils;
-const { routes, moduleName } = route;
-const dataContracts = config.modular ? _.map(modelTypes, "name") : [];
-
-%>
-<% if (dataContracts.length) { %>
-import { <%~ dataContracts.join(", ") %> } from "./<%~ config.fileNames.dataContracts %>"
-<% } %>
-
-export namespace <%~ pascalCase(moduleName) %> {
-    <% _.forEach(routes, (route) => { %>
-
-        <%~ includeFile('@base/route-type.ejs', { ...it, route }) %>
-
-    <% }) %>
-}
+<%
+const { utils, config, route, modelTypes } = it;
+const { _, pascalCase } = utils;
+const { routes, moduleName } = route;
+const dataContracts = config.modular ? _.map(modelTypes, "name") : [];
+
+%>
+<% if (dataContracts.length) { %>
+import { <%~ dataContracts.join(", ") %> } from "./<%~ config.fileNames.dataContracts %>"
+<% } %>
+
+export namespace <%~ pascalCase(moduleName) %> {
+    <% for (const route of routes) { %>
+
+        <%~ includeFile('@base/route-type.ejs', { ...it, route }) %>
+
+    <% } %>
+}

package/src/templates.js

@@ -1,177 +0,0 @@
-const { resolve } = require("path");
-const _ = require("lodash");
-const Eta = require("eta");
-const path = require("path");
-
-class Templates {
-  /**
-   * @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;
-  }
-
-  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,
-    };
-  };
-
-  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.templates, packageOrPath));
-    }
-
-    return require(packageOrPath);
-  };
-
-  getTemplate = ({ fileName, name, path }) => {
-    const { templatePaths } = this.config;
-
-    if (path) {
-      return this.fileSystem.getFileContent(path);
-    }
-
-    if (!fileName) return "";
-
-    const customFullPath = 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 {
-      this.logger.warn(
-        `"${_.lowerCase(name)}" template not found in "${templatePaths.custom}"`,
-        `\nCode generator will use the default template`,
-      );
-    }
-
-    const originalFullPath = this.getTemplateFullPath(templatePaths.original, fileName);
-
-    if (originalFullPath) {
-      fileContent = this.fileSystem.getFileContent(originalFullPath);
-    }
-
-    return fileContent;
-  };
-
-  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 }),
-      }),
-      {},
-    );
-  };
-
-  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.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 "";
-  };
-
-  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 = {
-  Templates,
-};

package/src/translators/JavaScript.js

@@ -1,60 +0,0 @@
-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);
-    const sourceContent = translated[sourceFileName];
-    const tsImportRows = sourceTypeScript.split("\n").filter((line) => line.startsWith("import "));
-    const declarationContent = translated[declarationFileName]
-      .split("\n")
-      .map((line) => {
-        if (line.startsWith("import ")) {
-          return tsImportRows.shift();
-        }
-        return line;
-      })
-      .join("\n");
-
-    return {
-      sourceContent: sourceContent,
-      declarationContent: declarationContent,
-    };
-  },
-};