@devlearning/swagger-generator 1.1.8 → 1.1.10

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');
   }
 }

package/src/swagger-downloader.ts

@@ -1,12 +1,46 @@
 import fetch, { RequestInit } from 'node-fetch';
 import { Swagger } from "./models/swagger/swagger.js";
+import { logger } from './utils/logger.js';
+import { SwaggerValidator } from './utils/swagger-validator.js';
 
 const settings: RequestInit = { method: "Get" };
 
 export class SwaggerDownloader {
-    async download(swaggerJsonUrl: URL) {
-        let response = await fetch(swaggerJsonUrl, settings);
-        let json = await response.json();
-        return <Swagger>json;
+    async download(swaggerJsonUrl: URL): Promise<Swagger> {
+        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 as any;
+            if (jsonAny.openapi && !jsonAny.openApi) {
+                jsonAny.openApi = jsonAny.openapi;
+            }
+            if (jsonAny.swagger && !jsonAny.openApi) {
+                jsonAny.openApi = jsonAny.swagger;
+            }
+
+            const swagger = jsonAny as Swagger;
+            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/src/utils/logger.ts

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

package/src/utils/swagger-validator.ts

@@ -0,0 +1,89 @@
+import { Swagger } from '../models/swagger/swagger.js';
+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: any): void {
+    const errors: string[] = [];
+
+    // 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: any): obj is Swagger {
+    return obj &&
+           typeof obj === 'object' &&
+           (obj.openApi || obj.openapi || obj.swagger) &&
+           obj.paths &&
+           typeof obj.paths === 'object';
+  }
+}