@toktokhan-dev/cli-plugin-gen-api-react-query 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,62 @@
+import * as _toktokhan_dev_cli from '@toktokhan-dev/cli';
+import { HttpClientType } from 'swagger-typescript-api';
+
+/**
+ * `Swagger` 의 json 을 조회하여 타입정의와 `api class`, `react-query` 관련 모듈을 생성합니다.
+ * `axios` 를 사용하는 환경에서 사용가능합니다.
+ *
+ * @packageDocumentation
+ */
+type GenerateFn = (param: {
+    apiInstanceName: string;
+    functionName: string;
+    pagination: {
+        keywords: string[];
+        nextKey: string;
+    };
+}) => string;
+interface PaginationConfig {
+    /** api 의 queryParams key 에 keywords 가 포함되어 있는 항목만 생성됩니다. 키워드 배열은 AND 연산으로써 사용됩니다. */
+    keywords: string[];
+    /** InfiniteQuery 의 nextPage 와 nextPageParam 을 구하는 함수를 작성하기 위해 사용됩니다. */
+    nextKey: string;
+    /**
+     * InfiniteQuery 의 initialPage 를 커스텀하기 위해 사용됩니다.
+     */
+    initialPageParam?: string | GenerateFn;
+    /** InfiniteQuery 의 nextPage 를 구하는 함수를 커스텀하기 위해 사용됩니다. */
+    getNextPage?: string | GenerateFn;
+    /** InfiniteQuery 의 nextPageParam 을 구하는 함수를 커스텀하기 위해 사용됩니다. */
+    getNextPageParam?: string | GenerateFn;
+}
+/**
+ * @category Types
+ */
+interface GenerateSwaggerApiConfig {
+    /** 조회할 스웨거의 url 혹은 file(yaml, json) 경로 입니다. 통상적으로
+     * 백앤드 개발자에게 공유받은  api-swagger-url 의 '/openapi.json' 경로에 해당합니다.
+     */
+    swaggerSchemaUrl: string;
+    /** 생성될 파일들이 위치할 경로입니다. */
+    output: string;
+    /** 생성되는 코드의 React Query 포함 여부 입니다.
+     *  해당 옵션이 false 일경우 infiniteQuery 를 포함한 모든 Query 가 생성되지 않습니다. */
+    includeReactQuery: boolean;
+    /** 생성되는 코드의 InfiniteQuery 포함 여부 입니다. */
+    includeReactInfiniteQuery: boolean;
+    /** Api 의 axios 혹은 fetch 요청 instance 주소입니다. */
+    instancePath: string;
+    /** http client 타입입니다. */
+    httpClientType: HttpClientType;
+    /**
+     * infiniteQuery 를 생성할 함수 필터 목록 입니다.
+     * */
+    paginations: PaginationConfig[];
+}
+/**
+ * @category Commands
+ */
+declare const genApi: _toktokhan_dev_cli.MyCommand<GenerateSwaggerApiConfig, "gen:api">;
+
+export { type GenerateFn, type GenerateSwaggerApiConfig, type PaginationConfig, genApi };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,196 @@
+import { defineCommand } from '@toktokhan-dev/cli';
+import { createPackageRoot, prettierString, prettierFile, withLoading, cwd } from '@toktokhan-dev/node';
+import path from 'path';
+import { generateApi } from 'swagger-typescript-api';
+import fs from 'fs';
+import camelCase from 'lodash/camelCase.js';
+
+
+// -- Shims --
+import cjsUrl from 'node:url';
+import cjsPath from 'node:path';
+import cjsModule from 'node:module';
+const __filename = cjsUrl.fileURLToPath(import.meta.url);
+const __dirname = cjsPath.dirname(__filename);
+const require = cjsModule.createRequire(import.meta.url);
+const packageRoot = createPackageRoot(__dirname);
+
+const GENERATE_SWAGGER_DATA = {
+    CUSTOM_AXIOS_TEMPLATE_FOLDER: packageRoot('templates/custom-axios'),
+    CUSTOM_FETCH_TEMPLATE_FOLDER: packageRoot('templates/custom-fetch'),
+    EXTRA_TEMPLATE_FOLTER: packageRoot('templates/my'),
+    TYPE_FILE: ['react-query-type.ts', 'data-contracts.ts', 'util-types.ts'],
+    UTIL_FILE: ['param-serializer-by.ts'],
+    QUERY_HOOK_INDICATOR: '@indicator-for-query-hook',
+    AXIOS_DEFAULT_INSTANCE_PATH: '@apis/_axios/instance',
+    FETCH_DEFAULT_INSTANCE_PATH: '@/configs/fetch/fetch-extend',
+};
+
+const { EXTRA_TEMPLATE_FOLTER, CUSTOM_AXIOS_TEMPLATE_FOLDER, CUSTOM_FETCH_TEMPLATE_FOLDER, QUERY_HOOK_INDICATOR: QUERY_HOOK_INDICATOR$1, } = GENERATE_SWAGGER_DATA;
+const parseSwagger = (config) => generateApi({
+    templates: config.httpClientType === 'axios' ?
+        CUSTOM_AXIOS_TEMPLATE_FOLDER
+        : CUSTOM_FETCH_TEMPLATE_FOLDER,
+    modular: true,
+    moduleNameFirstTag: true,
+    extractEnums: true,
+    addReadonly: true,
+    unwrapResponseData: true,
+    url: config.swaggerSchemaUrl,
+    input: config.swaggerSchemaUrl,
+    httpClientType: config.httpClientType, // "axios" or "fetch"
+    typeSuffix: 'Type',
+    prettier: {
+        printWidth: 120,
+    },
+    extraTemplates: [
+        {
+            name: 'react-query-type.ts', //
+            path: path.resolve(EXTRA_TEMPLATE_FOLTER, 'react-query-type.eta'),
+        },
+        {
+            name: 'util-types.ts', //
+            path: path.resolve(EXTRA_TEMPLATE_FOLTER, 'util-types.eta'),
+        },
+        {
+            name: 'param-serializer-by.ts', //
+            path: path.resolve(EXTRA_TEMPLATE_FOLTER, 'param-serializer-by.eta'),
+        },
+    ],
+    hooks: {
+        onPrepareConfig: (defaultConfig) => {
+            return {
+                ...defaultConfig,
+                myConfig: { QUERY_HOOK_INDICATOR: QUERY_HOOK_INDICATOR$1, ...config },
+            };
+        },
+    },
+});
+
+const { TYPE_FILE, UTIL_FILE, QUERY_HOOK_INDICATOR } = GENERATE_SWAGGER_DATA;
+const writeSwaggerApiFile = (params) => {
+    const { input, output, spinner } = params;
+    input.files.forEach(async ({ fileName, fileContent: content, fileExtension }) => {
+        const name = fileName + fileExtension;
+        try {
+            const isTypeFile = TYPE_FILE.includes(name);
+            const isUtilFile = UTIL_FILE.includes(name);
+            const isHttpClient = name === 'http-client.ts';
+            const isApiFile = content?.includes(QUERY_HOOK_INDICATOR);
+            const filename = name.replace('.ts', '');
+            const getTargetFolder = () => {
+                if (isUtilFile)
+                    return path.resolve(output, '@utils');
+                if (isTypeFile)
+                    return path.resolve(output, '@types');
+                if (isHttpClient)
+                    return path.resolve(output, `@${filename}`);
+                return path.resolve(output, filename);
+            };
+            const targetFolder = getTargetFolder();
+            fs.mkdirSync(targetFolder, { recursive: true });
+            if (spinner)
+                spinner.info(`generated: ${targetFolder}`);
+            if (isHttpClient) {
+                generate(path.resolve(targetFolder, 'index.ts'), content);
+                return;
+            }
+            if (isApiFile) {
+                const { apiContents, hookContents } = spilitHookContents(filename, content);
+                genreatePretty(path.resolve(targetFolder, `${filename}.api.ts`), apiContents);
+                genreatePretty(path.resolve(targetFolder, `${filename}.query.ts`), hookContents);
+                return;
+            }
+            generate(path.resolve(targetFolder, name), content);
+        }
+        catch (err) {
+            console.error(err);
+        }
+    });
+};
+async function genreatePretty(path, contents) {
+    generate(path, await prettierString(contents, {
+        parser: 'babel-ts',
+        plugins: ['prettier-plugin-organize-imports'],
+    }));
+    await prettierFile(path, { parser: 'typescript' });
+}
+function generate(path, contents) {
+    fs.writeFileSync(path, contents);
+}
+function spilitHookContents(filename, content) {
+    const [_apiContent, _hookContent] = content.split(QUERY_HOOK_INDICATOR);
+    const lastImport = getLastImportLine(content);
+    const lines = content.split('\n');
+    const importArea = [
+        `import { ${camelCase(filename)}Api } from './${filename}.api';`,
+        ...lines.slice(0, lastImport),
+    ].join('\n');
+    return {
+        apiContents: _apiContent,
+        hookContents: importArea + _hookContent,
+    };
+}
+function getLastImportLine(content) {
+    return (Math.max(...content
+        .split('\n')
+        .map((line, idx) => ({ idx, has: /from ('|").*('|");/.test(line) }))
+        .filter(({ has }) => has)
+        .map(({ idx }) => idx)) + 1);
+}
+
+/**
+ * @category Commands
+ */
+const genApi = defineCommand({
+    name: 'gen:api',
+    description: 'swagger schema 를 기반으로 api 를 생성합니다.',
+    cliOptions: [],
+    default: {
+        swaggerSchemaUrl: '',
+        output: 'src/generated/apis',
+        includeReactQuery: true,
+        includeReactInfiniteQuery: true,
+        httpClientType: 'axios',
+        instancePath: '@apis/_axios/instance',
+        paginations: [
+            {
+                keywords: ['cursor'],
+                nextKey: 'cursor',
+            },
+        ],
+    },
+    run: async (config) => {
+        console.log(config);
+        const isWebUrl = (string) => string.startsWith('http://') || string.startsWith('https://');
+        const coverPath = (config) => {
+            const { httpClientType, swaggerSchemaUrl, output } = config;
+            const { AXIOS_DEFAULT_INSTANCE_PATH, FETCH_DEFAULT_INSTANCE_PATH } = GENERATE_SWAGGER_DATA;
+            const instancePath = config.instancePath ||
+                (httpClientType === 'axios' ?
+                    AXIOS_DEFAULT_INSTANCE_PATH
+                    : FETCH_DEFAULT_INSTANCE_PATH);
+            return {
+                ...config,
+                instancePath,
+                swaggerSchemaUrl: isWebUrl(swaggerSchemaUrl) ? swaggerSchemaUrl : cwd(swaggerSchemaUrl),
+                output: cwd(output),
+            };
+        };
+        const covered = coverPath(config);
+        const parsed = await withLoading(`Parse Swagger`, covered.swaggerSchemaUrl, () => {
+            return parseSwagger(covered);
+        });
+        if (!parsed) {
+            console.error('Failed to generate api: swagger parse error.');
+            return;
+        }
+        withLoading('Write Swagger API', //
+        covered.output, (spinner) => {
+            writeSwaggerApiFile({ input: parsed, output: covered.output, spinner });
+        });
+    },
+});
+
+export { genApi };
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@toktokhan-dev/cli-plugin-gen-api-react-query",
+  "version": "0.0.1",
+  "description": "",
+  "type": "module",
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "templates",
+    "!dist/*.map"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/lodash": "^4.17.0",
+    "@toktokhan-dev/ts-config": "0.0.1"
+  },
+  "dependencies": {
+    "eta": "^3.4.0",
+    "lodash": "^4.17.21",
+    "prettier-plugin-organize-imports": "^3.2.4",
+    "swagger-typescript-api": "^13.0.3",
+    "@toktokhan-dev/cli": "0.0.1",
+    "@toktokhan-dev/node": "0.0.1"
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "build:watch": "rollup -c --watch",
+    "api-extractor": "api-extractor run --local --verbose",
+    "play": "pnpm build:watch & node --watch play/playground.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  }
+}

package/templates/custom-axios/api.eta

@@ -0,0 +1,176 @@
+<%
+const { utils, route, config, modelTypes, myConfig  } = it;
+const { _, classNameCase, pascalCase, require } = utils;
+const {  RESERVED_REQ_PARAMS_ARG_NAMES } = config.constants;
+
+const routes = route.routes;
+const dataContracts = _.map(modelTypes, "name");
+
+
+const projectRootPath = process.env.PWD;
+const myTemeplatePath = `../my`
+const reactQueryTemplatePath = `${myTemeplatePath}/react-query-hook.eta`
+const reactQuerKeyTemplatePath = `${myTemeplatePath}/react-query-key.eta`
+
+const apiClassName = classNameCase(route.moduleName) + 'Api';
+const paginations = myConfig?.paginations
+const instancePath = myConfig?.instancePath || "@apis/_axios/instance.ts"
+
+const apiInstanceName =route.moduleName + "Api";
+const queryKeyName = "QUERY_KEY_" + _.upperCase(apiClassName).replace(/ /g, '_');
+
+
+
+const hasPaginationKeyword = (queryString, keywords = paginationKeywords ) => {
+  if(!myConfig?.includeReactInfiniteQuery) return false;
+  const keywordUnion = keywords.map(str => `.*${str}.*`).join("|");
+  const rgxSting = keywords.map(str => `(${keywordUnion})`).join("");
+  const rgx = new RegExp(rgxSting);
+  return rgx.test(queryString);
+}
+
+
+const upperSnakeCase = (str) => _.upperCase(str).replace(/ /g, '_');
+
+const removeModuleName = (str) =>  str.replace(route.moduleName,'');
+
+const getConfigByRoute = (route) => {
+  const { specificArgNameResolver } = route
+  const { parameters, path, method, payload, query, formData, security, requestParams } = route.request;
+  const pathParams = _.values(parameters);
+  const pathParamsNames = _.map(pathParams, "name");
+  const queryName = (query && query.name) || "query";
+
+  const requestConfigParam = {
+    name: specificArgNameResolver.resolve(RESERVED_REQ_PARAMS_ARG_NAMES),
+    optional: true,
+    type: "RequestParams",
+}
+
+  const argToTmpl = ({ name, optional, type, defaultValue }) => `${name}${!defaultValue && optional ? '?' : ''}: ${type}`;
+
+  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('; ')
+
+
+  const functionName = route.routeName.usage;
+  const hookVariant = _.upperCase(method) === "GET" ? "Query" : "Mutation"
+  const key = upperSnakeCase(functionName);
+  const methodKey = upperSnakeCase(removeModuleName(functionName));
+  const pagination = paginations.find(d => !!query?.type &&  hasPaginationKeyword(query?.type.split("\n").join(""), d.keywords));
+
+  const isQuery = hookVariant === "Query";
+  const isMutation = hookVariant === "Mutation";
+  const hasPagination = !!pagination;
+
+  const isOptialnalVariabels  = _
+  // Find optional value
+  .filter(rawWrapperArgs, o => o.optional).length === rawWrapperArgs.length;
+
+  const conditionalVriablesText = isOptialnalVariabels? "variables?" : "variables";
+  const repalceTarget = "${" + conditionalVriablesText + ".";
+
+
+  return {
+    conditions:{
+      hasPagination,
+      isQuery,
+      isMutation,
+      isOptialnalVariabels,
+    },
+    data: {
+      rawWrapperArgs,
+      wrapperArgs,
+      queryKeyName,
+      functionName,
+      apiInstanceName,
+      apiClassName,
+      hookVariant,
+      key,
+      methodKey,
+      pagination,
+    },
+    utils: {
+      upperSnakeCase,
+      removeModuleName,
+      argToTmpl,
+    }
+  }
+}
+
+const dataForReactHookTemplate = {
+        getConfigByRoute,
+        queryKeyName,
+        apiClassName,
+        apiInstanceName,
+    };
+
+%>
+
+<% if (config.httpClientType === config.constants.HTTP_CLIENT.AXIOS) { %> import { AxiosRequestConfig, AxiosResponse } from "axios"; <% } %>
+
+import { AxiosError } from 'axios';
+import { useQuery, useMutation, useInfiniteQuery } from '@tanstack/react-query';
+import { QueryHookParams, InfiniteQueryHookParams, MutationHookParams, Parameter, RequestFnReturn } from "../@types/react-query-type";
+import { paramsSerializerBy } "../@utils/param-serializer-by"
+
+import instance from "<%~ instancePath %>";
+import { HttpClient, RequestParams, ContentType, HttpResponse } from "../@<%~ config.fileNames.httpClient %>";
+import { DeepOmitReadOnly } from '../@types/util-types';
+
+<% if (dataContracts.length) { %>
+  import { <%~ dataContracts.join(", ") %> } from "../@types/<%~ config.fileNames.dataContracts %>"
+<% } %>
+
+export class <%= apiClassName %><SecurityDataType = unknown><% if (!config.singleHttpClient) { %> extends HttpClient<SecurityDataType> <% } %> {
+<% if(config.singleHttpClient) { %>
+  http: HttpClient<SecurityDataType>;
+
+  constructor (http: HttpClient<SecurityDataType>) {
+    this.http = http;
+  }
+<% } %>
+
+    <% routes.forEach((route) => { %>
+        <%~ includeFile('./procedure-call.eta', { ...it, route }) %>
+    <% }) %>
+}
+
+
+export const <%= apiInstanceName %> = new <%= apiClassName %>({ instance })
+
+<% if(myConfig.includeReactQuery) { %>
+  //<%~ myConfig.QUERY_HOOK_INDICATOR %>
+
+  /**
+   * QUERY_KEYS
+   */
+   <%~ includeFile(reactQuerKeyTemplatePath, { ...it, route , dataFromApiTemplate:dataForReactHookTemplate}) %>
+  
+   <% routes.forEach((route) => { %>
+      <%~ includeFile(reactQueryTemplatePath, { ...it, route , dataFromApiTemplate:dataForReactHookTemplate}) %>
+    <% }) %>
+<% } %>
+ 
+

package/templates/custom-axios/data-contracts.eta

@@ -0,0 +1,76 @@
+<%
+  const { modelTypes, utils } = it;
+  const { formatDescription, require, _ } = utils;
+  
+
+  const dataContractTemplates = {
+    enum: (contract) => {
+    const enumNames = contract['x-enumNames'];
+
+    if (!contract.enum || !enumNames) {
+      console.warn("Warning: 'enum' or 'x-enum' not found in contract:", {
+        name: contract.name,
+        enum: contract.enum?.join(", "),
+        "x-enumNames": enumNames?.join(", ")
+      });
+      const comment = (() => {
+        if (!contract.enum?.length) return 'Enum Values Missing'
+        if (!enumNames?.length) return 'X-enumName Values Missing'
+        return ''
+      })()
+      return `type ${contract.name} = ${contract?.enum?.map(e => `"${e}"`).join("|") || "string"}; // ${comment}`;
+    }
+
+    if (contract.enum.length !== enumNames.length) {
+      console.warn("Warning: Length mismatch between 'enum' and 'x-enumNames' in contract:", {
+        name: contract.name,
+        enum: contract.enum?.join(", "),
+        "x-enumNames": enumNames?.join(", ")
+      });
+      return `type ${contract.name} = ${contract.enum?.map(e => `"${e}"`).join("|")}; // Length mismatch`;
+    }
+
+    const mapName =  contract.name + "Map"; 
+    const map = (contract.enum || []).map((key, idx) => {
+      const keyName = typeof key === 'number' ? key : `"${key}"`;
+      return `${keyName} : "${enumNames?.[idx]}"`;
+    }).join(", ");
+
+    return `type ${contract.name} = keyof typeof ${mapName};  export const ${mapName} = {\r\n${map} \r\n } as const`;
+
+    },
+    interface: (contract) => {
+      return `interface ${contract.name} {\r\n${contract.content}}`;
+    },
+    type: (contract) => {
+      return `type ${contract.name} = ${contract.content}`;
+    },
+  }
+
+  const createDescription = (contract) => {
+    if (!contract.typeData) return _.compact([contract.description]);
+
+    return _.compact([
+        contract.description && formatDescription(contract.description),
+        !_.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
+        }`,
+    ]);
+  }
+%>
+<% modelTypes.forEach((contract) => { %>
+<% const description = createDescription(contract); %>
+<% if (description.length) { %>
+/**
+<%~ description.map(part => `* ${part}`).join("\n") %>
+
+*/
+<% } %>
+export <%~ (dataContractTemplates[contract.typeIdentifier] || dataContractTemplates.type)(contract) %>
+
+
+<% }) %>

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

@@ -0,0 +1,144 @@
+<%
+const { apiConfig, generateResponses, config } = it;
+%>
+
+import axios, { AxiosInstance, AxiosRequestConfig, AxiosResponse, ResponseType, HeadersDefaults } 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> {
+  securityWorker?: (securityData: SecurityDataType | null) => Promise<AxiosRequestConfig | void> | AxiosRequestConfig | void;
+  secure?: boolean;
+  format?: ResponseType;
+  instance? : AxiosInstance;
+  axiosConfig?: Omit<AxiosRequestConfig, 'data' | 'cancelToken'>;
+}
+
+export enum ContentType {
+  Json = "application/json",
+  FormData = "multipart/form-data",
+  UrlEncoded = "application/x-www-form-urlencoded",
+  Text = "text/plain",
+}
+
+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, instance, axiosConfig }: ApiConfig<SecurityDataType> = {}) {
+        this.instance = instance || axios.create({
+            ...axiosConfig,
+            baseURL: axiosConfig?.baseURL|| ""
+          });
+        this.secure = secure;
+        this.format = format;
+        this.securityWorker = securityWorker;
+    }
+
+    public setSecurityData = (data: SecurityDataType | null) => {
+        this.securityData = data
+    }
+
+    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) || {}),
+        },
+      };
+    }
+
+    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: 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());
+    }
+
+    public request = async <T = any, _E = any>({
+        secure,
+        path,
+        type,
+        query,
+        format,
+        body,
+        ...params
+<% if (config.unwrapResponseData) { %>
+    }: FullRequestParams): Promise<T> => {
+<% } else { %>
+    }: FullRequestParams): Promise<AxiosResponse<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) || undefined;
+
+        if (type === ContentType.FormData && body && body !== null && typeof body === "object") {
+          body = this.createFormData(body as Record<string, unknown>);
+        }
+
+        if (type === ContentType.Text && body && body !== null && typeof body !== "string") {
+          body = JSON.stringify(body);
+        }
+
+        return this.instance.request({
+            ...requestParams,
+            headers: {
+                ...(requestParams.headers || {}),
+                ...(type && type !== ContentType.FormData ? { "Content-Type": type } : {}),
+            },
+            params: query,
+            responseType: responseFormat,
+            data: body,
+            url: path,
+<% if (config.unwrapResponseData) { %>
+        }).then(response => response.data);
+<% } else { %>
+        });
+<% } %>
+    };
+}