@devlearning/swagger-generator 1.0.11 → 1.0.13

package/dist/generator.js

@@ -3,13 +3,15 @@ import { ApiAngularWriter } from './generators-writers/angular/api-angular-write
 import { SingleBar, Presets } from 'cli-progress';
 import { ModelNextJsWriter } from './generators-writers/nextjs/model-nextjs-writer.js';
 import { ModelAngularWriter } from './generators-writers/angular/model-angular-writer.js';
+import { 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';
 const contentTypeApplicationJson = 'application/json';
 const contentTypeMultipartFormData = 'multipart/form-data';
 export class Generator {
     _swagger;
-    _outputDirectory;
-    _outputFormat;
-    _dateLibrary;
+    _commandLineArgs;
     _apis = [];
     _models = [];
     _barApis = new SingleBar({
@@ -26,18 +28,17 @@ export class Generator {
         hideCursor: true,
         barsize: 20,
     }, Presets.shades_classic);
-    constructor(swagger, outputDirectory, outputFormat, dateLibrary) {
+    constructor(swagger, commandLineArgs) {
         this._swagger = swagger;
-        this._outputDirectory = outputDirectory;
-        this._outputFormat = outputFormat;
-        this._dateLibrary = dateLibrary;
+        this._commandLineArgs = commandLineArgs;
     }
     generate() {
         console.info('%c[Swagger API Generator] %cStarting to parse Swagger JSON file...', 'color: #4CAF50; font-weight: bold;', 'color: #2196F3;');
+        Utils.clearDirectory(this._commandLineArgs.outputDirectory);
         this.computeApi();
-        this.generateApi();
         this.computeModel();
         this.generateModel();
+        this.generateApi();
         console.info('%c[Swagger Generator] %cSwagger file generated successfully!', 'color: #4CAF50; font-weight: bold;', 'color: #00C853;');
     }
     computeApi() {
@@ -59,6 +60,7 @@ export class Generator {
                 swaggerMethod: apiSwaggerMethod,
                 haveRequest: apiSwaggerMethod.requestBody != null,
                 isMultiPart: apiSwaggerMethod.requestBody != null && apiSwaggerMethod.requestBody.content[contentTypeMultipartFormData] != null,
+                tag: apiSwaggerMethod.tags && apiSwaggerMethod.tags.length > 0 ? apiSwaggerMethod.tags[0] : 'default',
             };
             this._apis.push(apiDto);
         }
@@ -109,6 +111,7 @@ export class Generator {
                 const swaggerComponent = this._swagger.components.schemas[modelName];
                 // console.debug(`\tModel - ${modelName}`);
                 this._models.push({
+                    typeName: modelName,
                     modelType: swaggerComponent.type == 'integer' ? 'enum' : 'class',
                     name: modelName,
                     properties: (swaggerComponent.type == 'object') ? this.retrieveComponentProperties(swaggerComponent) : [],
@@ -121,6 +124,7 @@ export class Generator {
             const method = Object.getOwnPropertyNames(swaggerMethod)[0];
             const swaggerMethodInfo = swaggerMethod[method];
             this._models.push({
+                typeName: this.getApiNameNormalized(apiName),
                 modelType: 'class',
                 name: this.getApiNameNormalized(apiName),
                 properties: this.retrieveComponentProperties(swaggerMethodInfo.requestBody.content[contentTypeMultipartFormData].schema),
@@ -130,28 +134,36 @@ export class Generator {
     }
     generateApi() {
         this._barApis.update(this._apis.length, { message: `Api generating...` });
-        if (this._outputFormat == 'angular') {
-            const apiWriter = new ApiAngularWriter(this._outputDirectory);
+        if (this._commandLineArgs.target == TargetGeneration.Angular) {
+            const apiWriter = new ApiAngularWriter(this._commandLineArgs.outputDirectory);
             apiWriter.write(this._apis);
         }
-        else if (this._outputFormat == 'next') {
-            const apiWriter = new ApiNextJsWriter(this._outputDirectory);
+        else if (this._commandLineArgs.target == TargetGeneration.Next) {
+            const apiWriter = new ApiNextJsWriter(this._commandLineArgs.outputDirectory);
             apiWriter.write(this._apis);
         }
-        this._barApis.update(this._apis.length, { message: `Api gerated` });
+        else if (this._commandLineArgs.target == TargetGeneration.Dart) {
+            const apiWriter = new ApiDartWriter(this._commandLineArgs);
+            apiWriter.write(this._apis, this._models);
+        }
+        this._barApis.update(this._apis.length, { message: `Api was generated successfully` });
         this._barApis.stop();
     }
     generateModel() {
         this._barModels.update(this._apis.length, { message: `Model generation...` });
-        if (this._outputFormat == 'angular') {
-            const apiWriter = new ModelAngularWriter(this._outputDirectory);
+        if (this._commandLineArgs.target == TargetGeneration.Angular) {
+            const apiWriter = new ModelAngularWriter(this._commandLineArgs.outputDirectory);
+            apiWriter.write(this._models);
+        }
+        else if (this._commandLineArgs.target == TargetGeneration.Next) {
+            const apiWriter = new ModelNextJsWriter(this._commandLineArgs.outputDirectory);
             apiWriter.write(this._models);
         }
-        else if (this._outputFormat == 'next') {
-            const apiWriter = new ModelNextJsWriter(this._outputDirectory);
+        else if (this._commandLineArgs.target == TargetGeneration.Dart) {
+            const apiWriter = new ModelDartWriter(this._commandLineArgs);
             apiWriter.write(this._models);
         }
-        this._barModels.update(this._apis.length, { message: `Model generated` });
+        this._barModels.update(this._apis.length, { message: `Model was generated successfully` });
         this._barModels.stop();
     }
     computeParameters(apiName, swaggerMethod) {
@@ -177,9 +189,10 @@ export class Generator {
             }
             else {
                 if (swaggerMethod.requestBody != null) {
+                    const type = this.retrieveType(swaggerMethod.requestBody.content[contentTypeApplicationJson].schema);
                     parameters.push({
                         name: 'request',
-                        typeName: swaggerMethod.requestBody.content[contentTypeApplicationJson].schema.$ref.replace('#/components/schemas/', ''),
+                        typeName: type.typeName,
                         nullable: false,
                         isQuery: false,
                         isEnum: false,
@@ -192,9 +205,10 @@ export class Generator {
                 else {
                     swaggerMethod.parameters?.filter(x => x.in == 'query').forEach(parameter => {
                         if (parameter.schema.$ref != null) {
+                            const type = this.retrieveType(parameter.schema);
                             parameters.push({
                                 name: this.toFirstLetterLowercase(parameter.name),
-                                typeName: parameter.schema.$ref.replace('#/components/schemas/', ''),
+                                typeName: type.typeName,
                                 nullable: !parameter.required,
                                 swaggerParameter: parameter,
                                 isQuery: true,
@@ -265,7 +279,7 @@ export class Generator {
         if (swaggerContent.schema.type != null) {
             let schema = swaggerContent.schema;
             if (schema.type == 'array') {
-                if (schema.items.$ref != null) {
+                if (schema.items?.$ref != null) {
                     return {
                         typeName: `${this.getObjectName(schema.items.$ref)}`,
                         nullable: false,
@@ -293,7 +307,7 @@ export class Generator {
         }
     }
     retrieveType(swaggerComponentProperty) {
-        if (swaggerComponentProperty.$ref != null)
+        if (swaggerComponentProperty.$ref != null) {
             return {
                 typeName: swaggerComponentProperty.$ref.replace('#/components/schemas/', ''),
                 isTypeReference: true,
@@ -302,8 +316,16 @@ export class Generator {
                 isArray: false,
                 isVoid: false,
             };
-        if (swaggerComponentProperty.type != null && swaggerComponentProperty.type == 'array')
-            if (swaggerComponentProperty.items.$ref != null)
+        }
+        if (swaggerComponentProperty.allOf != null) {
+            const type = this.retrieveType(swaggerComponentProperty.allOf[0]); //TODO per ora prendo solo il primo, ma potrebbe essere un array di tipi
+            return {
+                ...type,
+                nullable: swaggerComponentProperty.nullable ?? false,
+            };
+        }
+        if (swaggerComponentProperty.type != null && swaggerComponentProperty.type == 'array') {
+            if (swaggerComponentProperty.items?.$ref != null) {
                 return {
                     typeName: `${this.getObjectName(swaggerComponentProperty.items.$ref)}`,
                     isTypeReference: true,
@@ -312,7 +334,8 @@ export class Generator {
                     isArray: true,
                     isVoid: false,
                 };
-            else
+            }
+            else {
                 return {
                     typeName: this.getNativeType(swaggerComponentProperty),
                     isTypeReference: false,
@@ -321,7 +344,9 @@ export class Generator {
                     isArray: false,
                     isVoid: false,
                 };
-        if (swaggerComponentProperty.type != null)
+            }
+        }
+        if (swaggerComponentProperty.type != null) {
             return {
                 typeName: this.getNativeType(swaggerComponentProperty),
                 isTypeReference: false,
@@ -330,7 +355,8 @@ export class Generator {
                 isArray: false,
                 isVoid: false,
             };
-        if (swaggerComponentProperty.type == null)
+        }
+        if (swaggerComponentProperty.type == null) {
             return {
                 typeName: 'void',
                 isTypeReference: false,
@@ -339,6 +365,7 @@ export class Generator {
                 isArray: false,
                 isVoid: true,
             };
+        }
         console.error("unmanaged swaggerMethodInfo", swaggerComponentProperty);
         throw new Error("unmanaged swaggerMethodInfo");
     }
@@ -410,10 +437,15 @@ export class Generator {
             for (let j = 0; j < Object.getOwnPropertyNames(swaggerComponent.properties).length; j++) {
                 const propertyName = Object.getOwnPropertyNames(swaggerComponent.properties)[j];
                 let nestedUsedType = '';
-                if (swaggerComponent.properties[propertyName].$ref != null) {
+                if (!swaggerComponent.properties[propertyName])
+                    continue;
+                if (swaggerComponent.properties[propertyName].$ref) {
                     nestedUsedType = swaggerComponent.properties[propertyName].$ref.replace('#/components/schemas/', '');
                 }
-                else if (swaggerComponent.properties[propertyName].type == 'array' && swaggerComponent.properties[propertyName].items.$ref != null) {
+                else if (swaggerComponent.properties[propertyName].allOf && swaggerComponent.properties[propertyName].allOf[0] && swaggerComponent.properties[propertyName].allOf[0].$ref) {
+                    nestedUsedType = swaggerComponent.properties[propertyName].allOf[0].$ref.replace('#/components/schemas/', ''); //TODO Assuming allOf contains a single $ref
+                }
+                else if (swaggerComponent.properties[propertyName].type == 'array' && swaggerComponent.properties[propertyName].items?.$ref) {
                     nestedUsedType = swaggerComponent.properties[propertyName].items.$ref.replace('#/components/schemas/', '');
                 }
                 if (nestedUsedType != '' && usedTypes.findIndex(x => x.typeName == nestedUsedType) == -1) {
@@ -440,7 +472,7 @@ export class Generator {
         if (schema.$ref != null) {
             debugger;
         }
-        else if (schema.type == 'array') {
+        else if (schema.type == 'array' && schema.items != null) {
             nativeType = this.getNativeType(schema.items);
             nativeType += '[]';
         }
@@ -450,7 +482,7 @@ export class Generator {
             if (schema.type == 'string' && schema.format == null)
                 nativeType = 'string';
             if (schema.type == 'string' && schema.format == 'date-time')
-                nativeType = this._dateLibrary == 'moment' ? 'moment.Moment' : 'Date';
+                nativeType = this._commandLineArgs.dateTimeLibrary == DateTimeLibrary.Moment ? 'moment.Moment' : 'Date';
             if (schema.type == 'string' && schema.format == 'uuid')
                 nativeType = 'string';
             if (schema.type == 'string' && schema.format == 'binary')

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

@@ -14,7 +14,7 @@ export class ApiAngularWriter {
         this._writeFile(apiString);
     }
     _apiString(api) {
-        let apiNameNormalized = Utils.getApiNameNormalized(api.name);
+        let apiNameNormalized = Utils.getNormalizedApiPath(api.name);
         let parametersString = this._parameters(api);
         let queryParametersPreparation = this._queryParametersPreparation(api);
         let requestPreparation = this._requestPreparation(api);

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

@@ -0,0 +1,110 @@
+import fs, { writeFileSync } from 'fs';
+import { Utils } from '../utils.js';
+import * as Mustache from 'mustache';
+import { Normalizator } from './normalizator.js';
+export class ApiDartWriter {
+    _commandLineArgs;
+    constructor(commandLineArgs) {
+        this._commandLineArgs = commandLineArgs;
+    }
+    write(apis, models) {
+        const template = fs.readFileSync('src/generators-writers/dart/templates/api.mustache', 'utf-8');
+        const grouped = this._groupByTag(apis);
+        for (const [tag, apis] of Object.entries(grouped)) {
+            console.log(`Api: ${tag}`);
+            let subPath = '';
+            let filename = '';
+            let apiClassName = '';
+            subPath = Utils.toDartFileName(tag);
+            filename = `${Utils.toDartFileName(tag + 'Api')}`;
+            apiClassName = `${Utils.toDartClassName(tag + 'Api')}`;
+            var apiDefinition = {
+                package: this._commandLineArgs.package,
+                outputDirectory: this._commandLineArgs.outputDirectory,
+                filename: filename,
+                apiClassName: apiClassName,
+            };
+            var endpoints = [];
+            var imports = [];
+            for (const api of apis) {
+                var requestType = undefined;
+                requestType = api.haveRequest ? api.parameters[0]?.typeName || 'void' : undefined;
+                requestType = requestType?.split('.').pop();
+                requestType = Utils.toDartClassName(requestType);
+                var responseType = 'void';
+                responseType = api.returnType ? api.returnType.typeName : 'void';
+                responseType = responseType?.split('.').pop();
+                responseType = Utils.toDartClassName(responseType) ?? responseType;
+                var methodName = Utils.getNormalizedApiPath(api.name);
+                if (methodName.startsWith(Utils.toFirstLetterLowercase(tag))) {
+                    methodName = methodName.slice(tag.length);
+                    methodName = Utils.toFirstLetterLowercase(methodName);
+                }
+                const endpoint = {
+                    methodName: methodName,
+                    httpMethod: api.method.toLowerCase(),
+                    path: api.url,
+                    responseType: responseType,
+                    haveRequest: api.haveRequest,
+                    requestType: requestType,
+                    isGet: api.method.toLowerCase() === 'get'
+                };
+                if (api.haveRequest && api.parameters[0]?.typeName) {
+                    if (imports.findIndex(x => x.type.typeName == api.parameters[0]?.typeName) == -1) {
+                        models.forEach(model => {
+                            if (model.typeName === api.parameters[0]?.typeName) {
+                                const normalizedInfo = Normalizator.getNormalizedInfo(model);
+                                imports.push({
+                                    type: api.parameters[0],
+                                    import: `import 'package:${this._commandLineArgs.package}/${this._commandLineArgs.outputDirectory}/${normalizedInfo.subPath}/${normalizedInfo.filename}.dart';`
+                                });
+                            }
+                        });
+                    }
+                }
+                if (api.returnType && !api.returnType.isNativeType) {
+                    if (imports.findIndex(x => x.type.typeName == api.returnType.typeName) == -1) {
+                        models.forEach(model => {
+                            if (model.typeName === api.returnType.typeName) {
+                                const normalizedInfo = Normalizator.getNormalizedInfo(model);
+                                imports.push({
+                                    type: api.returnType,
+                                    import: `import 'package:${this._commandLineArgs.package}/${this._commandLineArgs.outputDirectory}/${normalizedInfo.subPath}/${normalizedInfo.filename}.dart';`
+                                });
+                            }
+                        });
+                    }
+                }
+                endpoints.push(endpoint);
+            }
+            apiDefinition.endpoints = endpoints;
+            apiDefinition.imports = imports.map(i => i.import);
+            let destinationPath = `${this._commandLineArgs.outputDirectory}/${subPath}/api`;
+            Utils.ensureDirectorySync(`${destinationPath}`);
+            var result = Mustache.default.render(template, apiDefinition);
+            writeFileSync(`${destinationPath}/${apiDefinition.filename}.dart`, result, 'utf-8');
+        }
+    }
+    _toPascalCase(input) {
+        return input
+            .replace(/[_\- ]+/g, ' ') // sostituisce underscore, dash e spazi con uno spazio singolo
+            .trim() // rimuove spazi iniziali/finali
+            .split(' ') // divide in parole
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join('');
+    }
+    _normalizeApiClassName(input) {
+        return input
+            .replace(/\./g, '');
+    }
+    _groupByTag(apis) {
+        const groupedByRole = apis.reduce((acc, api) => {
+            if (!acc[api.tag]) {
+                acc[api.tag] = [];
+            }
+            acc[api.tag].push(api);
+            return acc;
+        }, {});
+        return groupedByRole;
+    }
+}

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

@@ -0,0 +1,124 @@
+import { readFileSync, writeFileSync } from 'fs';
+import * as Mustache from 'mustache';
+import { Utils } from '../utils.js';
+import { Normalizator } from './normalizator.js';
+export class ModelDartWriter {
+    _commandLineArgs;
+    constructor(commandLineArgs) {
+        this._commandLineArgs = commandLineArgs;
+    }
+    write(models) {
+        const template = readFileSync('src/generators-writers/dart/templates/model.mustache', 'utf-8');
+        models.forEach(model => {
+            const normalizedInfo = Normalizator.getNormalizedInfo(model);
+            const dartModel = {
+                filename: normalizedInfo.filename,
+                path: this._commandLineArgs.outputDirectory,
+                modelName: normalizedInfo.modelName,
+                fields: [],
+                imports: [],
+            };
+            var imports = [];
+            model.properties.forEach(property => {
+                var fieldTypeName = this._mapTsTypeToDart(property.typeName);
+                //         if (fieldTypeName.endsWith('Exception')) {
+                // debugger
+                //         }
+                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}/${this._commandLineArgs.outputDirectory}/${normalizedInfo.subPath}/${normalizedInfo.filename}.dart';`
+                                });
+                            }
+                        });
+                    }
+                }
+                dartModel.fields.push({
+                    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);
+    }
+    _mapTsTypeToDart(type) {
+        const normalized = type.trim().toLowerCase();
+        if (normalized.endsWith("[]")) {
+            const inner = normalized.slice(0, -2).trim();
+            return `List<${this._mapTsTypeToDart(inner)}>`;
+        }
+        switch (normalized) {
+            case "string":
+            case "uuid":
+            case "date":
+            case "datetime":
+                return "String";
+            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/dist/generators-writers/dart/models/import-definition-dart.js

@@ -0,0 +1 @@
+export {};

package/dist/generators-writers/dart/normalizator.js

@@ -0,0 +1,35 @@
+import { Utils } from "../utils.js";
+export class Normalizator {
+    // public static normalizeModelName(modelName: string): string {
+    //      let normalizeModelName = modelName.split('.').pop()!;
+    //       return Utils.toDartClassName(filename) ?? filename;
+    //   }
+    //   subPath = model.name.split('.').slice(0, -1).join('');
+    //           subPath = `${Utils.toDartFileName(subPath)}/models`;
+    static getNormalizedInfo(model) {
+        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,
+        };
+    }
+    static getNormalizedTypeName(typeName) {
+        let formattedTypeName = typeName.split('.').pop();
+        return Utils.toDartClassName(formattedTypeName) ?? typeName;
+    }
+}

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

@@ -14,7 +14,7 @@ export class ApiNextJsWriter {
         this._writeFile(apiString);
     }
     _apiString(api) {
-        let apiNameNormalized = Utils.toCamelCase(Utils.getApiNameNormalized(api.name));
+        let apiNameNormalized = Utils.toCamelCase(Utils.getNormalizedApiPath(api.name));
         let parametersString = this._parameters(api);
         let queryParametersPreparation = this._queryParametersPreparation(api);
         let requestPreparation = this._requestPreparation(api);

package/dist/generators-writers/utils.js

@@ -1,10 +1,16 @@
+import fs from 'fs';
+import path from 'path';
 export class Utils {
-    static getApiNameNormalized(apiName) {
+    static getNormalizedApiPath(apiName) {
         let normalizedApiName = apiName.replace('/api/v{version}/', '').replaceAll('/', '_');
         if (normalizedApiName.charAt(0) == '_') {
             normalizedApiName = normalizedApiName.slice(1);
         }
-        return this.toFirstLetterLowercase(normalizedApiName);
+        normalizedApiName = normalizedApiName.replace(/-([a-zA-Z])/g, (_, char) => char.toUpperCase());
+        normalizedApiName = this.toCamelCase(normalizedApiName);
+        normalizedApiName = this.toFirstLetterLowercase(normalizedApiName);
+        normalizedApiName = normalizedApiName.replaceAll('_', '');
+        return normalizedApiName;
     }
     static toFirstLetterLowercase(value) {
         return value.charAt(0).toLowerCase() + value.slice(1);
@@ -12,9 +18,44 @@ export class Utils {
     static toCamelCase(input) {
         return input.replace(/_([a-zA-Z])/g, (_, letter) => letter.toUpperCase());
     }
+    static toPascalCase(input) {
+        return input
+            .replace(/[_\-\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ""))
+            .replace(/^(.)/, (_, c) => c.toUpperCase());
+    }
     static isDate(schema) {
         if (!schema)
             return false;
         return schema.type == 'string' && schema.format == 'date-time';
     }
+    static toDartFileName(name) {
+        return name
+            .replace(/\./g, '_') // sostituisce i punti con underscore
+            .replace(/([a-z0-9])([A-Z])/g, '$1_$2') // aggiunge _ tra camelCase
+            .toLowerCase();
+    }
+    static toDartClassName(name) {
+        if (!name)
+            return undefined;
+        return name.replace(/\./g, ''); // rimuove i punti per ottenere PascalCase
+    }
+    static async ensureDirectorySync(dirPath) {
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true });
+        }
+    }
+    static async clearDirectory(dirPath) {
+        if (!fs.existsSync(dirPath))
+            return;
+        for (const file of fs.readdirSync(dirPath)) {
+            const fullPath = path.join(dirPath, file);
+            const stat = fs.statSync(fullPath);
+            if (stat.isDirectory()) {
+                fs.rmSync(fullPath, { recursive: true, force: true });
+            }
+            else {
+                fs.unlinkSync(fullPath);
+            }
+        }
+    }
 }