@devlearning/swagger-generator 0.0.1

package/src/index.ts

@@ -0,0 +1,383 @@
+#!/usr/bin/env
+
+import fetch from 'node-fetch';
+import * as fs from 'fs';
+import { Swagger, SwaggerComponent, SwaggerComponentProperty, SwaggerMethod, SwaggerSchema } from './models/swagger.js';
+import { SwaggerDownloader } from './swagger-downloader.js';
+
+var args = process.argv.slice(2);
+
+if (args.length !== 2) {
+	console.log("Warning: Requires 2 arguments");
+	console.log("node index.js [swaggerJsonUrl] [outputDirectory]");
+	process.exit();
+}
+
+const swaggerJsonUrl = args[0];
+const outputDirectory = args[1];
+
+//const excludedModels = ['Type', 'MethodBase', 'Assembly', 'MethodInfo']
+// const apiUrl = args[0]//"http://localhost:5208";
+// const version = args[1]; //"1";
+// const swaggerJsonUrl = `${apiUrl}/swagger/v${version}/swagger.json`;
+const contentType = 'application/json';
+
+export class Generator {
+	private _swagger: Swagger;
+
+	constructor(swagger: Swagger) {
+		this._swagger = swagger;
+	}
+
+	generateApi() {
+		console.debug(`Start autogeneration Apis`);
+
+		let apiMethods = ``;
+		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);
+			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;
+
+			if (haveRequest) {
+				prepareRequestString = `request = this._handleRequest(request);
+	  `;
+			}
+
+			apiMethods +=
+				`
+  public ${apiName.replace('/api/v{version}/', '').replaceAll('/', '_')}(${parametersString}): Observable<${returnTypeString}>{
+    ${prepareRequestString}return this._http.${method}<${returnTypeString}>(\`\${environment.BASE_URL}${apiName.replace('{version}', '1')}${queryParameters}\`${haveRequest ? ', request' : ''}, httpOptions)
+      .pipe(
+        map(x => this._handleResponse(x)),
+          catchError((err, obs) => {
+          return this._handleError(err, <Observable<any>>obs);
+        })
+    );
+  }
+`;
+		}
+
+		fs.writeFileSync(outputDirectory + "/api.autogenerated.ts",
+			`${apiPre}
+${apiMethods}
+${apiPost}`,
+			{ flag: 'w' });
+	}
+
+	generateModel() {
+		let usedTypes: string[] = [];
+
+		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}/Ticket/Create"){
+			// 	debugger
+			// }
+			let parametersRefType = swaggerMethodInfo.parameters.filter(x => x.in == 'query' && x.schema?.$ref != null).map(x => x.schema.$ref.replace('#/components/schemas/', ''))
+			usedTypes = usedTypes.concat(parametersRefType);
+
+			if (swaggerMethodInfo.responses[200].content[contentType].schema.$ref != null) {
+				usedTypes.push(swaggerMethodInfo.responses[200].content[contentType].schema.$ref.replace('#/components/schemas/', ''));
+			}
+
+			if (swaggerMethodInfo.requestBody?.content[contentType]?.schema?.$ref) {
+				usedTypes.push(swaggerMethodInfo.requestBody?.content[contentType]?.schema?.$ref.replace('#/components/schemas/', ''));
+			}
+		}
+
+		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 = ``;
+		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}`);
+				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}
+}
+`;
+		}
+
+		fs.writeFileSync(outputDirectory + "/model.autogenerated.ts",
+			`${modelPre}
+${models}
+${modelPost}`,
+			{ flag: 'w' });
+	}
+
+	retrieveParameters(swaggerMethodInfo: SwaggerMethod) {
+		if (swaggerMethodInfo.requestBody != null) {
+			return `request: ${swaggerMethodInfo.requestBody.content[contentType].schema.$ref.replace('#/components/schemas/', '')}`
+		}
+
+		let parameters = ``;
+		swaggerMethodInfo.parameters.filter(x => x.in == 'query').forEach(parameter => {
+			if (parameter.schema.$ref != null) {
+				parameters += `${parameter.name}: ${parameter.schema.$ref.replace('#/components/schemas/', '')}, `;
+			} else {
+				parameters += `${parameter.name}: ${this.getNativeType(parameter.schema)}, `;
+			}
+		});
+
+		if (parameters.length > 2)
+			parameters = parameters.substring(0, parameters.length - 2);
+
+		return parameters;
+	}
+
+	retrieveQueryParameters(swaggerMethodInfo: SwaggerMethod) {
+		if (swaggerMethodInfo.requestBody != null) return ``;
+
+		let filteredParameters = swaggerMethodInfo.parameters.filter(x => x.in == 'query');
+		if (filteredParameters.length == 0) return ``;
+
+		let parameters = `?`;
+		filteredParameters.forEach(parameter => {
+			if (parameter.schema.$ref != null) {
+				this.parametrizeObject(parameter.schema.$ref)
+				//parameters += `${parameter.name}: ${parameter.schema.$ref.replace('#/components/schemas/', '')}&`;
+			} else {
+				parameters += `${this.lowercaseFirstLetter(parameter.name)}=\${` + this.lowercaseFirstLetter(parameter.name) + `}&`;
+			}
+		});
+
+		if (parameters.length > 1)
+			parameters = parameters.substring(0, parameters.length - 1);
+
+		return parameters;
+	}
+
+	retrieveReturnType(swaggerMethodInfo: SwaggerMethod) {
+		if (swaggerMethodInfo.responses[200] == null)
+			return 'void';
+
+		if (swaggerMethodInfo.responses[200].content[contentType].schema.$ref != null)
+			return swaggerMethodInfo.responses[200]?.content[contentType].schema.$ref.replace('#/components/schemas/', '')
+
+		if (swaggerMethodInfo.responses[200]?.content[contentType].schema.type != null)
+			return this.getNativeType(swaggerMethodInfo.responses[200]?.content[contentType].schema);
+
+		console.error("unmanaged swaggerMethodInfo", swaggerMethodInfo);
+		throw new Error("unmanaged swaggerMethodInfo");
+	}
+
+	retrieveType(swaggerComponentProperty: SwaggerComponentProperty) {
+		if (swaggerComponentProperty.$ref != null)
+			return swaggerComponentProperty.$ref.replace('#/components/schemas/', '');
+
+		if (swaggerComponentProperty.type != null && swaggerComponentProperty.type == 'array')
+			if (swaggerComponentProperty.items.$ref != null)
+				return swaggerComponentProperty.items.$ref.replace('#/components/schemas/', '');
+			else
+				return this.getNativeType(swaggerComponentProperty);
+
+		if (swaggerComponentProperty.type != null)
+			return this.getNativeType(swaggerComponentProperty);
+
+		if (swaggerComponentProperty.type == null)
+			return '';
+
+		console.error("unmanaged swaggerMethodInfo", swaggerComponentProperty);
+		throw new Error("unmanaged swaggerMethodInfo");
+	}
+
+	parametrizeObject(objectName: string) {
+		let component = this._swagger.components.schemas[objectName.replace('#/components/schemas/', '')];
+		if (component == null || component.properties == null) return ``;
+
+		console.debug(component.properties);
+
+		return ``;
+	}
+
+	retrieveObjectContent(name: string, swaggerComponent: SwaggerComponent) {
+		if (swaggerComponent.type == 'object')
+			return this.retrieveObjectProperties(swaggerComponent);
+		else if (swaggerComponent.type == 'integer')
+			return this.retrieveEnumValues(name, swaggerComponent);
+	}
+
+	retrieveObjectProperties(swaggerCopmponent: SwaggerComponent) {
+		if (swaggerCopmponent.properties == null) return ``;
+
+		// console.debug(`\t\t${Object.getOwnPropertyNames(swaggerCopmponent.properties).length}`);
+
+		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;
+	}
+
+	retrieveEnumValues(name: string, swaggerCopmponent: SwaggerComponent) {
+		if (swaggerCopmponent.enum == null) return ``;
+
+		let properties = ``;
+		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},`;
+		}
+
+		return properties;
+	}
+
+	retrieveNestedObjects(usedTypes: string[]) {
+		for (let i = 0; i < usedTypes.length; i++) {
+			const swaggerCopmponent = this._swagger.components.schemas[usedTypes[i]];
+			// const name = usedTypes[i]
+			// const modelName = <string>Object.getOwnPropertyNames(this._swagger.components.schemas)[name];
+			this.retrieveNestedObjects2(swaggerCopmponent, usedTypes);
+		}
+	}
+
+	/*
+	"ActivatedVoucherSnackReadQueryResponse": {
+		"type": "object",
+		"properties": {
+		  "list": {
+			"type": "array",
+			"items": {
+			  "$ref": "#/components/schemas/ActivatedVoucherSnackListResponse"
+			},
+			"nullable": true
+		  }
+		},
+		"additionalProperties": false
+	  },
+	*/
+
+	retrieveNestedObjects2(swaggerComponent: SwaggerComponent, usedTypes: string[]) {
+		if (!swaggerComponent.properties) return;
+
+		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) {
+				nestedUsedType = swaggerComponent.properties[propertyName].$ref.replace('#/components/schemas/', '');
+			} else if (swaggerComponent.properties[propertyName].type == 'array' && swaggerComponent.properties[propertyName].items.$ref != null) {
+				nestedUsedType = swaggerComponent.properties[propertyName].items.$ref.replace('#/components/schemas/', '');
+			}
+
+			if (nestedUsedType != '' && usedTypes.findIndex(x => x == nestedUsedType) == -1) {
+				usedTypes.push(nestedUsedType);
+				let nested = this._swagger.components.schemas[nestedUsedType];
+				this.retrieveNestedObjects2(nested, usedTypes);
+			}
+		}
+	}
+
+	getNativeType(schema: SwaggerSchema): string {
+		if (schema.type == 'integer') return 'number';
+		if (schema.type == 'string' && schema.format == null) return 'string';
+		if (schema.type == 'string' && schema.format == 'date-time') return 'moment.Moment';
+		if (schema.type == 'string' && schema.format == 'uuid') return 'string';
+		if (schema.type == 'number') return 'number';
+		if (schema.type == 'array') return '[]';
+		if (schema.type == 'boolean') return 'boolean';
+		if (schema.type == 'object') return 'any';
+
+		console.error("unmanaged schema type", schema);
+		throw new Error("unmanaged schema");
+	}
+
+	lowercaseFirstLetter(value: string) {
+		return value.charAt(0).toLowerCase() + value.slice(1);
+	}
+}
+
+const swaggerDownloader = new SwaggerDownloader();
+const apiPre =
+	`import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { Observable, catchError, map } from 'rxjs';
+import { httpOptions } from 'src/app/core/utils/http-options';
+import { DatiUtenteTestataResponse } from '../models/dati-utente-testata-response';
+import { LanguageCultureListQueryResponse } from '../models/language-culture';
+import { API_AIRLINE_COMPANY, API_LANGUAGE_CULTURE, API_TEST, API_USER, API_VOUCHER_SNACK } from '../utils/constants';
+import { ApiBase } from './../utils/api-base';
+import { DialogMessageService } from './dialog-message.service';
+import * as moment from 'moment-timezone';
+import { VoucherSnackResponse } from '../models/api/voucher-snack-response.models';
+import { VoucherSnackRequest } from '../models/api/voucher-snack-request.models';
+import { ActivatedSnackVoucherResponse, SnackType } from 'src/app/ticket/models/richiesta-servizio-snack.models';
+import { VoucherSnackRequestEmission } from '../models/api/voucher-snack-request-emission';
+import { ActivateSnackVoucherResponse } from '../models/api/activate-snack-voucher-response.models';
+import { VoucherActivationRequest } from '../models/api/voucher-activation-request.model';
+import { Utente } from '../models/utente';
+import { AirlineCompany } from 'src/app/sharedmodules/dialog-compagnie-aeree/compagnia-aerea.model';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class ApiService extends ApiBase {
+  constructor(
+    private _http: HttpClient,
+    _dialogMessage: DialogMessageService
+  ) {
+    super(_dialogMessage);
+  }
+`;
+const apiPost =
+	`}`;
+
+const modelPre =
+	`import * as moment from 'moment';
+`;
+
+const modelPost =
+	`
+`;
+
+swaggerDownloader.download(new URL(swaggerJsonUrl))
+	.then(swaggerDoc => {
+		return new Generator(swaggerDoc);
+	})
+	.then(generator => { generator.generateApi(); generator.generateModel() });
+
+
+// require('./index.js')({swaggerDownloader});

package/src/models/swagger.ts

@@ -0,0 +1,63 @@
+export interface Swagger {
+    openApi: string;
+    info: SwaggerInfo;
+    paths: { [key: string]: { [key: string]: SwaggerMethod; }; };
+    components: SwaggerComponents;
+}
+
+export interface SwaggerInfo {
+    title: string;
+    version: string;
+}
+
+export interface SwaggerMethod {
+    tags: string[];
+    parameters: SwaggerParameter[];
+    requestBody: SwaggerRequestBody;
+    responses: { [key: string]: SwaggerResponses; };
+}
+
+export interface SwaggerParameter {
+    name: string;
+    in: string;
+    required: boolean;
+    schema: SwaggerSchema;
+}
+
+export interface SwaggerRequestBody {
+    content: { [key: string]: SwaggerContent; };
+}
+
+export interface SwaggerResponses {
+    description: string;
+    content: { [key: string]: SwaggerContent; };
+}
+
+export interface SwaggerComponents {
+    schemas: { [key: string]: SwaggerComponent; };
+}
+
+export interface SwaggerComponent {
+    type: string;
+    properties: { [key: string]: SwaggerComponentProperty; };
+    additionalProperties: boolean;
+    enum: string[];
+}
+
+export interface SwaggerComponentProperty {
+    type: string;
+    $ref: string;
+    format: string;
+    items: SwaggerSchema;
+}
+
+export interface SwaggerContent {
+    schema: SwaggerSchema;
+}
+
+export interface SwaggerSchema {
+    type: string;
+    $ref: string;
+    format: string;
+    items: SwaggerSchema;
+}

package/src/swagger-downloader.ts

@@ -0,0 +1,11 @@
+import { Swagger } from "./models/swagger.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;
+	}
+}

package/tsconfig.json

@@ -0,0 +1,48 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "baseUrl": "./src",
+    "moduleResolution": "NodeNext",
+    "paths": {
+      "@src/*": [
+        "*"
+      ]
+    },
+    "outDir": "./dist",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": [
+    "src/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ],
+  "ts-node": {
+    "require": [
+      "tsconfig-paths/register"
+    ]
+  }
+}
+
+// {
+//   "compilerOptions": {
+//     "target": "es6",
+//     "module": "commonjs",
+//     "esModuleInterop": true,
+//     "outDir": "./dist",
+//     "rootDir": "./src",
+//     "resolveJsonModule": true,
+//     "sourceMap": true
+//   },
+//   "include": [
+//     "src//*.ts"
+//   ],
+//   "exclude": [
+//     "node_modules",
+//     "/*.spec.ts"
+//   ]
+// }