swagger-typescript-api 10.0.1 → 10.0.3

package/src/render/utils/index.js

@@ -1,7 +1,13 @@
 const { classNameCase, formatDescription, internalCase } = require("../../common");
 const { getComponentByRef } = require("../../components");
 const { formatModelName } = require("../../modelNames");
-const { getInlineParseContent, getParseContent, parseSchema } = require("../../schema");
+const {
+  getInlineParseContent,
+  getParseContent,
+  parseSchema,
+  checkAndAddNull,
+  isNeedToAddNull,
+} = require("../../schema");
 const { formatters, inlineExtraFormatters } = require("../../typeFormatters");
 const { NameResolver } = require("../../utils/resolveName");
 
@@ -14,6 +20,8 @@ module.exports = {
   getComponentByRef,
   parseSchema,
   formatters,
+  checkAndAddNull,
+  isNeedToAddNull,
   inlineExtraFormatters,
   formatModelName,
   fmtToJSDocLine: require("./fmtToJSDocLine"),

package/src/routes.js

@@ -520,7 +520,10 @@ const parseRoutes = ({ usageSchema, parsedSchemas, moduleNameIndex, moduleNameFi
             moduleNameFirstTag && firstTag
               ? _.camelCase(firstTag)
               : _.camelCase(_.compact(_.split(route, "/"))[moduleNameIndex]);
-          const hasSecurity = !!((globalSecurity && globalSecurity.length) || (security && security.length));
+          let hasSecurity = !!(globalSecurity && globalSecurity.length);
+          if (security) {
+            hasSecurity = security.length > 0;
+          }
 
           const routeParams = getRouteParams(routeInfo, pathParams);
 

package/src/schema.js

@@ -74,6 +74,23 @@ const getInternalSchemaType = (schema) => {
   return SCHEMA_TYPES.PRIMITIVE;
 };
 
+const isNeedToAddNull = (contract, value) => {
+  const { nullable, type } = contract || {};
+  return (
+    (nullable || !!_.get(contract, "x-nullable") || type === TS_KEYWORDS.NULL) &&
+    (!_.isString(value) || (!value.includes(` ${TS_KEYWORDS.NULL}`) && !value.includes(`${TS_KEYWORDS.NULL} `)))
+  );
+};
+
+const checkAndAddRequiredKeys = (schema, resultType) => {
+  if ("$$requiredKeys" in schema && schema.$$requiredKeys.length) {
+    config.internalTemplateOptions.addUtilRequiredKeysType = true;
+    return `UtilRequiredKeys<${resultType}, ${schema.$$requiredKeys.map((k) => `"${k}"`).join(" | ")}>`;
+  }
+
+  return resultType;
+};
+
 const checkAndAddNull = (schema, value) => {
   const { nullable, type } = schema || {};
   return (nullable || !!_.get(schema, "x-nullable") || type === TS_KEYWORDS.NULL) &&
@@ -88,9 +105,9 @@ const isRef = (property) => {
   return !!(property && property["$ref"]);
 };
 
-const getRefType = (property) => {
-  const ref = property && property["$ref"];
-  return (ref && config.componentsMap[ref]) || null;
+const getRefType = (schema) => {
+  const ref = schema && schema["$ref"];
+  return config.componentsMap[ref] || null;
 };
 
 const getType = (schema) => {
@@ -99,11 +116,11 @@ const getType = (schema) => {
   const refTypeInfo = getRefType(schema);
 
   if (refTypeInfo) {
-    return checkAndAddNull(schema, formatModelName(refTypeInfo.typeName));
+    return checkAndAddRequiredKeys(schema, checkAndAddNull(schema, formatModelName(refTypeInfo.typeName)));
   }
 
   const primitiveType = getTypeAlias(schema);
-  return primitiveType ? checkAndAddNull(schema, primitiveType) : TS_KEYWORDS.ANY;
+  return primitiveType ? checkAndAddRequiredKeys(schema, checkAndAddNull(schema, primitiveType)) : TS_KEYWORDS.ANY;
 };
 
 const isRequired = (property, name, requiredProperties) => {
@@ -177,73 +194,76 @@ const getObjectTypeContent = (schema) => {
   return propertiesContent;
 };
 
-const complexTypeGetter = (schema) => getInlineParseContent(schema);
-const filterContents = (contents, types) => _.filter(contents, (type) => !_.includes(types, type));
-
-const makeAddRequiredToChildSchema = (parentSchema) => (childSchema) => {
-  let required = childSchema.required || [];
-  let properties = childSchema.properties || {};
-
-  // Inherit all the required fields from the parent schema that are defined
-  // either on the parent schema or on the child schema
-  // TODO: any that are defined at grandparents or higher are ignored
-  required = required.concat(
-    (parentSchema.required || []).filter(
-      (key) =>
-        !required.includes(key) && (_.keys(properties).includes(key) || _.keys(parentSchema.properties).includes(key)),
-    ),
-  );
+const filterContents = (contents, types) => _.uniq(_.filter(contents, (type) => !_.includes(types, type)));
 
-  // Identify properties that are required in the child schema, but
-  // defined only in the parent schema (TODO: this only works one level deep)
-  const parentPropertiesRequiredByChild = required.filter(
-    (key) => !_.keys(childSchema.properties).includes(key) && _.keys(parentSchema.properties).includes(key),
-  );
+const makeAddRequiredToChildSchema = (parentSchema, childSchema) => {
+  if (!childSchema) return childSchema;
 
-  // Add such properties to the child so that they can be overriden and made required
-  properties = {
-    ...properties,
-    ...parentPropertiesRequiredByChild.reduce(
-      (additionalProperties, key) => ({
-        ...additionalProperties,
-        [key]: (parentSchema.properties || {})[key],
-      }),
-      {},
-    ),
-  };
-
-  return _.merge(
-    {
-      required: required,
-      properties: properties,
-    },
-    childSchema,
-  );
+  const required = _.uniq([...(parentSchema.required || []), ...(childSchema.required || [])]);
+
+  const refData = getRefType(childSchema);
+
+  if (refData) {
+    const refObjectProperties = _.keys((refData.rawTypeData && refData.rawTypeData.properties) || {});
+    const existedRequiredKeys = refObjectProperties.filter((key) => required.includes(key));
+
+    if (!existedRequiredKeys.length) return childSchema;
+
+    return {
+      ...childSchema,
+      $$requiredKeys: existedRequiredKeys,
+    };
+  } else if (childSchema.properties) {
+    const childSchemaProperties = _.keys(childSchema.properties);
+    const existedRequiredKeys = childSchemaProperties.filter((key) => required.includes(key));
+
+    if (!existedRequiredKeys.length) return childSchema;
+
+    return {
+      required: _.uniq([...(childSchema.required || []), ...existedRequiredKeys]),
+      ...childSchema,
+    };
+  }
+
+  return childSchema;
 };
 
 const complexSchemaParsers = {
+  // T1 | T2
   [SCHEMA_TYPES.COMPLEX_ONE_OF]: (schema) => {
-    // T1 | T2
-    const combined = _.map(_.map(schema.oneOf, makeAddRequiredToChildSchema(schema)), complexTypeGetter);
+    const combined = _.map(schema.oneOf, (childSchema) =>
+      getInlineParseContent(makeAddRequiredToChildSchema(schema, childSchema)),
+    );
+    const filtered = filterContents(combined, [TS_KEYWORDS.ANY]);
 
-    return checkAndAddNull(schema, filterContents(combined, [TS_KEYWORDS.ANY]).join(" | "));
+    const type = filtered.join(" | ");
+
+    return checkAndAddNull(schema, type);
   },
+  // T1 & T2
   [SCHEMA_TYPES.COMPLEX_ALL_OF]: (schema) => {
-    // T1 & T2
-    const combined = _.map(_.map(schema.allOf, makeAddRequiredToChildSchema(schema)), complexTypeGetter);
-    return checkAndAddNull(
-      schema,
-      filterContents(combined, [...JS_EMPTY_TYPES, ...JS_PRIMITIVE_TYPES, TS_KEYWORDS.ANY]).join(" & "),
+    const combined = _.map(schema.allOf, (childSchema) =>
+      getInlineParseContent(makeAddRequiredToChildSchema(schema, childSchema)),
     );
+    const filtered = filterContents(combined, [...JS_PRIMITIVE_TYPES, TS_KEYWORDS.ANY]);
+
+    const type = filtered.join(TS_KEYWORDS.TYPE_AND_OPERATOR);
+
+    return checkAndAddNull(schema, type);
   },
+  // T1 | T2 | (T1 & T2)
   [SCHEMA_TYPES.COMPLEX_ANY_OF]: (schema) => {
-    // T1 | T2 | (T1 & T2)
-    const combined = _.map(_.map(schema.anyOf, makeAddRequiredToChildSchema(schema)), complexTypeGetter);
-    const nonEmptyTypesCombined = filterContents(combined, [...JS_EMPTY_TYPES, ...JS_PRIMITIVE_TYPES, TS_KEYWORDS.ANY]);
-    return checkAndAddNull(
-      schema,
-      `${combined.join(" | ")}` + (nonEmptyTypesCombined.length > 1 ? ` | (${nonEmptyTypesCombined.join(" & ")})` : ""),
+    const combined = _.map(schema.anyOf, (childSchema) =>
+      getInlineParseContent(makeAddRequiredToChildSchema(schema, childSchema)),
     );
+    const filtered = filterContents(combined, [...JS_PRIMITIVE_TYPES, TS_KEYWORDS.ANY]);
+
+    const type = _.compact([
+      ...filtered,
+      filtered.length > 1 && `(${filtered.join(TS_KEYWORDS.TYPE_AND_OPERATOR)})`,
+    ]).join(TS_KEYWORDS.TYPE_OR_OPERATOR);
+
+    return checkAndAddNull(schema, type);
   },
   // TODO
   [SCHEMA_TYPES.COMPLEX_NOT]: (schema) => {
@@ -357,15 +377,17 @@ const schemaParsers = {
         schema.description || _.compact(_.map(schema[complexType], "description"))[0] || "",
       ),
       content:
-        _.compact([
-          complexSchemaContent && `(${complexSchemaContent})`,
-          getInternalSchemaType(simpleSchema) === TS_KEYWORDS.OBJECT && getInlineParseContent(simpleSchema),
-        ]).join(" & ") || TS_KEYWORDS.ANY,
+        _.uniq(
+          _.compact([
+            complexSchemaContent && `(${complexSchemaContent})`,
+            getInternalSchemaType(simpleSchema) === SCHEMA_TYPES.OBJECT && `(${getInlineParseContent(simpleSchema)})`,
+          ]),
+        ).join(" & ") || TS_KEYWORDS.ANY,
     });
   },
   [SCHEMA_TYPES.PRIMITIVE]: (schema, typeName) => {
     let contentType = null;
-    const { additionalProperties, type, description } = schema || {};
+    const { additionalProperties, type, description, $$requiredKeys } = schema || {};
 
     if (type === TS_KEYWORDS.OBJECT && additionalProperties) {
       const fieldType = _.isObject(additionalProperties)
@@ -444,6 +466,7 @@ module.exports = {
   parseSchemas,
   getInlineParseContent,
   getParseContent,
+  isNeedToAddNull,
   getType,
   getRefType,
   SCHEMA_TYPES,

package/src/swagger.js

@@ -25,7 +25,10 @@ const getSwaggerFile = (pathToSwagger, urlToSwagger, disableStrictSSL, disablePr
     } else {
       logger.log(`try to get swagger by URL "${urlToSwagger}"`);
       // setup options for Axios
-      const axiosOptions = {};
+      const axiosOptions = {
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity,
+      };
       //
       if (disableStrictSSL) {
         axiosOptions.httpsAgent = new https.Agent({

package/src/templates.js

@@ -5,16 +5,23 @@ 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.eta" },
-  { name: "dataContracts", fileName: "data-contracts.eta" },
-  { name: "httpClient", fileName: "http-client.eta" },
-  { name: "routeTypes", fileName: "route-types.eta" },
-  { name: "routeName", fileName: "route-name.eta" },
+  { 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 }) => {
@@ -38,6 +45,16 @@ const getTemplatePaths = ({ templates, modular }) => {
   };
 };
 
+const cropExtension = (path) =>
+  TEMPLATE_EXTENSIONS.reduce((path, ext) => (_.endsWith(path, ext) ? path.replace(ext, "") : path), path);
+
+const getTemplateFullPath = (path, fileName) => {
+  const raw = resolve(path, "./", cropExtension(fileName));
+  const pathVariants = TEMPLATE_EXTENSIONS.map((extension) => `${raw}${extension}`);
+
+  return pathVariants.find((variant) => !!pathIsExist(variant));
+};
+
 const getTemplate = ({ fileName, name, path }) => {
   const { templatePaths } = config;
 
@@ -47,14 +64,13 @@ const getTemplate = ({ fileName, name, path }) => {
 
   if (!fileName) return "";
 
-  const customFullPath = resolve(templatePaths.custom, "./", fileName);
-  let fileContent = pathIsExist(customFullPath) && getFileContent(customFullPath);
+  const customFullPath = getTemplateFullPath(templatePaths.custom, fileName);
+  let fileContent = customFullPath && getFileContent(customFullPath);
 
   if (!fileContent) {
-    const baseFullPath = resolve(templatePaths.base, "./", fileName);
-    const originalFullPath = resolve(templatePaths.original, "./", fileName);
+    const baseFullPath = getTemplateFullPath(templatePaths.base, fileName);
 
-    if (pathIsExist(baseFullPath)) {
+    if (baseFullPath) {
       fileContent = getFileContent(baseFullPath);
     } else {
       logger.warn(
@@ -63,7 +79,9 @@ const getTemplate = ({ fileName, name, path }) => {
       );
     }
 
-    if (pathIsExist(originalFullPath)) {
+    const originalFullPath = getTemplateFullPath(templatePaths.original, fileName);
+
+    if (originalFullPath) {
       fileContent = getFileContent(originalFullPath);
     }
   }
@@ -87,27 +105,30 @@ const getTemplates = ({ templatePaths }) => {
 };
 
 const getTemplateContent = (path) => {
-  let fixedPath = _.endsWith(path, ".eta") ? path : `${path}.eta`;
+  const foundTemplatePathKey = _.keys(config.templatePaths).find((key) => _.startsWith(path, `@${key}`));
 
-  _.keys(config.templatePaths).forEach((key) => {
-    if (_.startsWith(fixedPath, `@${key}`)) {
-      fixedPath = resolve(_.replace(fixedPath, `@${key}`, config.templatePaths[key]));
-    }
-  });
+  const findPathWithExt = (path) => {
+    const raw = cropExtension(path);
+    const pathVariants = TEMPLATE_EXTENSIONS.map((extension) => `${raw}${extension}`);
+    return pathVariants.find((variant) => pathIsExist(variant));
+  };
+
+  const rawPath = resolve(_.replace(path, `@${foundTemplatePathKey}`, config.templatePaths[foundTemplatePathKey]));
+  const fixedPath = findPathWithExt(rawPath);
 
-  if (pathIsExist(fixedPath)) {
+  if (fixedPath) {
     return getFileContent(fixedPath);
   }
 
-  const customPath = resolve(config.templatePaths.custom, fixedPath);
+  const customPath = findPathWithExt(resolve(config.templatePaths.custom, path));
 
-  if (pathIsExist(customPath)) {
+  if (customPath) {
     return getFileContent(customPath);
   }
 
-  const originalPath = resolve(config.templatePaths.original, fixedPath);
+  const originalPath = findPathWithExt(resolve(config.templatePaths.original, path));
 
-  if (pathIsExist(originalPath)) {
+  if (originalPath) {
     return getFileContent(originalPath);
   }
 
@@ -120,7 +141,9 @@ const renderTemplate = (template, configuration, options) => {
   return Eta.render(template, configuration, {
     async: false,
     ...(options || {}),
-    includeFile: (path, payload) => renderTemplate(getTemplateContent(path), payload),
+    includeFile: (path, payload, options) => {
+      return renderTemplate(getTemplateContent(path), payload, options);
+    },
   });
 };
 

package/src/translators/JavaScript.js

@@ -7,20 +7,9 @@ function translate(fileName, content, options) {
   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,
-    );
+      return originalSourceFileGet(sourceFileName, languageVersion, onError, shouldCreateNewSourceFile);
+
+    return ts.createSourceFile(sourceFileName, content, languageVersion, true, ts.ScriptKind.External);
   };
 
   host.writeFile = (fileName, contents) => {

package/src/typeFormatters.js

@@ -1,57 +1,70 @@
 const _ = require("lodash");
 const { config } = require("./config");
-const { TS_KEYWORDS, SCHEMA_TYPES } = require("./constants");
+const { TS_KEYWORDS, SCHEMA_TYPES, TS_EXTERNAL } = require("./constants");
+
+const checkAndAddNull = (schema, value) => {
+  const { nullable, type } = schema || {};
+  return (nullable || !!_.get(schema, "x-nullable") || type === TS_KEYWORDS.NULL) &&
+    _.isString(value) &&
+    !value.includes(` ${TS_KEYWORDS.NULL}`) &&
+    !value.includes(`${TS_KEYWORDS.NULL} `)
+    ? `${value} | ${TS_KEYWORDS.NULL}`
+    : value;
+};
 
 const formatters = {
-  [SCHEMA_TYPES.ENUM]: (content) => {
-    const isNumberEnum = _.some(content, (content) => typeof content.key === "number");
+  [SCHEMA_TYPES.ENUM]: (parsedSchema) => {
+    const isNumberEnum = _.some(parsedSchema.content, (content) => typeof content.key === "number");
     const formatAsUnionType = !!(isNumberEnum || config.generateUnionEnums);
 
     if (formatAsUnionType) {
-      return _.map(content, ({ value }) => value).join(" | ");
+      return {
+        ...parsedSchema,
+        $content: parsedSchema.content,
+        content: _.map(parsedSchema.content, ({ value }) => value).join(" | "),
+      };
     }
 
-    return _.map(content, ({ key, value }) => `  ${key} = ${value}`).join(",\n");
+    return {
+      ...parsedSchema,
+      $content: parsedSchema.content,
+      content: _.map(parsedSchema.content, ({ key, value }) => `  ${key} = ${value}`).join(",\n"),
+    };
   },
-  [SCHEMA_TYPES.OBJECT]: (content) =>
-    _.map(content, (part) => {
-      const extraSpace = "  ";
-      const result = `${extraSpace}${part.field};\n`;
-
-      const comments = _.uniq(_.compact([part.title, part.description]).reduce(
-        (acc, comment) => [...acc, ...comment.split(/\n/g)],
-        [],
-      ));
-
-      const commonText = comments.length
-        ? [
-            "",
-            ...(comments.length === 1
-              ? [`/** ${comments[0]} */`]
-              : ["/**", ...comments.map((commentPart) => ` * ${commentPart}`), " */"]),
-          ]
-            .map((part) => `${extraSpace}${part}\n`)
-            .join("")
-        : "";
-
-      return `${commonText}${result}`;
-    }).join(""),
-  [SCHEMA_TYPES.PRIMITIVE]: (content) => {
-    return content;
+  [SCHEMA_TYPES.OBJECT]: (parsedSchema) => {
+    if (parsedSchema.nullable) return inlineExtraFormatters[SCHEMA_TYPES.OBJECT](parsedSchema);
+    return {
+      ...parsedSchema,
+      $content: parsedSchema.content,
+      content: formatObjectContent(parsedSchema.content),
+    };
+  },
+  [SCHEMA_TYPES.PRIMITIVE]: (parsedSchema) => {
+    return {
+      ...parsedSchema,
+      $content: parsedSchema.content,
+    };
   },
 };
 
 /** transform content of parsed schema to string or compact size */
 const inlineExtraFormatters = {
   [SCHEMA_TYPES.OBJECT]: (parsedSchema) => {
+    if (_.isString(parsedSchema.content)) {
+      return {
+        ...parsedSchema,
+        typeIdentifier: TS_KEYWORDS.TYPE,
+        content: checkAndAddNull(parsedSchema.content),
+      };
+    }
+
     return {
       ...parsedSchema,
       typeIdentifier: TS_KEYWORDS.TYPE,
-      content: _.isString(parsedSchema.content)
-        ? parsedSchema.content
-        : parsedSchema.content.length
-        ? `{ ${parsedSchema.content.map((part) => part.field).join(", ")} }`
-        : TS_KEYWORDS.OBJECT,
+      content: checkAndAddNull(
+        parsedSchema,
+        parsedSchema.content.length ? `{\n${formatObjectContent(parsedSchema.content)}\n}` : TS_EXTERNAL.RECORD,
+      ),
     };
   },
   [SCHEMA_TYPES.ENUM]: (parsedSchema) => {
@@ -69,6 +82,39 @@ const inlineExtraFormatters = {
   },
 };
 
+const formatObjectContent = (content) => {
+  return _.map(content, (part) => {
+    const extraSpace = "  ";
+    const result = `${extraSpace}${part.field},\n`;
+
+    const comments = _.uniq(
+      _.compact([
+        part.title,
+        part.description,
+        part.deprecated && ` * @deprecated`,
+        !_.isUndefined(part.format) && `@format ${part.format}`,
+        !_.isUndefined(part.minimum) && `@min ${part.minimum}`,
+        !_.isUndefined(part.maximum) && `@max ${part.maximum}`,
+        !_.isUndefined(part.pattern) && `@pattern ${part.pattern}`,
+        !_.isUndefined(part.example) &&
+          `@example ${_.isObject(part.example) ? JSON.stringify(part.example) : part.example}`,
+      ]).reduce((acc, comment) => [...acc, ...comment.split(/\n/g)], []),
+    );
+
+    const commonText = comments.length
+      ? [
+          ...(comments.length === 1
+            ? [`/** ${comments[0]} */`]
+            : ["/**", ...comments.map((commentPart) => ` * ${commentPart}`), " */"]),
+        ]
+          .map((part) => `${extraSpace}${part}\n`)
+          .join("")
+      : "";
+
+    return `${commonText}${result}`;
+  }).join("");
+};
+
 module.exports = {
   formatters,
   inlineExtraFormatters,

package/src/utils/resolveName.js

@@ -82,10 +82,7 @@ class ComponentTypeNameResolver extends NameResolver {
    */
   constructor(reservedNames) {
     super(reservedNames, (variants) => {
-      return (
-        (variants[0] && `${variants[0]}${getRandomInt(1, 10)}`) ||
-        `ComponentType${getRandomInt(1, 10)}`
-      );
+      return (variants[0] && `${variants[0]}${getRandomInt(1, 10)}`) || `ComponentType${getRandomInt(1, 10)}`;
     });
   }
 }

package/templates/README.md

@@ -1,13 +1,17 @@
-# swagger-typescript-api  
-
-# templates  
-
-Templates:  
-- `api.eta` - Api class module (locations: [default](https://github.com/acacode/swagger-typescript-api/tree/next/templates/default/api.eta), [modular](https://github.com/acacode/swagger-typescript-api/tree/next/templates/modular/api.eta))  
-- `data-contracts.eta` - all types (data contracts) from swagger schema (locations: [base](https://github.com/acacode/swagger-typescript-api/tree/next/templates/base/data-contracts.eta))  
-- `http-client.eta` - HttpClient class module (locations: [base](https://github.com/acacode/swagger-typescript-api/tree/next/templates/base/http-client.eta))  
-- `procedure-call.eta` - route in Api class (locations: [default](https://github.com/acacode/swagger-typescript-api/tree/next/templates/default/procedure-call.eta), [modular](https://github.com/acacode/swagger-typescript-api/tree/next/templates/modular/procedure-call.eta))  
-- `route-docs.eta` - documentation for route in Api class (locations: [base](https://github.com/acacode/swagger-typescript-api/tree/next/templates/base/route-docs.eta))  
-- `route-name.eta` - route name for route in Api class (locations: [base](https://github.com/acacode/swagger-typescript-api/tree/next/templates/base/route-name.eta))  
-- `route-type.eta` - *(`--route-types` option)* (locations: [base](https://github.com/acacode/swagger-typescript-api/tree/next/templates/base/route-type.eta))  
-- `route-types.eta` - *(`--route-types` option)* (locations: [base](https://github.com/acacode/swagger-typescript-api/tree/next/templates/base/route-types.eta))  
+# swagger-typescript-api  
+
+# templates  
+
+Templates:  
+- `api.ejs` - *(generates file)* Api class module (locations: [default](https://github.com/acacode/swagger-typescript-api/tree/next/templates/default/api.ejs), [modular](https://github.com/acacode/swagger-typescript-api/tree/next/templates/modular/api.ejs))  
+- `data-contracts.ejs` - *(generates file)* all types (data contracts) from swagger schema (locations: [base](https://github.com/acacode/swagger-typescript-api/tree/next/templates/base/data-contracts.ejs))  
+- `http-client.ejs` - *(generates file)* HttpClient class module (locations: [base](https://github.com/acacode/swagger-typescript-api/tree/next/templates/base/http-client.ejs))  
+- `procedure-call.ejs` - *(subtemplate)* route in Api class (locations: [default](https://github.com/acacode/swagger-typescript-api/tree/next/templates/default/procedure-call.ejs), [modular](https://github.com/acacode/swagger-typescript-api/tree/next/templates/modular/procedure-call.ejs))  
+- `route-docs.ejs` - *(generates file)* documentation for route in Api class (locations: [base](https://github.com/acacode/swagger-typescript-api/tree/next/templates/base/route-docs.ejs))  
+- `route-name.ejs` - *(subtemplate)* route name for route in Api class (locations: [base](https://github.com/acacode/swagger-typescript-api/tree/next/templates/base/route-name.ejs))  
+- `route-type.ejs` - *(`--route-types` option)* *(subtemplate)* (locations: [base](https://github.com/acacode/swagger-typescript-api/tree/next/templates/base/route-type.ejs))  
+- `route-types.ejs` - *(`--route-types` option)* *(subtemplate)* (locations: [base](https://github.com/acacode/swagger-typescript-api/tree/next/templates/base/route-types.ejs))  - `data-contract-jsdoc.ejs` - *(subtemplate)* generates JSDOC for data contract (locations: [base](https://github.com/acacode/swagger-typescript-api/tree/next/templates/base/data-contract-jsdoc.ejs))
+
+[//]: # (- `enum-data-contract.ejs` - *(subtemplate)* generates `enum` data contract (locations: [base](https://github.com/acacode/swagger-typescript-api/tree/next/templates/base/enum-data-contract.ejs)))
+[//]: # (- `interface-data-contract.ejs` - *(subtemplate)* generates `interface` data contract (locations: [base](https://github.com/acacode/swagger-typescript-api/tree/next/templates/base/interface-data-contract.ejs)))
+[//]: # (- `type-data-contract.ejs` - *(subtemplate)* generates `type` data contract (locations: [base](https://github.com/acacode/swagger-typescript-api/tree/next/templates/base/type-data-contract.ejs)))

package/templates/base/README.md

@@ -1,8 +1,8 @@
-# swagger-typescript-api  
-
-# templates/base  
-
-This templates use both for multiple api files and single api file  
-
-
+# swagger-typescript-api  
+
+# templates/base  
+
+This templates use both for multiple api files and single api file  
+
+
 path prefix `@base`  

package/templates/base/data-contract-jsdoc.ejs

@@ -0,0 +1,32 @@
+<%
+const { contract, utils } = it;
+const { formatDescription, require, _ } = utils;
+
+let jsDocLines = [];
+
+jsDocLines.push(
+    contract.title,
+    contract.description && formatDescription(contract.description),
+)
+
+if (contract.typeData) {
+  jsDocLines.push(
+      contract.typeData.deprecated === true && '@deprecated',
+      !_.isUndefined(contract.typeData.format) && `@format ${contract.typeData.format}`,
+      !_.isUndefined(contract.typeData.minimum) && `@min ${contract.typeData.minimum}`,
+      !_.isUndefined(contract.typeData.maximum) && `@max ${contract.typeData.maximum}`,
+      !_.isUndefined(contract.typeData.pattern) && `@pattern ${contract.typeData.pattern}`,
+      !_.isUndefined(contract.typeData.example) && `@example ${
+              _.isObject(contract.typeData.example) ? JSON.stringify(contract.typeData.example) : contract.typeData.example
+      }`
+  )
+}
+
+jsDocLines = _.compact(jsDocLines);
+%>
+<% if (jsDocLines.length) { %>
+/**
+<%~ jsDocLines.map(part => `* ${part}`).join("\n") %>
+
+*/
+<% } %>