@paulpugovkin/api-docs-axios-ts-generator 1.1.0 → 1.2.0

package/src/generate-method/generateMethod.js

@@ -1,264 +0,0 @@
-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

@@ -1,79 +0,0 @@
-/**
- * Генератор конфигурации 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 };

package/src/index.js

@@ -1,187 +0,0 @@
-const {program} = require("commander");
-
-// Модули генератора
-const {
-    cleanGeneratedFolder,
-} = require("./clean-generated-folder/cleanGeneratedFolder");
-const {
-    updateApiDocsJson,
-} = require("./update-api-docs-json/updateApiDocsJson");
-const {parseAndGenerate} = require("./parse-and-generate/parseAndGenerate");
-const {
-    generateIndexFileWithOpenApi,
-} = require("./generate-index-file-with-public-api/generateIndexFileWithPublicApi");
-const {
-    generateMainIndexFile,
-} = require("./generate-main-index-file/generateMainIndexFile");
-const {generateAxiosConfig} = require("./generators/axiosConfigGenerator");
-
-// Simple configuration loader
-const fs = require('fs');
-const path = require('path');
-
-async function loadConfig(configPath, cliOptions = {}) {
-  const resolvedPath = path.resolve(configPath);
-
-  if (!fs.existsSync(resolvedPath)) {
-    throw new Error(`Configuration file not found: ${resolvedPath}`);
-  }
-
-  const ext = path.extname(resolvedPath);
-  let config;
-
-  try {
-    if (ext === '.js') {
-      const modulePath = resolvedPath;
-      config = require(modulePath);
-    } else if (ext === '.json') {
-      const content = fs.readFileSync(resolvedPath, 'utf8');
-      config = JSON.parse(content);
-    } else if (ext === '.ts') {
-      const ts = require('typescript');
-      const content = fs.readFileSync(resolvedPath, 'utf8');
-      const result = ts.transpileModule(content, {
-        compilerOptions: {
-          module: 1, // CommonJS
-          target: 99, // ESNext
-          esModuleInterop: true,
-        },
-      });
-      const modulePath = resolvedPath.replace('.ts', '.js');
-      fs.writeFileSync(modulePath, result.outputText);
-      config = require(modulePath);
-    } else {
-      throw new Error(`Unsupported configuration file format. Use .js, .json, or .ts`);
-    }
-  } catch (error) {
-    throw new Error(`Failed to load configuration: ${error.message}`);
-  }
-
-  // Merge CLI options with config, filtering out undefined values
-  const mergedConfig = { ...config };
-  Object.keys(cliOptions).forEach(key => {
-    if (cliOptions[key] !== undefined) {
-      mergedConfig[key] = cliOptions[key];
-    }
-  });
-
-  return mergedConfig;
-}
-
-// Основной инструмент CLI
-program
-    .version("1.0.0")
-    .description("Generate TypeScript API client from OpenAPI documentation")
-    .option("-c, --config <path>", "Path to configuration file")
-    .option("--api-docs-url <url>", "URL to fetch the OpenAPI documentation")
-    .option("--api-docs-path <path>", "Local path to OpenAPI documentation file")
-    .option("--output-dir <dir>", "Output directory for generated files")
-    .option("--clean", "Clean output directory before generation")
-    .parse(process.argv);
-
-// Основной вызов
-async function main() {
-    const options = program.opts();
-    let configPath = options.config;
-
-    // Автоматическое обнаружение конфигурационного файла, если он не указан явно
-    if (!configPath) {
-        const defaultConfigs = [
-            'api-docs-generator.config.js',
-            'api-docs-generator.config.json',
-            'api-docs-generator.config.ts'
-        ];
-        
-        for (const file of defaultConfigs) {
-            const filePath = path.join(process.cwd(), file);
-            if (fs.existsSync(filePath)) {
-                configPath = filePath;
-                console.log(`Auto-detected configuration file: ${file}`);
-                break;
-            }
-        }
-    }
-
-    let config = null;
-
-    // Загрузка конфигурации из файла или использование CLI аргументов
-    if (configPath) {
-        try {
-            config = await loadConfig(configPath, {
-                apiDocsUrl: options.apiDocsUrl,
-                apiDocsPath: options.apiDocsPath,
-                outputDir: options.outputDir,
-            });
-        } catch (error) {
-            console.error(`Failed to load configuration: ${error.message}`);
-            process.exit(1);
-        }
-    } else {
-        // Режим обратной совместимости - использование CLI аргументов
-        const apiDocsUrl = options.apiDocsUrl;
-        const outputDir = options.outputDir || path.resolve(process.cwd(), "generated");
-
-        // Проверяем, указан ли URL для API документации
-        if (!apiDocsUrl) {
-            console.error('Error: API documentation URL is required.');
-            console.error('Please specify --api-docs-url or --api-docs-path, or create a configuration file.');
-            console.error('Run "api-docs-generator --help" for more information.');
-            process.exit(1);
-        }
-
-        config = {
-            apiDocsUrl: apiDocsUrl,
-            outputDir: outputDir,
-            interfacesDir: path.join(outputDir, "interfaces"),
-            classesDir: path.join(outputDir, "classes"),
-            groupBy: "tag",
-            classMode: "multiple",
-            options: {
-                cleanOutputDir: options.clean !== undefined ? options.clean : true,
-                generateAxiosConfig: false,
-                generateIndexFiles: true,
-            },
-        };
-    }
-
-    console.log(`Using API Docs URL: ${config.apiDocsUrl}`);
-    console.log(`Output directory: ${config.outputDir || 'Not specified - using default'}`);
-
-    // Определяем пути
-    const outputDir = config.outputDir || path.resolve(process.cwd(), "generated");
-    const interfacesDir = config.interfacesDir || path.join(outputDir, "interfaces");
-    const classesDir = config.classesDir || path.join(outputDir, "classes");
-    const interfacesOpenApi = path.join(interfacesDir, "index.ts");
-    const classesOpenApi = path.join(classesDir, "index.ts");
-
-    // Очищаем папку, если нужно
-    if (config.options?.cleanOutputDir !== false) {
-        cleanGeneratedFolder(outputDir);
-    }
-
-    // Обновляем API-документацию
-    if (config.apiDocsUrl) {
-        await updateApiDocsJson(config.apiDocsUrl, "api-docs.json");
-    }
-
-    // Генерация кода на основе спецификаций OpenAPI
-    const apiDocsPath = config.apiDocsPath || "api-docs.json";
-    await parseAndGenerate(apiDocsPath, config);
-
-    // Генерация конфигурации axios, если нужно
-    if (config.options?.generateAxiosConfig) {
-        generateAxiosConfig(config, outputDir);
-    }
-
-    // Генерация файлов index.ts для интерфейсов
-    if (config.options?.generateIndexFiles !== false) {
-        await generateIndexFileWithOpenApi(interfacesDir, interfacesOpenApi);
-        await generateIndexFileWithOpenApi(classesDir, classesOpenApi);
-        await generateMainIndexFile(outputDir);
-    }
-
-    console.log("Generation completed successfully.");
-}
-
-// Вызов
-main().catch((err) => console.error("Error during generation:", err));

package/src/map-type/mapType.js

@@ -1,19 +0,0 @@
-/**
- * Маппинг типов OpenAPI в TypeScript.
- * @param {string} openapiType - Тип из спецификации OpenAPI.
- * @returns {string} - Соответствующий тип TypeScript.
- */
-function mapType(openapiType) {
-    const typeMapping = {
-        string: "string",
-        integer: "number",
-        boolean: "boolean",
-        array: "any[]",
-        object: "Record<string, any>",
-        binary: "File",
-    };
-
-    return typeMapping[openapiType] || "any";
-}
-
-module.exports = {mapType};