@devlearning/swagger-generator 0.0.37 → 1.0.0

package/dist/generator.js

@@ -1,92 +1,97 @@
-import fs from 'fs';
-import { API_PRE, API_POST } from './api.constants.js';
-import { MODEL_POST, MODEL_PRE } from './model.constants.js';
+import { ApiNextJsWriter } from './generators-writers/nextjs/api-nextjs-writer.js';
+import { ApiAngularWriter } from './generators-writers/angular/api-angular-writer.js';
+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';
 const contentTypeApplicationJson = 'application/json';
 const contentTypeMultipartFormData = 'multipart/form-data';
 export class Generator {
     _swagger;
     _outputDirectory;
-    constructor(swagger, outputDirectory) {
+    _outputFormat;
+    _dateLibrary;
+    _apis = [];
+    _models = [];
+    _barApis = new SingleBar({
+        format: '{bar} {percentage}% | {message} {value}/{total} Elapsed: {duration_formatted}',
+        barCompleteChar: '\u2588',
+        barIncompleteChar: '\u2591',
+        hideCursor: true,
+        barsize: 20,
+    }, Presets.shades_classic);
+    _barModels = new SingleBar({
+        format: '{bar} {percentage}% | {message} {value}/{total} Elapsed: {duration_formatted}',
+        barCompleteChar: '\u2588',
+        barIncompleteChar: '\u2591',
+        hideCursor: true,
+        barsize: 20,
+    }, Presets.shades_classic);
+    constructor(swagger, outputDirectory, outputFormat, dateLibrary) {
         this._swagger = swagger;
         this._outputDirectory = outputDirectory;
+        this._outputFormat = outputFormat;
+        this._dateLibrary = dateLibrary;
     }
-    generateApi() {
-        console.debug(`Start autogeneration Apis`);
-        let apiMethods = ``;
+    generate() {
+        console.info('%c[Swagger API Generator] %cStarting to parse Swagger JSON file...', 'color: #4CAF50; font-weight: bold;', 'color: #2196F3;');
+        this.computeApi();
+        this.generateApi();
+        this.computeModel();
+        this.generateModel();
+        console.info('%c[Swagger Generator] %cSwagger file generated successfully!', 'color: #4CAF50; font-weight: bold;', 'color: #00C853;');
+    }
+    computeApi() {
+        this._barApis.start(Object.getOwnPropertyNames(this._swagger.paths).length, 0);
         for (let index = 0; index < Object.getOwnPropertyNames(this._swagger.paths).length; index++) {
             const apiName = Object.getOwnPropertyNames(this._swagger.paths)[index];
-            const swaggerMethod = this._swagger.paths[apiName];
-            const method = Object.getOwnPropertyNames(swaggerMethod)[0];
-            const swaggerMethodInfo = swaggerMethod[method];
-            console.debug(`\tAPI - ${apiName} - ${method}`);
-            let parametersString = this.retrieveParameters(swaggerMethodInfo, apiName);
-            let queryParametersDeclaration = this.retrieveQueryParametersDeclaration(swaggerMethodInfo);
-            let queryParameters = this.retrieveQueryParameters(swaggerMethodInfo);
-            let returnTypeString = this.retrieveReturnType(swaggerMethodInfo);
-            if (returnTypeString == null)
-                returnTypeString = 'void';
-            let prepareRequestString = ``; //request = this._handleRequest(request);
-            let haveRequest = swaggerMethodInfo.requestBody != null;
-            let isMultiPart = haveRequest && swaggerMethodInfo.requestBody.content[contentTypeMultipartFormData] != null;
-            let httpOptions = 'httpOptions';
-            if (haveRequest && !isMultiPart) {
-                prepareRequestString = `const wrappedRequest = this._handleRequest(request);
-	  `;
-            }
-            else if (isMultiPart) {
-                prepareRequestString = `const wrappedRequest = this._handleMultipart(request);
-	  `;
-                httpOptions = `httpOptionsMultipart`;
-            }
-            apiMethods +=
-                `
-  public ${apiName.replace('/api/v{version}/', '').replaceAll('/', '_')}(${parametersString}): Observable<${returnTypeString}> {
-    ${queryParametersDeclaration}${prepareRequestString}return this._http.${method}<${returnTypeString}>(\`\${this._baseUrl}${apiName.replace('{version}', '1')}${queryParameters}\`${haveRequest ? ', wrappedRequest' : ''}, ${httpOptions})
-      .pipe(
-        map(x => this._handleResponse(x)),
-        catchError((err, obs) => this._handleError(err, <Observable<any>>obs))
-      );
-  }
-`;
+            this._barApis.update(index, { message: `Elaborando api... ${apiName}` });
+            const apiSwaggerMethodKey = this._swagger.paths[apiName];
+            const apiMethod = Object.getOwnPropertyNames(apiSwaggerMethodKey)[0];
+            const apiSwaggerMethod = apiSwaggerMethodKey[apiMethod];
+            // console.debug(`\tAPI - ${apiName} - ${apiMethod}`);
+            let apiDto = {
+                name: apiName,
+                url: apiName.replace('{version}', '1'),
+                method: apiMethod,
+                parameters: this.computeParameters(apiName, apiSwaggerMethod),
+                returnType: this.computeReturnType(apiSwaggerMethod),
+                swaggerMethodKey: apiSwaggerMethodKey,
+                swaggerMethod: apiSwaggerMethod,
+                haveRequest: apiSwaggerMethod.requestBody != null,
+                isMultiPart: apiSwaggerMethod.requestBody != null && apiSwaggerMethod.requestBody.content[contentTypeMultipartFormData] != null,
+            };
+            this._apis.push(apiDto);
         }
-        fs.writeFileSync(this._outputDirectory + "/api.autogenerated.ts", `${API_PRE}
-${apiMethods}
-${API_POST}`, { flag: 'w' });
     }
-    generateModel() {
+    computeModel() {
+        this._barModels.start(Object.getOwnPropertyNames(this._swagger.paths).length, 0);
         let usedTypes = [];
         let usedMultiPart = [];
         for (let index = 0; index < Object.getOwnPropertyNames(this._swagger.paths).length; index++) {
             const apiName = Object.getOwnPropertyNames(this._swagger.paths)[index];
-            const swaggerMethod = this._swagger.paths[apiName];
-            const method = Object.getOwnPropertyNames(swaggerMethod)[0];
-            const swaggerMethodInfo = swaggerMethod[method];
-            if (apiName == "/api/v{version}/TicketFile/Create") {
-                debugger;
-            }
-            let parametersRefType = swaggerMethodInfo.parameters?.filter(x => x.in == 'query' && x.schema?.$ref != null).map(x => x.schema.$ref.replace('#/components/schemas/', ''));
+            const apiSwaggerMethodKey = this._swagger.paths[apiName];
+            const apiMethod = Object.getOwnPropertyNames(apiSwaggerMethodKey)[0];
+            const apiSwaggerMethod = apiSwaggerMethodKey[apiMethod];
+            // if (apiName == "/api/v{version}/TicketFile/Create") {
+            //   debugger
+            // }
+            let 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);
-                if (swaggerMethodInfo.responses[200].content[contentTypeApplicationJson]?.schema.$ref != null) {
-                    usedTypes.push(swaggerMethodInfo.responses[200].content[contentTypeApplicationJson].schema.$ref.replace('#/components/schemas/', ''));
+                this._barModels.update(index, { message: `Elaborando model... ${usedTypes}` });
+                if (apiSwaggerMethod.responses[200].content[contentTypeApplicationJson]?.schema.$ref != null) {
+                    usedTypes.push(apiSwaggerMethod.responses[200].content[contentTypeApplicationJson].schema.$ref.replace('#/components/schemas/', ''));
                 }
-                if (swaggerMethodInfo.requestBody?.content[contentTypeApplicationJson]?.schema?.$ref) {
-                    usedTypes.push(swaggerMethodInfo.requestBody?.content[contentTypeApplicationJson]?.schema?.$ref.replace('#/components/schemas/', ''));
+                if (apiSwaggerMethod.requestBody?.content[contentTypeApplicationJson]?.schema?.$ref) {
+                    usedTypes.push(apiSwaggerMethod.requestBody?.content[contentTypeApplicationJson]?.schema?.$ref.replace('#/components/schemas/', ''));
                 }
-                if (swaggerMethodInfo.requestBody?.content[contentTypeMultipartFormData]?.schema != null) {
+                if (apiSwaggerMethod.requestBody?.content[contentTypeMultipartFormData]?.schema != null) {
                     usedMultiPart.push(apiName);
                 }
             }
         }
         this.retrieveNestedObjects(usedTypes);
         usedTypes = [...new Set(usedTypes.map(item => item))]; // [ 'A', 'B']
-        // usedTypes = usedTypes.filter((value, index, array) => {
-        // 	array.indexOf(value) === index;
-        // });
-        // usedTypes.forEach(element => {
-        // 	console.debug(element);
-        // });
-        console.debug(`Start autogeneration Models`);
         let models = ``;
         if (this._swagger.components != null
             && this._swagger.components != undefined
@@ -94,155 +99,156 @@ ${API_POST}`, { flag: 'w' });
             && this._swagger.components.schemas != undefined) {
             for (let index = 0; index < Object.getOwnPropertyNames(this._swagger.components.schemas).length; index++) {
                 const modelName = Object.getOwnPropertyNames(this._swagger.components.schemas)[index];
-                if (modelName == 'ActivatedVoucherSnackListResponse') {
-                    console.debug("ActivatedVoucherSnackListResponse");
-                }
                 if (usedTypes.indexOf(modelName) < 0) {
-                    console.debug(`\tModel SKIP - ${modelName}`);
+                    // console.debug(`\tModel SKIP - ${modelName}`);
                     continue;
                 }
                 ;
-                const swaggerCopmponent = this._swagger.components.schemas[modelName];
-                console.debug(`\tModel - ${modelName}`);
-                let type = swaggerCopmponent.type == 'integer' ? 'enum' : 'class';
-                let content = this.retrieveObjectContent(modelName, swaggerCopmponent);
-                models +=
-                    `
-export ${type} ${modelName} {${content}
-}
-`;
+                const swaggerComponent = this._swagger.components.schemas[modelName];
+                // console.debug(`\tModel - ${modelName}`);
+                this._models.push({
+                    modelType: swaggerComponent.type == 'integer' ? 'enum' : 'class',
+                    name: modelName,
+                    properties: (swaggerComponent.type == 'object') ? this.retrieveComponentProperties(swaggerComponent) : [],
+                    enumValues: (swaggerComponent.type == 'integer') ? this.retrieveEnumValues(modelName, swaggerComponent) : [],
+                });
             }
         }
         usedMultiPart.forEach(apiName => {
             const swaggerMethod = this._swagger.paths[apiName];
             const method = Object.getOwnPropertyNames(swaggerMethod)[0];
             const swaggerMethodInfo = swaggerMethod[method];
-            let type = 'class';
-            let modelName = this.getModelNameByApi(apiName);
-            let content = this.retrieveSchemaProperties(swaggerMethodInfo.requestBody.content[contentTypeMultipartFormData].schema);
-            models +=
-                `
-export ${type} ${modelName} {${content}
-}
-`;
+            this._models.push({
+                modelType: 'class',
+                name: this.getApiNameNormalized(apiName),
+                properties: this.retrieveComponentProperties(swaggerMethodInfo.requestBody.content[contentTypeMultipartFormData].schema),
+                enumValues: [],
+            });
         });
-        fs.writeFileSync(this._outputDirectory + "/model.autogenerated.ts", `${MODEL_PRE}
-${models}
-${MODEL_POST}`, { flag: 'w' });
     }
-    retrieveParameters(swaggerMethodInfo, apiName) {
-        if (swaggerMethodInfo.requestBody != null && swaggerMethodInfo.requestBody.content[contentTypeMultipartFormData] != null) {
-            var modelName = this.getModelNameByApi(apiName);
-            return `request: Models.${modelName}`;
+    generateApi() {
+        this._barApis.update(this._apis.length, { message: `Inizio scrittura api...` });
+        if (this._outputFormat == 'angular') {
+            const apiWriter = new ApiAngularWriter(this._outputDirectory);
+            apiWriter.write(this._apis);
         }
-        else {
-            if (swaggerMethodInfo.requestBody != null) {
-                return `request: Models.${swaggerMethodInfo.requestBody.content[contentTypeApplicationJson].schema.$ref.replace('#/components/schemas/', '')}`;
-            }
-            let parameters = ``;
-            swaggerMethodInfo.parameters?.filter(x => x.in == 'query').forEach(parameter => {
-                if (parameter.schema.$ref != null) {
-                    parameters += `${this.toFirstLetterLowercase(parameter.name)}: Models.${parameter.schema.$ref.replace('#/components/schemas/', '')}, `;
-                }
-                else {
-                    const nativeType = this.getNativeType(parameter.schema);
-                    const nullable = !parameter.required ? '?' : '';
-                    parameters += `${this.toFirstLetterLowercase(parameter.name)}${nullable}: ${nativeType}, `;
-                }
-            });
-            if (parameters.length > 2)
-                parameters = parameters.substring(0, parameters.length - 2);
-            return parameters;
+        else if (this._outputFormat == 'next') {
+            const apiWriter = new ApiNextJsWriter(this._outputDirectory);
+            apiWriter.write(this._apis);
         }
+        this._barApis.update(this._apis.length, { message: `Scrittura api completata` });
+        this._barApis.stop();
     }
-    retrieveQueryParametersDeclaration(swaggerMethodInfo) {
-        if (swaggerMethodInfo.requestBody != null)
-            return ``;
-        let filteredParameters = swaggerMethodInfo.parameters?.filter(x => x.in == 'query');
-        if (filteredParameters == null || filteredParameters == undefined || filteredParameters.length == 0)
-            return ``;
-        let parameters = ``;
-        filteredParameters.forEach(parameter => {
-            if (parameter.schema.$ref != null) {
-                if (this.isEnum(parameter.schema.$ref) != null) {
-                    parameters += this.retrieveQueryParametersDeclarationStatement(parameter);
-                }
-                else {
-                    throw new Error("retrieveQueryParameters unmanaged parameter.schema.$ref");
-                }
-            }
-            else {
-                parameters += this.retrieveQueryParametersDeclarationStatement(parameter);
-            }
-        });
-        // if (parameters.length > 2)
-        //   parameters = parameters.substring(0, parameters.length - 1);
-        return parameters;
+    generateModel() {
+        this._barModels.update(this._apis.length, { message: `Inizio scrittura model...` });
+        if (this._outputFormat == 'angular') {
+            const apiWriter = new ModelAngularWriter(this._outputDirectory);
+            apiWriter.write(this._models);
+        }
+        else if (this._outputFormat == 'next') {
+            const apiWriter = new ModelNextJsWriter(this._outputDirectory);
+            apiWriter.write(this._models);
+        }
+        this._barModels.update(this._apis.length, { message: `Scrittura model completata` });
+        this._barModels.stop();
     }
-    retrieveQueryParametersDeclarationStatement(parameter) {
-        let paramName = this.toFirstLetterLowercase(parameter.name);
-        if (!parameter.required) {
-            if (this.isDate(parameter.schema)) {
-                return `let ${paramName}Param: string = ${paramName} != null && ${paramName} != undefined && ${paramName}.isValid() ? encodeURIComponent(this._momentToString(${paramName})) : '';
-    `;
-            }
-            else {
-                return `let ${paramName}Param: string = ${paramName} != null && ${paramName} != undefined ? encodeURIComponent('' + ${paramName}) : '';
-    `;
-            }
+    computeParameters(apiName, swaggerMethod) {
+        if (!apiName)
+            return [];
+        if (!swaggerMethod || swaggerMethod == null)
+            return [];
+        let parameters = [];
+        if (swaggerMethod.requestBody != null && swaggerMethod.requestBody.content[contentTypeMultipartFormData] != null) {
+            var modelName = this.getApiNameNormalized(apiName);
+            parameters.push({
+                name: 'request',
+                typeName: modelName,
+                nullable: false,
+                isQuery: false,
+                isEnum: false,
+            });
         }
         else {
-            if (this.isDate(parameter.schema)) {
-                return `let ${paramName}Param: string = encodeURIComponent(this._momentToString(${paramName}));
-    `;
+            if (swaggerMethod.requestBody != null) {
+                parameters.push({
+                    name: 'request',
+                    typeName: swaggerMethod.requestBody.content[contentTypeApplicationJson].schema.$ref.replace('#/components/schemas/', ''),
+                    nullable: false,
+                    isQuery: false,
+                    isEnum: false,
+                });
             }
             else {
-                return `let ${paramName}Param: string = encodeURIComponent('' + ${paramName});
-    `;
+                swaggerMethod.parameters?.filter(x => x.in == 'query').forEach(parameter => {
+                    if (parameter.schema.$ref != null) {
+                        parameters.push({
+                            name: this.toFirstLetterLowercase(parameter.name),
+                            typeName: parameter.schema.$ref.replace('#/components/schemas/', ''),
+                            nullable: !parameter.required,
+                            swaggerParameter: parameter,
+                            isQuery: true,
+                            isEnum: this.isEnum(parameter.schema.$ref),
+                        });
+                    }
+                    else {
+                        parameters.push({
+                            name: this.toFirstLetterLowercase(parameter.name),
+                            typeName: this.getNativeType(parameter.schema),
+                            nullable: !parameter.required,
+                            swaggerParameter: parameter,
+                            isQuery: true,
+                            isEnum: false,
+                        });
+                    }
+                });
             }
         }
-    }
-    retrieveQueryParameters(swaggerMethodInfo) {
-        if (swaggerMethodInfo.requestBody != null)
-            return ``;
-        let filteredParameters = swaggerMethodInfo.parameters?.filter(x => x.in == 'query');
-        if (filteredParameters == null || filteredParameters == undefined || filteredParameters.length == 0)
-            return ``;
-        let parameters = `?`;
-        filteredParameters.forEach(parameter => {
-            if (parameter.schema.$ref != null) {
-                if (this.isEnum(parameter.schema.$ref) != null) {
-                    parameters += `${this.toFirstLetterLowercase(parameter.name)}=\${` + this.toFirstLetterLowercase(parameter.name) + `Param}&`;
-                    ;
-                }
-                else {
-                    throw new Error("retrieveQueryParameters unmanaged parameter.schema.$ref");
-                }
-            }
-            else {
-                parameters += `${this.toFirstLetterLowercase(parameter.name)}=\${` + this.toFirstLetterLowercase(parameter.name) + `Param}&`;
-            }
-        });
-        if (parameters.length > 1)
-            parameters = parameters.substring(0, parameters.length - 1);
         return parameters;
     }
-    retrieveReturnType(swaggerMethodInfo) {
-        if (swaggerMethodInfo.responses[200] == null)
-            return 'void';
+    computeReturnType(swaggerMethod) {
+        if (swaggerMethod.responses[200] == null) {
+            return {
+                typeName: 'void',
+                nullable: false,
+            };
+        }
         try {
-            if (swaggerMethodInfo.responses[200].content[contentTypeApplicationJson].schema.$ref != null)
-                return `Models.${this.getObjectName(swaggerMethodInfo.responses[200]?.content[contentTypeApplicationJson].schema.$ref)}`;
+            if (swaggerMethod.responses[200].content[contentTypeApplicationJson].schema.$ref != null)
+                return {
+                    typeName: this.getObjectName(swaggerMethod.responses[200]?.content[contentTypeApplicationJson].schema.$ref),
+                    nullable: 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');
             throw new Error(errorMessage);
         }
-        if (swaggerMethodInfo.responses[200]?.content[contentTypeApplicationJson].schema.type != null)
-            return this.getNativeType(swaggerMethodInfo.responses[200]?.content[contentTypeApplicationJson].schema);
-        console.error("unmanaged swaggerMethodInfo", swaggerMethodInfo);
-        throw new Error("unmanaged swaggerMethodInfo");
+        if (swaggerMethod.responses[200]?.content[contentTypeApplicationJson].schema.type != null) {
+            let schema = swaggerMethod.responses[200]?.content[contentTypeApplicationJson].schema;
+            if (schema.type == 'array') {
+                if (schema.items.$ref != null) {
+                    return {
+                        typeName: `${this.getObjectName(schema.items.$ref)}[]`,
+                        nullable: false,
+                    };
+                }
+            }
+            else {
+                return {
+                    typeName: this.getNativeType(swaggerMethod.responses[200]?.content[contentTypeApplicationJson].schema),
+                    nullable: false,
+                };
+            }
+            // if (swaggerComponentProperty.items.$ref != null)
+            //   return `${this.getObjectName(swaggerComponentProperty.items.$ref)}[]`;
+        }
+        else {
+            return {
+                typeName: this.getNativeType(swaggerMethod.responses[200]?.content[contentTypeApplicationJson].schema),
+                nullable: false,
+            };
+        }
     }
     retrieveType(swaggerComponentProperty) {
         if (swaggerComponentProperty.$ref != null)
@@ -276,48 +282,42 @@ ${MODEL_POST}`, { flag: 'w' });
     getObjectName(ref) {
         return ref.replace('#/components/schemas/', '');
     }
-    retrieveObjectContent(name, swaggerComponent) {
-        if (swaggerComponent.type == 'object')
-            return this.retrieveComponentProperties(swaggerComponent);
-        else if (swaggerComponent.type == 'integer')
-            return this.retrieveEnumValues(name, swaggerComponent);
-    }
     retrieveComponentProperties(swaggerCopmponent) {
         if (swaggerCopmponent.properties == null)
-            return ``;
-        let properties = ``;
+            return [];
+        let properties = [];
         for (let index = 0; index < Object.getOwnPropertyNames(swaggerCopmponent.properties).length; index++) {
             const propertyName = Object.getOwnPropertyNames(swaggerCopmponent.properties)[index];
-            properties +=
-                `
-  ${propertyName}: ${this.retrieveType(swaggerCopmponent.properties[propertyName])} | undefined;`;
-        }
-        return properties;
-    }
-    retrieveSchemaProperties(schema) {
-        if (schema.properties == null)
-            return ``;
-        let properties = ``;
-        for (let j = 0; j < Object.getOwnPropertyNames(schema.properties).length; j++) {
-            let propertyName = Object.getOwnPropertyNames(schema.properties)[j];
-            properties +=
-                `
-  ${this.toFirstLetterLowercase(propertyName)}: ${this.retrieveType(schema.properties[propertyName])} | undefined;`;
+            properties.push({
+                name: propertyName,
+                typeName: this.retrieveType(swaggerCopmponent.properties[propertyName]),
+                nullable: true,
+            });
         }
         return properties;
     }
+    // retrieveSchemaProperties(schema: SwaggerSchema) {
+    //   if (schema.properties == null) return [];
+    //   let properties: PropertyDto[] = [];
+    //   for (let j = 0; j < Object.getOwnPropertyNames(schema.properties).length; j++) {
+    //     let propertyName = Object.getOwnPropertyNames(schema.properties)[j];
+    //     properties +=
+    //       `
+    // ${this.toFirstLetterLowercase(propertyName)}: ${this.retrieveType(schema.properties[propertyName])} | undefined;`
+    //   }
+    //   return properties;
+    // }
     retrieveEnumValues(name, swaggerCopmponent) {
         if (swaggerCopmponent.enum == null)
-            return ``;
-        let properties = ``;
+            return [];
+        let values = [];
         for (let index = 0; index < swaggerCopmponent.enum.length; index++) {
-            const name = swaggerCopmponent.enum[index].split('-')[0].trim();
-            const value = swaggerCopmponent.enum[index].split('-')[1].trim();
-            properties +=
-                `
-  ${name} = ${value},`;
+            values.push({
+                name: swaggerCopmponent.enum[index].split('-')[0].trim(),
+                value: swaggerCopmponent.enum[index].split('-')[1].trim(),
+            });
         }
-        return properties;
+        return values;
     }
     retrieveNestedObjects(usedTypes) {
         for (let i = 0; i < usedTypes.length; i++) {
@@ -348,7 +348,10 @@ ${MODEL_POST}`, { flag: 'w' });
     }
     getNativeType(schema) {
         let nativeType = 'n.d.';
-        if (schema.type == 'array') {
+        if (schema.$ref != null) {
+            debugger;
+        }
+        else if (schema.type == 'array') {
             nativeType = this.getNativeType(schema.items);
             nativeType += '[]';
         }
@@ -358,7 +361,7 @@ ${MODEL_POST}`, { flag: 'w' });
             if (schema.type == 'string' && schema.format == null)
                 nativeType = 'string';
             if (schema.type == 'string' && schema.format == 'date-time')
-                nativeType = 'moment.Moment';
+                nativeType = this._dateLibrary == 'moment' ? 'moment.Moment' : 'Date';
             if (schema.type == 'string' && schema.format == 'uuid')
                 nativeType = 'string';
             if (schema.type == 'string' && schema.format == 'binary')
@@ -378,8 +381,12 @@ ${MODEL_POST}`, { flag: 'w' });
             throw new Error("unmanaged schema");
         }
     }
-    getModelNameByApi(apiName) {
-        return apiName.replace('/api/v{version}/', '').replaceAll('/', '_');
+    getApiNameNormalized(apiName) {
+        let normalizedApiName = apiName.replace('/api/v{version}/', '').replaceAll('/', '_');
+        if (normalizedApiName.charAt(0) == '_') {
+            normalizedApiName = normalizedApiName.slice(1);
+        }
+        return this.toFirstLetterLowercase(normalizedApiName);
     }
     toFirstLetterLowercase(value) {
         return value.charAt(0).toLowerCase() + value.slice(1);

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

@@ -0,0 +1,111 @@
+import fs from 'fs';
+import { API_POST, API_PRE } from './constants.js';
+import { Utils } from '../utils.js';
+export class ApiAngularWriter {
+    _outputDirectory;
+    constructor(_outputDirectory) {
+        this._outputDirectory = _outputDirectory;
+    }
+    write(apis) {
+        let apiString = '';
+        apis.forEach(api => {
+            apiString += this._apiString(api);
+        });
+        this._writeFile(apiString);
+    }
+    _apiString(api) {
+        let apiNameNormalized = Utils.getApiNameNormalized(api.name);
+        let parametersString = this._parameters(api);
+        let queryParametersPreparation = this._queryParametersPreparation(api);
+        let requestPreparation = this._requestPreparation(api);
+        let queryParameters = this._queryParameters(api);
+        let returnTypeString = this._returnType(api);
+        let haveRequest = api.haveRequest;
+        let method = api.method.toLowerCase();
+        let httpOptions = api.isMultiPart ? 'httpOptionsMultiPart' : 'httpOptions';
+        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, <Observable<any>>obs))
+      );
+  }
+`;
+        return apiString;
+    }
+    _parameters(api) {
+        let parametersString = '';
+        api.parameters.forEach(parameter => {
+            parametersString += `${parameter.name}${parameter.nullable ? '?' : ''}: ${parameter.typeName}, `;
+        });
+        if (api.parameters.length > 0)
+            parametersString = parametersString.substring(0, parametersString.length - 2);
+        return parametersString;
+    }
+    _returnType(api) {
+        return api.returnType ? api.returnType.typeName : 'any';
+    }
+    _queryParametersPreparation(api) {
+        let queryParametersPreparation = '';
+        api.parameters.forEach(parameter => {
+            if (parameter.isQuery) {
+                queryParametersPreparation += this._queryParametersPreparationStatement(parameter);
+            }
+        });
+        return queryParametersPreparation;
+    }
+    _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})) : '';
+      `;
+            }
+            else {
+                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}));
+      `;
+            }
+            else {
+                return `let ${parameter.name}Param: string = encodeURIComponent('' + ${parameter.name});
+      `;
+            }
+        }
+    }
+    _queryParameters(api) {
+        let queryParameters = '';
+        api.parameters.forEach(parameter => {
+            if (parameter.isQuery) {
+                queryParameters += this._queryParametersStatement(parameter);
+            }
+        });
+        if (queryParameters.length > 0) {
+            queryParameters = '?' + queryParameters.substring(0, queryParameters.length - 1);
+        }
+        return queryParameters;
+    }
+    _queryParametersStatement(parameter) {
+        if (parameter.swaggerParameter == null)
+            return '';
+        if (!parameter.isQuery)
+            return '';
+        return `${parameter.name}=\${${parameter.name}Param}&`;
+    }
+    _requestPreparation(api) {
+        if (!api.haveRequest) {
+            return '';
+        }
+        return `let wrappedRequest = this._handleRequest(request);
+    `;
+    }
+    _writeFile(apis) {
+        fs.writeFileSync(this._outputDirectory + "/api.autogenerated.ts", `${API_PRE}
+${apis}
+${API_POST}`, { flag: 'w' });
+    }
+}