swaggular 0.2.3 → 0.3.0

package/README.md

@@ -1,6 +1,8 @@
 # Swaggular
 
 A powerful tool to generate Angular services and models from Swagger/OpenAPI specifications.
+Note: Currently, it does not detects generic types or common interfaces. If you want a more
+customized version, please download the project in github and modify the templates folder.
 
 ## Features
 
@@ -63,6 +65,12 @@ The generated files will be available in the `results` folder.
 
 Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduct, and the process for submitting pull requests to us.
 
+### 🚀 Roadmap
+
+- [ ] Add TSDoc comments
+- [ ] Add function to identify common properties and generate interfaces
+- [ ] Add function to generate interfaces and services for just one path
+
 ## License
 
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/dist/core/state/interface-state.d.ts

@@ -12,6 +12,7 @@ declare class InterfaceState implements InterfaceStateI {
     setComponentsSchemas(componentsSchemas: Record<string, IJsonSchema>): void;
     getComponentsSchema(name: string): IJsonSchema | undefined;
     addInterfaces(interfacesData: InterfaceData[]): void;
+    getInterface(name: string): InterfaceData | undefined;
 }
 export declare const interfaceState: InterfaceState;
 export {};

package/dist/core/state/interface-state.js

@@ -17,5 +17,8 @@ class InterfaceState {
             this.generatedInterfaces[inter.name] = inter;
         }
     }
+    getInterface(name) {
+        return this.generatedInterfaces[name] || this.generatedEnums[name];
+    }
 }
 exports.interfaceState = new InterfaceState();

package/dist/index.js

@@ -1,11 +1,7 @@
 #!/usr/bin/env node
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.main = main;
-const fs_1 = __importDefault(require("fs"));
 const swagger_parser_1 = require("./parsers/swagger-parser");
 const generate_interface_1 = require("./renderers/generate-interface");
 const generate_service_1 = require("./renderers/generate-service");
@@ -16,6 +12,7 @@ async function main() {
     try {
         const parsed = (0, args_1.getParseArgs)(process.argv.slice(2));
         const variables = (0, variables_1.toVariables)(parsed);
+        console.log('Generating interfaces and services using Swaggular@' + process.env.npm_package_version);
         swagger_parser_1.SwaggerParser.parse(variables.input, {
             mode: variables.groupingMode,
             segmentsToIgnore: variables.segmentsToIgnore,
@@ -29,9 +26,6 @@ async function main() {
             console.log('Files not generated');
             return;
         }
-        if (fs_1.default.existsSync(variables.output)) {
-            fs_1.default.rmSync(variables.output, { recursive: true, force: true });
-        }
         await (0, create_file_1.createFileFromFileContents)(`${variables.output}/models`, interfaceFiles);
         await (0, create_file_1.createFileFromFileContents)(variables.output, serviceFiles);
         console.log('Files created successfully');

package/dist/parsers/swagger-parser.d.ts

@@ -1,4 +1,6 @@
+import { OpenAPIV3 } from 'openapi-types';
 import { GroupPathsOptions } from './path-grouper';
 export declare class SwaggerParser {
     static parse(filePath: string, options?: GroupPathsOptions): void;
+    static loadJsonOrYaml(filePath: string): OpenAPIV3.Document;
 }

package/dist/parsers/swagger-parser.js

@@ -32,22 +32,40 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SwaggerParser = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const path_grouper_1 = require("./path-grouper");
 const swagger_state_1 = require("../core/state/swagger-state");
+const yaml_1 = __importDefault(require("yaml"));
 class SwaggerParser {
     static parse(filePath, options = { mode: 'tags' }) {
+        try {
+            const swagger = this.loadJsonOrYaml(filePath);
+            const pathsGroupedByScope = path_grouper_1.PathGrouper.groupPaths(swagger.paths, options);
+            swagger_state_1.swaggerState.setSwagger(swagger);
+            swagger_state_1.swaggerState.setPathsGroupedByScope(pathsGroupedByScope);
+        }
+        catch (error) {
+            console.error('Failed to parse swagger file:', error);
+            process.exit(1);
+        }
+    }
+    static loadJsonOrYaml(filePath) {
         const absolutePath = path.resolve(filePath);
+        const ext = path.extname(absolutePath).toLowerCase();
         const content = fs.readFileSync(absolutePath, { encoding: 'utf8' });
-        const swagger = JSON.parse(content);
-        if (!swagger)
-            return;
-        const pathsGroupedByScope = path_grouper_1.PathGrouper.groupPaths(swagger.paths, options);
-        swagger_state_1.swaggerState.setSwagger(swagger);
-        swagger_state_1.swaggerState.setPathsGroupedByScope(pathsGroupedByScope);
+        if (ext === '.json') {
+            return JSON.parse(content);
+        }
+        if (ext === '.yaml' || ext === '.yml') {
+            return yaml_1.default.parse(content);
+        }
+        throw new Error(`Unsupported file extension: "${ext}". Use .json, .yaml or .yml`);
     }
 }
 exports.SwaggerParser = SwaggerParser;

package/dist/renderers/generate-comments.js

@@ -26,16 +26,19 @@ function generateInterfaceComments(param) {
 }
 function generateServiceComments(summary, responseType, parameters) {
     const summarySplited = [];
-    const summaryWords = summary.split(' ');
+    const summaryWords = summary.replaceAll('\r', ' ').replaceAll('\n', ' ').split(' ');
     for (let i = 0; i < summaryWords.length; i += 10) {
         summarySplited.push(summaryWords.slice(i, i + 10).join(' '));
     }
     const comments = summarySplited;
     if (parameters && parameters.length > 0) {
-        comments.push(`${parameters.map((p) => `@param ${p.name} : ${p.type}`).join('\n')}`);
+        parameters.forEach((p) => {
+            comments.push(`@param ${p.name} : ${p.type}`);
+        });
     }
     if (responseType) {
         comments.push(`@returns Observable<${responseType}>`);
     }
-    return `\t/**\n${comments.map((c) => `\t* ${c}\n`).join('')} */`;
+    const result = `\t/**\n${comments.map((c) => `\t * ${c}\n`).join('')} \t */`;
+    return result;
 }

package/dist/renderers/generate-interface.js

@@ -154,7 +154,11 @@ function generateComponentsSchemas() {
         const interData = {
             name: key,
             type: 'interface',
-            imports: properties.filter((p) => !(0, type_guard_1.isNativeType)(p.type)).map((p) => p.type),
+            imports: properties
+                .filter((p) => !(0, type_guard_1.isNativeType)(p.type))
+                .map((p) => {
+                return p.type.replaceAll('[]', '');
+            }),
             properties,
         };
         const generic = (0, generic_types_1.isGenericType)(interData);
@@ -175,7 +179,7 @@ function generateInterfacesFiles(locations) {
     const filesContent = [];
     for (const [key, value] of Object.entries(interfacesData)) {
         const location = [value.type === 'enum' ? 'enums' : 'dtos', ...(locations?.[key] ?? [])];
-        const content = generateContent(value, location.length);
+        const content = generateContent(value, location.length + 1);
         const extraName = value.type === 'enum' ? 'enum' : 'dto';
         filesContent.push({
             location: location,
@@ -188,11 +192,13 @@ function generateInterfacesFiles(locations) {
 }
 function generateContent(interfaceData, deep = 0) {
     const imports = [...interfaceData.imports];
-    const importsTemplate = imports.length > 0
-        ? `import { ${imports.join(', ')} } from "${'../'.repeat(deep)}models";`
-        : '';
+    const path = '../'.repeat(deep);
+    const importsTemplate = imports.length > 0 ? `import { ${imports.join(', ')} } from "${path}models";` : '';
     if (interfaceData.type === 'interface') {
-        const content = `${importsTemplate}\n\nexport interface ${interfaceData.name} ${interfaceData.extendsFrom && interfaceData.extendsFrom.length > 0 ? `extends ${interfaceData.extendsFrom.join(', ')}` : ''} {
+        const genericTypes = interfaceData.properties
+            .filter((p) => ['T', 'R', 'P'].includes(p.type.replace('[]', '')))
+            .map((p) => p.type.replace('[]', ''));
+        const content = `${importsTemplate}\n\nexport interface ${interfaceData.name}${genericTypes.length > 0 ? `<${genericTypes.join(', ')}>` : ''} ${interfaceData.extendsFrom && interfaceData.extendsFrom.length > 0 ? `extends ${interfaceData.extendsFrom.join(', ')}` : ''} {
     ${interfaceData.properties
             .map((p) => `${p.comments}\n\t${(0, string_utils_1.lowerFirst)(p.name)}${p.optional ? '?' : ''}: ${p.type};`)
             .join('\n')}

package/dist/renderers/generate-service.d.ts

@@ -7,4 +7,4 @@ import { ServiceDataMethod } from '../types/service-data';
  */
 export declare function generateServices(): void;
 export declare function generateServiceFiles(locations?: Record<string, string[]>): FileContent[];
-export declare function buildMethods(groupedPath: GroupedPath, pathData: OpenAPIV3.PathsObject): ServiceDataMethod[];
+export declare function buildMethods(groupedPath: GroupedPath, pathData: OpenAPIV3.PathsObject, serviceName: string): ServiceDataMethod[];

package/dist/renderers/generate-service.js

@@ -12,6 +12,9 @@ const string_utils_1 = require("../utils/string-utils");
 const type_guard_1 = require("../utils/type-guard");
 const generate_comments_1 = require("./generate-comments");
 const object_utils_1 = require("../utils/object-utils");
+const generate_interface_1 = require("./generate-interface");
+const http_params_handler_1 = require("../templates/services/http-params-handler");
+const interface_state_1 = require("../core/state/interface-state");
 /**
  * Pick the paths grouped by scope and generate services for them.
  */
@@ -22,13 +25,18 @@ function generateServices() {
     if (!groupedPaths || !paths)
         return;
     for (const [key, value] of Object.entries(groupedPaths)) {
-        const serviceMethods = buildMethods(value, paths);
+        const serviceMethods = buildMethods(value, paths, key);
         const imports = new Set();
         serviceMethods.forEach((method) => {
             addTypeToImports(method.responseType, imports);
             method.parameters.forEach((param) => {
-                addTypeToImports(param.type, imports);
+                if (!method.queryParamType || param.in !== 'query') {
+                    addTypeToImports(param.type, imports);
+                }
             });
+            if (method.queryParamType) {
+                imports.add(method.queryParamType);
+            }
         });
         const serviceData = {
             name: key,
@@ -71,7 +79,7 @@ function generateServiceFiles(locations) {
             baseUrl: service.baseUrl,
             methods: methods,
             imports: service.imports.join(', '),
-            hasHttpParamsHandler: service.methods.some((m) => m.parameters.some((p) => p.in === 'query')),
+            hasHttpParamsHandler: service.methods.some((m) => !!m.queryParamType),
         };
         const content = (0, angular_template_1.angularTemplate)(templateParams);
         filesContent.push({
@@ -83,7 +91,7 @@ function generateServiceFiles(locations) {
     }
     return filesContent;
 }
-function buildMethods(groupedPath, pathData) {
+function buildMethods(groupedPath, pathData, serviceName) {
     const methods = [];
     const usedNames = [];
     for (const path of groupedPath.paths) {
@@ -92,17 +100,32 @@ function buildMethods(groupedPath, pathData) {
         const pathItem = pathData[path];
         const operations = pathItemToMethods(pathItem);
         for (const [method, operation] of Object.entries(operations)) {
-            const name = buildMethodName(method, path, groupedPath, usedNames);
+            const name = buildMethodName(method, path, groupedPath, usedNames, serviceName);
             usedNames.push(name);
             const parameters = buildParameters(operation, pathItem.parameters);
             const responseType = buildResponseType(operation.responses);
+            const queryParams = parameters.filter((p) => p.in === 'query');
+            let queryParamType;
+            if (queryParams.length > 0) {
+                queryParamType = (0, generate_interface_1.computeParametersName)(method, path, groupedPath);
+            }
+            const commentParams = parameters.filter((p) => p.in !== 'query');
+            if (queryParamType) {
+                commentParams.push({
+                    name: 'queryParams',
+                    type: queryParamType,
+                    in: 'query',
+                    required: false,
+                });
+            }
             methods.push({
                 name,
                 path: (0, path_utils_1.getExtraSegments)(path, groupedPath.baseUrl).join('/'),
                 method: method,
                 parameters,
                 responseType,
-                comments: (0, generate_comments_1.generateServiceComments)(operation.summary ?? '', responseType, parameters),
+                comments: (0, generate_comments_1.generateServiceComments)(operation.summary ?? '', responseType, commentParams),
+                queryParamType,
             });
         }
     }
@@ -117,24 +140,130 @@ function pathItemToMethods(pathItem) {
         patch: pathItem.patch,
     });
 }
-function buildMethodName(method, path, groupedPath, usedNames) {
-    const dict = {
+/**
+ * buildMethodName: High-performance semantic naming algorithm.
+ *
+ * This engine generates clean, non-redundant, and intuitive method names by
+ * analyzing the relationship between the base URL and extra path segments.
+ *
+ * For Mutation methods (POST, PUT, PATCH, DELETE), it prioritizes using the
+ * path segments as the method name itself if they describe an action,
+ * avoiding generic "create" or "update" prefixes where possible.
+ */
+function buildMethodName(method, path, groupedPath, usedNames, serviceName) {
+    // 1. Core mapping of HTTP verbs to professional action prefixes
+    const verbMap = {
         get: 'get',
         post: 'create',
         put: 'update',
         delete: 'delete',
         patch: 'patch',
     };
-    const prefix = dict[method];
-    const extraSegments = (0, path_utils_1.getExtraSegments)(path, groupedPath.baseUrl);
-    // Create name segments, removing variables from name
-    const nameSegments = extraSegments.map((s) => s.replace(/[{}]/g, ''));
-    const extra = (0, string_utils_1.kebabToPascalCase)(nameSegments.join(''));
-    let name = prefix + (0, string_utils_1.upFirst)(extra);
-    if (usedNames.includes(name)) {
-        name += (0, string_utils_1.upFirst)(method);
-    }
-    return name;
+    const defaultVerb = verbMap[method.toLowerCase()] || method.toLowerCase();
+    const segments = (0, path_utils_1.getExtraSegments)(path, groupedPath.baseUrl);
+    // 2. Redundancy Filtering: Remove segments already implied by the service name
+    const serviceWords = serviceName.split(/(?=[A-Z])/).map((w) => w.toLowerCase());
+    const cleanSegments = segments.filter((seg) => {
+        if ((0, path_utils_1.isVariable)(seg))
+            return true;
+        const segWords = seg.split('-').map((w) => w.toLowerCase());
+        return !segWords.every((sw) => serviceWords.includes(sw));
+    });
+    // 3. Structural Analysis: Identify resources and variable positioning
+    const staticBefore = [];
+    const variableParts = [];
+    const staticAfter = [];
+    let passedVariable = false;
+    for (const segment of cleanSegments) {
+        if ((0, path_utils_1.isVariable)(segment)) {
+            variableParts.push(segment.replace(/[{}]/g, ''));
+            passedVariable = true;
+        }
+        else if (passedVariable) {
+            staticAfter.push(segment);
+        }
+        else {
+            staticBefore.push(segment);
+        }
+    }
+    const nameParts = [];
+    // 4. Logic specific to data fetching (GET)
+    if (method.toLowerCase() === 'get') {
+        nameParts.push('get');
+        if (staticAfter.length > 0) {
+            nameParts.push((0, string_utils_1.toPascalCase)(staticAfter));
+            nameParts.push('ById');
+        }
+        else if (staticBefore.length > 0) {
+            nameParts.push((0, string_utils_1.toPascalCase)(staticBefore));
+            if (variableParts.length > 0)
+                nameParts.push('ById');
+        }
+        else if (variableParts.length > 0) {
+            nameParts.push('ById');
+        }
+    }
+    // 5. Logic for state mutation (POST, PUT, PATCH, DELETE)
+    else {
+        const actionParts = [...staticBefore, ...staticAfter];
+        if (actionParts.length > 0) {
+            // If the path contains an action (e.g., /assign, /send-to-user), use it directly.
+            nameParts.push((0, string_utils_1.toPascalCase)(actionParts));
+        }
+        else {
+            // No extra segments, use the default verb prefix (e.g., create, update)
+            nameParts.push((0, string_utils_1.upFirst)(defaultVerb));
+        }
+        if (variableParts.length > 0) {
+            nameParts.push('ById');
+        }
+    }
+    // 6. Pattern-based Refinement: Detect and prioritize standard REST suffixes
+    const normalizedPath = path.toLowerCase();
+    const suffixes = [
+        { pattern: '/all', label: 'All' },
+        { pattern: '/search', label: 'Search' },
+        { pattern: '/stats', label: 'Stats' },
+        { pattern: '/history', label: 'History' },
+        { pattern: '/summary', label: 'Summary' },
+        { pattern: '/details', label: 'Details' },
+    ];
+    for (const suffix of suffixes) {
+        if (normalizedPath.endsWith(suffix.pattern)) {
+            if (!nameParts.join('').endsWith(suffix.label)) {
+                nameParts.push(suffix.label);
+            }
+            break;
+        }
+    }
+    // 7. Base candidate assembly
+    let candidateName = (0, string_utils_1.lowerFirst)(nameParts.join(''));
+    // Simplification for the primary resource GET
+    if (candidateName === 'getById' && !usedNames.includes('get')) {
+        candidateName = 'get';
+    }
+    // Fallback for empty/ambiguous names
+    if (candidateName === '' || (candidateName === defaultVerb && segments.length > 0)) {
+        candidateName = (0, string_utils_1.lowerFirst)(defaultVerb + (0, string_utils_1.toPascalCase)(segments.map((s) => s.replace(/[{}]/g, ''))));
+    }
+    // 8. Multi-strategy Collision Resolution
+    let finalName = candidateName;
+    let counter = 0;
+    while (usedNames.includes(finalName)) {
+        counter++;
+        if (counter === 1 && variableParts.length > 0) {
+            finalName = candidateName + (0, string_utils_1.upFirst)(variableParts[variableParts.length - 1]);
+        }
+        else if (counter === 2) {
+            finalName = (0, string_utils_1.lowerFirst)(defaultVerb + (0, string_utils_1.toPascalCase)(segments.map((s) => s.replace(/[{}]/g, ''))));
+            if (usedNames.includes(finalName))
+                finalName += (0, string_utils_1.upFirst)(method);
+        }
+        else {
+            finalName = candidateName + counter;
+        }
+    }
+    return finalName;
 }
 function buildParameters(operation, pathParameters) {
     const results = [];
@@ -142,9 +271,12 @@ function buildParameters(operation, pathParameters) {
     for (const param of allParams) {
         if ((0, type_guard_1.isReference)(param)) {
             const ref = param.$ref.split('/').pop();
+            console.log('🚀 ~ buildParameters ~ ref:', ref);
+            const interfaceData = interface_state_1.interfaceState.getInterface(ref);
+            console.log('🚀 ~ buildParameters ~ interfaceData:', interfaceData);
             results.push({
                 name: (0, string_utils_1.lowerFirst)(ref),
-                in: 'query',
+                in: interfaceData?.type !== undefined ? 'query' : 'path',
                 required: true,
                 type: ref,
             });
@@ -157,7 +289,6 @@ function buildParameters(operation, pathParameters) {
             type: (0, build_types_1.switchTypeJson)(param.schema),
         });
     }
-    // Handle requestBody in V3
     if (operation.requestBody) {
         let bodyType = 'any';
         if (!(0, type_guard_1.isReference)(operation.requestBody)) {
@@ -177,6 +308,7 @@ function buildParameters(operation, pathParameters) {
             type: bodyType,
         });
     }
+    console.log('🚀 ~ buildParameters ~ results:', results);
     return results;
 }
 function buildResponseType(responses) {
@@ -191,31 +323,43 @@ function buildResponseType(responses) {
     return (0, build_types_1.switchTypeJson)(content.schema);
 }
 function buildMethodTemplate(method) {
-    const params = method.parameters
-        .map((p) => `${p.name}${p.required ? '' : '?'}: ${p.type}`)
-        .join(', ');
-    let pathStr = method.path
-        .split('/')
-        .filter((s) => s !== '')
-        .map((s) => ((0, path_utils_1.isVariable)(s) ? `\${${s.replace(/[{}]/g, '')}}` : s))
+    const pathParams = method.parameters.filter((p) => p.in === 'path');
+    const bodyParam = method.parameters.find((p) => p.in === 'body');
+    const methodArgs = [];
+    pathParams.forEach((p) => methodArgs.push(`${p.name}: ${p.type}`));
+    if (bodyParam) {
+        methodArgs.push(`${bodyParam.name === 'formData' ? 'formData' : 'body'}: ${bodyParam.type}`);
+    }
+    if (method.queryParamType) {
+        methodArgs.push(`queryParams?: ${method.queryParamType}`);
+    }
+    const argsString = methodArgs.join(', ');
+    const pathSegments = method.path.split('/').filter((s) => s !== '');
+    const pathStr = pathSegments
+        .map((s) => ((0, path_utils_1.isVariable)(s) ? `\${${(0, string_utils_1.lowerFirst)(s.replace(/[{}]/g, ''))}}` : s))
         .join('/');
-    if (pathStr) {
-        pathStr = '/' + pathStr;
+    const url = `\`\${this.baseUrl}${pathStr ? '/' + pathStr : ''}\``;
+    let handler = '';
+    const optionsList = [];
+    if (method.queryParamType) {
+        handler = `\n\t\t${(0, http_params_handler_1.httpParamsHandler)('queryParams')}`;
+        optionsList.push('params');
     }
-    const queryParams = method.parameters.filter((p) => p.in === 'query');
-    const bodyParam = method.parameters.find((p) => p.in === 'body');
-    let options = '';
-    if (queryParams.length > 0) {
-        options = `, { params: HttpHelper.toHttpParams({ ${queryParams.map((p) => p.name).join(', ')} }) }`;
+    if (['Blob', 'File'].includes(method.responseType)) {
+        optionsList.push("responseType: 'blob'");
     }
-    const url = `\`\${this.baseUrl}${pathStr}\``;
-    const methodCall = bodyParam
-        ? `this.http.${method.method}<${method.responseType}>(${url}, ${bodyParam.name}${options})`
+    const options = optionsList.length > 0 ? `, { ${optionsList.join(', ')} }` : '';
+    const bodyArg = bodyParam ? (bodyParam.name === 'formData' ? 'formData' : 'body') : null;
+    const genericType = ['Blob', 'File'].includes(method.responseType)
+        ? ''
+        : `<${method.responseType}>`;
+    const methodCall = bodyArg
+        ? `this.http.${method.method}${genericType}(${url}, ${bodyArg}${options})`
         : ['post', 'put', 'patch'].includes(method.method)
-            ? `this.http.${method.method}<${method.responseType}>(${url}, {}${options})`
-            : `this.http.${method.method}<${method.responseType}>(${url}${options})`;
+            ? `this.http.${method.method}${genericType}(${url}, {}${options})`
+            : `this.http.${method.method}${genericType}(${url}${options})`;
     return `${method.comments}
-  ${method.name}(${params}): Observable<${method.responseType}> {
+  ${method.name}(${argsString}): Observable<${method.responseType}> {${handler}
     return ${methodCall};
   }`;
 }

package/dist/templates/services/http-params-handler.js

@@ -8,9 +8,7 @@ exports.httpParamsHandlerImport = httpParamsHandlerImport;
  * used in your service.
  */
 function httpParamsHandler(params) {
-    return `
-  const params = HttpHelper.toHttpParams(${params} || {})
-`;
+    return `const params = HttpHelper.toHttpParams(${params} || {})`;
 }
 /**
  * Modify this function according to your needs and your template.

package/dist/types/service-data.d.ts

@@ -12,6 +12,7 @@ export interface ServiceDataMethod {
     parameters: ServiceDataParameter[];
     responseType: string;
     comments: string;
+    queryParamType?: string;
 }
 export interface ServiceDataParameter {
     name: string;

package/dist/utils/create-file.d.ts

@@ -1,7 +1,2 @@
 import { FileContent } from '../types/file-content';
-export declare function generateFile(content: string, group: string): void;
-export declare function createFolderWithFiles(folderPath: string, files: string[], filesContent: Record<string, {
-    content: string;
-    imports: string[];
-}>, withIndex?: boolean): void;
 export declare function createFileFromFileContents(basePath: string, fileContent: FileContent[]): Promise<void>;

package/dist/utils/create-file.js

@@ -3,49 +3,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateFile = generateFile;
-exports.createFolderWithFiles = createFolderWithFiles;
 exports.createFileFromFileContents = createFileFromFileContents;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const string_utils_1 = require("./string-utils");
-function generateFile(content, group) {
-    const dir = `results/${group}`;
-    if (fs_1.default.existsSync(dir)) {
-        for (const file of fs_1.default.readdirSync(dir)) {
-            fs_1.default.unlinkSync(path_1.default.join(dir, file));
+async function writeIfDifferent(filePath, content) {
+    try {
+        const existingContent = await fs_1.default.promises.readFile(filePath, 'utf8');
+        if (existingContent === content) {
+            return;
         }
     }
-    else {
-        fs_1.default.mkdirSync(dir, { recursive: true });
-    }
-    fs_1.default.writeFileSync(path_1.default.join(dir, `${new Date().toISOString().replaceAll(':', '-')}.ts`), content, 'utf8');
-}
-function createFolderWithFiles(folderPath, files, filesContent, withIndex = true) {
-    fs_1.default.mkdirSync(folderPath, { recursive: true });
-    const exports = [];
-    for (const fileName of files) {
-        if (!fileName || !filesContent[fileName]) {
-            continue;
-        }
-        const realFileName = (0, string_utils_1.toKebabCase)(fileName);
-        const finalName = `${realFileName}.model.ts`;
-        const filePath = path_1.default.join(folderPath, finalName);
-        fs_1.default.writeFileSync(filePath, filesContent[fileName].content, 'utf8');
-        if (withIndex) {
-            exports.push(`export * from "./${realFileName}.model";`);
-        }
-    }
-    if (withIndex && exports.length > 0) {
-        fs_1.default.writeFileSync(path_1.default.join(folderPath, 'index.ts'), exports.join('\n'), 'utf8');
+    catch {
+        // File doesn't exist, proceed to write
     }
+    const dir = path_1.default.dirname(filePath);
+    await fs_1.default.promises.mkdir(dir, { recursive: true });
+    await fs_1.default.promises.writeFile(filePath, content, 'utf8');
 }
 async function createFileFromFileContents(basePath, fileContent) {
     const folderExports = new Map();
     for (const file of fileContent) {
         const dir = path_1.default.join(basePath, ...file.location);
-        await fs_1.default.promises.mkdir(dir, { recursive: true });
-        await fs_1.default.promises.writeFile(path_1.default.join(dir, `${file.name}.${file.extension}`), file.content, 'utf8');
+        const filePath = path_1.default.join(dir, `${file.name}.${file.extension}`);
+        await writeIfDifferent(filePath, file.content);
         if (file.extension.endsWith('ts') && file.name !== 'index') {
             if (!folderExports.has(dir)) {
                 folderExports.set(dir, new Set());
@@ -66,9 +46,7 @@ async function createFileFromFileContents(basePath, fileContent) {
         const indexContent = Array.from(exports)
             .sort()
             .map((item) => `export * from "./${item}";`)
-            .join('\n');
-        if (indexContent) {
-            await fs_1.default.promises.writeFile(path_1.default.join(dir, 'index.ts'), indexContent + '\n', 'utf8');
-        }
+            .join('\n') + '\n';
+        await writeIfDifferent(path_1.default.join(dir, 'index.ts'), indexContent);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swaggular",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
@@ -64,7 +64,8 @@
     "typescript-eslint": "^8.55.0"
   },
   "dependencies": {
-    "openapi-types": "^12.1.3"
+    "openapi-types": "^12.1.3",
+    "yaml": "^2.8.2"
   },
   "engines": {
     "node": ">=18.0.0"