@devlearning/swagger-generator 1.1.9 → 1.1.11

package/dist/generator.js

@@ -7,6 +7,7 @@ import { 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';
+import { logger } from './utils/logger.js';
 const contentTypeApplicationJson = 'application/json';
 const contentTypeMultipartFormData = 'multipart/form-data';
 export class Generator {
@@ -33,13 +34,13 @@ export class Generator {
         this._commandLineArgs = commandLineArgs;
     }
     generate() {
-        console.info('%c[Swagger API Generator] %cStarting to parse Swagger JSON file...', 'color: #4CAF50; font-weight: bold;', 'color: #2196F3;');
+        logger.info('Starting Swagger API generation...');
         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;');
+        logger.success('Swagger generation completed successfully!');
     }
     computeApi() {
         this._barApis.start(Object.getOwnPropertyNames(this._swagger.paths).length, 0);
@@ -73,18 +74,6 @@ export class Generator {
             const apiSwaggerMethodKey = this._swagger.paths[apiName];
             const apiMethod = Object.getOwnPropertyNames(apiSwaggerMethodKey)[0];
             const apiSwaggerMethod = apiSwaggerMethodKey[apiMethod];
-            //   const parametersRefType = apiSwaggerMethod.parameters?.filter(x => x.in == 'query' && x.schema?.$ref != null).map(x => x.schema.$ref.replace('#/components/schemas/', ''));
-            //   if (parametersRefType) {
-            //     usedTypes = usedTypes.concat(parametersRefType);
-            //   }
-            //   const responseRefType = this.computeRequestBodyType(apiSwaggerMethod!);
-            //   if (responseRefType && !responseRefType.isVoid && !responseRefType.isNativeType) {
-            //     usedTypes = usedTypes.concat(responseRefType.typeName);
-            //   }
-            //   const contentRefType = this.computeResponseType(apiSwaggerMethod!);
-            //   if (contentRefType && !contentRefType.isVoid && !contentRefType.isNativeType) {
-            //     usedTypes = usedTypes.concat(contentRefType.typeName);
-            //   }
             if (apiSwaggerMethod.requestBody?.content[contentTypeMultipartFormData]?.schema != null) {
                 usedMultiPart.push(apiName);
             }
@@ -92,17 +81,11 @@ export class Generator {
         for (let index = 0; index < this._apis.length; index++) {
             if (this._apis[index].returnType && this._apis[index].returnType.isTypeReference) {
                 usedTypes.push(this._apis[index].returnType);
-                // if (this._apis[index].returnType!.typeName.startsWith("hotac_")) {
-                //   debugger
-                // }
             }
             if (this._apis[index].parameters) {
                 this._apis[index].parameters.forEach(parameter => {
                     if (parameter.isTypeReference) {
                         usedTypes.push(parameter);
-                        // if (parameter.typeName.startsWith("hotac_")) {
-                        //   debugger
-                        // }
                     }
                 });
             }
@@ -280,8 +263,8 @@ export class Generator {
                 };
         }
         catch (error) {
-            const errorMessage = "\t\tAttenzione forse hai dimenticato IActionResult e non hai tipizzato il tipo restituito dal servizio";
-            console.error(`%c${errorMessage}`, 'color: red');
+            const errorMessage = "Make sure your API endpoint uses IActionResult with a typed return value";
+            logger.error(errorMessage, error);
             throw new Error(errorMessage);
         }
         if (swaggerContent.schema.type != null) {
@@ -438,7 +421,7 @@ export class Generator {
                 });
             }
             catch (error) {
-                debugger;
+                logger.error(`Error parsing enum value at index ${index}:`, swaggerCopmponent.enum[index]);
             }
         }
         return values;
@@ -455,8 +438,8 @@ export class Generator {
         if (!swaggerComponent.properties)
             return;
         for (let j = 0; j < Object.getOwnPropertyNames(swaggerComponent.properties).length; j++) {
+            const propertyName = Object.getOwnPropertyNames(swaggerComponent.properties)[j];
             try {
-                const propertyName = Object.getOwnPropertyNames(swaggerComponent.properties)[j];
                 let nestedUsedType = '';
                 if (!swaggerComponent.properties[propertyName])
                     continue;
@@ -485,14 +468,15 @@ export class Generator {
                 }
             }
             catch (error) {
-                debugger;
+                logger.error(`Error processing nested object for property ${propertyName}`, error);
             }
         }
     }
     getNativeType(schema) {
         let nativeType = 'n.d.';
         if (schema.$ref != null) {
-            debugger;
+            logger.error('Unexpected $ref in getNativeType:', schema.$ref);
+            throw new Error(`Schema with $ref should not be processed as native type: ${schema.$ref}`);
         }
         else if (schema.type == 'array' && schema.items != null) {
             nativeType = this.getNativeType(schema.items);
@@ -522,8 +506,8 @@ export class Generator {
             return nativeType;
         }
         else {
-            console.error("unmanaged schema type", schema);
-            throw new Error("unmanaged schema");
+            logger.error("Unmanaged schema type", schema);
+            throw new Error("Unmanaged schema type");
         }
     }
     getApiNameNormalized(apiName) {

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

@@ -4,6 +4,7 @@ import Mustache from 'mustache';
 import { Normalizator } from './normalizator.js';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import { logger } from '@src/utils/logger.js';
 export class ApiDartWriter {
     _commandLineArgs;
     constructor(commandLineArgs) {
@@ -20,7 +21,7 @@ export class ApiDartWriter {
         }
         const grouped = this._groupByTag(apis);
         for (const [tag, apis] of Object.entries(grouped)) {
-            console.log(`Api: ${tag}`);
+            logger.progress(`Generating Dart API: ${tag}`);
             let subPath = '';
             let filename = '';
             let apiClassName = '';
@@ -54,10 +55,6 @@ export class ApiDartWriter {
                     methodName = methodName.slice(tag.length);
                     methodName = Utils.toFirstLetterLowercase(methodName);
                 }
-                // console.debug(`\tAPI - ${apiName} - ${apiMethod}`);
-                if (methodName.toLowerCase().indexOf("productsave") >= 0) {
-                    debugger;
-                }
                 const endpoint = {
                     methodName: methodName,
                     httpMethod: api.method.toLowerCase(),

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

@@ -30,7 +30,7 @@ class {{apiClassName}} {
       {{/haveRequest}}
     );
     {{#isResponseNativeType}}
-    return parseNative<{{responseType}}>(response.data);
+    return _parseNative<{{responseType}}>(response.data);
     {{/isResponseNativeType}}
     {{^isResponseNativeType}}
     return {{responseType}}.fromJson(response.data);
@@ -39,11 +39,40 @@ class {{apiClassName}} {
 
   {{/endpoints}}
 
-  T parseNative<T>(dynamic data) {
-    if (T == int) return int.parse(data.toString()) as T;
-    if (T == double) return double.parse(data.toString()) as T;
-    if (T == String) return data as T;
-    if (T == bool) return data as T;
+  T _parseNative<T>(dynamic data) {
+    if (data == null) {
+      throw Exception('Cannot parse null data as $T');
+    }
+    
+    if (T == String) {
+      return data.toString() as T;
+    }
+    if (T == int) {
+      if (data is int) return data as T;
+      if (data is double) return data.toInt() as T;
+      return int.parse(data.toString()) as T;
+    }
+    if (T == double) {
+      if (data is double) return data as T;
+      if (data is int) return data.toDouble() as T;
+      return double.parse(data.toString()) as T;
+    }
+    if (T == bool) {
+      if (data is bool) return data as T;
+      if (data is String) {
+        final lower = data.toLowerCase();
+        if (lower == 'true' || lower == '1') return true as T;
+        if (lower == 'false' || lower == '0') return false as T;
+      }
+      if (data is int) return (data != 0) as T;
+      throw Exception('Cannot convert $data to bool');
+    }
+    
+    // Se il tipo è dynamic o Object, ritorna direttamente
+    if (T == dynamic || T == Object) {
+      return data as T;
+    }
+    
     throw UnsupportedError('Unsupported native type $T');
   }
 }

package/dist/swagger-downloader.js

@@ -1,9 +1,36 @@
 import fetch from 'node-fetch';
+import { logger } from './utils/logger.js';
+import { SwaggerValidator } from './utils/swagger-validator.js';
 const settings = { method: "Get" };
 export class SwaggerDownloader {
     async download(swaggerJsonUrl) {
-        let response = await fetch(swaggerJsonUrl, settings);
-        let json = await response.json();
-        return json;
+        try {
+            logger.progress(`Downloading Swagger from: ${swaggerJsonUrl}`);
+            const response = await fetch(swaggerJsonUrl, settings);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const json = await response.json();
+            // Validate the downloaded swagger document
+            if (!SwaggerValidator.isValidSwaggerDocument(json)) {
+                throw new Error('Downloaded document is not a valid Swagger/OpenAPI specification');
+            }
+            // Normalize openapi field to openApi (camelCase) if needed
+            const jsonAny = json;
+            if (jsonAny.openapi && !jsonAny.openApi) {
+                jsonAny.openApi = jsonAny.openapi;
+            }
+            if (jsonAny.swagger && !jsonAny.openApi) {
+                jsonAny.openApi = jsonAny.swagger;
+            }
+            const swagger = jsonAny;
+            SwaggerValidator.validate(swagger);
+            logger.success(`Swagger document downloaded successfully`);
+            return swagger;
+        }
+        catch (error) {
+            logger.error(`Failed to download Swagger from ${swaggerJsonUrl}`, error);
+            throw error;
+        }
     }
 }

package/dist/utils/logger.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Centralized logging utility for the Swagger Generator
+ * Provides consistent logging with levels and formatting
+ */
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3,
+    SILENT = 4
+}
+export declare class Logger {
+    private static instance;
+    private logLevel;
+    private constructor();
+    static getInstance(): Logger;
+    setLogLevel(level: LogLevel): void;
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, error?: any): void;
+    success(message: string): void;
+    progress(message: string): void;
+}
+export declare const logger: Logger;

package/dist/utils/logger.js

@@ -0,0 +1,63 @@
+/**
+ * Centralized logging utility for the Swagger Generator
+ * Provides consistent logging with levels and formatting
+ */
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+    LogLevel[LogLevel["SILENT"] = 4] = "SILENT";
+})(LogLevel || (LogLevel = {}));
+export class Logger {
+    static instance;
+    logLevel = LogLevel.INFO;
+    constructor() { }
+    static getInstance() {
+        if (!Logger.instance) {
+            Logger.instance = new Logger();
+        }
+        return Logger.instance;
+    }
+    setLogLevel(level) {
+        this.logLevel = level;
+    }
+    debug(message, ...args) {
+        if (this.logLevel <= LogLevel.DEBUG) {
+            console.debug(`[DEBUG] ${message}`, ...args);
+        }
+    }
+    info(message, ...args) {
+        if (this.logLevel <= LogLevel.INFO) {
+            console.info(`[INFO] ${message}`, ...args);
+        }
+    }
+    warn(message, ...args) {
+        if (this.logLevel <= LogLevel.WARN) {
+            console.warn(`[WARN] ${message}`, ...args);
+        }
+    }
+    error(message, error) {
+        if (this.logLevel <= LogLevel.ERROR) {
+            if (error) {
+                console.error(`[ERROR] ${message}`, error);
+            }
+            else {
+                console.error(`[ERROR] ${message}`);
+            }
+        }
+    }
+    success(message) {
+        if (this.logLevel <= LogLevel.INFO) {
+            console.info(`✓ ${message}`);
+        }
+    }
+    progress(message) {
+        if (this.logLevel <= LogLevel.INFO) {
+            console.info(`→ ${message}`);
+        }
+    }
+}
+// Export singleton instance
+export const logger = Logger.getInstance();

package/dist/utils/swagger-validator.d.ts

@@ -0,0 +1,19 @@
+import { Swagger } from '../models/swagger/swagger.js';
+/**
+ * Validates Swagger/OpenAPI specification
+ * Ensures the document has required fields before processing
+ */
+export declare class SwaggerValidator {
+    /**
+     * Validates a Swagger document structure
+     * @param swagger - The Swagger document to validate
+     * @throws Error if validation fails
+     */
+    static validate(swagger: any): void;
+    /**
+     * Checks if the Swagger document is likely valid without throwing
+     * @param obj - Object to check
+     * @returns true if it looks like a valid Swagger document
+     */
+    static isValidSwaggerDocument(obj: any): obj is Swagger;
+}

package/dist/utils/swagger-validator.js

@@ -0,0 +1,76 @@
+import { logger } from './logger.js';
+/**
+ * Validates Swagger/OpenAPI specification
+ * Ensures the document has required fields before processing
+ */
+export class SwaggerValidator {
+    /**
+     * Validates a Swagger document structure
+     * @param swagger - The Swagger document to validate
+     * @throws Error if validation fails
+     */
+    static validate(swagger) {
+        const errors = [];
+        // Check required top-level fields (support both openapi and openApi)
+        const version = swagger.openapi || swagger.swagger || swagger.openApi;
+        if (!version) {
+            errors.push('Missing openapi/swagger version field');
+        }
+        if (!swagger.paths || Object.keys(swagger.paths).length === 0) {
+            errors.push('Missing or empty paths object');
+        }
+        if (!swagger.info) {
+            errors.push('Missing info object');
+        }
+        else {
+            if (!swagger.info.title) {
+                errors.push('Missing info.title');
+            }
+            if (!swagger.info.version) {
+                errors.push('Missing info.version');
+            }
+        }
+        // Check components
+        if (!swagger.components && !swagger.definitions) {
+            logger.warn('No components/definitions found - model generation may be limited');
+        }
+        // Validate paths structure
+        if (swagger.paths) {
+            for (const [path, methods] of Object.entries(swagger.paths)) {
+                if (!methods || typeof methods !== 'object') {
+                    errors.push(`Invalid path definition for: ${path}`);
+                    continue;
+                }
+                const validMethods = ['get', 'post', 'put', 'delete', 'patch', 'options', 'head'];
+                const pathMethods = Object.keys(methods);
+                if (pathMethods.length === 0) {
+                    errors.push(`No HTTP methods defined for path: ${path}`);
+                }
+                for (const method of pathMethods) {
+                    if (!validMethods.includes(method.toLowerCase())) {
+                        logger.warn(`Unexpected HTTP method '${method}' in path: ${path}`);
+                    }
+                }
+            }
+        }
+        // If there are errors, throw
+        if (errors.length > 0) {
+            const errorMessage = `Swagger validation failed:\n${errors.map(e => `  - ${e}`).join('\n')}`;
+            logger.error(errorMessage);
+            throw new Error(errorMessage);
+        }
+        logger.success('Swagger document validation passed');
+    }
+    /**
+     * Checks if the Swagger document is likely valid without throwing
+     * @param obj - Object to check
+     * @returns true if it looks like a valid Swagger document
+     */
+    static isValidSwaggerDocument(obj) {
+        return obj &&
+            typeof obj === 'object' &&
+            (obj.openApi || obj.openapi || obj.swagger) &&
+            obj.paths &&
+            typeof obj.paths === 'object';
+    }
+}

package/package.json

@@ -1,15 +1,17 @@
 {
   "name": "@devlearning/swagger-generator",
-  "version": "1.1.9",
+  "version": "1.1.11",
   "description": "Swagger generator apis and models for Angular and NextJS",
   "main": "index.js",
   "type": "module",
   "scripts": {
+    "build": "npx tsc && npm run copy-templates",
     "debug-angular": "npx tsx src/index.ts --url http://localhost:5208/swagger/v1/swagger.json --output autogen --target angular --dateTimeLibrary moment",
     "debug-nextjs": "npx tsx src/index.ts --url http://localhost:7550/swagger/ApiGateway/swagger.json --output autogen --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",
     "copy-templates": "copyfiles -u 3 \"src/generators-writers/dart/templates/**/*\" dist/generators-writers/dart",
-    "deploy": "npx tsc && npm publish"
+    "prepublishOnly": "npm run build",
+    "deploy": "npm publish"
   },
   "bin": {
     "swgen": "./dist/index.js"

package/src/generator.ts

@@ -19,6 +19,7 @@ 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';
+import { logger } from './utils/logger.js';
 
 const contentTypeApplicationJson = 'application/json';
 const contentTypeMultipartFormData = 'multipart/form-data';
@@ -52,7 +53,7 @@ export class Generator {
   }
 
   generate() {
-    console.info('%c[Swagger API Generator] %cStarting to parse Swagger JSON file...', 'color: #4CAF50; font-weight: bold;', 'color: #2196F3;');
+    logger.info('Starting Swagger API generation...');
 
     Utils.clearDirectory(this._commandLineArgs.outputDirectory);
 
@@ -62,7 +63,7 @@ export class Generator {
     this.generateModel();
     this.generateApi();
 
-    console.info('%c[Swagger Generator] %cSwagger file generated successfully!', 'color: #4CAF50; font-weight: bold;', 'color: #00C853;');
+    logger.success('Swagger generation completed successfully!');
   }
 
   computeApi() {
@@ -102,21 +103,6 @@ export class Generator {
       const apiMethod = Object.getOwnPropertyNames(apiSwaggerMethodKey)[0];
       const apiSwaggerMethod = apiSwaggerMethodKey[apiMethod];
 
-      //   const parametersRefType = apiSwaggerMethod.parameters?.filter(x => x.in == 'query' && x.schema?.$ref != null).map(x => x.schema.$ref.replace('#/components/schemas/', ''));
-      //   if (parametersRefType) {
-      //     usedTypes = usedTypes.concat(parametersRefType);
-      //   }
-
-      //   const responseRefType = this.computeRequestBodyType(apiSwaggerMethod!);
-      //   if (responseRefType && !responseRefType.isVoid && !responseRefType.isNativeType) {
-      //     usedTypes = usedTypes.concat(responseRefType.typeName);
-      //   }
-
-      //   const contentRefType = this.computeResponseType(apiSwaggerMethod!);
-      //   if (contentRefType && !contentRefType.isVoid && !contentRefType.isNativeType) {
-      //     usedTypes = usedTypes.concat(contentRefType.typeName);
-      //   }
-
       if (apiSwaggerMethod.requestBody?.content[contentTypeMultipartFormData]?.schema != null) {
         usedMultiPart.push(apiName);
       }
@@ -125,18 +111,12 @@ export class Generator {
     for (let index = 0; index < this._apis.length; index++) {
       if (this._apis[index].returnType && this._apis[index].returnType!.isTypeReference) {
         usedTypes.push(this._apis[index].returnType!);
-        // if (this._apis[index].returnType!.typeName.startsWith("hotac_")) {
-        //   debugger
-        // }
       }
 
       if (this._apis[index].parameters) {
         this._apis[index].parameters.forEach(parameter => {
           if (parameter.isTypeReference) {
             usedTypes.push(parameter);
-            // if (parameter.typeName.startsWith("hotac_")) {
-            //   debugger
-            // }
           }
         });
       }
@@ -328,8 +308,8 @@ export class Generator {
           isNativeType: false,
         };
     } catch (error) {
-      const errorMessage = "\t\tAttenzione forse hai dimenticato IActionResult e non hai tipizzato il tipo restituito dal servizio";
-      console.error(`%c${errorMessage}`, 'color: red');
+      const errorMessage = "Make sure your API endpoint uses IActionResult with a typed return value";
+      logger.error(errorMessage, error);
       throw new Error(errorMessage);
     }
 
@@ -502,7 +482,7 @@ export class Generator {
           value: swaggerCopmponent.enum[index].split('-')[1].trim(),
         });
       } catch (error) {
-        debugger
+        logger.error(`Error parsing enum value at index ${index}:`, swaggerCopmponent.enum[index]);
       }
 
     }
@@ -522,9 +502,9 @@ export class Generator {
     if (!swaggerComponent.properties) return;
 
     for (let j = 0; j < Object.getOwnPropertyNames(swaggerComponent.properties).length; j++) {
+      const propertyName = Object.getOwnPropertyNames(swaggerComponent.properties)[j];
+      
       try {
-        const propertyName = Object.getOwnPropertyNames(swaggerComponent.properties)[j];
-
         let nestedUsedType = '';
 
         if (!swaggerComponent.properties[propertyName]) continue;
@@ -552,7 +532,7 @@ export class Generator {
           this.retrieveNestedObjectsRecursive(nested, usedTypes);
         }
       } catch (error) {
-        debugger
+        logger.error(`Error processing nested object for property ${propertyName}`, error);
       }
     }
   }
@@ -561,7 +541,8 @@ export class Generator {
     let nativeType = 'n.d.';
 
     if (schema.$ref != null) {
-      debugger
+      logger.error('Unexpected $ref in getNativeType:', schema.$ref);
+      throw new Error(`Schema with $ref should not be processed as native type: ${schema.$ref}`);
     } else if (schema.type == 'array' && schema.items != null) {
       nativeType = this.getNativeType(schema.items);
       nativeType += '[]';
@@ -580,8 +561,8 @@ export class Generator {
     if (nativeType.indexOf('n.d') == -1) {
       return nativeType;
     } else {
-      console.error("unmanaged schema type", schema);
-      throw new Error("unmanaged schema");
+      logger.error("Unmanaged schema type", schema);
+      throw new Error("Unmanaged schema type");
     }
   }
 

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

@@ -10,6 +10,7 @@ import { ImportDefinitionDart } from './models/import-definition-dart.js';
 import { Normalizator } from './normalizator.js';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import { logger } from '@src/utils/logger.js';
 
 interface ApiDefinitionDart {
   package: string;
@@ -60,7 +61,7 @@ export class ApiDartWriter {
     const grouped = this._groupByTag(apis);
 
     for (const [tag, apis] of Object.entries(grouped)) {
-      console.log(`Api: ${tag}`);
+      logger.progress(`Generating Dart API: ${tag}`);
 
       let subPath = '';
       let filename = '';
@@ -103,11 +104,6 @@ export class ApiDartWriter {
           methodName = Utils.toFirstLetterLowercase(methodName);
         }
 
-        // console.debug(`\tAPI - ${apiName} - ${apiMethod}`);
-        if (methodName.toLowerCase().indexOf("productsave") >= 0) {
-          debugger
-        }
-
         const endpoint = <EndpointDefinitionDart>{
           methodName: methodName,
           httpMethod: api.method.toLowerCase() as HttpMethodDart,

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

@@ -30,7 +30,7 @@ class {{apiClassName}} {
       {{/haveRequest}}
     );
     {{#isResponseNativeType}}
-    return parseNative<{{responseType}}>(response.data);
+    return _parseNative<{{responseType}}>(response.data);
     {{/isResponseNativeType}}
     {{^isResponseNativeType}}
     return {{responseType}}.fromJson(response.data);
@@ -39,11 +39,40 @@ class {{apiClassName}} {
 
   {{/endpoints}}
 
-  T parseNative<T>(dynamic data) {
-    if (T == int) return int.parse(data.toString()) as T;
-    if (T == double) return double.parse(data.toString()) as T;
-    if (T == String) return data as T;
-    if (T == bool) return data as T;
+  T _parseNative<T>(dynamic data) {
+    if (data == null) {
+      throw Exception('Cannot parse null data as $T');
+    }
+    
+    if (T == String) {
+      return data.toString() as T;
+    }
+    if (T == int) {
+      if (data is int) return data as T;
+      if (data is double) return data.toInt() as T;
+      return int.parse(data.toString()) as T;
+    }
+    if (T == double) {
+      if (data is double) return data as T;
+      if (data is int) return data.toDouble() as T;
+      return double.parse(data.toString()) as T;
+    }
+    if (T == bool) {
+      if (data is bool) return data as T;
+      if (data is String) {
+        final lower = data.toLowerCase();
+        if (lower == 'true' || lower == '1') return true as T;
+        if (lower == 'false' || lower == '0') return false as T;
+      }
+      if (data is int) return (data != 0) as T;
+      throw Exception('Cannot convert $data to bool');
+    }
+    
+    // Se il tipo è dynamic o Object, ritorna direttamente
+    if (T == dynamic || T == Object) {
+      return data as T;
+    }
+    
     throw UnsupportedError('Unsupported native type $T');
   }
 }