fastify-flux-cli 2.19.0

package/dist/schema/helper/convertEmptyObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertEmptyObject.d.ts","sourceRoot":"","sources":["../../../src/schema/helper/convertEmptyObject.ts"],"names":[],"mappings":"AAEA,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAMnD"}

package/dist/schema/helper/convertEmptyObject.js

@@ -0,0 +1,9 @@
+import _ from 'lodash';
+export function convertEmptyObject(object) {
+    return _.cloneDeepWith(object, (value) => {
+        if (_.isEqual(value, { type: 'object' })) {
+            return { ...value, additionalProperties: true };
+        }
+    });
+}
+//# sourceMappingURL=convertEmptyObject.js.map

package/dist/schema/helper/convertEmptyObject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertEmptyObject.js","sourceRoot":"","sources":["../../../src/schema/helper/convertEmptyObject.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAEvB,MAAM,UAAU,kBAAkB,CAAC,MAAW;IAC5C,OAAO,CAAC,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE;QACvC,IAAI,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE;YACxC,OAAO,EAAE,GAAG,KAAK,EAAE,oBAAoB,EAAE,IAAI,EAAE,CAAC;SACjD;IACH,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/schema/helper/convertNullToNullable.d.ts

@@ -0,0 +1,2 @@
+export declare function convertNullToNullable(object: any): any;
+//# sourceMappingURL=convertNullToNullable.d.ts.map

package/dist/schema/helper/convertNullToNullable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertNullToNullable.d.ts","sourceRoot":"","sources":["../../../src/schema/helper/convertNullToNullable.ts"],"names":[],"mappings":"AAaA,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAuBtD"}

package/dist/schema/helper/convertNullToNullable.js

@@ -0,0 +1,33 @@
+import _ from 'lodash';
+function handleAnyOf(anyOf) {
+    const hasTypeNull = anyOf.find((x) => x.type === 'null');
+    if (!hasTypeNull || anyOf.length !== 2) {
+        return;
+    }
+    const noneNull = anyOf.find((x) => x.type !== 'null');
+    return { nullable: true, ...noneNull };
+}
+export function convertNullToNullable(object) {
+    return _.cloneDeepWith(object, (value) => {
+        if (value['anyOf']) {
+            const result = handleAnyOf(value['anyOf']);
+            if (result) {
+                return convertNullToNullable(result);
+            }
+        }
+        if (value.type && _.isArray(value.type) && value.type.includes('null')) {
+            if (value.type.includes('null')) {
+                value.nullable = true;
+            }
+            const notNullTypes = value.type.filter((x) => x !== 'null');
+            if (notNullTypes.length === 1) {
+                value.type = notNullTypes[0];
+            }
+            else {
+                value.type = notNullTypes;
+            }
+            return convertNullToNullable(value);
+        }
+    });
+}
+//# sourceMappingURL=convertNullToNullable.js.map

package/dist/schema/helper/convertNullToNullable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertNullToNullable.js","sourceRoot":"","sources":["../../../src/schema/helper/convertNullToNullable.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAEvB,SAAS,WAAW,CAAC,KAA2B;IAC9C,MAAM,WAAW,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC;IAC9D,IAAI,CAAC,WAAW,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;QACtC,OAAO;KACR;IAED,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC;IAE3D,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,QAAQ,EAAE,CAAC;AACzC,CAAC;AAED,MAAM,UAAU,qBAAqB,CAAC,MAAW;IAC/C,OAAO,CAAC,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE;QACvC,IAAI,KAAK,CAAC,OAAO,CAAC,EAAE;YAClB,MAAM,MAAM,GAAG,WAAW,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;YAC3C,IAAI,MAAM,EAAE;gBACV,OAAO,qBAAqB,CAAC,MAAM,CAAC,CAAC;aACtC;SACF;QAED,IAAI,KAAK,CAAC,IAAI,IAAI,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE;YACtE,IAAI,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE;gBAC/B,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC;aACvB;YACD,MAAM,YAAY,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAS,EAAE,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC;YACpE,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE;gBAC7B,KAAK,CAAC,IAAI,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;aAC9B;iBAAM;gBACL,KAAK,CAAC,IAAI,GAAG,YAAY,CAAC;aAC3B;YAED,OAAO,qBAAqB,CAAC,KAAK,CAAC,CAAC;SACrC;IACH,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/schema/nullableSchema.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=nullableSchema.test.d.ts.map

package/dist/schema/nullableSchema.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nullableSchema.test.d.ts","sourceRoot":"","sources":["../../src/schema/nullableSchema.test.ts"],"names":[],"mappings":""}

package/dist/schema/nullableSchema.test.js

@@ -0,0 +1,93 @@
+import { convertNullToNullable } from './convertNullToNullable';
+const input = {
+    UpdateTodo: {
+        type: 'object',
+        properties: {
+            text: {
+                type: 'string',
+            },
+            foo: {
+                anyOf: [
+                    {
+                        type: 'null',
+                    },
+                    {
+                        type: 'string',
+                    },
+                    {
+                        type: 'number',
+                    },
+                ],
+            },
+            user: {
+                anyOf: [
+                    {
+                        type: 'null',
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            id: {
+                                type: 'number',
+                            },
+                            anyOf: [
+                                {
+                                    type: 'null',
+                                },
+                                {
+                                    type: 'object',
+                                    properties: {
+                                        id: {
+                                            type: 'number',
+                                        },
+                                    },
+                                },
+                            ],
+                        },
+                    },
+                ],
+            },
+        },
+    },
+};
+test('convert anyOf to nullable', () => {
+    expect(convertNullToNullable(input)).toMatchInlineSnapshot(`
+    Object {
+      "UpdateTodo": Object {
+        "properties": Object {
+          "foo": Object {
+            "anyOf": Array [
+              Object {
+                "type": "null",
+              },
+              Object {
+                "type": "string",
+              },
+              Object {
+                "type": "number",
+              },
+            ],
+          },
+          "text": Object {
+            "type": "string",
+          },
+          "user": Object {
+            "nullable": true,
+            "properties": Object {
+              "nullable": true,
+              "properties": Object {
+                "id": Object {
+                  "type": "number",
+                },
+              },
+              "type": "object",
+            },
+            "type": "object",
+          },
+        },
+        "type": "object",
+      },
+    }
+  `);
+});
+//# sourceMappingURL=nullableSchema.test.js.map

package/dist/schema/nullableSchema.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nullableSchema.test.js","sourceRoot":"","sources":["../../src/schema/nullableSchema.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,MAAM,KAAK,GAAG;IACZ,UAAU,EAAE;QACV,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE;YACV,IAAI,EAAE;gBACJ,IAAI,EAAE,QAAQ;aACf;YACD,GAAG,EAAE;gBACH,KAAK,EAAE;oBACL;wBACE,IAAI,EAAE,MAAM;qBACb;oBACD;wBACE,IAAI,EAAE,QAAQ;qBACf;oBACD;wBACE,IAAI,EAAE,QAAQ;qBACf;iBACF;aACF;YACD,IAAI,EAAE;gBACJ,KAAK,EAAE;oBACL;wBACE,IAAI,EAAE,MAAM;qBACb;oBACD;wBACE,IAAI,EAAE,QAAQ;wBACd,UAAU,EAAE;4BACV,EAAE,EAAE;gCACF,IAAI,EAAE,QAAQ;6BACf;4BACD,KAAK,EAAE;gCACL;oCACE,IAAI,EAAE,MAAM;iCACb;gCACD;oCACE,IAAI,EAAE,QAAQ;oCACd,UAAU,EAAE;wCACV,EAAE,EAAE;4CACF,IAAI,EAAE,QAAQ;yCACf;qCACF;iCACF;6BACF;yBACF;qBACF;iBACF;aACF;SACF;KACF;CACF,CAAC;AAEF,IAAI,CAAC,2BAA2B,EAAE,GAAG,EAAE;IACrC,MAAM,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC,CAAC,qBAAqB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqC1D,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,13 @@
+import { BuildOptions } from 'esbuild';
+import { GenerateApiParams } from 'swagger-typescript-api';
+export interface FluxProjectConfig {
+    sdk?: GenerateApiParams;
+    run: string[];
+}
+export interface FluxCliConfig {
+    entry: string;
+    outdir: string;
+    esbuild?: BuildOptions;
+    tasks: FluxProjectConfig[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAE3D,MAAM,WAAW,iBAAiB;IAChC,GAAG,CAAC,EAAE,iBAAiB,CAAC;IACxB,GAAG,EAAE,MAAM,EAAE,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,KAAK,EAAE,iBAAiB,EAAE,CAAC;CAC5B"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "fastify-flux-cli",
+  "version": "2.19.0",
+  "description": "",
+  "main": "./dist/index.js",
+  "exports": "./dist/index.js",
+  "bin": {
+    "flux": "./cli.js"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@apidevtools/json-schema-ref-parser": "^9.0.9",
+    "@types/lodash": "^4.14.182",
+    "chalk": "^5.0.1",
+    "chokidar": "^3.5.3",
+    "commander": "^9.4.0",
+    "esbuild": "^0.14.49",
+    "execa": "^6.1.0",
+    "fast-glob": "^3.2.11",
+    "lodash": "^4.17.21",
+    "p-map": "5.5.0",
+    "pidtree": "^0.6.0",
+    "piscina": "^3.2.0",
+    "source-map-support": "^0.5.21",
+    "swagger-typescript-api": "^9.3.1",
+    "ts-json-schema-generator": "^1.0.0",
+    "ts-morph": "^15.1.0",
+    "typescript": "4.7.4"
+  },
+  "devDependencies": {
+    "@fluxapi/common": "npm:fastify-flux@2.19.0",
+    "@types/fs-extra": "^9.0.13",
+    "@types/jest": "^28.1.6",
+    "@types/node": "^18.0.6",
+    "jest": "^28.1.3",
+    "ts-jest": "^28.0.7"
+  },
+  "peerDependencies": {
+    "esbuild": "0.x"
+  },
+  "files": [
+    "cli.js",
+    "dist/",
+    "sdk-templates/"
+  ],
+  "type": "module",
+  "engines": {
+    "node": ">=14"
+  },
+  "scripts": {
+    "clean": "rm -rf dist/",
+    "test": "jest",
+    "dev": "tsc --watch",
+    "build": "tsc"
+  }
+}

package/sdk-templates/api.eta

@@ -0,0 +1,65 @@
+<%
+const { apiConfig, routes, utils, config } = it;
+const { info, servers, externalDocs } = apiConfig;
+const { _, require, formatDescription } = utils;
+
+const server = (servers && servers[0]) || { url: "" };
+
+const descriptionLines = _.compact([
+  `@title ${info.title || "No title"}`,
+  info.version && `@version ${info.version}`,
+  info.license && `@license ${_.compact([
+    info.license.name,
+    info.license.url && `(${info.license.url})`,
+  ]).join(" ")}`,
+  info.termsOfService && `@termsOfService ${info.termsOfService}`,
+  server.url && `@baseUrl ${server.url}`,
+  externalDocs.url && `@externalDocs ${externalDocs.url}`,
+  info.contact && `@contact ${_.compact([
+    info.contact.name,
+    info.contact.email && `<${info.contact.email}>`,
+    info.contact.url && `(${info.contact.url})`,
+  ]).join(" ")}`,
+  info.description && " ",
+  info.description && _.replace(formatDescription(info.description), /\n/g, "\n * "),
+]);
+
+%>
+
+<% if (config.httpClientType === config.constants.HTTP_CLIENT.AXIOS) { %> import { AxiosRequestConfig, AxiosResponse } from "axios"; <% } %>
+
+<% if (descriptionLines.length) { %>
+/**
+<% descriptionLines.forEach((descriptionLine) => { %>
+* <%~ descriptionLine %>
+
+<% }) %>
+*/
+<% } %>
+export class Api<SecurityDataType extends unknown><% if (!config.singleHttpClient) { %> extends HttpClient<SecurityDataType> <% } %> {
+
+<% if(config.singleHttpClient) { %>
+  http: HttpClient<SecurityDataType>;
+
+  constructor (http: HttpClient<SecurityDataType>) {
+    this.http = http;
+  }
+<% } %>
+
+
+<% routes.outOfModule && routes.outOfModule.forEach((route) => { %>
+
+        <%~ includeFile('./procedure-call.eta', { ...it, route }) %>
+
+<% }) %>
+
+<% routes.combined && routes.combined.forEach(({ routes = [], moduleName }) => { %>
+    <%~ moduleName %> = {
+    <% routes.forEach((route) => { %>
+
+        <%~ includeFile('./procedure-call.eta', { ...it, route }) %>
+
+    <% }) %>
+    }
+<% }) %>
+}

package/sdk-templates/axios-http-client.eta

@@ -0,0 +1,133 @@
+<%
+const { apiConfig, generateResponses, config } = it;
+%>
+
+import axios, { AxiosInstance, AxiosRequestConfig, AxiosResponse, ResponseType } from "axios";
+
+export type QueryParamsType = Record<string | number, any>;
+
+export interface FullRequestParams extends Omit<AxiosRequestConfig, "data" | "params" | "url" | "responseType"> {
+  /** set parameter to `true` for call `securityWorker` for this request */
+  secure?: boolean;
+  /** request path */
+  path: string;
+  /** content type of request body */
+  type?: ContentType;
+  /** query params */
+  query?: QueryParamsType;
+  /** format of response (i.e. response.json() -> format: "json") */
+  format?: ResponseType;
+  /** request body */
+  body?: unknown;
+}
+
+export type RequestParams = Omit<FullRequestParams, "body" | "method" | "query" | "path">;
+
+export interface ApiConfig<SecurityDataType = unknown> extends Omit<AxiosRequestConfig, "data" | "cancelToken"> {
+  securityWorker?: (securityData: SecurityDataType | null) => Promise<AxiosRequestConfig | void> | AxiosRequestConfig | void;
+  secure?: boolean;
+  format?: ResponseType;
+}
+
+export enum ContentType {
+  Json = "application/json",
+  FormData = "multipart/form-data",
+  UrlEncoded = "application/x-www-form-urlencoded",
+}
+
+export class HttpClient<SecurityDataType = unknown> {
+    public instance: AxiosInstance;
+    private securityData: SecurityDataType | null = null;
+    private securityWorker?: ApiConfig<SecurityDataType>["securityWorker"];
+    private secure?: boolean;
+    private format?: ResponseType;
+
+    constructor({ securityWorker, secure, format, ...axiosConfig }: ApiConfig<SecurityDataType> = {}) {
+        this.instance = axios.create({ ...axiosConfig, baseURL: axiosConfig.baseURL || "<%~ apiConfig.baseUrl %>" })
+        this.secure = secure;
+        this.format = format;
+        this.securityWorker = securityWorker;
+    }
+
+    public setSecurityData = (data: SecurityDataType | null) => {
+        this.securityData = data
+    }
+
+    private mergeRequestParams(params1: AxiosRequestConfig, params2?: AxiosRequestConfig): AxiosRequestConfig {
+        return {
+            ...this.instance.defaults,
+            ...params1,
+            ...(params2 || {}),
+            headers: {
+                ...(params1.headers || {}),
+                ...((params2 && params2.headers) || {}),
+            },
+        };
+    }
+
+    private createFormData(input: Record<string, unknown>): FormData {
+      return Object.keys(input || {}).reduce((formData, key) => {
+        const property = input[key];
+        formData.append(
+            key,
+            property instanceof Blob ?
+                property :
+            typeof property === "object" && property !== null ?
+                JSON.stringify(property) :
+            `${property}`
+        );
+        return formData;
+      }, new FormData())
+    }
+
+    public request = async <T = any, _E = any>({
+        secure,
+        path,
+        type,
+        query,
+        format,
+        body,
+        ...params
+    }: FullRequestParams): Promise<T> => {
+        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;
+
+        if (type === ContentType.FormData && body && body !== null && typeof body === "object") {
+          body = this.createFormData(body as Record<string, unknown>);
+        }
+
+	if (!type) {
+	  type = ContentType.Json;
+	}
+
+	if (!body) {
+	    body = {};
+	}
+
+        try {
+          const result: any = await this.instance.request({
+              ...requestParams,
+              headers: {
+                  ...(type && type !== ContentType.FormData ? { "Content-Type": type } : {}),
+                  ...(requestParams.headers || {}),
+              },
+              params: query,
+              responseType: responseFormat,
+              data: body,
+              url: path,
+          });
+
+          return result.data;
+        } catch(err) {
+          if (axios.isAxiosError(err)) {
+            err.message += ` [${err.config.method}] ${err.config.url}`;
+            if (err.response) {
+              (err as any).data = err.response.data;
+            }
+          }
+
+          throw err;
+        } 
+    };
+}

package/sdk-templates/http-client.eta

@@ -0,0 +1,3 @@
+<% const { config } = it; %>
+<% /* https://github.com/acacode/swagger-typescript-api/tree/next/templates/base/http-clients/ */ %>
+<%~ includeFile(`./axios-http-client`, it) %>

package/sdk-templates/procedure-call.eta

@@ -0,0 +1,99 @@
+<%
+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",
+}
+// 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 %><%~ route.namespace ? ': ' : ' = ' %>(<%~ 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") %>,
+    })<%~ route.namespace ? ',' : '' %>

package/sdk-templates/route-types.eta

@@ -0,0 +1,28 @@
+<%
+const { utils, config, routes, modelTypes } = it;
+const { _, classNameCase } = utils;
+const dataContracts = config.modular ? _.map(modelTypes, "name") : [];
+%>
+
+<% if (dataContracts.length) { %>
+import { <%~ dataContracts.join(", ") %> } from "./<%~ config.fileNames.dataContracts %>"
+<% } %>
+
+<%
+/* TODO: outOfModule, combined should be attributes of route, which will allow to avoid duplication of code */
+%>
+
+<% routes.outOfModule && routes.outOfModule.forEach(({ routes = [] }) => { %>
+    <% routes.forEach((route) => { %>
+        <%~ includeFile('@base/route-type.eta', { ...it, route }) %>
+    <% }) %>
+<% }) %>
+
+<% routes.combined && routes.combined.forEach(({ routes = [], moduleName }) => { %>
+    export namespace <%~ classNameCase(moduleName) %> {
+    <% routes.forEach((route) => { %>
+        <%~ includeFile('@base/route-type.eta', { ...it, route }) %>
+    <% }) %>
+    }
+
+<% }) %>