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

package/package.json

@@ -1,16 +1,17 @@
 {
   "name": "@paulpugovkin/api-docs-axios-ts-generator",
-  "version": "1.0.17",
+  "version": "1.2.0",
   "description": "Generate TypeScript interfaces and axios classes from OpenAPI documentation",
-  "main": "src/index.js",
+  "main": "dist/index.js",
   "bin": {
-    "api-docs-generator": "./bin/cli.js"
+    "api-docs-generator": "dist/index.js"
   },
-  "types": "src/types/index.d.ts",
   "scripts": {
     "generate-services": "npx @paulpugovkin/api-docs-axios-ts-generator --config api-docs-generator.config.js",
     "dev": "node scripts/dev.js",
     "dev:ts": "ts-node scripts/dev.ts",
+    "build": "tsup",
+    "prepublishOnly": "npm run build",
     "postinstall": "node src/scripts/createConfigFile.js"
   },
   "keywords": [
@@ -27,35 +28,23 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "commander": "^11.0.0",
-    "node-fetch": "^2.7.0",
+    "commander": "^11.0.0"
+  },
+  "peerDependencies": {
     "axios": "^1.6.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
+    "tsup": "^8.5.1",
     "typescript": "^5.0.0"
   },
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=18.0.0"
   },
   "files": [
-    "src/index.min.js",
-    "src/clean-generated-folder",
-    "src/collect-genereted-files",
-    "src/generate-class",
-    "src/generate-index-file-with-public-api",
-    "src/generate-interface",
-    "src/generate-js-doc",
-    "src/generate-main-index-file",
-    "src/generate-method",
-    "src/generators",
-    "src/map-type",
-    "src/parse-and-generate",
-    "src/resolve-type",
+    "dist",
     "src/scripts",
     "src/templates",
-    "src/update-api-docs-json",
-    "bin",
     "README.md",
     "LICENSE"
   ],

package/bin/cli.js

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * CLI entry point for api-docs-axios-ts-generator
- */
-require('../src/index.js');

package/src/clean-generated-folder/cleanGeneratedFolder.js

@@ -1,21 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-
-/**
- * Удаляет содержимое папки и пересоздает её.
- * @param {string} outputDir - Путь к папке.
- */
-function cleanGeneratedFolder(outputDir) {
-    if (fs.existsSync(outputDir)) {
-        fs.rmSync(outputDir, {recursive: true}); // Удаляем папку и все вложенные файлы
-        console.log(`Deleted: ${outputDir}`);
-    }
-
-    fs.mkdirSync(outputDir, {recursive: true}); // Создаем основную папку
-    fs.mkdirSync(path.join(outputDir, "interfaces"), {recursive: true});
-    fs.mkdirSync(path.join(outputDir, "classes"), {recursive: true});
-
-    console.log(`Recreated necessary directories.`);
-}
-
-module.exports = {cleanGeneratedFolder};

package/src/collect-genereted-files/collectGeneratedFiles.js

@@ -1,33 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-
-function collectGeneratedFiles(outputDir) {
-    const classFiles = [];
-    const interfaceFiles = [];
-
-    // Рекурсивный обход папок
-    function walkDir(currentPath) {
-        const entries = fs.readdirSync(currentPath, {withFileTypes: true});
-        for (const entry of entries) {
-            const fullPath = path.join(currentPath, entry.name);
-
-            if (entry.isDirectory()) {
-                walkDir(fullPath); // Рекурсивный вызов для папок
-            } else if (
-                entry.isFile() &&
-                entry.name.endsWith(".ts") &&
-                entry.name !== "index.ts"
-            ) {
-                if (fullPath.includes("interfaces")) {
-                    interfaceFiles.push(fullPath);
-                } else {
-                    classFiles.push(fullPath);
-                }
-            }
-        }
-    }
-
-    walkDir(outputDir); // Запуск обхода с указанной папки
-
-    return {classFiles, interfaceFiles};
-}

package/src/generate-class/generateClass.js

@@ -1,42 +0,0 @@
-/**
- * Генерация классов TypeScript
- * @param {string} name - Название класса
- * @param {string[]} methods - Список методов класса
- * @param {Set<string>} usedInterfaces - Набор используемых интерфейсов
- * @param {Object} config - Конфигурация генератора
- * @returns {string} - Сгенерированный код класса TypeScript
- */
-const path = require('path');
-
-function generateClass(name, methods, usedInterfaces, config) {
-    const axiosResponseImport =
-        'import { AxiosResponse, AxiosRequestConfig } from "axios";\n';
-
-    // Определяем пути импорта из конфигурации
-    const axiosPath = config?.imports?.axiosPath || 'axios';
-    const baseUrlPath = config?.imports?.baseUrlPath || './config/axios/axios';
-
-    // Определяем базовый путь для импорта интерфейсов (папка выше, чем папка с классами)
-    const interfaceImportPath = config?.outputDir
-        ? path.relative(path.join(config.outputDir, 'classes'), config.outputDir)
-        : '../../';
-
-    // Импорты интерфейсов
-    let interfaceImport = '';
-    if (usedInterfaces && usedInterfaces.size > 0) {
-        interfaceImport = Array.from(usedInterfaces)
-            .sort()
-            .map((interfaceName) => `import { ${interfaceName} } from '${interfaceImportPath}';`)
-            .join("\n");
-    }
-
-    // Импорты axios
-    const axiosImport = `\nimport axios from '${axiosPath}'`;
-    const baseApiUrl = `\nimport { BASE_URL } from '${baseUrlPath}'`;
-
-    const imports = `${axiosResponseImport}${interfaceImport}${axiosImport}${baseApiUrl}`;
-    const tsMethods = methods.join("\n");
-    return `${imports}\n\nexport class ${name} {\n${tsMethods}\n}\n`;
-}
-
-module.exports = {generateClass};

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

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

@@ -1,81 +0,0 @@
-const {resolveType} = require("../resolve-type/resolveType"); // Импорт функции resolveType
-const path = require("path");
-
-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, config) {
-    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 interfaceImportPath = config?.outputDir
-        ? path.relative(path.join(config.outputDir, 'interfaces'), config.outputDir)
-        : './';
-
-    const imports = Array.from(usedInterfaces)
-        .sort()
-        .map((interfaceName) => `import { ${interfaceName} } from '${interfaceImportPath}';`)
-        .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

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

@@ -1,21 +0,0 @@
-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};