@devlearning/swagger-generator 1.0.24 → 1.0.25

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

@@ -1,144 +1,163 @@
-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';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-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 __filename = fileURLToPath(import.meta.url);
-    const __dirname = path.dirname(__filename);
-    const templatePath = path.join(__dirname, 'templates', 'model.mustache');
-    const template = readFileSync(templatePath, 'utf-8');
-    let importDirectory = this._commandLineArgs.outputDirectory;
-    if (importDirectory.startsWith('lib/')) {
-      importDirectory = importDirectory.slice('lib/'.length);
-    }
-
-    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 = Normalizator.mapTsTypeToDart(property.typeName);
-
-        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}/${importDirectory}/${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);
-  }
+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';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+interface ClassDefinitionDart {
+  className?: string;
+  fields?: { name: string; type: string }[];
+  imports?: string[];
+}
+
+interface EnumDefinitionDart {
+  enumName?: string;
+  fields?: EnumItemDefinitionDart[];
+  imports?: string[];
+}
+
+interface EnumItemDefinitionDart {
+  name: string;
+  value: string;
+  isLast: boolean;
+}
+
+interface FieldDefinitionDart {
+  name: string;
+  type: string;
+  typeName: string;
+  nullable: string;
+  required: string;
+}
+
+interface ExportClassDefinitionDart {
+  classes: ClassDefinitionDart[];
+}
+
+interface ExportEnumDefinitionDart {
+  classes: EnumDefinitionDart[];
+}
+
+interface ExportModelItemDefinitionDart {
+  filename?: string;
+}
+
+export class ModelDartWriter {
+  private _commandLineArgs: CommandLineArgs;
+
+  constructor(commandLineArgs: CommandLineArgs) {
+    this._commandLineArgs = commandLineArgs;
+  }
+
+  write(models: ModelDto[]) {
+    this.writeEnums(models.filter(m => m.modelType === 'enum'));
+    this.writeClasses(models);
+  }
+
+  writeClasses(models: ModelDto[]) {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const templatePath = path.join(__dirname, 'templates', 'model.mustache');
+    const template = readFileSync(templatePath, 'utf-8');
+
+    let importDirectory = this._commandLineArgs.outputDirectory;
+    if (importDirectory.startsWith('lib/')) {
+      importDirectory = importDirectory.slice('lib/'.length);
+    }
+
+    models.forEach(model => {
+      if (model.modelType === 'class' || model.modelType === 'interface') {
+        const normalizedInfo = Normalizator.getNormalizedInfo(model);
+        const dartModel = <ClassDefinitionDart>{
+          filename: normalizedInfo.filename,
+          path: this._commandLineArgs.outputDirectory,
+          className: normalizedInfo.modelName,
+          fields: [],
+          imports: [],
+        };
+
+        var imports = <ImportDefinitionDart[]>[];
+
+        model.properties.forEach(property => {
+          var fieldTypeName = Normalizator.mapTsTypeToDart(property.typeName);
+
+          fieldTypeName = Normalizator.getNormalizedTypeName(fieldTypeName);
+
+          dartModel.fields!.push(<FieldDefinitionDart>{
+            name: property.name,
+            type: fieldTypeName,
+            typeName: property.typeName,
+            nullable: property.nullable ? '?' : '',
+            required: property.nullable ? '' : 'required ',
+          });
+
+          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}/${importDirectory}/${normalizedInfo.subPath}/${normalizedInfo.filename}.dart';`
+                  });
+                }
+              });
+            }
+          }
+        });
+
+        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');
+      }
+    });
+  }
+
+  writeEnums(models: ModelDto[]) {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const templatePath = path.join(__dirname, 'templates', 'enum.mustache');
+    const template = readFileSync(templatePath, 'utf-8');
+
+    let importDirectory = this._commandLineArgs.outputDirectory;
+    if (importDirectory.startsWith('lib/')) {
+      importDirectory = importDirectory.slice('lib/'.length);
+    }
+
+    models.forEach(model => {
+      const normalizedInfo = Normalizator.getNormalizedInfo(model);
+      const dartModel = <EnumDefinitionDart>{
+        enumName: normalizedInfo.modelName,
+        path: this._commandLineArgs.outputDirectory,
+        fields: [],
+      };
+
+      model.enumValues.forEach(enumItem => {
+        dartModel.fields!.push(<EnumItemDefinitionDart>{
+          name: enumItem.name,
+          value: enumItem.value,
+          isLast: false,
+        });
+      });
+
+      const lastIndex = dartModel.fields!.length - 1;
+      dartModel.fields![lastIndex].isLast = true;
+
+      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');
+    });
+  }
 }

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

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

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

@@ -1,73 +1,73 @@
-import { ModelDto } from "@src/models/model-dto.js";
-import { Utils } from "../utils.js";
-
-export class Normalizator {
-
-  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;
-  }
-
-  public static mapTsTypeToDart(type: string): string {
-    const normalized = type.trim().toLowerCase();
-
-    if (normalized.endsWith("[]")) {
-      const inner = normalized.slice(0, -2).trim();
-      return `List<${Normalizator.mapTsTypeToDart(inner)}>`;
-    }
-
-    switch (normalized) {
-      case "string":
-      case "uuid":
-      case "date":
-        return "String";
-      case "dateTime":
-        return "DateTime";
-      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);
-    }
-  }
-
+import { ModelDto } from "@src/models/model-dto.js";
+import { Utils } from "../utils.js";
+
+export class Normalizator {
+
+  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;
+  }
+
+  public static mapTsTypeToDart(type: string): string {
+    const normalized = type.trim().toLowerCase();
+
+    if (normalized.endsWith("[]")) {
+      const inner = normalized.slice(0, -2).trim();
+      return `List<${Normalizator.mapTsTypeToDart(inner)}>`;
+    }
+
+    switch (normalized) {
+      case "string":
+      case "uuid":
+      case "date":
+        return "String";
+      case "dateTime":
+        return "DateTime";
+      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/templates/api.mustache

@@ -1,36 +1,36 @@
-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}}
-    {{#queryParams}}
-    {{type}}{{#nullable}}?{{/nullable}} {{name}},
-    {{/queryParams}}
-    ) async {
-    final response = await _dio.{{httpMethod}}(
-      '{{{path}}}',
-      {{#haveRequest}}
-      data: request.toJson(),
-      {{/haveRequest}}
-      {{^haveRequest}}
-      queryParameters: {
-      {{#queryParams}}
-      {{#nullable}}if ({{name}} != null) {{/nullable}}'{{name}}': {{name}},
-      {{/queryParams}}
-      },
-      {{/haveRequest}}
-    );
-    return {{responseType}}.fromJson(response.data);
-  }
-
-  {{/endpoints}}
-}
+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}}
+    {{#queryParams}}
+    {{type}}{{#nullable}}?{{/nullable}} {{name}},
+    {{/queryParams}}
+    ) async {
+    final response = await _dio.{{httpMethod}}(
+      '{{{path}}}',
+      {{#haveRequest}}
+      data: request.toJson(),
+      {{/haveRequest}}
+      {{^haveRequest}}
+      queryParameters: {
+      {{#queryParams}}
+      {{#nullable}}if ({{name}} != null) {{/nullable}}'{{name}}': {{name}},
+      {{/queryParams}}
+      },
+      {{/haveRequest}}
+    );
+    return {{responseType}}.fromJson(response.data);
+  }
+
+  {{/endpoints}}
+}

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

@@ -0,0 +1,14 @@
+import 'package:freezed_annotation/freezed_annotation.dart';
+{{#imports}}
+{{{.}}}
+{{/imports}}
+
+@JsonEnum(fieldRename: FieldRename.pascal)
+enum {{enumName}} {
+    {{#fields}}
+    {{name}}({{value}}){{#isLast}};{{/isLast}}{{^isLast}},{{/isLast}}
+    {{/fields}}
+
+    final int value;
+    const {{enumName}}(this.value);
+}

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

@@ -1,18 +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);
-}
+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);
+}