@devlearning/swagger-generator 1.1.16 → 1.1.17

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

@@ -1,210 +1,213 @@
-import fs, { readFileSync, writeFileSync } from 'fs';
-import { ModelDto } from '../../models/model-dto.js';
-import Mustache from 'mustache';
-import { Utils } from '../utils.js';
-import { CommandLineArgs } from '../../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;
-  jsonKeyAnnotation?: string;
-  defaultAnnotation?: 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[]>[];
-
-        const needsDartIo = model.properties.some(p => {
-          const normalized = (p.typeName ?? '').trim();
-          return normalized === 'File' || (p.isArray && normalized === 'File');
-        });
-
-        if (needsDartIo) {
-          imports.push({
-            type: { typeName: 'dart:io' } as any,
-            import: `import 'dart:io';`
-          });
-        }
-
-        model.properties.forEach(property => {
-          var fieldTypeName = Normalizator.mapTsTypeToDart(property.typeName);
-
-          fieldTypeName = Normalizator.getNormalizedTypeName(fieldTypeName);
-
-          const isFileField = property.typeName === 'File';
-          const isFileArrayField = isFileField && property.isArray === true;
-          const jsonKeyAnnotation = isFileField
-            ? "@JsonKey(includeFromJson: false, includeToJson: false)"
-            : undefined;
-          const defaultAnnotation = isFileArrayField
-            ? "@Default(<File>[])"
-            : undefined;
-
-          // File fields are excluded from JSON serialization; they must not be `required` for fromJson.
-          const nullable = isFileField && !property.isArray
-            ? '?'
-            : (property.nullable && !property.isArray ? '?' : '');
-          const required = isFileField
-            ? ''
-            : (property.nullable && !property.isArray ? '' : 'required ');
-
-          dartModel.fields!.push(<FieldDefinitionDart>{
-            name: property.name,
-            type: property.isArray ? `List<${fieldTypeName}>` : fieldTypeName,
-            typeName: property.typeName,
-            nullable,
-            required,
-            jsonKeyAnnotation,
-            defaultAnnotation,
-          });
-
-          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);
-                  const importPath = this._buildImportPath(importDirectory, normalizedInfo.subPath, normalizedInfo.filename);
-                  imports.push({
-                    type: property,
-                    import: `import 'package:${this._commandLineArgs.package}/${importPath}';`
-                  });
-                }
-              });
-            }
-          }
-        });
-
-        dartModel.imports = imports.map(i => i.import);
-
-        let destinationPath = `${this._commandLineArgs.outputDirectory}/${normalizedInfo.subPath}`;
-
-        Utils.ensureDirectorySync(`${destinationPath}`);
-
-        let result = Mustache.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.render(template, dartModel);
-      writeFileSync(`${destinationPath}/${normalizedInfo.filename}.dart`, result, 'utf-8');
-    });
-  }
-
-  private _buildImportPath(importDirectory: string, subPath: string, filename: string): string {
-    // Rimuove slash iniziali e finali da ogni parte
-    const parts = [importDirectory, subPath]
-      .filter(p => p && p.length > 0)
-      .map(p => p.replace(/^\/+|\/+$/g, ''));
-    
-    // Aggiunge il filename alla fine
-    parts.push(`${filename}.dart`);
-    
-    // Unisce con un singolo slash
-    return parts.join('/');
-  }
+import fs, { readFileSync, writeFileSync } from 'fs';
+import { ModelDto } from '../../models/model-dto.js';
+import Mustache from 'mustache';
+import { Utils } from '../utils.js';
+import { CommandLineArgs } from '../../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[];
+  valueType?: string;
+}
+
+interface EnumItemDefinitionDart {
+  name: string;
+  value: string;
+  isLast: boolean;
+}
+
+interface FieldDefinitionDart {
+  name: string;
+  type: string;
+  typeName: string;
+  nullable: string;
+  required: string;
+  jsonKeyAnnotation?: 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[]>[];
+
+        const needsDartIo = model.properties.some(p => {
+          const normalized = (p.typeName ?? '').trim();
+          return normalized === 'File' || (p.isArray && normalized === 'File');
+        });
+
+        if (needsDartIo) {
+          imports.push({
+            type: { typeName: 'dart:io' } as any,
+            import: `import 'dart:io';`
+          });
+        }
+
+        model.properties.forEach(property => {
+          var fieldTypeName = Normalizator.mapTsTypeToDart(property.typeName);
+
+          fieldTypeName = Normalizator.getNormalizedTypeName(fieldTypeName);
+
+          const isFileField = property.typeName === 'File';
+          const jsonKeyAnnotation = isFileField
+            ? "@JsonKey(includeFromJson: false, includeToJson: false)"
+            : undefined;
+
+          dartModel.fields!.push(<FieldDefinitionDart>{
+            name: property.name,
+            type: property.isArray ? `List<${fieldTypeName}>` : fieldTypeName,
+            typeName: property.typeName,
+            nullable: property.nullable && !property.isArray ? '?' : '',
+            required: property.nullable && !property.isArray ? '' : 'required ',
+            jsonKeyAnnotation,
+          });
+
+          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);
+                  const importPath = this._buildImportPath(importDirectory, normalizedInfo.subPath, normalizedInfo.filename);
+                  imports.push({
+                    type: property,
+                    import: `import 'package:${this._commandLineArgs.package}/${importPath}';`
+                  });
+                }
+              });
+            }
+          }
+        });
+
+        dartModel.imports = imports.map(i => i.import);
+
+        let destinationPath = `${this._commandLineArgs.outputDirectory}/${normalizedInfo.subPath}`;
+
+        Utils.ensureDirectorySync(`${destinationPath}`);
+
+        let result = Mustache.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 valueType = this._inferDartEnumValueType(model.enumValues);
+      const dartModel = <EnumDefinitionDart>{
+        enumName: normalizedInfo.modelName,
+        path: this._commandLineArgs.outputDirectory,
+        fields: [],
+        valueType,
+      };
+
+      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.render(template, dartModel);
+      writeFileSync(`${destinationPath}/${normalizedInfo.filename}.dart`, result, 'utf-8');
+    });
+  }
+
+  private _inferDartEnumValueType(enumValues: { value: string }[]): string {
+    // If values are unquoted and numeric, assume int; otherwise String.
+    // Generator will quote string enums using JSON.stringify ("...").
+    if (!enumValues || enumValues.length === 0) return 'String';
+
+    const allNumeric = enumValues.every(v => {
+      const trimmed = (v.value ?? '').trim();
+      return /^-?\d+$/.test(trimmed);
+    });
+
+    return allNumeric ? 'int' : 'String';
+  }
+
+  private _buildImportPath(importDirectory: string, subPath: string, filename: string): string {
+    // Rimuove slash iniziali e finali da ogni parte
+    const parts = [importDirectory, subPath]
+      .filter(p => p && p.length > 0)
+      .map(p => p.replace(/^\/+|\/+$/g, ''));
+    
+    // Aggiunge il filename alla fine
+    parts.push(`${filename}.dart`);
+    
+    // Unisce con un singolo slash
+    return parts.join('/');
+  }
 }

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

@@ -1,6 +1,6 @@
-import { TypeDto } from "../../../models/type-dto.js";
-
-export interface ImportDefinitionDart {
-  type: TypeDto;
-  import: string
+import { TypeDto } from "../../../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 "../../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 "../../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);
+    }
+  }
+
 }