@devlearning/swagger-generator 1.0.11 → 1.0.13

package/dist/index.js

@@ -1,24 +1,80 @@
 #!/usr/bin/env node
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
 import { Generator } from './generator.js';
 import { SwaggerDownloader } from './swagger-downloader.js';
-var args = process.argv.slice(2);
-if (args.length !== 4) {
-    console.log("Warning: Requires 3 arguments");
-    console.log("node index.js [swaggerJsonUrl] [outputDirectory] [angular|next] [moment|date-fns]");
-    process.exit();
-}
-const swaggerJsonUrl = args[0];
-const outputDirectory = args[1];
-const outputFormat = args[2] == 'next' ? 'next' : 'angular';
-const dateLib = args[3] == 'moment' ? 'moment' : 'date-fns';
-//const excludedModels = ['Type', 'MethodBase', 'Assembly', 'MethodInfo']
-// const apiUrl = args[0]//"http://localhost:5208";
-// const version = args[1]; //"1";
-// const swaggerJsonUrl = `${apiUrl}/swagger/v${version}/swagger.json`;
+export var DateTimeLibrary;
+(function (DateTimeLibrary) {
+    DateTimeLibrary["Moment"] = "moment";
+    DateTimeLibrary["DateFns"] = "date-fn";
+})(DateTimeLibrary || (DateTimeLibrary = {}));
+export var TargetGeneration;
+(function (TargetGeneration) {
+    TargetGeneration["Angular"] = "angular";
+    TargetGeneration["Next"] = "next";
+    TargetGeneration["Dart"] = "dart";
+})(TargetGeneration || (TargetGeneration = {}));
+const argv = yargs(hideBin(process.argv))
+    .scriptName("swagger-gen")
+    .usage('Usage: $0 --url <swaggerJsonUrl> --output <outputDirectory> --target <target> [--dateTimeLibrary <dateTimeLibrary>] [--package <name>]')
+    .option('url', {
+    alias: 'u',
+    type: 'string',
+    demandOption: true,
+    describe: 'URL of swagger.json file',
+})
+    .option('output', {
+    alias: 'o',
+    type: 'string',
+    demandOption: true,
+    describe: 'Output directory for generated code',
+})
+    .option('target', {
+    alias: 't',
+    type: 'string',
+    choices: ['angular', 'next', 'dart'],
+    demandOption: true,
+    describe: 'Target format for the generated code',
+})
+    .option('dateTimeLibrary', {
+    alias: 'd',
+    type: 'string',
+    choices: ['moment', 'date-fns'],
+    default: 'date-fns',
+    describe: 'Date library to use for date handling',
+})
+    .option('package', {
+    alias: 'p',
+    type: 'string',
+    describe: 'For Dart: package name for Dart project',
+})
+    .help()
+    .parseSync();
+const commandLineArgs = {
+    swaggerJsonUrl: argv.url,
+    outputDirectory: argv.output,
+    target: parseTargetGeneration(argv.target),
+    dateTimeLibrary: parseDateTimeLibrary(argv.dateTimeLibrary),
+    package: argv.package ?? '',
+};
 const swaggerDownloader = new SwaggerDownloader();
-swaggerDownloader.download(new URL(swaggerJsonUrl))
+swaggerDownloader.download(new URL(commandLineArgs.swaggerJsonUrl))
     .then(swaggerDoc => {
-    return new Generator(swaggerDoc, outputDirectory, outputFormat, dateLib);
+    return new Generator(swaggerDoc, commandLineArgs);
 })
     .then(generator => { generator.generate(); });
 // require('./index.js')({swaggerDownloader});
+function parseDateTimeLibrary(value) {
+    const values = Object.values(DateTimeLibrary);
+    if (values.includes(value)) {
+        return value;
+    }
+    return undefined;
+}
+function parseTargetGeneration(value) {
+    const values = Object.values(TargetGeneration);
+    if (values.includes(value)) {
+        return value;
+    }
+    throw new Error(`Invalid OutputFormat: ${value}`);
+}

package/dist/models/swagger/swagger-component-property.js

@@ -1 +1,11 @@
 export {};
+// export interface SwaggerComponentProperty {
+//     type: string;
+//     $ref: string;
+//     allOf: SwaggerComponentProperty[];
+//     format: string;
+//     items: SwaggerSchema;
+//     properties: { [key: string]: SwaggerComponentProperty; };
+//     nullable: boolean;
+//     minLength: number;
+// }

package/dist/models/swagger/swagger-component.js

@@ -1 +1,2 @@
+// import { SwaggerComponentProperty } from "./swagger-component-property.js";
 export {};

package/dist/models/swagger/swagger-schema.js

@@ -1 +1,2 @@
+// import { SwaggerComponentProperty } from "./swagger-component-property.js";
 export {};

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@devlearning/swagger-generator",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "Swagger generator apis and models for Angular and NextJS",
   "main": "index.js",
   "type": "module",
   "scripts": {
-    "dev": "ts-node --esm ./src/index.ts http://localhost:7550/swagger/ApiGateway/swagger.json autogeneration/output",
-    "debug-angular": "npx tsx src/index.ts http://localhost:7550/swagger/ApiGateway/swagger.json autogeneration/output angular moment",
-    "debug-nextjs": "npx tsx src/index.ts http://localhost:7550/swagger/ApiGateway/swagger.json autogeneration/output next date-fns",
+    "debug-angular": "npx tsx src/index.ts --url http://localhost:7550/swagger/ApiGateway/swagger.json --output autogeneration/output --target angular --dateTimeLibrary moment",
+    "debug-nextjs": "npx tsx src/index.ts --url http://localhost:7550/swagger/ApiGateway/swagger.json --output autogeneration/output --target next --dateTimeLibrary date-fns",
+    "debug-flutter": "npx tsx src/index.ts --url http://localhost:7550/swagger/ApiGateway/swagger.json --output autogen --target flutter --package coqudo_app",
     "deploy": "npx tsc && npm publish"
   },
   "bin": {
@@ -17,6 +17,8 @@
     "swagger",
     "angular",
     "nextjs",
+    "dart",
+    "flutter",
     "api",
     "generator"
   ],
@@ -24,12 +26,16 @@
   "license": "ISC",
   "dependencies": {
     "cli-progress": "^3.12.0",
-    "node-fetch": "^3.3.2"
+    "mustache": "^4.2.0",
+    "node-fetch": "^3.3.2",
+    "yargs": "^18.0.0"
   },
   "node-fetch": "^3.3.2",
   "devDependencies": {
     "@types/cli-progress": "^3.11.6",
+    "@types/mustache": "^4.2.6",
     "@types/node": "^18.15.0",
+    "@types/yargs": "^17.0.33",
     "ts-node": "^10.9.1",
     "tsconfig-paths": "^4.2.0",
     "typescript": "^5.1.6"

package/src/generator.ts

@@ -2,7 +2,6 @@ import fs from 'fs';
 import { SwaggerComponent } from './models/swagger/swagger-component.js';
 import { Swagger } from './models/swagger/swagger.js';
 import { SwaggerMethod } from './models/swagger/swagger-method.js';
-import { SwaggerComponentProperty } from './models/swagger/swagger-component-property.js';
 import { SwaggerSchema } from './models/swagger/swagger-schema.js';
 import { ApiDto } from './models/api-dto.js';
 import { TypeDto } from './models/type-dto.js';
@@ -16,15 +15,17 @@ import { ModelAngularWriter } from './generators-writers/angular/model-angular-w
 import { PropertyDto } from './models/property-dto.js';
 import { EnumValueDto } from './models/enum-value-dto.js';
 import { SwaggerContent } from './models/swagger/swagger-content.js';
+import { CommandLineArgs, DateTimeLibrary, TargetGeneration } from './index.js';
+import { ApiDartWriter } from './generators-writers/dart/api-dart-writer.js';
+import { ModelDartWriter } from './generators-writers/dart/model-dart-writer.js';
+import { Utils } from './generators-writers/utils.js';
 
 const contentTypeApplicationJson = 'application/json';
 const contentTypeMultipartFormData = 'multipart/form-data';
 
 export class Generator {
   private _swagger: Swagger;
-  private _outputDirectory: string;
-  private _outputFormat: 'angular' | 'next';
-  private _dateLibrary: 'moment' | 'date-fns';
+  private _commandLineArgs: CommandLineArgs;
 
   private _apis: ApiDto[] = [];
   private _models: ModelDto[] = [];
@@ -45,21 +46,21 @@ export class Generator {
     barsize: 20,
   }, Presets.shades_classic);
 
-  constructor(swagger: Swagger, outputDirectory: string, outputFormat: 'angular' | 'next', dateLibrary: 'moment' | 'date-fns') {
+  constructor(swagger: Swagger, commandLineArgs: CommandLineArgs) {
     this._swagger = swagger;
-    this._outputDirectory = outputDirectory;
-    this._outputFormat = outputFormat;
-    this._dateLibrary = dateLibrary;
+    this._commandLineArgs = commandLineArgs;
   }
 
   generate() {
     console.info('%c[Swagger API Generator] %cStarting to parse Swagger JSON file...', 'color: #4CAF50; font-weight: bold;', 'color: #2196F3;');
 
-    this.computeApi();
-    this.generateApi();
+    Utils.clearDirectory(this._commandLineArgs.outputDirectory);
 
+    this.computeApi();
     this.computeModel();
+
     this.generateModel();
+    this.generateApi();
 
     console.info('%c[Swagger Generator] %cSwagger file generated successfully!', 'color: #4CAF50; font-weight: bold;', 'color: #00C853;');
   }
@@ -85,6 +86,7 @@ export class Generator {
         swaggerMethod: apiSwaggerMethod,
         haveRequest: apiSwaggerMethod.requestBody != null,
         isMultiPart: apiSwaggerMethod.requestBody != null && apiSwaggerMethod.requestBody.content[contentTypeMultipartFormData] != null,
+        tag: apiSwaggerMethod.tags && apiSwaggerMethod.tags.length > 0 ? apiSwaggerMethod.tags[0] : 'default',
       };
       this._apis.push(apiDto);
     }
@@ -149,6 +151,7 @@ export class Generator {
 
         // console.debug(`\tModel - ${modelName}`);
         this._models.push({
+          typeName: modelName,
           modelType: swaggerComponent.type == 'integer' ? 'enum' : 'class',
           name: modelName,
           properties: (swaggerComponent.type == 'object') ? this.retrieveComponentProperties(swaggerComponent) : [],
@@ -164,6 +167,7 @@ export class Generator {
       const swaggerMethodInfo = swaggerMethod[method];
 
       this._models.push({
+        typeName: this.getApiNameNormalized(apiName),
         modelType: 'class',
         name: this.getApiNameNormalized(apiName),
         properties: this.retrieveComponentProperties(swaggerMethodInfo.requestBody.content[contentTypeMultipartFormData].schema),
@@ -175,15 +179,18 @@ export class Generator {
   generateApi() {
     this._barApis.update(this._apis.length, { message: `Api generating...` });
 
-    if (this._outputFormat == 'angular') {
-      const apiWriter = new ApiAngularWriter(this._outputDirectory);
+    if (this._commandLineArgs.target == TargetGeneration.Angular) {
+      const apiWriter = new ApiAngularWriter(this._commandLineArgs.outputDirectory);
       apiWriter.write(this._apis);
-    } else if (this._outputFormat == 'next') {
-      const apiWriter = new ApiNextJsWriter(this._outputDirectory);
+    } else if (this._commandLineArgs.target == TargetGeneration.Next) {
+      const apiWriter = new ApiNextJsWriter(this._commandLineArgs.outputDirectory);
       apiWriter.write(this._apis);
+    } else if (this._commandLineArgs.target == TargetGeneration.Dart) {
+      const apiWriter = new ApiDartWriter(this._commandLineArgs);
+      apiWriter.write(this._apis, this._models);
     }
 
-    this._barApis.update(this._apis.length, { message: `Api gerated` });
+    this._barApis.update(this._apis.length, { message: `Api was generated successfully` });
 
     this._barApis.stop();
   }
@@ -192,15 +199,18 @@ export class Generator {
   generateModel() {
     this._barModels.update(this._apis.length, { message: `Model generation...` });
 
-    if (this._outputFormat == 'angular') {
-      const apiWriter = new ModelAngularWriter(this._outputDirectory);
+    if (this._commandLineArgs.target == TargetGeneration.Angular) {
+      const apiWriter = new ModelAngularWriter(this._commandLineArgs.outputDirectory);
       apiWriter.write(this._models);
-    } else if (this._outputFormat == 'next') {
-      const apiWriter = new ModelNextJsWriter(this._outputDirectory);
+    } else if (this._commandLineArgs.target == TargetGeneration.Next) {
+      const apiWriter = new ModelNextJsWriter(this._commandLineArgs.outputDirectory);
+      apiWriter.write(this._models);
+    } else if (this._commandLineArgs.target == TargetGeneration.Dart) {
+      const apiWriter = new ModelDartWriter(this._commandLineArgs);
       apiWriter.write(this._models);
     }
 
-    this._barModels.update(this._apis.length, { message: `Model generated` });
+    this._barModels.update(this._apis.length, { message: `Model was generated successfully` });
 
     this._barModels.stop();
   }
@@ -226,9 +236,10 @@ export class Generator {
         });
       } else {
         if (swaggerMethod.requestBody != null) {
+          const type = this.retrieveType(swaggerMethod.requestBody.content[contentTypeApplicationJson].schema);
           parameters.push({
             name: 'request',
-            typeName: swaggerMethod.requestBody.content[contentTypeApplicationJson].schema.$ref.replace('#/components/schemas/', ''),
+            typeName: type.typeName, //swaggerMethod.requestBody.content[contentTypeApplicationJson].schema.$ref.replace('#/components/schemas/', ''),
             nullable: false,
             isQuery: false,
             isEnum: false,
@@ -240,9 +251,10 @@ export class Generator {
         } else {
           swaggerMethod.parameters?.filter(x => x.in == 'query').forEach(parameter => {
             if (parameter.schema.$ref != null) {
+              const type = this.retrieveType(parameter.schema);
               parameters.push({
                 name: this.toFirstLetterLowercase(parameter.name),
-                typeName: parameter.schema.$ref.replace('#/components/schemas/', ''),
+                typeName: type.typeName, //parameter.schema.$ref.replace('#/components/schemas/', ''),
                 nullable: !parameter.required,
                 swaggerParameter: parameter,
                 isQuery: true,
@@ -316,7 +328,7 @@ export class Generator {
     if (swaggerContent.schema.type != null) {
       let schema = swaggerContent.schema;
       if (schema.type == 'array') {
-        if (schema.items.$ref != null) {
+        if (schema.items?.$ref != null) {
           return <TypeDto>{
             typeName: `${this.getObjectName(schema.items.$ref)}`,
             nullable: false,
@@ -344,8 +356,8 @@ export class Generator {
     }
   }
 
-  retrieveType(swaggerComponentProperty: SwaggerComponentProperty): TypeDto {
-    if (swaggerComponentProperty.$ref != null)
+  retrieveType(swaggerComponentProperty: SwaggerSchema): TypeDto {
+    if (swaggerComponentProperty.$ref != null) {
       return {
         typeName: swaggerComponentProperty.$ref.replace('#/components/schemas/', ''),
         isTypeReference: true,
@@ -354,9 +366,18 @@ export class Generator {
         isArray: false,
         isVoid: false,
       };
+    }
 
-    if (swaggerComponentProperty.type != null && swaggerComponentProperty.type == 'array')
-      if (swaggerComponentProperty.items.$ref != null)
+    if (swaggerComponentProperty.allOf != null) {
+      const type = this.retrieveType(swaggerComponentProperty.allOf[0]); //TODO per ora prendo solo il primo, ma potrebbe essere un array di tipi
+      return {
+        ...type,
+        nullable: swaggerComponentProperty.nullable ?? false,
+      };
+    }
+
+    if (swaggerComponentProperty.type != null && swaggerComponentProperty.type == 'array') {
+      if (swaggerComponentProperty.items?.$ref != null) {
         return {
           typeName: `${this.getObjectName(swaggerComponentProperty.items.$ref)}`,
           isTypeReference: true,
@@ -365,7 +386,8 @@ export class Generator {
           isArray: true,
           isVoid: false,
         };
-      else
+      }
+      else {
         return {
           typeName: this.getNativeType(swaggerComponentProperty),
           isTypeReference: false,
@@ -374,8 +396,10 @@ export class Generator {
           isArray: false,
           isVoid: false,
         };
+      }
+    }
 
-    if (swaggerComponentProperty.type != null)
+    if (swaggerComponentProperty.type != null) {
       return {
         typeName: this.getNativeType(swaggerComponentProperty),
         isTypeReference: false,
@@ -384,8 +408,8 @@ export class Generator {
         isArray: false,
         isVoid: false,
       };
-
-    if (swaggerComponentProperty.type == null)
+    }
+    if (swaggerComponentProperty.type == null) {
       return {
         typeName: 'void',
         isTypeReference: false,
@@ -394,7 +418,7 @@ export class Generator {
         isArray: false,
         isVoid: true,
       };
-
+    }
     console.error("unmanaged swaggerMethodInfo", swaggerComponentProperty);
     throw new Error("unmanaged swaggerMethodInfo");
   }
@@ -428,6 +452,7 @@ export class Generator {
     let properties: PropertyDto[] = [];
     for (let index = 0; index < Object.getOwnPropertyNames(swaggerCopmponent.properties).length; index++) {
       const propertyName = Object.getOwnPropertyNames(swaggerCopmponent.properties)[index];
+
       const type = this.retrieveType(swaggerCopmponent.properties[propertyName]);
       properties.push({
         ...type,
@@ -483,10 +508,14 @@ export class Generator {
 
         let nestedUsedType = '';
 
-        if (swaggerComponent.properties[propertyName].$ref != null) {
-          nestedUsedType = swaggerComponent.properties[propertyName].$ref.replace('#/components/schemas/', '');
-        } else if (swaggerComponent.properties[propertyName].type == 'array' && swaggerComponent.properties[propertyName].items.$ref != null) {
-          nestedUsedType = swaggerComponent.properties[propertyName].items.$ref.replace('#/components/schemas/', '');
+        if (!swaggerComponent.properties[propertyName]) continue;
+
+        if (swaggerComponent.properties[propertyName].$ref) {
+          nestedUsedType = swaggerComponent.properties[propertyName].$ref!.replace('#/components/schemas/', '');
+        }else if (swaggerComponent.properties[propertyName].allOf && swaggerComponent.properties[propertyName].allOf![0] && swaggerComponent.properties[propertyName].allOf![0]!.$ref) {
+          nestedUsedType = swaggerComponent.properties[propertyName].allOf![0]!.$ref!.replace('#/components/schemas/', ''); //TODO Assuming allOf contains a single $ref
+        } else if (swaggerComponent.properties[propertyName].type == 'array' && swaggerComponent.properties[propertyName].items?.$ref) {
+          nestedUsedType = swaggerComponent.properties[propertyName].items!.$ref!.replace('#/components/schemas/', '');
         }
 
         if (nestedUsedType != '' && usedTypes.findIndex(x => x.typeName == nestedUsedType) == -1) {
@@ -513,13 +542,13 @@ export class Generator {
 
     if (schema.$ref != null) {
       debugger
-    } else if (schema.type == 'array') {
+    } else if (schema.type == 'array' && schema.items != null) {
       nativeType = this.getNativeType(schema.items);
       nativeType += '[]';
     } else {
       if (schema.type == 'integer') nativeType = 'number';
       if (schema.type == 'string' && schema.format == null) nativeType = 'string';
-      if (schema.type == 'string' && schema.format == 'date-time') nativeType = this._dateLibrary == 'moment' ? 'moment.Moment' : 'Date';
+      if (schema.type == 'string' && schema.format == 'date-time') nativeType = this._commandLineArgs.dateTimeLibrary == DateTimeLibrary.Moment ? 'moment.Moment' : 'Date';
       if (schema.type == 'string' && schema.format == 'uuid') nativeType = 'string';
       if (schema.type == 'string' && schema.format == 'binary') nativeType = 'File';
       if (schema.type == 'number') nativeType = 'number';

package/src/generators-writers/angular/api-angular-writer.ts

@@ -24,7 +24,7 @@ export class ApiAngularWriter {
 
   private _apiString(api: ApiDto) {
 
-    let apiNameNormalized = Utils.getApiNameNormalized(api.name);
+    let apiNameNormalized = Utils.getNormalizedApiPath(api.name);
     let parametersString = this._parameters(api);
     let queryParametersPreparation = this._queryParametersPreparation(api);
     let requestPreparation = this._requestPreparation(api);

package/src/generators-writers/dart/api-dart-writer.ts

@@ -0,0 +1,164 @@
+import fs, { writeFileSync } from 'fs';
+import { ApiDto } from '@src/models/api-dto.js';
+import { Utils } from '../utils.js';
+import { ParameterDto } from '@src/models/parameter-dto.js';
+import * as Mustache from 'mustache';
+import { CommandLineArgs } from '@src/index.js';
+import { ModelDto } from '@src/models/model-dto.js';
+import { TypeDto } from '@src/models/type-dto.js';
+import { ImportDefinitionDart } from './models/import-definition-dart.js';
+import { Normalizator } from './normalizator.js';
+
+interface ApiDefinitionDart {
+  package: string;
+  outputDirectory: string;
+  filename: string;
+  apiClassName: string;
+  imports: string[];
+  endpoints: EndpointDefinitionDart[];
+}
+
+interface EndpointDefinitionDart {
+  methodName: string;
+  httpMethod: HttpMethodDart;
+  path: string;
+  responseType: string;
+  haveRequest?: boolean;
+  requestType?: string; // solo se haveRequest è true
+  isGet?: boolean; // per indicare se è un metodo GET
+}
+
+type HttpMethodDart = 'get' | 'post' | 'put' | 'delete' | 'patch';
+
+
+export class ApiDartWriter {
+  private _commandLineArgs: CommandLineArgs;
+
+  constructor(commandLineArgs: CommandLineArgs) {
+    this._commandLineArgs = commandLineArgs;
+  }
+
+  write(apis: ApiDto[], models: ModelDto[]) {
+
+    const template = fs.readFileSync('src/generators-writers/dart/templates/api.mustache', 'utf-8');
+
+    const grouped = this._groupByTag(apis);
+
+    for (const [tag, apis] of Object.entries(grouped)) {
+      console.log(`Api: ${tag}`);
+
+      let subPath = '';
+      let filename = '';
+      let apiClassName = '';
+
+      subPath = Utils.toDartFileName(tag);
+      filename = `${Utils.toDartFileName(tag + 'Api')}`;
+      apiClassName = `${Utils.toDartClassName(tag + 'Api')}`;
+
+      var apiDefinition = <ApiDefinitionDart>{
+        package: this._commandLineArgs.package,
+        outputDirectory: this._commandLineArgs.outputDirectory,
+        filename: filename,
+        apiClassName: apiClassName,
+      }
+
+      var endpoints = <EndpointDefinitionDart[]>[];
+      var imports = <ImportDefinitionDart[]>[];
+
+      for (const api of apis) {
+        var requestType: string | undefined = undefined;
+        requestType = api.haveRequest ? api.parameters[0]?.typeName || 'void' : undefined;
+        requestType = requestType?.split('.').pop()!
+        requestType = Utils.toDartClassName(requestType);
+
+        var responseType: string = 'void';
+        responseType = api.returnType ? api.returnType.typeName : 'void';
+        responseType = responseType?.split('.').pop()!;
+        responseType = Utils.toDartClassName(responseType) ?? responseType;
+
+        var methodName = Utils.getNormalizedApiPath(api.name);
+        if (methodName.startsWith(Utils.toFirstLetterLowercase(tag))) {
+          methodName = methodName.slice(tag.length);
+          methodName = Utils.toFirstLetterLowercase(methodName);
+        }
+
+        const endpoint = <EndpointDefinitionDart>{
+          methodName: methodName,
+          httpMethod: api.method.toLowerCase() as HttpMethodDart,
+          path: api.url,
+          responseType: responseType,
+          haveRequest: api.haveRequest,
+          requestType: requestType,
+          isGet: api.method.toLowerCase() === 'get'
+        };
+
+        if (api.haveRequest && api.parameters[0]?.typeName) {
+          if (imports.findIndex(x => x.type.typeName == api.parameters[0]?.typeName) == -1) {
+            models.forEach(model => {
+              if (model.typeName === api.parameters[0]?.typeName) {
+                const normalizedInfo = Normalizator.getNormalizedInfo(model);
+                imports.push({
+                  type: api.parameters[0],
+                  import: `import 'package:${this._commandLineArgs.package}/${this._commandLineArgs.outputDirectory}/${normalizedInfo.subPath}/${normalizedInfo.filename}.dart';`
+                });
+              }
+            });
+          }
+        }
+
+        if (api.returnType && !api.returnType.isNativeType) {
+          if (imports.findIndex(x => x.type.typeName == api.returnType!.typeName) == -1) {
+            models.forEach(model => {
+              if (model.typeName === api.returnType!.typeName) {
+                const normalizedInfo = Normalizator.getNormalizedInfo(model);
+                imports.push({
+                  type: api.returnType!,
+                  import: `import 'package:${this._commandLineArgs.package}/${this._commandLineArgs.outputDirectory}/${normalizedInfo.subPath}/${normalizedInfo.filename}.dart';`
+                });
+              }
+            });
+          }
+        }
+
+        endpoints.push(endpoint);
+      }
+
+      apiDefinition.endpoints = endpoints;
+      apiDefinition.imports = imports.map(i => i.import);
+
+      let destinationPath = `${this._commandLineArgs.outputDirectory}/${subPath}/api`;
+
+      Utils.ensureDirectorySync(`${destinationPath}`);
+
+      var result = Mustache.default.render(template, apiDefinition);
+      writeFileSync(`${destinationPath}/${apiDefinition.filename}.dart`, result, 'utf-8');
+    }
+  }
+
+  private _toPascalCase(input: string): string {
+    return input
+      .replace(/[_\- ]+/g, ' ')              // sostituisce underscore, dash e spazi con uno spazio singolo
+      .trim()                                // rimuove spazi iniziali/finali
+      .split(' ')                            // divide in parole
+      .map(word =>
+        word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
+      )
+      .join('');
+  }
+
+  private _normalizeApiClassName(input: string): string {
+    return input
+      .replace(/\./g, '');
+  }
+
+  private _groupByTag(apis: ApiDto[]) {
+    const groupedByRole = apis.reduce<Record<string, ApiDto[]>>((acc, api) => {
+      if (!acc[api.tag]) {
+        acc[api.tag] = [];
+      }
+      acc[api.tag].push(api);
+      return acc;
+    }, {});
+    return groupedByRole;
+  }
+}