@devlearning/swagger-generator 1.0.11 → 1.0.13

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

@@ -0,0 +1,176 @@
+import fs, { readFileSync, writeFileSync } from 'fs';
+import { ModelDto } from '@src/models/model-dto.js';
+import * as Mustache from 'mustache';
+import { Utils } from '../utils.js';
+import { CommandLineArgs } from '@src/index.js';
+import { ImportDefinitionDart } from './models/import-definition-dart.js';
+import { Normalizator } from './normalizator.js';
+
+interface ModelDefinitionDart {
+  modelName?: string;
+  fields?: { name: string; type: string }[];
+  imports?: string[];
+}
+
+interface FieldDefinitionDart {
+  name: string;
+  type: string;
+  typeName: string;
+  nullable: string;
+  required: string;
+}
+
+interface ExportModelDefinitionDart {
+  models: ExportModelItemDefinitionDart[];
+}
+
+interface ExportModelItemDefinitionDart {
+  filename?: string;
+}
+
+export class ModelDartWriter {
+  private _commandLineArgs: CommandLineArgs;
+
+  constructor(commandLineArgs: CommandLineArgs) {
+    this._commandLineArgs = commandLineArgs;
+  }
+
+  write(models: ModelDto[]) {
+    const template = readFileSync('src/generators-writers/dart/templates/model.mustache', 'utf-8');
+
+    models.forEach(model => {
+      const normalizedInfo = Normalizator.getNormalizedInfo(model);
+      const dartModel = <ModelDefinitionDart>{
+        filename: normalizedInfo.filename,
+        path: this._commandLineArgs.outputDirectory,
+        modelName: normalizedInfo.modelName,
+        fields: [],
+        imports: [],
+      };
+      
+      var imports = <ImportDefinitionDart[]>[];
+
+      model.properties.forEach(property => {
+        var fieldTypeName = this._mapTsTypeToDart(property.typeName);
+
+//         if (fieldTypeName.endsWith('Exception')) {
+// debugger
+//         }
+
+        fieldTypeName = Normalizator.getNormalizedTypeName(fieldTypeName);
+
+        if (property.isTypeReference) {
+          if (imports.findIndex(x => x.type.typeName == property.typeName) == -1) {
+            models.forEach(currModel => {
+              if (currModel.typeName === property.typeName) {
+                const normalizedInfo = Normalizator.getNormalizedInfo(currModel);
+                imports.push({
+                  type: property,
+                  import: `import 'package:${this._commandLineArgs.package}/${this._commandLineArgs.outputDirectory}/${normalizedInfo.subPath}/${normalizedInfo.filename}.dart';`
+                });
+              }
+            });
+          }
+        }
+
+
+        dartModel.fields!.push(<FieldDefinitionDart>{
+          name: property.name,
+          type: fieldTypeName,
+          typeName: property.typeName,
+          nullable: property.nullable ? '?' : '',
+          required: property.nullable ? '' : 'required ',
+        });
+
+      });
+
+      dartModel.imports = imports.map(i => i.import);
+
+      let destinationPath = `${this._commandLineArgs.outputDirectory}/${normalizedInfo.subPath}`;
+
+      Utils.ensureDirectorySync(`${destinationPath}`);
+
+      let result = Mustache.default.render(template, dartModel);
+      writeFileSync(`${destinationPath}/${normalizedInfo.filename}.dart`, result, 'utf-8');
+    });
+
+    // var exportDataModels = <ExportModelItemDefinitionDart[]>[];
+    // models.forEach(model => {
+    //   exportDataModels.push({
+    //     filename: `${model.filename}.dart`
+    //   });
+    // });
+
+    // var exportData = <ExportModelDefinitionDart>{
+    //   models: exportDataModels
+    // };
+    // const exportTemplate = readFileSync('src/generators-writers/dart/templates/model.export.mustache', 'utf-8');
+    // const exportContent = Mustache.default.render(exportTemplate, exportData);
+    // writeFileSync(`${this._commandLineArgs.outputDirectory}/_export_models.dart`, exportContent, 'utf-8');
+
+    // const model = [
+    //   {
+    //     filename: 'login_request',
+    //     modelName: 'LoginRequest',
+    //     fields: [
+    //       { name: 'email', type: 'String' },
+    //       { name: 'password', type: 'String' }
+    //     ]
+    //   },
+    //   {
+    //     filename: 'login_response',
+    //     modelName: 'LoginResponse',
+    //     fields: [
+    //       { name: 'token', type: 'String' }
+    //     ]
+    //   }
+    // ];
+
+
+    // let modelString = '';
+
+    // models.forEach(model => {
+    //   modelString += this._modelString(model);
+    // });
+
+
+    // this._writeFile(modelString);
+  }
+
+  private _mapTsTypeToDart(type: string): string {
+    const normalized = type.trim().toLowerCase();
+
+    if (normalized.endsWith("[]")) {
+      const inner = normalized.slice(0, -2).trim();
+      return `List<${this._mapTsTypeToDart(inner)}>`;
+    }
+
+    switch (normalized) {
+      case "string":
+      case "uuid":
+      case "date":
+      case "datetime":
+        return "String";
+      case "number":
+      case "float":
+      case "double":
+        return "double";
+      case "integer":
+      case "int":
+      case "long":
+        return "int";
+      case "boolean":
+      case "bool":
+        return "bool";
+      case "any":
+      case "object":
+        return "dynamic";
+      case "null":
+      case "undefined":
+        return "Null";
+      default:
+        // per tipi personalizzati (es. modelli) restituisci con PascalCase
+        return Utils.toPascalCase(type);
+    }
+  }
+}

package/src/generators-writers/dart/models/import-definition-dart.ts

@@ -0,0 +1,6 @@
+import { TypeDto } from "@src/models/type-dto.js";
+
+export interface ImportDefinitionDart {
+  type: TypeDto;
+  import: string
+}

package/src/generators-writers/dart/normalizator.ts

@@ -0,0 +1,44 @@
+import { ModelDto } from "@src/models/model-dto.js";
+import { Utils } from "../utils.js";
+
+export class Normalizator {
+
+  // public static normalizeModelName(modelName: string): string {
+  //      let normalizeModelName = modelName.split('.').pop()!;
+  //       return Utils.toDartClassName(filename) ?? filename;
+  //   }
+
+
+  //   subPath = model.name.split('.').slice(0, -1).join('');
+  //           subPath = `${Utils.toDartFileName(subPath)}/models`;
+
+  public static getNormalizedInfo(model: ModelDto) {
+    let subPath = '';
+    let filename = '';
+    let modelName = '';
+
+    if (model.name && model.name.includes('.')) {
+      subPath = model.name.split('.').slice(0, -1).join('');
+      subPath = `${Utils.toDartFileName(subPath)}/models`;
+      filename = model.name.split('.').pop()!;
+      modelName = Utils.toDartClassName(filename) ?? filename;
+      filename = Utils.toDartFileName(filename!);
+    } else {
+      subPath = '';
+      filename = Utils.toDartFileName(model.name);
+      modelName = Utils.toDartClassName(model.name) ?? model.name;
+    }
+
+    return {
+      filename: filename,
+      subPath: subPath,
+      modelName: modelName,
+    }
+  }
+
+  public static getNormalizedTypeName(typeName: string): string {
+    let formattedTypeName = typeName.split('.').pop()!;
+    return Utils.toDartClassName(formattedTypeName) ?? typeName;
+  }
+
+}

package/src/generators-writers/dart/templates/api.mustache

@@ -0,0 +1,29 @@
+import 'package:{{package}}/core/di/injector.dart';
+import 'package:dio/dio.dart';
+{{#imports}}
+{{{.}}}
+{{/imports}}
+
+class {{apiClassName}} {
+  final Dio _dio;
+
+  {{apiClassName}}() : _dio = getIt<Dio>();
+
+  {{#endpoints}}
+  Future<{{responseType}}> {{methodName}}({{#haveRequest}}{{requestType}} request{{/haveRequest}}) async {
+    final response = await _dio.{{httpMethod}}(
+      '{{{path}}}',
+      {{#haveRequest}}
+      {{#isGet}}
+      queryParameters: request.toJson(),
+      {{/isGet}}
+      {{^isGet}}
+      data: request.toJson(),
+      {{/isGet}}
+      {{/haveRequest}}
+    );
+    return {{responseType}}.fromJson(response.data);
+  }
+
+  {{/endpoints}}
+}

package/src/generators-writers/dart/templates/model.mustache

@@ -0,0 +1,18 @@
+import 'package:freezed_annotation/freezed_annotation.dart';
+{{#imports}}
+{{{.}}}
+{{/imports}}
+
+part '{{filename}}.freezed.dart';
+part '{{filename}}.g.dart';
+
+@freezed
+abstract class {{modelName}} with _${{modelName}} {
+  const factory {{modelName}}({
+    {{#fields}}
+    {{required}}{{type}}{{nullable}} {{name}},
+    {{/fields}}
+  }) = _{{modelName}};
+
+  factory {{modelName}}.fromJson(Map<String, dynamic> json) => _${{modelName}}FromJson(json);
+}

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

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

package/src/generators-writers/utils.ts

@@ -1,14 +1,25 @@
 import { SwaggerSchema } from "@src/models/swagger/swagger-schema.js";
+import fs from 'fs';
+import path from 'path';
 
 export class Utils {
 
-  public static getApiNameNormalized(apiName: string) {
+  public static getNormalizedApiPath(apiName: string) {
     let normalizedApiName = apiName.replace('/api/v{version}/', '').replaceAll('/', '_');
 
     if (normalizedApiName.charAt(0) == '_') {
       normalizedApiName = normalizedApiName.slice(1);
     }
-    return this.toFirstLetterLowercase(normalizedApiName);
+
+    normalizedApiName = normalizedApiName.replace(/-([a-zA-Z])/g, (_, char) => char.toUpperCase());
+
+    normalizedApiName = this.toCamelCase(normalizedApiName);
+
+    normalizedApiName = this.toFirstLetterLowercase(normalizedApiName);
+
+    normalizedApiName = normalizedApiName.replaceAll('_', '');
+
+    return normalizedApiName;
   }
 
   public static toFirstLetterLowercase(value: string) {
@@ -19,9 +30,50 @@ export class Utils {
     return input.replace(/_([a-zA-Z])/g, (_, letter) => letter.toUpperCase());
   }
 
+  public static toPascalCase(input: string): string {
+    return input
+      .replace(/[_\-\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ""))
+      .replace(/^(.)/, (_, c) => c.toUpperCase());
+  }
+
   public static isDate(schema?: SwaggerSchema) {
     if (!schema) return false;
 
     return schema.type == 'string' && schema.format == 'date-time';
   }
+
+  public static toDartFileName(name: string): string {
+    return name
+      .replace(/\./g, '_')                     // sostituisce i punti con underscore
+      .replace(/([a-z0-9])([A-Z])/g, '$1_$2')  // aggiunge _ tra camelCase
+      .toLowerCase();
+  }
+
+  public static toDartClassName(name: string): string | undefined {
+    if (!name) return undefined;
+
+    return name.replace(/\./g, ''); // rimuove i punti per ottenere PascalCase
+  }
+
+  public static async ensureDirectorySync(dirPath: string) {
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+  }
+
+  public static async clearDirectory(dirPath: string) {
+    if (!fs.existsSync(dirPath)) return;
+
+    for (const file of fs.readdirSync(dirPath)) {
+      const fullPath = path.join(dirPath, file);
+      const stat = fs.statSync(fullPath);
+
+      if (stat.isDirectory()) {
+        fs.rmSync(fullPath, { recursive: true, force: true });
+      } else {
+        fs.unlinkSync(fullPath);
+      }
+    }
+  }
+
 }

package/src/index.ts

@@ -1,33 +1,97 @@
 #!/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);
+export enum DateTimeLibrary {
+	Moment = 'moment',
+	DateFns = 'date-fn',
+}
 
-if (args.length !== 4) {
-	console.log("Warning: Requires 3 arguments");
-	console.log("node index.js [swaggerJsonUrl] [outputDirectory] [angular|next] [moment|date-fns]");
-	process.exit();
+export enum TargetGeneration {
+	Angular = 'angular',
+	Next = 'next',
+	Dart = 'dart',
 }
 
-const swaggerJsonUrl = args[0];
-const outputDirectory = args[1];
-const outputFormat = args[2] == 'next' ? 'next' : 'angular';	
-const dateLib = args[3] == 'moment' ? 'moment' : 'date-fns';	
+export interface CommandLineArgs {
+	swaggerJsonUrl: string;
+	outputDirectory: string;
+	target: TargetGeneration;
+	dateTimeLibrary?: DateTimeLibrary;
+	package?: string;
+}
 
-//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`;
+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: 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});
+// require('./index.js')({swaggerDownloader});
+
+function parseDateTimeLibrary(value: string): DateTimeLibrary | undefined {
+	const values = Object.values(DateTimeLibrary);
+	if (values.includes(value as DateTimeLibrary)) {
+		return value as DateTimeLibrary;
+	}
+	return undefined;
+}
+
+function parseTargetGeneration(value: string): TargetGeneration {
+	const values = Object.values(TargetGeneration);
+	if (values.includes(value as TargetGeneration)) {
+		return value as TargetGeneration;
+	}
+	throw new Error(`Invalid OutputFormat: ${value}`);
+}

package/src/models/api-dto.ts

@@ -11,6 +11,7 @@ export interface ApiDto {
   returnType: TypeDto | undefined;
   haveRequest: boolean;
   isMultiPart: boolean;
+  tag: string;
 
   swaggerMethodKey: { [key: string]: SwaggerMethod; };
   swaggerMethod: SwaggerMethod;

package/src/models/model-dto.ts

@@ -2,6 +2,7 @@ import { EnumValueDto } from "./enum-value-dto.js";
 import { PropertyDto } from "./property-dto.js";
 
 export interface ModelDto {
+  typeName: string;
   modelType: 'enum' | 'interface' | 'class';
   name: string;
   properties: PropertyDto[];

package/src/models/swagger/swagger-component-property.ts

@@ -1,11 +1,12 @@
 import { SwaggerSchema } from "./swagger-schema.js";
 
-export interface SwaggerComponentProperty {
-    type: string;
-    $ref: string;
-    format: string;
-    items: SwaggerSchema;
-    properties: { [key: string]: SwaggerComponentProperty; };
-    nullable: boolean;
-    minLength: number;
-}
+// export interface SwaggerComponentProperty {
+//     type: string;
+//     $ref: string;
+//     allOf: SwaggerComponentProperty[];
+//     format: string;
+//     items: SwaggerSchema;
+//     properties: { [key: string]: SwaggerComponentProperty; };
+//     nullable: boolean;
+//     minLength: number;
+// }

package/src/models/swagger/swagger-component.ts

@@ -1,8 +1,17 @@
-import { SwaggerComponentProperty } from "./swagger-component-property.js";
+// import { SwaggerComponentProperty } from "./swagger-component-property.js";
+
+import { SwaggerSchema } from "./swagger-schema.js";
+
+// export interface SwaggerComponent {
+//     type: string;
+//     properties: { [key: string]: SwaggerComponentProperty; };
+//     additionalProperties: boolean;
+//     enum: string[];
+// }
 
 export interface SwaggerComponent {
     type: string;
-    properties: { [key: string]: SwaggerComponentProperty; };
+    properties: { [key: string]: SwaggerSchema; };
     additionalProperties: boolean;
     enum: string[];
 }

package/src/models/swagger/swagger-schema.ts

@@ -1,9 +1,21 @@
-import { SwaggerComponentProperty } from "./swagger-component-property.js";
+// import { SwaggerComponentProperty } from "./swagger-component-property.js";
+
+// export interface SwaggerSchema {
+//     type: string;
+//     $ref: string;
+//     allOf: SwaggerSchema[];
+//     format: string;
+//     items: SwaggerSchema;
+//     properties: { [key: string]: SwaggerComponentProperty; };
+// }
 
 export interface SwaggerSchema {
-    type: string;
-    $ref: string;
-    format: string;
-    items: SwaggerSchema;
-    properties: { [key: string]: SwaggerComponentProperty; };
+    type?: string;
+    $ref?: string;
+    allOf?: SwaggerSchema[];
+    format?: string;
+    items?: SwaggerSchema;
+    properties?: { [key: string]: SwaggerSchema };
+    nullable?: boolean;
+    minLength?: number;
 }

package/src/models/swagger/swagger.ts

@@ -21,6 +21,7 @@ export interface SwaggerParameter {
 export interface SwaggerRequestBody {
     content: { [key: string]: SwaggerContent; };
     encoding : SwaggerEncoding;
+    required?: boolean;
 }
 
 export interface SwaggerResponses {

package/autogeneration/output/api.autogenerated.ts

@@ -1,95 +0,0 @@
-import { HttpClient } from '@angular/common/http';
-import { Observable, catchError, map } from 'rxjs';
-import * as Models from './model.autogenerated';
-import { HttpHeaders } from "@angular/common/http";
-
-export const httpOptions = {
-  headers: new HttpHeaders({ 'Content-Type': 'application/json' }),
-};
-
-export const httpOptionsMultipart = {};
-
-export abstract class ApiAutogeneratedService {
-  constructor(
-    public _http: HttpClient,
-    public _baseUrl: string,
-  ) { }
-
-  protected abstract _momentToString(moment: moment.Moment): string;
-  protected abstract _handleRequest<T>(request: T): T;
-  protected abstract _handleMultipart<T>(request: T): FormData;
-  protected abstract _handleResponse<T>(response: T): T;
-  protected abstract _handleError(error: any, obs: any): Observable<never>;
-
-
-  public catalog_Product_Read(idProduct?: number): Observable<Models.Product> {
-    let idProductParam: string = idProduct != null && idProduct != undefined ? encodeURIComponent('' + idProduct) : '';
-      return this._http.get<Models.Product>(`${this._baseUrl}/catalog/Product/Read?idProduct=${idProductParam}`, httpOptions)
-      .pipe(
-        map(x => this._handleResponse(x)),
-        catchError((err, obs) => this._handleError(err, <Observable<any>>obs))
-      );
-  }
-
-  public catalog_Product_List(): Observable<Models.Product[]> {
-    return this._http.get<Models.Product[]>(`${this._baseUrl}/catalog/Product/List`, httpOptions)
-      .pipe(
-        map(x => this._handleResponse(x)),
-        catchError((err, obs) => this._handleError(err, <Observable<any>>obs))
-      );
-  }
-
-  public identiy_token(request: Models.AuthTokenCommand): Observable<Models.AuthenticationToken> {
-    let wrappedRequest = this._handleRequest(request);
-    return this._http.post<Models.AuthenticationToken>(`${this._baseUrl}/identiy/token`, wrappedRequest, httpOptions)
-      .pipe(
-        map(x => this._handleResponse(x)),
-        catchError((err, obs) => this._handleError(err, <Observable<any>>obs))
-      );
-  }
-
-  public identiy_refreshToken(request: Models.AuthRefreshTokenCommand): Observable<Models.AuthenticationToken> {
-    let wrappedRequest = this._handleRequest(request);
-    return this._http.post<Models.AuthenticationToken>(`${this._baseUrl}/identiy/refreshToken`, wrappedRequest, httpOptions)
-      .pipe(
-        map(x => this._handleResponse(x)),
-        catchError((err, obs) => this._handleError(err, <Observable<any>>obs))
-      );
-  }
-
-  public identiy_generateResetPasswordCode(request: Models.AuthGenerateResetPasswordCodeCommand): Observable<Models.Result> {
-    let wrappedRequest = this._handleRequest(request);
-    return this._http.post<Models.Result>(`${this._baseUrl}/identiy/generateResetPasswordCode`, wrappedRequest, httpOptions)
-      .pipe(
-        map(x => this._handleResponse(x)),
-        catchError((err, obs) => this._handleError(err, <Observable<any>>obs))
-      );
-  }
-
-  public identiy_resetPassword(request: Models.AuthResetPasswordCommand): Observable<Models.Result> {
-    let wrappedRequest = this._handleRequest(request);
-    return this._http.post<Models.Result>(`${this._baseUrl}/identiy/resetPassword`, wrappedRequest, httpOptions)
-      .pipe(
-        map(x => this._handleResponse(x)),
-        catchError((err, obs) => this._handleError(err, <Observable<any>>obs))
-      );
-  }
-
-  public identiy_verifyResetPasswordCode(request: Models.AuthVerifyResetPasswordCodeCommand): Observable<Models.Result> {
-    let wrappedRequest = this._handleRequest(request);
-    return this._http.post<Models.Result>(`${this._baseUrl}/identiy/verifyResetPasswordCode`, wrappedRequest, httpOptions)
-      .pipe(
-        map(x => this._handleResponse(x)),
-        catchError((err, obs) => this._handleError(err, <Observable<any>>obs))
-      );
-  }
-
-  public tenant_Tenant(): Observable<string> {
-    return this._http.get<string>(`${this._baseUrl}/tenant/Tenant`, httpOptions)
-      .pipe(
-        map(x => this._handleResponse(x)),
-        catchError((err, obs) => this._handleError(err, <Observable<any>>obs))
-      );
-  }
-
-}