@paulpugovkin/api-docs-axios-ts-generator 1.0.5

package/src/generate-index-file-with-public-api/generateIndexFileWithPublicApi.js

@@ -0,0 +1,45 @@
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Генерирует файл `index.ts`, экспортирующий все модули из указанной папки.
+ * @param {string} targetDir - Папка, для которой нужно сгенерировать экспорт.
+ * @param {string} outputFile - Полный путь для записи файла `index.ts`.
+ */
+function generateIndexFileWithOpenApi(targetDir, outputFile) {
+    const exports = [];
+
+    // Рекурсивно перебираем все файлы в целевой директории
+    function walkDir(currentDir) {
+        const entries = fs.readdirSync(currentDir, {withFileTypes: true});
+
+        for (const entry of entries) {
+            const fullPath = path.join(currentDir, entry.name);
+
+            if (entry.isDirectory()) {
+                // Рекурсивный вызов для папок
+                walkDir(fullPath);
+            } else if (
+                entry.isFile() &&
+                entry.name.endsWith(".ts") &&
+                entry.name !== "index.ts"
+            ) {
+                // Вычисляем относительный путь
+                const relativePath = path
+                    .relative(targetDir, fullPath)
+                    .replace(/\\/g, "/");
+                const modulePath = relativePath.replace(/\.ts$/, "");
+                exports.push(`export * from './${modulePath}';`);
+            }
+        }
+    }
+
+    walkDir(targetDir); // Запуск обхода с целевой директории
+
+    // Записываем все экспорты в файл index.ts
+    fs.writeFileSync(outputFile, exports.join("\n"), {encoding: "utf-8"});
+
+    console.log(`Generated ${outputFile} with ${exports.length} exports.`);
+}
+
+module.exports = {generateIndexFileWithOpenApi};

package/src/generate-interface/generateInterface.js

@@ -0,0 +1,75 @@
+const {resolveType} = require("../resolve-type/resolveType"); // Импорт функции resolveType
+
+function capitalizeOnlyFirst(text) {
+    return text ? text.charAt(0).toUpperCase() + text.slice(1) : text;
+}
+
+function mergeAllOf(allOf, schemaRefs, usedInterfaces) {
+    let mergedProperties = {};
+    let extendsInterfaces = [];
+
+    for (const item of allOf) {
+        if (item.$ref) {
+            const refName = item.$ref.split("/").pop();
+            usedInterfaces.add(refName);
+            extendsInterfaces.push(refName);
+        } else if (item.properties) {
+            mergedProperties = {...mergedProperties, ...item.properties};
+        }
+    }
+
+    return {mergedProperties, extendsInterfaces};
+}
+
+function processOneOf(oneOf, schemaRefs, usedInterfaces) {
+    const unionTypes = [];
+
+    for (const item of oneOf) {
+        if (item.$ref) {
+            const refName = item.$ref.split("/").pop();
+            usedInterfaces.add(refName);
+            unionTypes.push(refName);
+        }
+    }
+
+    return unionTypes;
+}
+
+function generateInterface(name, schema, schemaRefs) {
+    const usedInterfaces = new Set();
+    let properties = schema.properties || {};
+    let extendsInterfaces = [];
+
+    // Обработка allOf
+    if (schema.allOf) {
+        const merged = mergeAllOf(schema.allOf, schemaRefs, usedInterfaces);
+        properties = {...properties, ...merged.mergedProperties};
+        extendsInterfaces = merged.extendsInterfaces;
+    }
+
+    // Обработка oneOf
+    if (schema.oneOf) {
+        const unionTypes = processOneOf(schema.oneOf, schemaRefs, usedInterfaces);
+        extendsInterfaces.push(...unionTypes);
+    }
+
+    const props = [];
+
+    for (const [propName, propDetails] of Object.entries(properties)) {
+        const tsType = resolveType(propDetails, schemaRefs, usedInterfaces);
+        props.push(`  ${propName}: ${tsType};`);
+    }
+
+    const imports = Array.from(usedInterfaces)
+        .sort()
+        .map((interfaceName) => `import { ${interfaceName} } from './';`)
+        .join("\n");
+
+    const extendsClause = extendsInterfaces.length
+        ? ` extends ${extendsInterfaces.join(", ")}`
+        : "";
+
+    return `${imports}\n\nexport interface ${capitalizeOnlyFirst(name)}${extendsClause} {\n${props.join("\n")}\n}\n`;
+}
+
+module.exports = {generateInterface};

package/src/generate-js-doc/generateJSDoc.js

@@ -0,0 +1,136 @@
+const {resolveType} = require("../resolve-type/resolveType");
+
+/**
+ * Функция для генерации JSDoc на основе массива объектов
+ * @param {object} method - объект метода
+ * @returns {string} - JSDoc строка
+ */
+function generateJSDoc(method) {
+
+    let valueArg = ""
+
+    let formDataArg = ""
+
+    const params = method.parameters || [];
+
+    const summary = method.summary || "";
+
+    const docLines = [`/**`];
+
+    if (method.requestBody) {
+        const content = method.requestBody.content || {};
+        if (content["application/json"]) {
+            const schema = content["application/json"].schema || {};
+            if (schema.oneOf) {
+                valueArg = schema.oneOf.map(s => s.$ref.split("/").pop()).join(' | ');
+            } else if (schema.$ref) {
+                const refName = schema.$ref.split("/").pop();
+                if (!!refName) {
+                    valueArg = refName
+                }
+            }
+        }
+        if (content["multipart/form-data"]) {
+            formDataArg = 'FormData'
+        }
+    }
+
+    if (!!summary) {
+        docLines.push(` * @description ${summary}`);
+    }
+
+    if (!!formDataArg) {
+        docLines.push(` * @param {${formDataArg}} data - тело запроса`)
+    }
+
+    if (!!valueArg) {
+        docLines.push(` * @param {${valueArg}} values - тело запроса`)
+    }
+
+    const queryParams = {}; // Хранилище для параметров с in: 'query'
+    const otherParams = []; // Хранилище для всех остальных параметров
+
+    // Разделение параметров на query и остальные
+    params.forEach((param) => {
+        if (param.in === "query") {
+            if (param.name.includes(".")) {
+                const [objectName, propertyName] = param.name.split(".");
+                if (!queryParams[objectName]) {
+                    queryParams[objectName] = [];
+                }
+                queryParams[objectName].push({
+                    propertyName,
+                    description: param.description || "",
+                    type: param.schema.type || "string",
+                    required: param.required || false,
+                });
+            } else {
+                if (!queryParams[param.name]) {
+                    queryParams[param.name] = [];
+                }
+                queryParams[param.name].push({
+                    description: param.description || "",
+                    type: param.schema.type || "string",
+                    required: param.required || false,
+                });
+            }
+        } else {
+            otherParams.push({
+                name: param.name,
+                description: param.description || "",
+                type: param.schema.type || "string",
+                required: param.required || false,
+            });
+        }
+    });
+
+    // Добавляем queryParams в JSDoc
+    if (Object.keys(queryParams).length > 0) {
+        docLines.push(` * @param {object} queryParams`);
+        Object.keys(queryParams).forEach((key) => {
+            const group = queryParams[key];
+            // Сортировка: сначала обязательные параметры
+            const sortedGroup = group.sort(
+                (a, b) => (b.required ? 1 : 0) - (a.required ? 1 : 0)
+            );
+            if (
+                sortedGroup.length === 1 &&
+                sortedGroup[0].propertyName === undefined
+            ) {
+                // Одиночный параметр без вложенности
+                const param = sortedGroup[0];
+                const jsType = param.type === "integer" ? "number" : param.type;
+                docLines.push(
+                    ` * @param {${jsType}} queryParams.${key} - ${param.description}`
+                );
+            } else {
+                // Вложенные параметры
+                docLines.push(
+                    ` * @param {object} queryParams.${key} - Query parameter`
+                );
+                sortedGroup.forEach((subParam) => {
+                    const {propertyName, description, type} = subParam;
+                    const jsType = type === "integer" ? "number" : type;
+                    docLines.push(
+                        ` * @param {${jsType}} queryParams.${key}.${propertyName} - ${description}`
+                    );
+                });
+            }
+        });
+    }
+
+    // Сортировка других параметров: сначала обязательные
+    const sortedOtherParams = otherParams.sort(
+        (a, b) => (b.required ? 1 : 0) - (a.required ? 1 : 0)
+    );
+    sortedOtherParams.forEach((param) => {
+        const jsType = param.type === "integer" ? "number" : param.type;
+        docLines.push(` * @param {${jsType}} ${param.name} - ${param.description}`);
+    });
+
+    docLines.push(` * @param {AxiosRequestConfig} config - Конфигурация axios`);
+    docLines.push(` */`);
+    return docLines.join("\n");
+}
+
+module.exports = {generateJSDoc};

package/src/generate-main-index-file/generateMainIndexFile.js

@@ -0,0 +1,21 @@
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Генерирует главный `index.ts` файл в указанной папке, экспортирующий `openapi.ts` из интерфейсов и классов.
+ * @param {string} outputDir - Корневая папка, где будет создан `index.ts`.
+ */
+function generateMainIndexFile(outputDir) {
+    const indexFilePath = path.join(outputDir, "index.ts");
+    const exports = [
+        "export * from './interfaces/';",
+        "export * from './classes/';",
+    ];
+
+    // Создание или перезапись index.ts
+    fs.writeFileSync(indexFilePath, exports.join("\n"), {encoding: "utf-8"});
+
+    console.log(`Generated main index.ts at ${indexFilePath}.`);
+}
+
+module.exports = {generateMainIndexFile};

package/src/generate-method/generateMethod.js

@@ -0,0 +1,264 @@
+const path = require("path");
+const {resolveType} = require("../resolve-type/resolveType");
+const {generateJSDoc} = require("../generate-js-doc/generateJSDoc");
+
+/**
+ * Генерирует метод TypeScript на основе спецификации API.
+ * @param {string} name - Имя метода.
+ * @param {Object} method - Описание метода API (из OpenAPI).
+ * @param {string} path - Путь API.
+ * @param {string} methodType - HTTP-метод (GET, POST и т.д.).
+ * @param {Object<string, string>} schemaRefs - Ссылки на схемы для разрешения типов.
+ * @param {Set<string>} usedInterfaces - Набор интерфейсов, используемых в методе.
+ * @param {Object} config - Конфигурация генератора.
+ * @returns {string} - Сгенерированный метод TypeScript.
+ */
+function generateMethod(
+    name,
+    method,
+    path,
+    methodType,
+    schemaRefs,
+    usedInterfaces,
+    config = {}
+) {
+    const allowConfigSpread = config?.options?.allowAxiosConfigSpread !== false;
+    const pathParams = [...path.matchAll(/\{(\w+)\}/g)].map((match) => match[1]);
+    pathParams.forEach((param) => {
+        path = path.replace(`{${param}}`, `\${${param}}`);
+    });
+
+    const requiredParams = [];
+    const requiredQueryParams = [];
+    const optionalQueryParams = [];
+    const nestedParams = {};
+    let bodyParam = null;
+    let bodyString = "";
+    let isMultipart = false;
+
+    // Обработка параметров запроса
+    for (const param of method.parameters || []) {
+        const paramName = param.name;
+        const paramLocation = param.in;
+        const paramRequired = param.required || false;
+        const paramSchema = param.schema || {};
+
+        // Проверяем, является ли параметр сложным объектом (имеет $ref или properties)
+        const isComplexObject = paramSchema.$ref || paramSchema.properties;
+
+        if (paramLocation === "path") {
+            const paramType = resolveType(paramSchema, schemaRefs, usedInterfaces);
+            requiredParams.push(`${paramName}: ${paramType}`);
+        } else if (paramLocation === "query") {
+            if (isComplexObject) {
+                // Для сложных объектов добавляем распыление
+                const paramType = resolveType(paramSchema, schemaRefs, usedInterfaces);
+                if (paramRequired) {
+                    requiredParams.push(`${paramName}: ${paramType}`);
+                    // Вместо добавления в requiredQueryParams, просто отмечаем что есть сложный объект
+                    // который нужно распылить
+                    requiredQueryParams.push(`...${paramName}`);
+                } else {
+                    optionalQueryParams.push(`${paramName}?: ${paramType}`);
+                    // Для опциональных сложных объектов тоже добавляем распыление
+                    requiredQueryParams.push(`...(${paramName} || {})`);
+                }
+            } else if (paramName.includes(".")) {
+                const [nestedName, subfield] = paramName.split(".");
+                nestedParams[nestedName] = nestedParams[nestedName] || [];
+                const paramType = resolveType(paramSchema, schemaRefs, usedInterfaces);
+                nestedParams[nestedName].push(`${subfield}?: ${paramType}`);
+            } else {
+                const paramType = resolveType(paramSchema, schemaRefs, usedInterfaces);
+                if (paramRequired) {
+                    requiredQueryParams.push(paramName);
+                    requiredParams.push(`${paramName}: ${paramType}`);
+                } else {
+                    optionalQueryParams.push(`${paramName}?: ${paramType}`);
+                }
+            }
+        }
+    }
+
+    // Обрабатываем вложенные параметры (только для простых типов)
+    for (const [nestedName, fields] of Object.entries(nestedParams)) {
+        optionalQueryParams.push(`${nestedName}?: { ${fields.join(", ")} }`);
+    }
+
+    // Проверяем наличие тела запроса (только для методов, которые могут иметь тело)
+    const methodsWithBody = ['post', 'put', 'patch', 'delete'];
+    const hasRequestBody = methodsWithBody.includes(methodType.toLowerCase()) &&
+        method.requestBody &&
+        method.requestBody.content &&
+        Object.keys(method.requestBody.content).length > 0;
+
+    if (hasRequestBody) {
+        const content = method.requestBody.content || {};
+        if (content["application/json"]) {
+            const schema = content["application/json"].schema || {};
+            if (schema.oneOf) {
+                const refName = resolveType(schema, schemaRefs, usedInterfaces);
+                bodyParam = `values: ${refName}`;
+            } else if (schema.$ref) {
+                const refName = schema.$ref.split("/").pop();
+                usedInterfaces.add(refName);
+                bodyParam = `values: ${refName}`;
+            } else if (schema.properties) {
+                const props = Object.entries(schema.properties)
+                    .map(
+                        ([key, value]) =>
+                            `${key}: ${resolveType(value, schemaRefs, usedInterfaces)}`
+                    )
+                    .join(", ");
+                bodyParam = `values: { ${props} }`;
+            } else {
+                bodyParam = 'values: any'
+            }
+            bodyString = "values";
+        } else if (content["multipart/form-data"]) {
+            isMultipart = true;
+            const schema = content["multipart/form-data"].schema || {};
+            if (schema.properties) {
+                for (const [fieldName, fieldDetails] of Object.entries(
+                    schema.properties
+                )) {
+                    let tsType = resolveType(fieldDetails, schemaRefs, usedInterfaces);
+                    if (fieldDetails.format === "binary") {
+                        tsType = "File";
+                    }
+                }
+            }
+            bodyParam = `data: FormData`;
+            bodyString = "data";
+        }
+    }
+
+    let responseType = "void";
+    if (method.responses) {
+        for (const [status, response] of Object.entries(method.responses)) {
+            if (response.content) {
+                const contentSchema = Object.values(response.content)[0].schema || {};
+                if (contentSchema.$ref) {
+                    const refName = contentSchema.$ref.split("/").pop();
+                    responseType = refName;
+                    usedInterfaces.add(refName);
+                }
+            }
+        }
+    }
+
+    const returnType = `Promise<AxiosResponse<${responseType}>>`;
+    const optionalArgsName = optionalQueryParams.length ? "queryParams" : null;
+    const optionalArgsDefinition = optionalArgsName
+        ? `${optionalArgsName}: { ${optionalQueryParams.join(", ")} }`
+        : "";
+
+    // Определяем, есть ли параметры запроса (query params)
+    const hasQueryParams = requiredQueryParams.length > 0 || optionalQueryParams.length > 0;
+
+    const jsDocComment = generateJSDoc(method);
+
+    // Строки для аргументов функции
+    const functionArgs = `(${[
+        ...requiredParams,
+        bodyParam,
+        optionalArgsDefinition,
+        "config?: AxiosRequestConfig",
+    ]
+        .filter(Boolean)
+        .join(", ")}): ${returnType}`;
+    const functionString = `${name}${functionArgs}`;
+
+    // Строка url для запроса
+    const fullUrlString = `const fullURL = \`\${BASE_URL}${path}\`;`;
+
+    // Формируем строку для axios вызова
+    let axiosString = '';
+
+    // Функция для формирования объекта параметров
+    const buildParamsObject = () => {
+        const parts = [];
+
+        // Добавляем обязательные параметры (простые и распыленные сложные)
+        if (requiredQueryParams.length > 0) {
+            parts.push(...requiredQueryParams);
+        }
+
+        // Добавляем опциональные параметры
+        if (optionalArgsName) {
+            if (parts.length > 0) {
+                parts.push(`...${optionalArgsName}`);
+            } else {
+                parts.push(`...${optionalArgsName}`);
+            }
+        }
+
+        return parts.length > 0 ? `{ ${parts.join(', ')} }` : '{}';
+    };
+
+    if (methodType.toLowerCase() === "delete") {
+        // DELETE запросы могут иметь и тело, и параметры запроса
+        if (bodyParam) {
+            // Есть тело запроса
+            if (hasQueryParams) {
+                // Есть и тело, и параметры запроса
+                const paramsObject = buildParamsObject();
+                axiosString = `return axios.delete(fullURL, { data: values, ...config, params: ${paramsObject} });`;
+            } else {
+                // Только тело запроса, без параметров
+                axiosString = `return axios.delete(fullURL, { data: values, ...config });`;
+            }
+        } else {
+            // Нет тела запроса
+            if (hasQueryParams) {
+                // Только параметры запроса
+                const paramsObject = buildParamsObject();
+                axiosString = `return axios.delete(fullURL, { ...config, params: ${paramsObject} });`;
+            } else {
+                // Нет ни тела, ни параметров
+                axiosString = `return axios.delete(fullURL, config);`;
+            }
+        }
+    } else if (methodType.toLowerCase() === "get") {
+        // GET запросы никогда не имеют тела
+        if (hasQueryParams) {
+            const paramsObject = buildParamsObject();
+            axiosString = `return axios.get(fullURL, { ...config, params: ${paramsObject} });`;
+        } else {
+            axiosString = `return axios.get(fullURL, config);`;
+        }
+    } else {
+        // PUT/POST/PATCH методы
+        if (hasRequestBody) {
+            // Есть тело запроса
+            if (hasQueryParams) {
+                // Есть и тело, и параметры запроса
+                const paramsObject = buildParamsObject();
+                axiosString = `return axios.${methodType}(fullURL, ${isMultipart ? 'data' : bodyString}, { ...config, params: ${paramsObject} });`;
+            } else {
+                // Только тело запроса, без параметров
+                axiosString = `return axios.${methodType}(fullURL, ${isMultipart ? 'data' : bodyString}, config);`;
+            }
+        } else {
+            // Нет тела запроса, но могут быть параметры
+            if (hasQueryParams) {
+                // Только параметры запроса
+                const paramsObject = buildParamsObject();
+                axiosString = `return axios.${methodType}(fullURL, null, { ...config, params: ${paramsObject} });`;
+            } else {
+                // Нет ни тела, ни параметров
+                axiosString = `return axios.${methodType}(fullURL, null, config);`;
+            }
+        }
+    }
+
+    return `
+      ${jsDocComment}
+      ${functionString} {
+        ${fullUrlString}
+        ${axiosString}
+      }
+    `;
+}
+
+module.exports = {generateMethod};

package/src/generators/axiosConfigGenerator.js

@@ -0,0 +1,79 @@
+/**
+ * Генератор конфигурации axios
+ */
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Генерирует конфигурацию axios для сгенерированного API клиента
+ * @param {Object} config - Конфигурация генератора
+ * @param {string} outputDir - Директория вывода
+ */
+function generateAxiosConfig(config, outputDir) {
+  const axiosDir = path.join(outputDir, 'config', 'axios');
+  fs.mkdirSync(axiosDir, { recursive: true });
+
+  const axiosConfig = config.axios || {};
+  const baseURL = axiosConfig.baseURL || '';
+  const timeout = axiosConfig.timeout || 30000;
+  const headers = axiosConfig.headers || { 'Content-Type': 'application/json' };
+  const withCredentials = axiosConfig.withCredentials || false;
+
+  // Генерация файла axios.ts
+  const axiosTsContent = `import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';
+
+export const BASE_URL = '${baseURL}';
+
+const axiosConfig: AxiosRequestConfig = {
+  baseURL: BASE_URL,
+  timeout: ${timeout},
+  headers: ${JSON.stringify(headers, null, 2)},
+  withCredentials: ${withCredentials},
+};
+
+const axiosInstance: AxiosInstance = axios.create(axiosConfig);
+
+// Перехватчик запросов
+axiosInstance.interceptors.request.use(
+  (config) => {
+    // Можно добавить токен авторизации
+    // const token = localStorage.getItem('token');
+    // if (token) {
+    //   config.headers.Authorization = \`Bearer \${token}\`;
+    // }
+    return config;
+  },
+  (error) => {
+    return Promise.reject(error);
+  }
+);
+
+// Перехватчик ответов
+axiosInstance.interceptors.response.use(
+  (response) => {
+    return response;
+  },
+  (error) => {
+    // Обработка ошибок
+    if (error.response) {
+      // Сервер ответил со статусом, отличным от 2xx
+      console.error('Response error:', error.response.status, error.response.data);
+    } else if (error.request) {
+      // Запрос был сделан, но ответ не получен
+      console.error('Request error:', error.request);
+    } else {
+      // Произошла ошибка при настройке запроса
+      console.error('Error:', error.message);
+    }
+    return Promise.reject(error);
+  }
+);
+
+export default axiosInstance;
+`;
+
+  fs.writeFileSync(path.join(axiosDir, 'axios.ts'), axiosTsContent, { encoding: 'utf-8' });
+  console.log(`Generated axios config at: ${axiosDir}/axios.ts`);
+}
+
+module.exports = { generateAxiosConfig };