swagger-fsd-gen 1.0.0

package/scripts/generate-all.js

@@ -0,0 +1,341 @@
+#!/usr/bin/env node
+
+/**
+ * Swagger API 클라이언트 자동 생성 도구
+ * - ky HTTP 클라이언트 기반 API 클래스 생성
+ * - TanStack Query 훅 생성 (useQuery, useMutation)
+ * - FSD(Feature-Sliced Design) 패턴 적용
+ */
+
+import path from "node:path";
+import minimist from "minimist";
+import { fileURLToPath } from "url";
+import { generateApi } from "swagger-typescript-api";
+import { fetchSwagger } from "../utils/fetch-swagger.js";
+import { writeFileToPath } from "../utils/file.js";
+import { AnyOfSchemaParser } from "../utils/parser.js";
+import { isUrl } from "../utils/url.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * 명령행 인수 파싱
+ * @returns {Object} 파싱된 인수들
+ */
+const parseArguments = () => {
+  const argv = minimist(process.argv.slice(2), {
+    string: [
+      "uri",
+      "username",
+      "password",
+      "dto-output-path",
+      "api-output-path",
+      "api-instance-output-path",
+      "query-output-path",
+      "mutation-output-path",
+      "project-template",
+    ],
+    alias: {
+      u: "uri",
+      un: "username",
+      pw: "password",
+      dp: "dto-output-path",
+      ap: "api-output-path",
+      aip: "api-instance-output-path",
+      qp: "query-output-path",
+      mp: "mutation-output-path",
+      pt: "project-template",
+    },
+  });
+
+  return {
+    uri: argv.uri,
+    username: argv.username,
+    password: argv.password,
+    dtoOutputPath: argv["dto-output-path"],
+    apiOutputPath: argv["api-output-path"],
+    apiInstanceOutputPath: argv["api-instance-output-path"],
+    queryOutputPath: argv["query-output-path"],
+    mutationOutputPath: argv["mutation-output-path"],
+    projectTemplate: argv["project-template"],
+  };
+};
+
+/**
+ * 출력 경로 설정 (FSD 패턴 기본값)
+ * @param {Object} args - 명령행 인수
+ * @returns {Object} 설정된 출력 경로들
+ */
+const setupOutputPaths = (args) => {
+  return {
+    // DTO 타입 정의 파일 (공통)
+    dto: {
+      relativePath: args.dtoOutputPath ?? "src/shared/api/dto.ts",
+      absolutePath: path.resolve(
+        process.cwd(),
+        args.dtoOutputPath ?? "src/shared/api/dto.ts"
+      ),
+    },
+    // API 클래스 파일 (모듈별)
+    api: {
+      relativePath:
+        args.apiOutputPath ?? "src/entities/{moduleName}/api/index.ts",
+      absolutePath: path.resolve(
+        process.cwd(),
+        args.apiOutputPath ?? "src/entities/{moduleName}/api/index.ts"
+      ),
+    },
+    // API 인스턴스 파일 (모듈별)
+    apiInstance: {
+      relativePath:
+        args.apiInstanceOutputPath ??
+        "src/entities/{moduleName}/api/instance.ts",
+      absolutePath: path.resolve(
+        process.cwd(),
+        args.apiInstanceOutputPath ??
+          "src/entities/{moduleName}/api/instance.ts"
+      ),
+    },
+    // TanStack Query 훅 파일 (모듈별)
+    query: {
+      relativePath:
+        args.queryOutputPath ?? "src/entities/{moduleName}/api/queries.ts",
+      absolutePath: path.resolve(
+        process.cwd(),
+        args.queryOutputPath ?? "src/entities/{moduleName}/api/queries.ts"
+      ),
+    },
+    // TanStack Mutation 훅 파일 (모듈별)
+    mutation: {
+      relativePath:
+        args.mutationOutputPath ?? "src/entities/{moduleName}/api/mutations.ts",
+      absolutePath: path.resolve(
+        process.cwd(),
+        args.mutationOutputPath ?? "src/entities/{moduleName}/api/mutations.ts"
+      ),
+    },
+  };
+};
+
+/**
+ * 사용법 출력
+ * @param {Object} outputPaths - 출력 경로 설정
+ */
+const printUsage = (outputPaths) => {
+  console.error(
+    "❗️ Error: Please provide the swagger URL or swagger file name"
+  );
+  console.error(
+    "Usage: generate-all --uri <swagger-url|swagger-file-name> " +
+      "[--username <username>] [--password <password>] " +
+      "[--dto-output-path <dto-output-path>] " +
+      "[--api-output-path <api-output-path>] " +
+      "[--query-output-path <query-output-path>] " +
+      "[--mutation-output-path <mutation-output-path>] " +
+      "[--project-template <project-template>]"
+  );
+  console.error(
+    `\nCurrent output paths:\n` +
+      `  DTO Path: ${outputPaths.dto.relativePath}\n` +
+      `  API Path: ${outputPaths.api.relativePath}\n` +
+      `  Query Path: ${outputPaths.query.relativePath}\n` +
+      `  Mutation Path: ${outputPaths.mutation.relativePath}`
+  );
+};
+
+/**
+ * swagger-typescript-api를 사용하여 API 코드 생성
+ * @param {Object} params - 생성 파라미터
+ * @returns {Promise<Object>} 생성된 파일들
+ */
+export const generateApiCode = async ({
+  uri,
+  username,
+  password,
+  templates,
+  ...params
+}) => {
+  const isLocal = !isUrl(uri);
+
+  return generateApi({
+    // 로컬 파일 또는 원격 URL 처리
+    input: isLocal ? path.resolve(process.cwd(), uri) : undefined,
+    spec: !isLocal && (await fetchSwagger(uri, username, password)),
+    templates: templates,
+    generateClient: true,
+    generateUnionEnums: true,
+    cleanOutput: false,
+    silent: true,
+    // Prettier 설정
+    prettier: {
+      semi: true,
+      trailingComma: "es5",
+      singleQuote: true,
+      printWidth: 100,
+      tabWidth: 2,
+      arrowParens: "always",
+      jsxBracketSameLine: false,
+      jsxSingleQuote: false,
+    },
+    modular: true,
+    moduleNameFirstTag: true, // Swagger 태그를 모듈명으로 사용
+    moduleNameIndex: 1,
+    // typeSuffix: "Dto", // 타입에 Dto 접미사 추가
+    generateRouteTypes: true,
+    schemaParsers: {
+      complexAnyOf: AnyOfSchemaParser,
+    },
+    ...params,
+  });
+};
+
+/**
+ * API 클래스와 DTO 파일 생성
+ * @param {Object} args - 명령행 인수
+ * @param {Object} outputPaths - 출력 경로 설정
+ */
+const generateApiFunctionCode = async (args, outputPaths) => {
+  const { projectTemplate, uri, username, password } = args;
+
+  // 템플릿 경로 결정 (커스텀 템플릿 또는 기본 템플릿)
+  const templatePath = projectTemplate
+    ? path.resolve(process.cwd(), projectTemplate)
+    : path.resolve(__dirname, "../templates");
+
+  console.log("🔄 Generating API classes and DTOs...");
+
+  const apiFunctionCode = await generateApiCode({
+    uri,
+    username,
+    password,
+    templates: templatePath,
+  });
+
+  // 생성된 파일들을 적절한 위치에 저장
+  for (const { fileName, fileContent } of apiFunctionCode.files) {
+    // http-client 파일은 사용하지 않음 (ky 사용)
+    if (fileName === "http-client") continue;
+
+    if (fileName === "data-contracts") {
+      // DTO 타입 정의 파일 저장
+      await writeFileToPath(outputPaths.dto.absolutePath, fileContent);
+      console.log(`✅ Generated DTO: ${outputPaths.dto.relativePath}`);
+    } else {
+      // 모듈명 추출 (예: UserRoute -> user)
+      const moduleName = fileName.replace("Route", "").toLowerCase();
+
+      if (fileName.match(/Route$/)) {
+        // API 인스턴스 파일 생성 (예: UserRoute -> user/api/instance.ts)
+        const output = outputPaths.apiInstance.absolutePath.replace(
+          "{moduleName}",
+          moduleName
+        );
+        await writeFileToPath(output, fileContent);
+        console.log(
+          `✅ Generated API instance: ${output.replace(process.cwd(), ".")}`
+        );
+      } else {
+        // API 클래스 파일 생성 (예: User -> user/api/index.ts)
+        const output = outputPaths.api.absolutePath.replace(
+          "{moduleName}",
+          moduleName
+        );
+        await writeFileToPath(output, fileContent);
+        console.log(
+          `✅ Generated API class: ${output.replace(process.cwd(), ".")}`
+        );
+      }
+    }
+  }
+};
+
+/**
+ * TanStack Query 훅 파일 생성
+ * @param {Object} args - 명령행 인수
+ * @param {Object} outputPaths - 출력 경로 설정
+ */
+const generateTanstackQueryCode = async (args, outputPaths) => {
+  const { projectTemplate, uri, username, password } = args;
+
+  // TanStack Query 템플릿 경로 결정
+  const templatePath = projectTemplate
+    ? path.resolve(process.cwd(), projectTemplate, "tanstack-query")
+    : path.resolve(__dirname, "../templates/tanstack-query");
+
+  console.log("🔄 Generating TanStack Query hooks...");
+
+  const tanstackQueryCode = await generateApiCode({
+    uri,
+    username,
+    password,
+    templates: templatePath,
+  });
+
+  // 생성된 파일들을 적절한 위치에 저장
+  for (const { fileName, fileContent } of tanstackQueryCode.files) {
+    // 불필요한 파일들 제외
+    if (fileName === "http-client" || fileName === "data-contracts") continue;
+
+    const moduleName = fileName.replace("Route", "").toLowerCase();
+
+    if (fileName.match(/Route$/)) {
+      // Mutation 훅 파일 생성
+      const output = outputPaths.mutation.absolutePath.replace(
+        "{moduleName}",
+        moduleName
+      );
+      await writeFileToPath(output, fileContent);
+      console.log(
+        `✅ Generated mutations: ${output.replace(process.cwd(), ".")}`
+      );
+    } else {
+      // Query 훅 파일 생성
+      const output = outputPaths.query.absolutePath.replace(
+        "{moduleName}",
+        moduleName
+      );
+      await writeFileToPath(output, fileContent);
+      console.log(
+        `✅ Generated queries: ${output.replace(process.cwd(), ".")}`
+      );
+    }
+  }
+};
+
+/**
+ * 메인 실행 함수
+ */
+const main = async () => {
+  console.log("🚀 Starting Swagger API client generation...\n");
+
+  const args = parseArguments();
+  const outputPaths = setupOutputPaths(args);
+
+  // URI 필수 체크
+  if (!args.uri) {
+    printUsage(outputPaths);
+    process.exit(1);
+  }
+
+  try {
+    // 1. API 클래스와 DTO 생성
+    await generateApiFunctionCode(args, outputPaths);
+
+    // 2. TanStack Query 훅 생성
+    await generateTanstackQueryCode(args, outputPaths);
+
+    console.log("\n🎉 API client generation completed successfully!");
+    console.log("\n📁 Generated files:");
+    console.log(`   - DTOs: ${outputPaths.dto.relativePath}`);
+    console.log(`   - API classes: ${outputPaths.api.relativePath}`);
+    console.log(`   - Query hooks: ${outputPaths.query.relativePath}`);
+    console.log(`   - Mutation hooks: ${outputPaths.mutation.relativePath}`);
+  } catch (error) {
+    console.error("\n❌ Error during generation:");
+    console.error(error.message);
+    process.exit(1);
+  }
+};
+
+main();

package/templates/api.ejs

@@ -0,0 +1,77 @@
+<%
+/**
+ * API 클래스 생성 템플릿
+ * - Swagger 태그별로 API 클래스 생성
+ * - ky HTTP 클라이언트 기반
+ * - 타입 안전성을 위한 TypeScript 지원
+ * - 쿼리 파라미터 처리를 위한 유틸리티 메서드 포함
+ */
+
+const { utils, route, config, modelTypes } = it;
+const { _, pascalCase, require } = utils;
+
+// 모듈명을 PascalCase로 변환하여 클래스명 생성 (예: user -> UserApi)
+const apiClassName = pascalCase(route.moduleName);
+
+// 해당 모듈의 모든 API 엔드포인트
+const routes = route.routes;
+
+// 사용 가능한 DTO 타입들의 이름 목록
+const dataContracts = _.map(modelTypes, "name");
+%>
+
+import { KyInstance, Options } from 'ky';
+
+<%~ includeFile('./dto-import.ejs', { ...it }) %>
+
+/**
+ * <%= route.moduleName %> 모듈 API 클래스
+ * - ky HTTP 클라이언트를 사용한 API 호출
+ * - 타입 안전성을 위한 TypeScript 지원
+ * - 쿼리 파라미터 자동 변환 기능
+ */
+export class <%= apiClassName %>Api {
+private readonly instance: KyInstance;
+
+/**
+ * API 클래스 생성자
+ * @param instance - ky HTTP 클라이언트 인스턴스
+ */
+constructor(instance: KyInstance) {
+this.instance = instance;
+}
+
+/**
+ * 객체를 URLSearchParams로 변환하는 정적 유틸리티 메서드
+ * - 중첩된 객체나 배열을 쿼리 파라미터로 변환
+ * - undefined 값은 자동으로 제외
+ * - 배열 값은 여러 개의 동일한 키로 변환
+ * 
+ * @param params - 쿼리 파라미터 객체
+ * @returns URLSearchParams 인스턴스
+ * 
+ * @example
+ * createSearchParams({ name: 'john', tags: ['tag1', 'tag2'] })
+ * // 결과: name=john&tags=tag1&tags=tag2
+ */
+static createSearchParams(
+  params?: Record<string, string | number | boolean | Array<string | number | boolean>>
+): URLSearchParams {
+  const urlSearchParams = new URLSearchParams();
+
+  if (params) {
+    Object.entries(params)
+      .filter(([, value]) => value !== undefined)
+      .forEach(([key, value]) => {
+        const values = Array.isArray(value) ? value : [value];
+        values.forEach((v) => urlSearchParams.append(key, v.toString()));
+      });
+  }
+
+  return urlSearchParams;
+}
+
+<% for (const route of routes) { %>
+<%~ includeFile('./procedure-call.ejs', { ...it, route, apiClassName }) %>
+<% } %>
+}

package/templates/data-contracts.ejs

@@ -0,0 +1,94 @@
+<%
+/**
+ * DTO(Data Transfer Object) 타입 정의 템플릿
+ * - Swagger 스키마에서 TypeScript 타입 정의 생성
+ * - enum, interface, type 등 다양한 타입 지원
+ * - 제네릭 타입 지원
+ * - Query 파라미터 및 Header 타입 자동 생성
+ */
+
+const { modelTypes, utils, config, routes } = it;
+const { formatDescription, require, _, Ts, pascalCase } = utils;
+
+/**
+ * 제네릭 타입 문자열 생성
+ * @param {Object} contract - 타입 계약 객체
+ * @returns {string} 제네릭 타입 문자열 (예: <T extends string = any>)
+ */
+const buildGenerics = (contract) => {
+    if (!contract.genericArgs || !contract.genericArgs.length) return '';
+
+    return '<' + contract.genericArgs.map(({ name, default: defaultType, extends: extendsType }) => {
+        return [
+            name,
+            extendsType && `extends ${extendsType}`,
+            defaultType && `= ${defaultType}`,
+        ].join('')
+    }).join(',') + '>'
+}
+
+/**
+ * 데이터 계약 템플릿 정의
+ * - enum: 열거형 타입 생성
+ * - interface: 인터페이스 타입 생성 (실제로는 type alias 사용)
+ * - type: 타입 별칭 생성
+ */
+const dataContractTemplates = {
+    // 열거형 타입 템플릿
+    enum: (contract) => {
+        return `enum ${contract.name} {\r\n${contract.content} \r\n }`;
+    },
+    // 인터페이스 타입 템플릿 (객체 형태)
+    interface: (contract) => {
+        return `type ${contract.name}${buildGenerics(contract)} = {\r\n${contract.content}}`;
+    },
+    // 일반 타입 별칭 템플릿
+    type: (contract) => {
+        return `type ${contract.name}${buildGenerics(contract)} = ${contract.content}`;
+    },
+}
+%>
+
+<% if (config.internalTemplateOptions.addUtilRequiredKeysType) { %>
+/**
+ * 유틸리티 타입: 특정 키를 필수로 만드는 헬퍼 타입
+ * @template T - 원본 타입
+ * @template K - 필수로 만들 키들
+ */
+type <%~ config.Ts.CodeGenKeyword.UtilRequiredKeys %><T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>
+<% } %>
+
+<% for (const contract of modelTypes) { %>
+<%~ includeFile('@base/data-contract-jsdoc.ejs', { ...it, data: { ...contract, ...contract.typeData } }) %>
+<%~ contract.internal ? '' : 'export'%> <%~ (dataContractTemplates[contract.typeIdentifier] || dataContractTemplates.type)(contract) %>
+
+
+<% } %>
+
+<%
+/**
+ * API 엔드포인트별 Query 파라미터 및 Header 타입 생성
+ * - 각 API 엔드포인트의 쿼리 파라미터를 별도 타입으로 정의
+ * - 각 API 엔드포인트의 헤더를 별도 타입으로 정의
+ * - TanStack Query와 API 클래스에서 사용
+ */
+%>
+<% for (const route of routes.combined) { %>
+    <% for (const api of route.routes) { %>
+
+        <% const queryName = `${pascalCase(api.routeName.usage)}QueryParams`; %>
+        <% const queryContent = api.specificArgs.query?.type; %>
+        <% if (queryContent) { %>
+            /** <%= api.routeName.usage %> API의 쿼리 파라미터 타입 */
+            export type <%= queryName %> = <%= queryContent %>;
+        <% } %>
+
+        <% const headerName = `${pascalCase(api.routeName.usage)}Headers`; %>
+        <% const headerContent = api.specificArgs.headers?.type; %>
+        <% if (headerContent) { %>
+            /** <%= api.routeName.usage %> API의 헤더 타입 */
+            export type <%~ headerName %> = <%~ headerContent %>;
+        <% } %>
+
+    <% } %>
+<% } %>

package/templates/dto-import.ejs

@@ -0,0 +1,27 @@
+<%
+/**
+ * DTO Import 템플릿
+ * - 생성된 DTO 타입들을 import하는 구문 생성
+ * - 상대 경로를 사용하여 dto.ts 파일에서 타입 가져오기
+ * - API 클래스와 TanStack Query 훅에서 사용
+ */
+
+const { modelTypes, utils } = it;
+const { _ } = utils;
+
+// 사용 가능한 모든 DTO 타입명 추출
+const dataContracts = _.map(modelTypes, "name");
+%>
+
+<% if (dataContracts?.length) { %>
+/**
+ * 생성된 DTO 타입들을 import
+ * - 모든 API에서 사용되는 공통 타입 정의
+ * - 요청/응답 데이터의 타입 안전성 보장
+ */
+import type {
+<% for (const dataContract of dataContracts) { %>
+  <%= dataContract %>,
+<% } %>
+} from '../../../shared/api/dto';
+<% } %>

package/templates/procedure-call.ejs

@@ -0,0 +1,103 @@
+<%
+/**
+ * API 메서드 호출 템플릿
+ * - 각 Swagger 엔드포인트에 대한 TypeScript 메서드 생성
+ * - ky HTTP 클라이언트를 사용한 요청 처리
+ * - 경로 파라미터, 쿼리 파라미터, 요청 본문, 헤더 지원
+ * - 타입 안전성을 위한 TypeScript 타입 적용
+ */
+
+const { utils, route, config, apiClassName } = it;
+const { _, pascalCase } = utils;
+const routeDocs = includeFile("./route-docs", { config, route, utils });
+
+/**
+ * API 메서드명 생성
+ * HTTP 메서드 + 경로를 조합하여 camelCase 함수명 생성
+ * 예: GET /users/{id} -> getUserById
+ */
+const functionName = route.request.method + pascalCase(`${route.request.path
+        .split('/')
+        .map((segment) =>
+                segment.includes('${') ? `By_${segment.replace(/[${}]/g, '')}` : segment
+        )
+        .join('_')}`);
+
+// 응답 타입 추출 (성공 응답의 타입 또는 any)
+const responseType = route.responseBodyInfo?.success?.type || 'any';
+
+// 경로 파라미터 추출 (예: /users/{id}에서 id)
+const pathParams = _.values(route.request.parameters);
+const hasPathParams = pathParams.length > 0;
+
+// 요청 본문 데이터 (POST, PUT, PATCH에서 사용)
+const payload = route.request.payload;
+
+// 쿼리 파라미터 (URL 뒤에 ?key=value 형태)
+const query = route.request.query;
+
+// 커스텀 헤더
+const headers = route.request.headers;
+const headerName = headers ? `${pascalCase(route.routeName.usage)}Headers` : null;
+
+// 쿼리 파라미터 타입명 생성
+const queryTypeName = query ? `${pascalCase(route.routeName.usage)}QueryParams` : null;
+
+/**
+ * 메서드 파라미터 문자열 생성
+ * @param {Array} params - 경로 파라미터 배열
+ * @param {Object} query - 쿼리 파라미터 객체
+ * @param {Object} payload - 요청 본문 객체
+ * @param {string} headerName - 헤더 타입명
+ * @returns {string} 메서드 파라미터 문자열
+ */
+const generateParams = (params, query, payload, headerName) => {
+    const paramList = [
+        // 경로 파라미터 (예: id: number)
+        ...(params ? params.map(param => `${param.name}${param.optional ? '?' : ''}: ${param.type}`) : []),
+        // 쿼리 파라미터 (예: params?: UserQueryParams)
+        ...(query ? [`params${query.optional ? '?' : ''}: ${queryTypeName || query.type}`] : []),
+        // 요청 본문 (예: data: CreateUserDto)
+        ...(payload ? [`data${payload.optional ? '?' : ''}: ${payload.type}`] : [])
+    ];
+
+    // ky Options에서 제외할 타입들 (중복 방지)
+    const omitTypes = [
+        ...(query ? ["'searchParams'"] : []),
+        ...(payload ? ["'json'"] : []),
+        ...(headerName ? ["'headers'"] : [])
+    ];
+
+    // ky Options 타입 생성 (중복되는 속성 제외)
+    const optionsType = omitTypes.length > 0
+            ? `Omit<Options, ${omitTypes.join(' | ')}>${headerName ? ` & { headers: ${headerName} }` : ''}`
+            : 'Options';
+
+    // ky 인스턴스와 옵션 파라미터 추가
+    paramList.push('kyInstance?: KyInstance', `options?: ${optionsType}`);
+    return paramList.join(', ');
+};
+%>
+
+/**
+<%~ routeDocs.lines %> */
+<%= functionName %>(<%~ generateParams(pathParams, query, payload, headerName) %>) {
+// ky 인스턴스 선택 (전달된 인스턴스 또는 기본 인스턴스)
+const instance = kyInstance ?? this.instance;
+
+<% if (query) { %>
+    // 쿼리 파라미터를 URLSearchParams로 변환
+    const urlSearchParams = <%= apiClassName %>Api.createSearchParams(params);
+<% } %>
+
+// HTTP 요청 실행 및 JSON 응답 반환
+return instance.<%= route.request.method.toLowerCase() %><<%= responseType %>>(`<%= route.request.path.replace(/{/g, '{').replace(/}/g, '}').slice(1,) %>`,{
+<% if (query) { %>
+    searchParams: urlSearchParams, // 쿼리 파라미터 설정
+<% } %>
+<% if (payload) { %>
+    json: data, // 요청 본문 JSON 설정
+<% } %>
+...options, // 추가 ky 옵션 병합
+}).json();
+}

package/templates/route-docs.ejs

@@ -0,0 +1,29 @@
+<%
+const { config, route, utils } = it;
+const { _, formatDescription, fmtToJSDocLine, pascalCase, require } = utils;
+const { raw, request, routeName } = route;
+
+const jsDocDescription = raw.description ?
+        ` * @description ${formatDescription(raw.description, true)}` :
+        fmtToJSDocLine('No description', { eol: false });
+const jsDocLines = _.compact([
+    _.size(raw.tags) && ` * @tags ${raw.tags.join(", ")}`,
+    raw.summary && ` * @summary ${raw.summary}`,
+    ` * @request ${_.upperCase(request.method)}:${raw.route}`,
+    raw.deprecated && ` * @deprecated`,
+    routeName.duplicate && ` * @originalName ${routeName.original}`,
+    routeName.duplicate && ` * @duplicate`,
+    request.security && ` * @secure`,
+    ...(config.generateResponses && raw.responsesTypes.length
+            ? raw.responsesTypes.map(
+                    ({ type, status, description, isSuccess }) =>
+                            ` * @response \`${status}\` \`${_.replace(_.replace(type, /\/\*/g, "\\*"), /\*\//g, "*\\")}\` ${description}`,
+            )
+            : []),
+]).map(str => str.trimEnd()).join("\n");
+
+return {
+    description: jsDocDescription,
+    lines: jsDocLines,
+}
+%>

package/templates/route-types.ejs

@@ -0,0 +1,15 @@
+<%
+const { utils, route, config, modelTypes } = it;
+const { _, pascalCase, require } = utils;
+const apiClassName = pascalCase(route.moduleName);
+const routes = route.routes;
+const dataContracts = _.map(modelTypes, "name");
+%>
+
+import { kyInstance } from "@/shared/api"
+
+import { <%= apiClassName %>Api } from './index'
+
+const <%= route.moduleName %>Api = new <%= apiClassName %>Api(kyInstance);
+
+export { <%= route.moduleName %>Api };