swagger-typescript-api 9.3.0 → 10.0.1

package/CHANGELOG.md

@@ -1,4 +1,43 @@
-# next release  
+# next release
+
+# 10.0.1  
+
+- fix problem linked with [this.name is not a function](https://github.com/acacode/swagger-typescript-api/issues/381)  
+- [internal] add cli tests  
+- fix problem with not correct working the `--no-client` option
+
+# 10.0.0  
+
+- `--extract-response-body` option - extract response body type to data contract  
+- `--extract-response-error` option - extract response error type to data contract   
+- `--add-readonly` option - generate readonly properties  
+- `authorizationToken` for axios fetch swagger schema request  
+- fix: change COMPLEX_NOT_OF to COMPLEX_NOT (internal)
+- feat: improve `@deprecated` jsdoc info
+- feat: improve `required` field in complex data schemas (anyOf, oneOf, allOf etc)  
+- feat: abortSignal for fetch http client
+- chore: improve typings in index.d.ts
+- fixed [Request falls if FormData attachment is File instance](https://github.com/acacode/swagger-typescript-api/issues/293)
+- fixed [Response format - global default or override ?](https://github.com/acacode/swagger-typescript-api/issues/251)
+
+> Co-authored-by: Sergey S. Volkov <js2me@outlook.com>  
+> Co-authored-by: Xavier Cassel <57092100+xcassel@users.noreply.github.com>  
+> Co-authored-by: cassel <xavier.cassel35@gmail.com>  
+> Co-authored-by: Adrian Wieprzkowicz <Argeento@users.noreply.github.com>  
+> Co-authored-by: EvgenBabenko <evgen.babenko@gmail.com>  
+> Co-authored-by: RoCat <catoio.romain@gmail.com>  
+> Co-authored-by: rcatoio <rcatoio@doubletrade.com>  
+> Co-authored-by: 卡色 <cipchk@qq.com>  
+> Co-authored-by: 江麻妞 <50100681+jiangmaniu@users.noreply.github.com>  
+> Co-authored-by: Kasper Moskwiak <kasper.moskwiak@gmail.com>  
+> Co-authored-by: Ben Watkins <ben@outdatedversion.com>  
+> Co-authored-by: bonukai <bonukai@protonmail.com>  
+> Co-authored-by: baggoedw <92381702+baggoedw@users.noreply.github.com>  
+> Co-authored-by: Marcus Dunn <51931484+MarcusDunn@users.noreply.github.com>  
+> Co-authored-by: Daniele De Matteo <daniele@kuama.net>  
+> Co-authored-by: Daniel Playfair Cal <daniel.playfair.cal@gmail.com>  
+> Co-authored-by: Anders Cassidy <anders.cassidy@dailypay.com>  
+> Co-authored-by: Daniel Playfair Cal <dcal@atlassian.com>  
 
 # 9.2.0  
 

package/README.md

@@ -19,7 +19,11 @@ Any questions you can ask [**here**](https://github.com/acacode/swagger-typescri
   
 <br>  
 
-![](https://raw.githubusercontent.com/acacode/swagger-typescript-api/master/assets/components-converter-example.jpg)  
+![](https://raw.githubusercontent.com/acacode/swagger-typescript-api/master/assets/components-converter-example.jpg)    
+
+👀 This project is looking for a code maintainer 👀    
+P.S. If you are creating the PR, please check your changes with using command `npm run prepare`  
+P.S. If you want to contribute please use branch `next`. All PRs which will have target `master` will be declined  
 
 ## 👀 Examples  
 
@@ -33,36 +37,39 @@ Usage: swagger-typescript-api [options]
 
 Options:
   -v, --version                 output the current version
-  -p, --path <path>             path/url to swagger scheme
-  -o, --output <output>         output path of typescript api file (default: "./")
-  -n, --name <name>             name of output typescript api file (default: "Api.ts")
-  -t, --templates <path>        path to folder containing templates
+  -p, --path <string>           path/url to swagger scheme
+  -o, --output <string>         output path of typescript api file (default: "./")
+  -n, --name <string>           name of output typescript api file (default: "Api.ts")
+  -t, --templates <string>      path to folder containing templates
   -d, --default-as-success      use "default" response status code as success response too.
-                                some swagger schemas use "default" response status code
-                                as success response type by default. (default: false)
+                                some swagger schemas use "default" response status code as success response type by default. (default: false)
   -r, --responses               generate additional information about request responses
                                 also add typings for bad responses (default: false)
   --union-enums                 generate all "enum" types as union types (T1 | T2 | TN) (default: false)
+  --add-readonly                generate readonly properties (default: false)
   --route-types                 generate type definitions for API routes (default: false)
   --no-client                   do not generate an API class
   --enum-names-as-values        use values in 'x-enumNames' as enum values (not only as keys) (default: false)
-  --js                          generate js api module with declaration file (default: false)
-  --extract-request-params      extract request params to data contract (default: false)
-                                Also combine path params and query params into one object
-  --extract-request-body        extract request body type to data contract (default: false)                         
-  --module-name-index <number>  determines which path index should be used for routes separation (default: 0)
-                                (example: GET:/fruites/getFruit -> index:0 -> moduleName -> fruites)
-  --module-name-first-tag       splits routes based on the first tag
+  --extract-request-params      extract request params to data contract (Also combine path params and query params into one object) (default: false)
+  --extract-request-body        extract request body type to data contract (default: false)
+  --extract-response-body       extract response body type to data contract (default: false)
+  --extract-response-error      extract response error type to data contract (default: false)
   --modular                     generate separated files for http client, data contracts, and routes (default: false)
+  --js                          generate js api module with declaration file (default: false)
+  --module-name-index <number>  determines which path index should be used for routes separation (example: GET:/fruites/getFruit -> index:0 -> moduleName -> fruites) (default: 0)
+  --module-name-first-tag       splits routes based on the first tag (default: false)
   --disableStrictSSL            disabled strict SSL (default: false)
   --disableProxy                disabled proxy (default: false)
-  --clean-output                clean output folder before generate api. WARNING: May cause data loss (default: false)
   --axios                       generate axios http client (default: false)
+  --unwrap-response-data        unwrap the data item from the response (default: false)
+  --disable-throw-on-error      Do not throw an error when response.ok is not true (default: false)
   --single-http-client          Ability to send HttpClient instance to Api constructor (default: false)
   --silent                      Output only errors to console (default: false)
   --default-response <type>     default type for empty response schema (default: "void")
   --type-prefix <string>        data contract name prefix (default: "")
   --type-suffix <string>        data contract name suffix (default: "")
+  --clean-output                clean output folder before generate api. WARNING: May cause data loss (default: false)
+  --api-class-name <string>     name of the api class
   --patch                       fix up small errors in the swagger source definition (default: false)
   -h, --help                    display help for command
 ```

package/index.d.ts

@@ -1,19 +1,4 @@
-interface GenerateApiParams {
-  /**
-   * path to swagger schema
-   */
-  input: string;
-
-  /**
-   * url to swagger schema
-   */
-  url: string;
-
-  /**
-   * swagger schema JSON
-   */
-  spec: import("swagger-schema-official").Spec;
-
+interface GenerateApiParamsBase {
   /**
    * default 'api.ts'
    */
@@ -25,7 +10,7 @@ interface GenerateApiParams {
   output?: string;
 
   /**
-   * path to folder containing templates (default: ./scr/templates)
+   * path to folder containing templates (default: ./src/templates)
    */
   templates?: string;
 
@@ -92,6 +77,14 @@ interface GenerateApiParams {
    * extract request body type to data contract
    */
   extractRequestBody?: boolean;
+  /**
+   * extract response body type to data contract
+   */
+  extractResponseBody?: boolean;
+  /**
+   * extract response error type to data contract
+   */
+  extractResponseError?: boolean;
   /**
    * prettier configuration
    */
@@ -121,8 +114,35 @@ interface GenerateApiParams {
    * fix up small errors in the swagger source definition
    */
   patch?: boolean;
+  /**
+   *  authorization token
+   */
+  authorizationToken?: string;
+}
+
+interface GenerateApiParamsFromPath extends GenerateApiParamsBase {
+  /**
+   * path to swagger schema
+   */
+  input: string;
+}
+
+interface GenerateApiParamsFromUrl extends GenerateApiParamsBase {
+  /**
+   * url to swagger schema
+   */
+  url: string;
+}
+
+interface GenerateApiParamsFromSpecLiteral extends GenerateApiParamsBase {
+  /**
+   * swagger schema JSON
+   */
+  spec: import("swagger-schema-official").Spec;
 }
 
+export type GenerateApiParams = GenerateApiParamsFromPath | GenerateApiParamsFromUrl | GenerateApiParamsFromSpecLiteral;
+
 export interface Hooks {
   /** calls after parse schema component */
   onCreateComponent: (component: SchemaComponent) => SchemaComponent | void;
@@ -323,6 +343,7 @@ export interface GenerateApiConfiguration {
       routeName: string;
     };
     routeNameDuplicatesMap: Map<string, string>;
+    apiClassName: string
   };
   modelTypes: ModelType[];
   rawModelTypes: SchemaComponent[];
@@ -371,6 +392,4 @@ export interface GenerateApiOutput {
   formatTSContent: (content: string) => string;
 }
 
-export declare function generateApi(params: Omit<GenerateApiParams, "url" | "spec">): Promise<GenerateApiOutput>;
-export declare function generateApi(params: Omit<GenerateApiParams, "input" | "spec">): Promise<GenerateApiOutput>;
-export declare function generateApi(params: Omit<GenerateApiParams, "input" | "url">): Promise<GenerateApiOutput>;
+export declare function generateApi(params: GenerateApiParams): Promise<GenerateApiOutput>;

package/index.js

@@ -14,17 +14,14 @@ const { TS_KEYWORDS, HTTP_CLIENT } = require("./src/constants");
 
 const program = new Command(packageName);
 
-program.storeOptionsAsProperties(true);
-
-program
+const options = program
+  .alias("sta")
   .version(version, "-v, --version", "output the current version")
-  .description("Generate api via swagger scheme.\nSupports OA 3.0, 2.0, JSON, yaml.");
-
-program
-  .requiredOption("-p, --path <path>", "path/url to swagger scheme")
-  .option("-o, --output <output>", "output path of typescript api file", "./")
-  .option("-n, --name <name>", "name of output typescript api file", "Api.ts")
-  .option("-t, --templates <path>", "path to folder containing templates")
+  .description("Generate api via swagger scheme.\nSupports OA 3.0, 2.0, JSON, yaml.")
+  .requiredOption("-p, --path <string>", "path/url to swagger scheme")
+  .option("-o, --output <string>", "output path of typescript api file", "./")
+  .option("-n, --name <string>", "name of output typescript api file", "Api.ts")
+  .option("-t, --templates <string>", "path to folder containing templates")
   .option(
     "-d, --default-as-success",
     'use "default" response status code as success response too.\n' +
@@ -37,8 +34,9 @@ program
     false,
   )
   .option("--union-enums", 'generate all "enum" types as union types (T1 | T2 | TN)', false)
+  .option("--add-readonly", "generate readonly properties", false)
   .option("--route-types", "generate type definitions for API routes", false)
-  .option("--no-client", "do not generate an API class", false)
+  .option("--no-client", "do not generate an API class", true)
   .option("--enum-names-as-values", "use values in 'x-enumNames' as enum values (not only as keys)", false)
   .option(
     "--extract-request-params",
@@ -46,6 +44,8 @@ program
     false,
   )
   .option("--extract-request-body", "extract request body type to data contract", false)
+  .option("--extract-response-body", "extract response body type to data contract", false)
+  .option("--extract-response-error", "extract response error type to data contract", false)
   .option("--modular", "generate separated files for http client, data contracts, and routes", false)
   .option("--js", "generate js api module with declaration file", false)
   .option(
@@ -65,73 +65,46 @@ program
   .option("--type-prefix <string>", "data contract name prefix", "")
   .option("--type-suffix <string>", "data contract name suffix", "")
   .option("--clean-output", "clean output folder before generate api. WARNING: May cause data loss", false)
-  .option("--patch", "fix up small errors in the swagger source definition", false);
-
-program.parse(process.argv);
-
-const {
-  path,
-  output,
-  name,
-  templates,
-  unionEnums,
-  routeTypes,
-  client,
-  defaultAsSuccess,
-  responses,
-  modular,
-  js,
-  moduleNameIndex,
-  moduleNameFirstTag,
-  extractRequestParams,
-  extractRequestBody,
-  enumNamesAsValues,
-  disableStrictSSL,
-  disableProxy,
-  cleanOutput,
-  defaultResponse,
-  unwrapResponseData,
-  disableThrowOnError,
-  sortTypes,
-  singleHttpClient,
-  axios,
-  silent,
-  typePrefix,
-  typeSuffix,
-  patch,
-} = program;
+  .option("--api-class-name <string>", "name of the api class")
+  .option("--patch", "fix up small errors in the swagger source definition", false)
+  .parse(process.argv)
+  .opts();
 
 generateApi({
-  name,
-  url: path,
-  generateRouteTypes: routeTypes,
-  generateClient: !!(axios || client),
-  httpClientType: axios ? HTTP_CLIENT.AXIOS : HTTP_CLIENT.FETCH,
-  defaultResponseAsSuccess: defaultAsSuccess,
-  defaultResponseType: defaultResponse,
-  unwrapResponseData: unwrapResponseData,
-  disableThrowOnError: disableThrowOnError,
-  sortTypes: sortTypes,
-  generateUnionEnums: unionEnums,
-  generateResponses: responses,
-  extractRequestParams: !!extractRequestParams,
-  extractRequestBody: !!extractRequestBody,
-  input: resolve(process.cwd(), path),
-  output: resolve(process.cwd(), output || "."),
-  templates,
-  modular: !!modular,
-  toJS: !!js,
-  enumNamesAsValues: enumNamesAsValues,
-  moduleNameIndex: +(moduleNameIndex || 0),
-  moduleNameFirstTag: moduleNameFirstTag,
-  disableStrictSSL: !!disableStrictSSL,
-  disableProxy: !!disableProxy,
-  singleHttpClient: !!singleHttpClient,
-  cleanOutput: !!cleanOutput,
-  silent: !!silent,
-  typePrefix,
-  typeSuffix,
-  patch: !!patch,
+  name: options.name,
+  url: options.path,
+  generateRouteTypes: options.routeTypes,
+  generateClient: !!(options.axios || options.client),
+  httpClientType: options.axios ? HTTP_CLIENT.AXIOS : HTTP_CLIENT.FETCH,
+  defaultResponseAsSuccess: options.defaultAsSuccess,
+  defaultResponseType: options.defaultResponse,
+  unwrapResponseData: options.unwrapResponseData,
+  disableThrowOnError: options.disableThrowOnError,
+  sortTypes: options.sortTypes,
+  generateUnionEnums: options.unionEnums,
+  addReadonly: options.addReadonly,
+  generateResponses: options.responses,
+  extractRequestParams: !!options.extractRequestParams,
+  extractRequestBody: !!options.extractRequestBody,
+  extractResponseBody: !!options.extractResponseBody,
+  extractResponseError: !!options.extractResponseError,
+  input: resolve(process.cwd(), options.path),
+  output: resolve(process.cwd(), options.output || "."),
+  templates: options.templates,
+  modular: !!options.modular,
+  toJS: !!options.js,
+  enumNamesAsValues: options.enumNamesAsValues,
+  moduleNameIndex: +(options.moduleNameIndex || 0),
+  moduleNameFirstTag: options.moduleNameFirstTag,
+  disableStrictSSL: !!options.disableStrictSSL,
+  disableProxy: !!options.disableProxy,
+  singleHttpClient: !!options.singleHttpClient,
+  cleanOutput: !!options.cleanOutput,
+  silent: !!options.silent,
+  typePrefix: options.typePrefix,
+  typeSuffix: options.typeSuffix,
+  patch: !!options.patch,
+  apiClassName: options.apiClassName,
 }).catch((err) => {
   // NOTE collect all errors on top level and shows to users in any case
   console.error(err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swagger-typescript-api",
-  "version": "9.3.0",
+  "version": "10.0.1",
   "description": "Generate typescript/javascript api from swagger schema",
   "scripts": {
     "cli:json": "node index.js -r -d -p ./swagger-test-cli.json -n swagger-test-cli.ts",
@@ -23,6 +23,7 @@
     "test:--default-as-success": "node tests/spec/defaultAsSuccess/test.js",
     "test:--templates": "node tests/spec/templates/test.js",
     "test:--union-enums": "node tests/spec/unionEnums/test.js",
+    "test:--add-readonly": "node tests/spec/readonly/test.js",
     "test:--responses": "node tests/spec/responses/test.js",
     "test:specProperty": "node tests/spec/specProperty/test.js",
     "test:--module-name-index": "node tests/spec/moduleNameIndex/test.js",
@@ -31,6 +32,8 @@
     "test:--single-http-client": "node tests/spec/singleHttpClient/test.js",
     "test:--extract-request-params": "node tests/spec/extractRequestParams/test.js",
     "test:--extract-request-body": "node tests/spec/extractRequestBody/test.js",
+    "test:--extract-response-body": "node tests/spec/extractResponseBody/test.js",
+    "test:--extract-response-error": "node tests/spec/extractResponseError/test.js",
     "test:--enum-names-as-values": "node tests/spec/enumNamesAsValues/test.js",
     "test:--default-response": "node tests/spec/defaultResponse/test.js",
     "test:--js": "node tests/spec/js/test.js",
@@ -38,6 +41,7 @@
     "test:--axios": "node tests/spec/axios/test.js",
     "test:--axios--single-http-client": "node tests/spec/axiosSingleHttpClient/test.js",
     "test:--type-suffix--type-prefix": "node tests/spec/typeSuffixPrefix/test.js",
+    "test:--cli": "node index.js -p tests/spec/cli/schema.json -o tests/spec/cli -n schema.ts --extract-response-body --extract-response-error --type-prefix Prefix --api-class-name MySuperApi --no-client",
     "test:partialBaseTemplate": "node tests/spec/partialBaseTemplate/test.js",
     "test:partialDefaultTemplate": "node tests/spec/partialDefaultTemplate/test.js",
     "test:--patch": "node tests/spec/patch/test.js"
@@ -48,28 +52,28 @@
   "main": "src/index.js",
   "devDependencies": {
     "@types/axios": "^0.14.0",
-    "@types/lodash": "^4.14.166",
+    "@types/lodash": "^4.14.182",
     "@types/node": "^15.0.2",
-    "@types/prettier": "^2.1.6",
-    "all-contributors-cli": "^6.19.0",
-    "axios": "^0.21.4",
+    "@types/prettier": "^2.7.0",
+    "all-contributors-cli": "^6.20.0",
     "husky": "^4.3.6",
     "pretty-quick": "^3.1.0"
   },
   "dependencies": {
-    "@types/swagger-schema-official": "2.0.21",
-    "commander": "^6.2.1",
-    "cosmiconfig": "^7.0.0",
-    "eta": "^1.12.1",
-    "js-yaml": "^4.0.0",
+    "axios": "^0.27.2",
+    "@types/swagger-schema-official": "2.0.22",
+    "commander": "^9.4.0",
+    "cosmiconfig": "^7.0.1",
+    "eta": "^1.12.3",
+    "js-yaml": "^4.1.0",
     "lodash": "^4.17.21",
     "make-dir": "^3.1.0",
-    "nanoid": "^3.1.22",
-    "node-emoji": "^1.10.0",
-    "prettier": "^2.2.1",
+    "nanoid": "^3.3.4",
+    "node-emoji": "^1.11.0",
+    "prettier": "^2.7.1",
     "swagger-schema-official": "2.0.0-bab6bed",
-    "swagger2openapi": "^7.0.5",
-    "typescript": "^4.2.4"
+    "swagger2openapi": "^7.0.8",
+    "typescript": "^4.7.4"
   },
   "bin": {
     "swagger-typescript-api": "index.js",

package/src/config.js

@@ -14,6 +14,8 @@ const config = {
   generateClient: true,
   /** CLI flag */
   generateUnionEnums: false,
+  /** CLI flag */
+  addReadonly: false,
   enumNamesAsValues: false,
   /** parsed swagger schema from getSwaggerObject() */
 
@@ -36,6 +38,8 @@ const config = {
   disableProxy: false,
   extractRequestParams: false,
   extractRequestBody: false,
+  extractResponseBody: false,
+  extractResponseError: false,
   fileNames: {
     dataContracts: "data-contracts",
     routeTypes: "route-types",
@@ -87,6 +91,8 @@ const config = {
   typeSuffix: "",
   patch: false,
   componentTypeNameResolver: new NameResolver([]),
+  /** name of the main exported class */
+  apiClassName: "Api",
 };
 
 /** needs to use data everywhere in project */

package/src/index.js

@@ -40,10 +40,13 @@ module.exports = {
     generateClient = config.generateClient,
     httpClientType = config.httpClientType,
     generateUnionEnums = config.generateUnionEnums,
+    addReadonly = config.addReadonly,
     moduleNameIndex = config.moduleNameIndex,
     moduleNameFirstTag = config.moduleNameFirstTag,
     extractRequestParams = config.extractRequestParams,
     extractRequestBody = config.extractRequestBody,
+    extractResponseBody = config.extractResponseBody,
+    extractResponseError = config.extractResponseError,
     defaultResponseType = config.defaultResponseType,
     unwrapResponseData = config.unwrapResponseData,
     disableThrowOnError = config.disableThrowOnError,
@@ -60,6 +63,8 @@ module.exports = {
     typePrefix = config.typePrefix,
     typeSuffix = config.typeSuffix,
     patch = config.patch,
+    authorizationToken,
+    apiClassName = config.apiClassName,
   }) =>
     new Promise((resolve, reject) => {
       addToConfig({
@@ -70,12 +75,15 @@ module.exports = {
         generateResponses,
         templates,
         generateUnionEnums,
+        addReadonly,
         moduleNameIndex,
         moduleNameFirstTag,
         prettierOptions,
         modular,
         extractRequestParams,
         extractRequestBody,
+        extractResponseBody,
+        extractResponseError,
         hooks: _.merge(config.hooks, rawHooks || {}),
         enumNamesAsValues,
         disableStrictSSL,
@@ -92,10 +100,11 @@ module.exports = {
         typePrefix,
         typeSuffix,
         patch,
+        apiClassName,
       });
       (spec
         ? convertSwaggerObject(spec, { patch })
-        : getSwaggerObject(input, url, disableStrictSSL, disableProxy, { patch })
+        : getSwaggerObject(input, url, disableStrictSSL, disableProxy, authorizationToken, { patch })
       )
         .then(({ usageSchema, originalSchema }) => {
           const templatePaths = getTemplatePaths(config);
@@ -120,9 +129,7 @@ module.exports = {
 
           const componentsMap = createComponentsMap(components);
 
-          const componentSchemasNames = filterComponentsMap(componentsMap, "schemas").map(
-            (c) => c.typeName,
-          );
+          const componentSchemasNames = filterComponentsMap(componentsMap, "schemas").map((c) => c.typeName);
 
           addToConfig({
             componentTypeNameResolver: new ComponentTypeNameResolver(componentSchemasNames),
@@ -146,29 +153,32 @@ module.exports = {
 
           const usageComponentSchemas = filterComponentsMap(componentsMap, "schemas");
           const sortByProperty = (o1, o2, propertyName) => {
-            if(o1[propertyName] > o2[propertyName]) {
+            if (o1[propertyName] > o2[propertyName]) {
               return 1;
             }
-            if(o1[propertyName] < o2[propertyName]) {
+            if (o1[propertyName] < o2[propertyName]) {
               return -1;
             }
             return 0;
-          }
-          const sortByTypeName = (o1, o2) => sortByProperty(o1, o2, 'typeName');
+          };
+          const sortByTypeName = (o1, o2) => sortByProperty(o1, o2, "typeName");
 
-          const sortByName = (o1, o2) => sortByProperty(o1, o2, 'name');
+          const sortByName = (o1, o2) => sortByProperty(o1, o2, "name");
 
           const sortSchemas = (schemas) => {
-            if(config.sortTypes) {
+            if (config.sortTypes) {
               return schemas.sort(sortByTypeName).map((schema) => {
-                if(schema.rawTypeData?.properties) {
+                if (schema.rawTypeData?.properties) {
                   return {
                     ...schema,
                     rawTypeData: {
                       ...schema.rawTypeData,
-                      '$parsed': {...schema.rawTypeData['$parsed'], content: schema.rawTypeData['$parsed'].content.sort(sortByName)}
-                    }
-                  }
+                      $parsed: {
+                        ...schema.rawTypeData["$parsed"],
+                        content: schema.rawTypeData["$parsed"].content.sort(sortByName),
+                      },
+                    },
+                  };
                 }
                 return schema;
               });

package/src/routeNames.js

@@ -13,19 +13,15 @@ const getRouteName = (routeInfo) => {
     config,
   });
 
-  const routeName =
-    config.hooks.onFormatRouteName(routeInfo, routeNameFromTemplate) || routeNameFromTemplate;
+  const routeName = config.hooks.onFormatRouteName(routeInfo, routeNameFromTemplate) || routeNameFromTemplate;
 
   const duplicateIdentifier = `${moduleName}|${routeName}`;
 
   if (routeNameDuplicatesMap.has(duplicateIdentifier)) {
-    routeNameDuplicatesMap.set(
-      duplicateIdentifier,
-      routeNameDuplicatesMap.get(duplicateIdentifier) + 1,
-    );
+    routeNameDuplicatesMap.set(duplicateIdentifier, routeNameDuplicatesMap.get(duplicateIdentifier) + 1);
 
     logger.warn(
-      `Module "${moduleName}" already have method "${routeName}()"`,
+      `Module "${moduleName}" already has method "${routeName}()"`,
       `\nThis method has been renamed to "${
         routeName + routeNameDuplicatesMap.get(duplicateIdentifier)
       }()" to solve conflict names.`,

package/src/routes.js

@@ -1,12 +1,5 @@
 const _ = require("lodash");
-const {
-  types,
-  parseSchema,
-  getType,
-  getRefType,
-  getInlineParseContent,
-  checkAndAddNull,
-} = require("./schema");
+const { types, parseSchema, getType, getRefType, getInlineParseContent, checkAndAddNull } = require("./schema");
 const { formatModelName } = require("./modelNames");
 const {
   DEFAULT_BODY_ARG_NAME,
@@ -19,7 +12,7 @@ const {
 } = require("./constants");
 const { formatDescription, classNameCase } = require("./common");
 const { config } = require("./config");
-const { nanoid } = require("nanoid");
+const { generateId } = require("./utils/id");
 const { getRouteName } = require("./routeNames");
 const { createComponent } = require("./components");
 const { logger } = require("./logger");
@@ -47,26 +40,15 @@ const getSchemaFromRequestType = (requestInfo) => {
   return null;
 };
 
-const getTypeFromRequestInfo = ({
-  requestInfo,
-  parsedSchemas,
-  operationId,
-  defaultType,
-  typeName,
-}) => {
+const getTypeFromRequestInfo = ({ requestInfo, parsedSchemas, operationId, defaultType, typeName }) => {
   // TODO: make more flexible pick schema without content type
   const schema = getSchemaFromRequestType(requestInfo);
   const refTypeInfo = getRefType(requestInfo);
 
   if (schema) {
     const content = getInlineParseContent(schema, typeName);
-    const foundedSchemaByName = _.find(
-      parsedSchemas,
-      (parsedSchema) => formatModelName(parsedSchema.name) === content,
-    );
-    const foundSchemaByContent = _.find(parsedSchemas, (parsedSchema) =>
-      _.isEqual(parsedSchema.content, content),
-    );
+    const foundedSchemaByName = _.find(parsedSchemas, (parsedSchema) => formatModelName(parsedSchema.name) === content);
+    const foundSchemaByContent = _.find(parsedSchemas, (parsedSchema) => _.isEqual(parsedSchema.content, content));
 
     const foundSchema = foundedSchemaByName || foundSchemaByContent;
 
@@ -88,10 +70,7 @@ const getTypeFromRequestInfo = ({
         return formatModelName(refTypeInfo.typeName);
       case "responses":
       case "requestBodies":
-        return getInlineParseContent(
-          getSchemaFromRequestType(refTypeInfo.rawTypeData),
-          refTypeInfo.typeName || null,
-        );
+        return getInlineParseContent(getSchemaFromRequestType(refTypeInfo.rawTypeData), refTypeInfo.typeName || null);
       default:
         return getInlineParseContent(refTypeInfo.rawTypeData, refTypeInfo.typeName || null);
     }
@@ -344,9 +323,7 @@ const createRequestParamsSchema = ({
   if (fixedSchema) return fixedSchema;
 
   if (extractRequestParams) {
-    const typeName = config.componentTypeNameResolver.resolve([
-      classNameCase(`${routeName.usage} Params`),
-    ]);
+    const typeName = config.componentTypeNameResolver.resolve([classNameCase(`${routeName.usage} Params`)]);
 
     return createComponent("schemas", typeName, { ...schema });
   }
@@ -358,9 +335,7 @@ const getContentTypes = (requestInfo, extraContentTypes) =>
   _.uniq(
     _.compact([
       ...(extraContentTypes || []),
-      ..._.flatten(
-        _.map(requestInfo, (requestInfoData) => requestInfoData && _.keys(requestInfoData.content)),
-      ),
+      ..._.flatten(_.map(requestInfo, (requestInfoData) => requestInfoData && _.keys(requestInfoData.content))),
     ]),
   );
 
@@ -400,10 +375,7 @@ const getRequestBodyInfo = (routeInfo, routeParams, parsedSchemas, routeName) =>
   let schema = null;
   let type = null;
 
-  const contentTypes = getContentTypes(
-    [requestBody],
-    [...(consumes || []), routeInfo["x-contentType"]],
-  );
+  const contentTypes = getContentTypes([requestBody], [...(consumes || []), routeInfo["x-contentType"]]);
   let contentKind = getContentKind(contentTypes);
 
   let typeName = null;
@@ -454,8 +426,7 @@ const getRequestBodyInfo = (routeInfo, routeParams, parsedSchemas, routeName) =>
     contentKind,
     schema,
     type,
-    required:
-      requestBody && (typeof requestBody.required === "undefined" || !!requestBody.required),
+    required: requestBody && (typeof requestBody.required === "undefined" || !!requestBody.required),
   };
 };
 
@@ -472,9 +443,7 @@ const getResponseBodyInfo = (routeInfo, routeParams, parsedSchemas) => {
   });
 
   const successResponse = responseInfos.find((response) => response.isSuccess);
-  const errorResponses = responseInfos.filter(
-    (response) => !response.isSuccess && response.type !== TS_KEYWORDS.ANY,
-  );
+  const errorResponses = responseInfos.filter((response) => !response.isSuccess && response.type !== TS_KEYWORDS.ANY);
 
   const handleResponseHeaders = (src) => {
     if (!src) {
@@ -507,24 +476,16 @@ const getResponseBodyInfo = (routeInfo, routeParams, parsedSchemas) => {
         responseInfos
           .map(
             (response) => `{
-      data: ${response.type}, status: ${response.status}, statusCode: ${
-              response.status
-            }, statusText: "${response.description}", ${handleResponseHeaders(
-              response.headers,
-            )} config: {} }`,
+      data: ${response.type}, status: ${response.status}, statusCode: ${response.status}, statusText: "${
+              response.description
+            }", ${handleResponseHeaders(response.headers)} config: {} }`,
           )
           .join(" | ") || TS_KEYWORDS.ANY,
     },
   };
 };
 
-const parseRoutes = ({
-  usageSchema,
-  parsedSchemas,
-  moduleNameIndex,
-  moduleNameFirstTag,
-  extractRequestParams,
-}) => {
+const parseRoutes = ({ usageSchema, parsedSchemas, moduleNameIndex, moduleNameFirstTag, extractRequestParams }) => {
   const { paths, security: globalSecurity } = usageSchema;
   const pathsEntries = _.entries(paths);
 
@@ -553,16 +514,13 @@ const parseRoutes = ({
           } = routeInfo;
           const { route, pathParams } = parseRoute(rawRoute);
 
-          const routeId = nanoid(12);
+          const routeId = generateId();
           const firstTag = tags && tags.length > 0 ? tags[0] : null;
           const moduleName =
             moduleNameFirstTag && firstTag
               ? _.camelCase(firstTag)
               : _.camelCase(_.compact(_.split(route, "/"))[moduleNameIndex]);
-          const hasSecurity = !!(
-            (globalSecurity && globalSecurity.length) ||
-            (security && security.length)
-          );
+          const hasSecurity = !!((globalSecurity && globalSecurity.length) || (security && security.length));
 
           const routeParams = getRouteParams(routeInfo, pathParams);
 
@@ -599,12 +557,7 @@ const parseRoutes = ({
 
           const routeName = getRouteName(rawRouteInfo);
 
-          const requestBodyInfo = getRequestBodyInfo(
-            routeInfo,
-            routeParams,
-            parsedSchemas,
-            routeName,
-          );
+          const requestBodyInfo = getRequestBodyInfo(routeInfo, routeParams, parsedSchemas, routeName);
 
           const requestParamsSchema = createRequestParamsSchema({
             queryParams: routeParams.query,
@@ -614,13 +567,12 @@ const parseRoutes = ({
             routeName,
           });
 
-          const queryType = routeParams.query.length
-            ? getInlineParseContent(queryObjectSchema)
-            : null;
+          extractResponseBodyIfItNeeded(routeInfo, responseBodyInfo, routeParams, rawRouteInfo, routeName);
+          extractResponseErrorIfItNeeded(routeInfo, responseBodyInfo, routeParams, rawRouteInfo, routeName);
+
+          const queryType = routeParams.query.length ? getInlineParseContent(queryObjectSchema) : null;
           const pathType = routeParams.path.length ? getInlineParseContent(pathObjectSchema) : null;
-          const headersType = routeParams.header.length
-            ? getInlineParseContent(headersObjectSchema)
-            : null;
+          const headersType = routeParams.header.length ? getInlineParseContent(headersObjectSchema) : null;
 
           const nameResolver = new SpecificArgNameResolver(pathArgsNames);
 
@@ -634,10 +586,7 @@ const parseRoutes = ({
               : void 0,
             body: requestBodyInfo.type
               ? {
-                  name: nameResolver.resolve([
-                    requestBodyInfo.paramName,
-                    ...RESERVED_BODY_ARG_NAMES,
-                  ]),
+                  name: nameResolver.resolve([requestBodyInfo.paramName, ...RESERVED_BODY_ARG_NAMES]),
                   optional: !requestBodyInfo.required,
                   type: requestBodyInfo.type,
                 }
@@ -764,10 +713,7 @@ const groupRoutes = (routes) => {
             if (
               packRoutes.length > 1 &&
               usageName !== originalName &&
-              !_.some(
-                packRoutes,
-                ({ routeName, id }) => id !== route.id && originalName === routeName.original,
-              )
+              !_.some(packRoutes, ({ routeName, id }) => id !== route.id && originalName === routeName.original)
             ) {
               return {
                 ...route,
@@ -788,6 +734,72 @@ const groupRoutes = (routes) => {
   );
 };
 
+const extractResponseBodyIfItNeeded = (routeInfo, responseBodyInfo, routeParams, rawRouteInfo, routeName) => {
+  if (
+    config.extractResponseBody &&
+    responseBodyInfo.responses.length &&
+    responseBodyInfo.success &&
+    responseBodyInfo.success.schema
+  ) {
+    const typeName = config.componentTypeNameResolver.resolve([
+      classNameCase(`${routeName.usage} Data`),
+      classNameCase(`${routeName.usage} Result`),
+      classNameCase(`${routeName.usage} Output`),
+    ]);
+
+    const idx = responseBodyInfo.responses.indexOf(responseBodyInfo.success.schema);
+
+    let successResponse = responseBodyInfo.success;
+
+    if (successResponse.schema && !successResponse.schema.$ref) {
+      const schema = getSchemaFromRequestType(successResponse.schema);
+      successResponse.schema = createComponent("schemas", typeName, { ...schema });
+      successResponse.type = getInlineParseContent(successResponse.schema);
+
+      if (idx > -1) {
+        responseBodyInfo.responses[idx] = successResponse.schema;
+      }
+    }
+  }
+};
+
+const extractResponseErrorIfItNeeded = (routeInfo, responseBodyInfo, routeParams, rawRouteInfo, routeName) => {
+  if (
+    config.extractResponseError &&
+    responseBodyInfo.responses.length &&
+    responseBodyInfo.error.schemas &&
+    responseBodyInfo.error.schemas.length
+  ) {
+    const typeName = config.componentTypeNameResolver.resolve([
+      classNameCase(`${routeName.usage} Error`),
+      classNameCase(`${routeName.usage} Fail`),
+      classNameCase(`${routeName.usage} Fails`),
+      classNameCase(`${routeName.usage} ErrorData`),
+      classNameCase(`${routeName.usage} HttpError`),
+      classNameCase(`${routeName.usage} BadResponse`),
+    ]);
+
+    const errorSchemas = responseBodyInfo.error.schemas.map(getSchemaFromRequestType).filter(Boolean);
+
+    if (!errorSchemas.length) return;
+
+    const schema = parseSchema({
+      oneOf: errorSchemas,
+      title: errorSchemas
+        .map((schema) => schema.title)
+        .filter(Boolean)
+        .join(" "),
+      description: errorSchemas
+        .map((schema) => schema.description)
+        .filter(Boolean)
+        .join("\n"),
+    });
+    const component = createComponent("schemas", typeName, { ...schema });
+    responseBodyInfo.error.schemas = [component];
+    responseBodyInfo.error.type = formatModelName(component.typeName);
+  }
+};
+
 module.exports = {
   parseRoutes,
   groupRoutes,

package/src/schema.js

@@ -63,12 +63,7 @@ const getTypeAlias = (rawSchema) => {
 };
 
 const getEnumNames = (schema) => {
-  return (
-    schema["x-enumNames"] ||
-    schema["xEnumNames"] ||
-    schema["x-enumnames"] ||
-    schema["x-enum-varnames"]
-  );
+  return schema["x-enumNames"] || schema["xEnumNames"] || schema["x-enumnames"] || schema["x-enum-varnames"];
 };
 
 const getInternalSchemaType = (schema) => {
@@ -137,6 +132,7 @@ const getObjectTypeContent = (schema) => {
     const nullable = !!(rawTypeData.nullable || property.nullable);
     const fieldName = isValidName(name) ? name : `"${name}"`;
     const fieldValue = getInlineParseContent(property);
+    const readOnly = property.readOnly;
 
     return {
       $$raw: property,
@@ -147,20 +143,25 @@ const getObjectTypeContent = (schema) => {
           rawTypeData.description ||
           _.compact(_.map(rawTypeData[getComplexType(rawTypeData)], "description"))[0] ||
           "",
+        !_.isUndefined(property.deprecated) && `@deprecated`,
         !_.isUndefined(property.format) && `@format ${property.format}`,
         !_.isUndefined(property.minimum) && `@min ${property.minimum}`,
         !_.isUndefined(property.maximum) && `@max ${property.maximum}`,
         !_.isUndefined(property.pattern) && `@pattern ${property.pattern}`,
         !_.isUndefined(property.example) &&
-          `@example ${
-            _.isObject(property.example) ? JSON.stringify(property.example) : property.example
-          }`,
+          `@example ${_.isObject(property.example) ? JSON.stringify(property.example) : property.example}`,
       ]).join("\n"),
       isRequired: required,
       isNullable: nullable,
       name: fieldName,
       value: fieldValue,
-      field: _.compact([fieldName, !required && "?", ": ", fieldValue]).join(""),
+      field: _.compact([
+        readOnly && config.addReadonly && "readonly ",
+        fieldName,
+        !required && "?",
+        ": ",
+        fieldValue,
+      ]).join(""),
     };
   });
 
@@ -179,39 +180,73 @@ const getObjectTypeContent = (schema) => {
 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)),
+    ),
+  );
+
+  // 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),
+  );
+
+  // 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 complexSchemaParsers = {
   [SCHEMA_TYPES.COMPLEX_ONE_OF]: (schema) => {
     // T1 | T2
-    const combined = _.map(schema.oneOf, complexTypeGetter);
+    const combined = _.map(_.map(schema.oneOf, makeAddRequiredToChildSchema(schema)), complexTypeGetter);
 
     return checkAndAddNull(schema, filterContents(combined, [TS_KEYWORDS.ANY]).join(" | "));
   },
   [SCHEMA_TYPES.COMPLEX_ALL_OF]: (schema) => {
     // T1 & T2
-    const combined = _.map(schema.allOf, complexTypeGetter);
+    const combined = _.map(_.map(schema.allOf, makeAddRequiredToChildSchema(schema)), complexTypeGetter);
     return checkAndAddNull(
       schema,
-      filterContents(combined, [...JS_EMPTY_TYPES, ...JS_PRIMITIVE_TYPES, TS_KEYWORDS.ANY]).join(
-        " & ",
-      ),
+      filterContents(combined, [...JS_EMPTY_TYPES, ...JS_PRIMITIVE_TYPES, TS_KEYWORDS.ANY]).join(" & "),
     );
   },
   [SCHEMA_TYPES.COMPLEX_ANY_OF]: (schema) => {
     // T1 | T2 | (T1 & T2)
-    const combined = _.map(schema.anyOf, complexTypeGetter);
-    const nonEmptyTypesCombined = filterContents(combined, [
-      ...JS_EMPTY_TYPES,
-      ...JS_PRIMITIVE_TYPES,
-      TS_KEYWORDS.ANY,
-    ]);
+    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(" & ")})` : ""),
+      `${combined.join(" | ")}` + (nonEmptyTypesCombined.length > 1 ? ` | (${nonEmptyTypesCombined.join(" & ")})` : ""),
     );
   },
   // TODO
-  [SCHEMA_TYPES.COMPLEX_NOT_OF]: (schema) => {
+  [SCHEMA_TYPES.COMPLEX_NOT]: (schema) => {
     // TODO
     return TS_KEYWORDS.ANY;
   },
@@ -228,8 +263,7 @@ const getComplexType = (schema) => {
 };
 
 const attachParsedRef = (originalSchema, parsedSchema) => {
-  const parsedSchemaAfterHook =
-    config.hooks.onParseSchema(originalSchema, parsedSchema) || parsedSchema;
+  const parsedSchemaAfterHook = config.hooks.onParseSchema(originalSchema, parsedSchema) || parsedSchema;
 
   if (originalSchema) {
     originalSchema.$parsed = parsedSchemaAfterHook;
@@ -264,12 +298,7 @@ const schemaParsers = {
         return {
           key: formattedKey,
           type: keyType,
-          value:
-            enumValue === null
-              ? enumValue
-              : isIntegerOrBooleanEnum
-              ? `${enumValue}`
-              : `"${enumValue}"`,
+          value: enumValue === null ? enumValue : isIntegerOrBooleanEnum ? `${enumValue}` : `"${enumValue}"`,
         };
       });
     } else {
@@ -291,9 +320,7 @@ const schemaParsers = {
       type: SCHEMA_TYPES.ENUM,
       keyType: keyType,
       typeIdentifier:
-        config.generateUnionEnums || (!enumNames && isIntegerOrBooleanEnum)
-          ? TS_KEYWORDS.TYPE
-          : TS_KEYWORDS.ENUM,
+        config.generateUnionEnums || (!enumNames && isIntegerOrBooleanEnum) ? TS_KEYWORDS.TYPE : TS_KEYWORDS.ENUM,
       name: typeName,
       description: formatDescription(schema.description),
       content,
@@ -332,8 +359,7 @@ const schemaParsers = {
       content:
         _.compact([
           complexSchemaContent && `(${complexSchemaContent})`,
-          getInternalSchemaType(simpleSchema) === TS_KEYWORDS.OBJECT &&
-            getInlineParseContent(simpleSchema),
+          getInternalSchemaType(simpleSchema) === TS_KEYWORDS.OBJECT && getInlineParseContent(simpleSchema),
         ]).join(" & ") || TS_KEYWORDS.ANY,
     });
   },
@@ -401,10 +427,7 @@ const parseSchema = (rawSchema, typeName, formattersMap) => {
     parsedSchema = schemaParsers[schemaType](fixedRawSchema, typeName);
   }
 
-  return (
-    (formattersMap && formattersMap[schemaType] && formattersMap[schemaType](parsedSchema)) ||
-    parsedSchema
-  );
+  return (formattersMap && formattersMap[schemaType] && formattersMap[schemaType](parsedSchema)) || parsedSchema;
 };
 
 const parseSchemas = (components) =>
@@ -413,8 +436,7 @@ const parseSchemas = (components) =>
 const getInlineParseContent = (rawTypeData, typeName = null) =>
   parseSchema(rawTypeData, typeName, inlineExtraFormatters).content;
 
-const getParseContent = (rawTypeData, typeName = null) =>
-  parseSchema(rawTypeData, typeName).content;
+const getParseContent = (rawTypeData, typeName = null) => parseSchema(rawTypeData, typeName).content;
 
 module.exports = {
   types,

package/src/swagger.js

@@ -17,7 +17,7 @@ const parseSwaggerFile = (file) => {
   }
 };
 
-const getSwaggerFile = (pathToSwagger, urlToSwagger, disableStrictSSL, disableProxy) =>
+const getSwaggerFile = (pathToSwagger, urlToSwagger, disableStrictSSL, disableProxy, authorizationToken) =>
   new Promise((resolve, reject) => {
     if (pathIsExist(pathToSwagger)) {
       logger.log(`try to get swagger by path "${pathToSwagger}"`);
@@ -33,15 +33,21 @@ const getSwaggerFile = (pathToSwagger, urlToSwagger, disableStrictSSL, disablePr
         });
       }
       //
+      if (authorizationToken) {
+        axiosOptions.headers = {
+          Authorization: authorizationToken,
+        };
+      }
+      //
       if (disableProxy) axiosOptions.proxy = false;
       //
       axios
         .get(urlToSwagger, axiosOptions)
         .then((res) => resolve(res.data))
-        .catch(() => {
+        .catch((error) => {
           const message = `error while getting swagger by URL ${urlToSwagger}`;
 
-          logger.error(message);
+          logger.error(message, "response" in error ? error.response : error);
 
           reject(message);
         });
@@ -53,9 +59,10 @@ const getSwaggerObject = (
   urlToSwagger,
   disableStrictSSL,
   disableProxy,
+  authorizationToken,
   converterOptions,
 ) =>
-  getSwaggerFile(pathToSwagger, urlToSwagger, disableStrictSSL, disableProxy).then((file) =>
+  getSwaggerFile(pathToSwagger, urlToSwagger, disableStrictSSL, disableProxy, authorizationToken).then((file) =>
     convertSwaggerObject(parseSwaggerFile(file), converterOptions),
   );
 

package/src/utils/id.js

@@ -0,0 +1,9 @@
+const { customAlphabet } = require("nanoid");
+
+const ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
+
+const generateId = customAlphabet(ALPHABET, 12);
+
+module.exports = {
+  generateId,
+};

package/templates/base/data-contracts.eta

@@ -1,7 +1,7 @@
 <%
   const { modelTypes, utils } = it;
   const { formatDescription, require, _ } = utils;
-  
+
 
   const dataContractTemplates = {
     enum: (contract) => {
@@ -20,6 +20,7 @@
 
     return _.compact([
         contract.description && formatDescription(contract.description),
+        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}`,

package/templates/base/http-clients/axios-http-client.eta

@@ -2,7 +2,7 @@
 const { apiConfig, generateResponses, config } = it;
 %>
 
-import axios, { AxiosInstance, AxiosRequestConfig, AxiosResponse, ResponseType } from "axios";
+import axios, { AxiosInstance, AxiosRequestConfig, AxiosResponse, ResponseType, HeadersDefaults } from "axios";
 
 export type QueryParamsType = Record<string | number, any>;
 
@@ -53,20 +53,44 @@ export class HttpClient<SecurityDataType = unknown> {
         this.securityData = data
     }
 
-    private mergeRequestParams(params1: AxiosRequestConfig, params2?: AxiosRequestConfig): AxiosRequestConfig {
-        return {
-            ...this.instance.defaults,
-            ...params1,
-            ...(params2 || {}),
-            headers: {
-                ...(this.instance.defaults.headers || {}),
-                ...(params1.headers || {}),
-                ...((params2 && params2.headers) || {}),
-            },
-        };
+    protected mergeRequestParams(params1: AxiosRequestConfig, params2?: AxiosRequestConfig): AxiosRequestConfig {
+      const method = params1.method || (params2 && params2.method)
+
+      return {
+        ...this.instance.defaults,
+        ...params1,
+        ...(params2 || {}),
+        headers: {
+          ...((method && this.instance.defaults.headers[method.toLowerCase() as keyof HeadersDefaults]) || {}),
+          ...(params1.headers || {}),
+          ...((params2 && params2.headers) || {}),
+        },
+      };
     }
 
-    private createFormData(input: Record<string, unknown>): FormData {
+    protected stringifyFormItem(formItem: unknown) {
+      if (typeof formItem === "object" && formItem !== null) {
+        return JSON.stringify(formItem);
+      } else {
+        return `${formItem}`;
+      }
+    }
+
+    protected createFormData(input: Record<string, unknown>): FormData {
+      return Object.keys(input || {}).reduce((formData, key) => {
+        const property = input[key];
+        const propertyContent: Iterable<any> = (property instanceof Array) ? property : [property]
+
+        for (const formItem of propertyContent) {
+          const isFileType = formItem instanceof Blob || formItem instanceof File;
+          formData.append(
+            key,
+            isFileType ? formItem : this.stringifyFormItem(formItem)
+            );
+        }
+
+        return formData;
+      }, new FormData());
       return Object.keys(input || {}).reduce((formData, key) => {
         const property = input[key];
         formData.append(
@@ -96,13 +120,9 @@ export class HttpClient<SecurityDataType = unknown> {
 <% } %>
         const secureParams = ((typeof secure === 'boolean' ? secure : this.secure) && this.securityWorker && (await this.securityWorker(this.securityData))) || {};
         const requestParams = this.mergeRequestParams(params, secureParams);
-        const responseFormat = (format && this.format) || void 0;
+        const responseFormat = (format || this.format) || undefined;
 
         if (type === ContentType.FormData && body && body !== null && typeof body === "object") {
-          requestParams.headers.common = { Accept: "*/*" };
-          requestParams.headers.post = {};
-          requestParams.headers.put = {};
-
           body = this.createFormData(body as Record<string, unknown>);
         }
 

package/templates/base/http-clients/fetch-http-client.eta

@@ -68,17 +68,17 @@ export class HttpClient<SecurityDataType = unknown> {
     public setSecurityData = (data: SecurityDataType | null) => {
         this.securityData = data;
     }
-    
-    private encodeQueryParam(key: string, value: any) {
+
+    protected encodeQueryParam(key: string, value: any) {
         const encodedKey = encodeURIComponent(key);
         return `${encodedKey}=${encodeURIComponent(typeof value === "number" ? value : `${value}`)}`;
     }
 
-    private addQueryParam(query: QueryParamsType, key: string) {
+    protected addQueryParam(query: QueryParamsType, key: string) {
         return this.encodeQueryParam(key, query[key]);
     }
 
-    private addArrayQueryParam(query: QueryParamsType, key: string) {
+    protected addArrayQueryParam(query: QueryParamsType, key: string) {
         const value = query[key];
         return value.map((v: any) => this.encodeQueryParam(key, v)).join("&");
     }
@@ -118,7 +118,7 @@ export class HttpClient<SecurityDataType = unknown> {
         [ContentType.UrlEncoded]: (input: any) => this.toQueryString(input),
     }
 
-    private mergeRequestParams(params1: RequestParams, params2?: RequestParams): RequestParams {
+    protected mergeRequestParams(params1: RequestParams, params2?: RequestParams): RequestParams {
         return {
             ...this.baseApiParams,
             ...params1,
@@ -131,7 +131,7 @@ export class HttpClient<SecurityDataType = unknown> {
         };
     }
 
-    private createAbortSignal = (cancelToken: CancelToken): AbortSignal | undefined => {
+    protected createAbortSignal = (cancelToken: CancelToken): AbortSignal | undefined => {
         if (this.abortControllers.has(cancelToken)) {
             const abortController = this.abortControllers.get(cancelToken);
             if (abortController) {
@@ -183,7 +183,7 @@ export class HttpClient<SecurityDataType = unknown> {
             ...(type && type !== ContentType.FormData ? { "Content-Type": type } : {}),
             ...(requestParams.headers || {}),
             },
-            signal: cancelToken ? this.createAbortSignal(cancelToken) : void 0,
+            signal: cancelToken ? this.createAbortSignal(cancelToken) : requestParams.signal,
             body: typeof body === "undefined" || body === null ? null : payloadFormatter(body),
         }
         ).then(async (response) => {

package/templates/default/api.eta

@@ -36,7 +36,7 @@ const descriptionLines = _.compact([
 <% }) %>
 */
 <% } %>
-export class Api<SecurityDataType extends unknown><% if (!config.singleHttpClient) { %> extends HttpClient<SecurityDataType> <% } %> {
+export class <%~ config.apiClassName %><SecurityDataType extends unknown><% if (!config.singleHttpClient) { %> extends HttpClient<SecurityDataType> <% } %> {
 
 <% if(config.singleHttpClient) { %>
   http: HttpClient<SecurityDataType>;