@devlearning/swagger-generator 1.1.16 → 1.1.18

package/dist/generator.js

@@ -103,6 +103,18 @@ export class Generator {
             for (let index = 0; index < Object.getOwnPropertyNames(this._swagger.components.schemas).length; index++) {
                 const modelName = Object.getOwnPropertyNames(this._swagger.components.schemas)[index];
                 const swaggerComponent = this._swagger.components.schemas[modelName];
+                // Flutter target: support enums of type string/integer and inline property enums.
+                if (this._commandLineArgs.target === TargetGeneration.Flutter) {
+                    const isEnumSchema = swaggerComponent.enum != null && (swaggerComponent.type === 'string' || swaggerComponent.type === 'integer');
+                    this._models.push({
+                        typeName: modelName,
+                        modelType: isEnumSchema ? 'enum' : 'class',
+                        name: modelName,
+                        properties: (swaggerComponent.type === 'object') ? this.retrieveComponentPropertiesFlutter(modelName, swaggerComponent) : [],
+                        enumValues: isEnumSchema ? this.retrieveEnumValuesFlexible(swaggerComponent.enum) : [],
+                    });
+                    continue;
+                }
                 this._models.push({
                     typeName: modelName,
                     modelType: swaggerComponent.type == 'integer' ? 'enum' : 'class',
@@ -427,7 +439,7 @@ export class Generator {
         let properties = [];
         for (let index = 0; index < Object.getOwnPropertyNames(swaggerComponent.properties).length; index++) {
             const propertyName = Object.getOwnPropertyNames(swaggerComponent.properties)[index];
-            const required = swaggerComponent.required && swaggerComponent.required.includes(propertyName);
+            const required = !!(swaggerComponent.required && swaggerComponent.required.includes(propertyName));
             const type = this.retrieveType(swaggerComponent.properties[propertyName]);
             properties.push({
                 ...type,
@@ -437,6 +449,107 @@ export class Generator {
         }
         return properties;
     }
+    retrieveComponentPropertiesFlutter(parentModelName, swaggerComponent) {
+        if (swaggerComponent.properties == null)
+            return [];
+        let properties = [];
+        for (let index = 0; index < Object.getOwnPropertyNames(swaggerComponent.properties).length; index++) {
+            const propertyName = Object.getOwnPropertyNames(swaggerComponent.properties)[index];
+            const required = !!(swaggerComponent.required && swaggerComponent.required.includes(propertyName));
+            const schema = swaggerComponent.properties[propertyName];
+            // Inline enum on property.
+            const inlineEnum = schema?.enum;
+            if (inlineEnum != null && (schema.type === 'string' || schema.type === 'integer')) {
+                const enumTypeName = `${parentModelName}${Utils.toPascalCase(propertyName)}`;
+                this.ensureEnumModel(enumTypeName, inlineEnum);
+                properties.push({
+                    typeName: enumTypeName,
+                    isTypeReference: true,
+                    isNativeType: false,
+                    nullable: required || (schema.nullable ?? false),
+                    isArray: false,
+                    isVoid: false,
+                    name: propertyName,
+                });
+                continue;
+            }
+            // Array of enums.
+            if (schema?.type === 'array' && schema.items?.enum != null && (schema.items.type === 'string' || schema.items.type === 'integer')) {
+                const enumTypeName = `${parentModelName}${Utils.toPascalCase(propertyName)}Item`;
+                this.ensureEnumModel(enumTypeName, schema.items.enum);
+                properties.push({
+                    typeName: enumTypeName,
+                    isTypeReference: true,
+                    isNativeType: false,
+                    nullable: required || (schema.nullable ?? false),
+                    isArray: true,
+                    isVoid: false,
+                    name: propertyName,
+                });
+                continue;
+            }
+            const type = this.retrieveType(schema);
+            properties.push({
+                ...type,
+                name: propertyName,
+                nullable: required || type.nullable,
+            });
+        }
+        return properties;
+    }
+    ensureEnumModel(typeName, enumValues) {
+        if (this._models.findIndex(m => m.typeName === typeName) !== -1)
+            return;
+        this._models.push({
+            typeName,
+            modelType: 'enum',
+            name: typeName,
+            properties: [],
+            enumValues: this.retrieveEnumValuesFlexible(enumValues),
+        });
+    }
+    retrieveEnumValuesFlexible(enumValues) {
+        if (enumValues == null)
+            return [];
+        const values = [];
+        for (let index = 0; index < enumValues.length; index++) {
+            const raw = enumValues[index];
+            if (raw == null)
+                continue;
+            // Legacy format: "NAME-1" (kept for backward compatibility)
+            const asString = String(raw);
+            if (asString.includes('-')) {
+                const parts = asString.split('-');
+                const namePart = parts[0]?.trim();
+                const valuePart = parts.slice(1).join('-').trim();
+                if (namePart && valuePart) {
+                    values.push({
+                        name: namePart,
+                        value: valuePart,
+                    });
+                    continue;
+                }
+            }
+            // Standard OpenAPI string/number enum values.
+            // Many APIs expose ALL_CAPS_UNDERSCORE values; normalize to lowerCamelCase.
+            const normalizedForName = asString.toLowerCase();
+            const enumCaseName = this.sanitizeEnumCaseName(Utils.toFirstLetterLowercase(Utils.toPascalCase(normalizedForName)));
+            const literal = typeof raw === 'number' ? String(raw) : JSON.stringify(asString);
+            values.push({
+                name: enumCaseName,
+                value: literal,
+            });
+        }
+        return values;
+    }
+    sanitizeEnumCaseName(name) {
+        if (!name)
+            return 'value';
+        // Dart identifiers cannot start with a digit.
+        if (/^\d/.test(name))
+            return `v${name}`;
+        return name;
+    }
     retrieveSchemaProperties(schema) {
         if (schema.properties == null)
             return [];
@@ -459,9 +572,10 @@ export class Generator {
         let values = [];
         for (let index = 0; index < swaggerCopmponent.enum.length; index++) {
             try {
+                const item = String(swaggerCopmponent.enum[index]);
                 values.push({
-                    name: swaggerCopmponent.enum[index].split('-')[0].trim(),
-                    value: swaggerCopmponent.enum[index].split('-')[1].trim(),
+                    name: item.split('-')[0].trim(),
+                    value: item.split('-')[1].trim(),
                 });
             }
             catch (error) {
@@ -498,7 +612,7 @@ export class Generator {
                 }
                 if (nestedUsedType != '' && usedTypes.findIndex(x => x.typeName == nestedUsedType) == -1) {
                     let nested = this._swagger.components.schemas[nestedUsedType];
-                    const required = swaggerComponent.required && swaggerComponent.required.includes(propertyName);
+                    const required = !!(swaggerComponent.required && swaggerComponent.required.includes(propertyName));
                     usedTypes.push({
                         typeName: nestedUsedType,
                         isTypeReference: nested.type == 'object',

package/dist/generators-writers/angular/api-angular-writer.js

@@ -27,14 +27,14 @@ export class ApiAngularWriter {
         if (apiNameNormalized.includes('TicketFile')) {
             debugger;
         }
-        let apiString = `
-  public ${apiNameNormalized}(${parametersString}): Observable<${returnTypeString}> {
-    ${queryParametersPreparation}${requestPreparation}return this._http.${method}<${returnTypeString}>(\`\${this._baseUrl}${api.url}${queryParameters}\`${haveRequest ? ', wrappedRequest' : ''}, ${httpOptions})
-      .pipe(
-        map(x => this._handleResponse(x)),
-        catchError((err, obs) => this._handleError(err, obs, skipErrorHandling))
-      );
-  }
+        let apiString = `
+  public ${apiNameNormalized}(${parametersString}): Observable<${returnTypeString}> {
+    ${queryParametersPreparation}${requestPreparation}return this._http.${method}<${returnTypeString}>(\`\${this._baseUrl}${api.url}${queryParameters}\`${haveRequest ? ', wrappedRequest' : ''}, ${httpOptions})
+      .pipe(
+        map(x => this._handleResponse(x)),
+        catchError((err, obs) => this._handleError(err, obs, skipErrorHandling))
+      );
+  }
 `;
         return apiString;
     }
@@ -68,21 +68,21 @@ export class ApiAngularWriter {
     _queryParametersPreparationStatement(parameter) {
         if (parameter.nullable) {
             if (Utils.isDate(parameter.swaggerParameter?.schema)) {
-                return `let ${parameter.name}Param: string = ${parameter.name} != null && ${parameter.name} != undefined && ${parameter.name}.isValid() ? encodeURIComponent(this._momentToString(${parameter.name})) : '';
+                return `let ${parameter.name}Param: string = ${parameter.name} != null && ${parameter.name} != undefined && ${parameter.name}.isValid() ? encodeURIComponent(this._momentToString(${parameter.name})) : '';
       `;
             }
             else {
-                return `let ${parameter.name}Param: string = ${parameter.name} != null && ${parameter.name} != undefined ? encodeURIComponent('' + ${parameter.name}) : '';
+                return `let ${parameter.name}Param: string = ${parameter.name} != null && ${parameter.name} != undefined ? encodeURIComponent('' + ${parameter.name}) : '';
       `;
             }
         }
         else {
             if (Utils.isDate(parameter.swaggerParameter?.schema)) {
-                return `let ${parameter.name}Param: string = encodeURIComponent(this._momentToString(${parameter.name}));
+                return `let ${parameter.name}Param: string = encodeURIComponent(this._momentToString(${parameter.name}));
       `;
             }
             else {
-                return `let ${parameter.name}Param: string = encodeURIComponent('' + ${parameter.name});
+                return `let ${parameter.name}Param: string = encodeURIComponent('' + ${parameter.name});
       `;
             }
         }
@@ -111,44 +111,44 @@ export class ApiAngularWriter {
             return '';
         }
         if (api.isMultiPart) {
-            return `let wrappedRequest = this._handleMultipart(request);
+            return `let wrappedRequest = this._handleMultipart(request);
     `;
         }
         else {
-            return `let wrappedRequest = this._handleRequest(request);
+            return `let wrappedRequest = this._handleRequest(request);
     `;
         }
     }
     _writeFile(apis) {
         const className = this._commandLineArgs.apiClientName || 'ApiAutogeneratedService';
         const apiPre = this._getApiPre(className);
-        fs.writeFileSync(this._commandLineArgs.outputDirectory + "/api.autogenerated.ts", `${apiPre}
-${apis}
+        fs.writeFileSync(this._commandLineArgs.outputDirectory + "/api.autogenerated.ts", `${apiPre}
+${apis}
 ${API_POST}`, { flag: 'w' });
     }
     _getApiPre(className) {
-        return `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 ${className} {
-  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>;
+        return `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 ${className} {
+  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>;
 `;
     }
 }

package/dist/generators-writers/angular/constants.js

@@ -1,28 +1,28 @@
-export const API_PRE = `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<T>(error: any, obs: Observable<T>, skipErrorHandling: boolean): Observable<never>;
+export const API_PRE = `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<T>(error: any, obs: Observable<T>, skipErrorHandling: boolean): Observable<never>;
 `;
 export const API_POST = `}`;
-export const MODEL_PRE = `import * as moment from 'moment';
+export const MODEL_PRE = `import * as moment from 'moment';
   `;
-export const MODEL_POST = `
+export const MODEL_POST = `
 `;

package/dist/generators-writers/angular/model-angular-writer.js

@@ -15,10 +15,10 @@ export class ModelAngularWriter {
         this._writeFile(modelString);
     }
     _modelString(model) {
-        let modelString = `
-export ${model.modelType} ${Utils.toPascalCase(model.name)} {
-${this._properties(model)}${this._enumValues(model)}
-}
+        let modelString = `
+export ${model.modelType} ${Utils.toPascalCase(model.name)} {
+${this._properties(model)}${this._enumValues(model)}
+}
 `;
         return modelString;
     }
@@ -41,8 +41,8 @@ ${this._properties(model)}${this._enumValues(model)}
         return enumValuesString.trimEnd();
     }
     _writeFile(models) {
-        fs.writeFileSync(this._outputDirectory + "/model.autogenerated.ts", `${MODEL_PRE}
-  ${models}
+        fs.writeFileSync(this._outputDirectory + "/model.autogenerated.ts", `${MODEL_PRE}
+  ${models}
   ${MODEL_POST}`, { flag: 'w' });
     }
 }

package/dist/generators-writers/dart/model-dart-writer.d.ts

@@ -6,5 +6,6 @@ export declare class ModelDartWriter {
     write(models: ModelDto[]): void;
     writeClasses(models: ModelDto[]): void;
     writeEnums(models: ModelDto[]): void;
+    private _inferDartEnumValueType;
     private _buildImportPath;
 }

package/dist/generators-writers/dart/model-dart-writer.js

@@ -47,28 +47,16 @@ export class ModelDartWriter {
                     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({
                         name: property.name,
                         type: property.isArray ? `List<${fieldTypeName}>` : fieldTypeName,
                         typeName: property.typeName,
-                        nullable,
-                        required,
+                        nullable: property.nullable && !property.isArray ? '?' : '',
+                        required: property.nullable && !property.isArray ? '' : 'required ',
                         jsonKeyAnnotation,
-                        defaultAnnotation,
                     });
                     if (property.isTypeReference) {
                         if (imports.findIndex(x => x.type.typeName == property.typeName) == -1) {
@@ -104,10 +92,12 @@ export class ModelDartWriter {
         }
         models.forEach(model => {
             const normalizedInfo = Normalizator.getNormalizedInfo(model);
+            const valueType = this._inferDartEnumValueType(model.enumValues);
             const dartModel = {
                 enumName: normalizedInfo.modelName,
                 path: this._commandLineArgs.outputDirectory,
                 fields: [],
+                valueType,
             };
             model.enumValues.forEach(enumItem => {
                 dartModel.fields.push({
@@ -124,6 +114,17 @@ export class ModelDartWriter {
             writeFileSync(`${destinationPath}/${normalizedInfo.filename}.dart`, result, 'utf-8');
         });
     }
+    _inferDartEnumValueType(enumValues) {
+        // 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';
+    }
     _buildImportPath(importDirectory, subPath, filename) {
         // Rimuove slash iniziali e finali da ogni parte
         const parts = [importDirectory, subPath]