@devlearning/swagger-generator 1.0.9 → 1.0.11

package/dist/generator.js

@@ -0,0 +1,483 @@
+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;
+    _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;
+    }
+    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];
+            this._barApis.update(index, { message: `Apis parsing... ${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.computeResponseType(apiSwaggerMethod),
+                swaggerMethodKey: apiSwaggerMethodKey,
+                swaggerMethod: apiSwaggerMethod,
+                haveRequest: apiSwaggerMethod.requestBody != null,
+                isMultiPart: apiSwaggerMethod.requestBody != null && apiSwaggerMethod.requestBody.content[contentTypeMultipartFormData] != null,
+            };
+            this._apis.push(apiDto);
+        }
+    }
+    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 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);
+        //   }
+        // }
+        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].parameters) {
+                this._apis[index].parameters.forEach(parameter => {
+                    if (parameter.isTypeReference) {
+                        usedTypes.push(parameter);
+                    }
+                });
+            }
+        }
+        usedTypes = [...new Set(usedTypes.map(item => item))]; // distinct
+        this.retrieveNestedObjects(usedTypes);
+        let models = ``;
+        if (this._swagger.components != null
+            && this._swagger.components != undefined
+            && this._swagger.components.schemas != null
+            && 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];
+                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];
+            this._models.push({
+                modelType: 'class',
+                name: this.getApiNameNormalized(apiName),
+                properties: this.retrieveComponentProperties(swaggerMethodInfo.requestBody.content[contentTypeMultipartFormData].schema),
+                enumValues: [],
+            });
+        });
+    }
+    generateApi() {
+        this._barApis.update(this._apis.length, { message: `Api generating...` });
+        if (this._outputFormat == 'angular') {
+            const apiWriter = new ApiAngularWriter(this._outputDirectory);
+            apiWriter.write(this._apis);
+        }
+        else if (this._outputFormat == 'next') {
+            const apiWriter = new ApiNextJsWriter(this._outputDirectory);
+            apiWriter.write(this._apis);
+        }
+        this._barApis.update(this._apis.length, { message: `Api gerated` });
+        this._barApis.stop();
+    }
+    generateModel() {
+        this._barModels.update(this._apis.length, { message: `Model generation...` });
+        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: `Model generated` });
+        this._barModels.stop();
+    }
+    computeParameters(apiName, swaggerMethod) {
+        if (!apiName)
+            return [];
+        if (!swaggerMethod || swaggerMethod == null)
+            return [];
+        let parameters = [];
+        try {
+            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,
+                    isTypeReference: true,
+                    isNativeType: false,
+                    isArray: false,
+                    isVoid: false,
+                });
+            }
+            else {
+                if (swaggerMethod.requestBody != null) {
+                    parameters.push({
+                        name: 'request',
+                        typeName: swaggerMethod.requestBody.content[contentTypeApplicationJson].schema.$ref.replace('#/components/schemas/', ''),
+                        nullable: false,
+                        isQuery: false,
+                        isEnum: false,
+                        isTypeReference: true,
+                        isNativeType: false,
+                        isArray: false,
+                        isVoid: false,
+                    });
+                }
+                else {
+                    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),
+                                isTypeReference: false,
+                                isNativeType: false,
+                                isArray: false,
+                                isVoid: false,
+                            });
+                        }
+                        else {
+                            parameters.push({
+                                name: this.toFirstLetterLowercase(parameter.name),
+                                typeName: this.getNativeType(parameter.schema),
+                                nullable: !parameter.required,
+                                swaggerParameter: parameter,
+                                isQuery: true,
+                                isEnum: false,
+                                isTypeReference: false,
+                                isNativeType: true,
+                                isArray: false,
+                                isVoid: false,
+                            });
+                        }
+                    });
+                }
+            }
+        }
+        catch (error) {
+            console.error(`\t\tError in ${apiName} - Attenzione forse hai dimenticato IActionResult e non hai tipizzato il tipo restituito dal servizio`);
+        }
+        return parameters;
+    }
+    computeResponseType(swaggerMethod) {
+        if (swaggerMethod.responses[200] == null) {
+            return {
+                typeName: 'void',
+                nullable: false,
+                isVoid: true,
+            };
+        }
+        return this.computeSwaggerContentType(swaggerMethod.responses[200].content[contentTypeApplicationJson]);
+    }
+    computeRequestBodyType(swaggerMethod) {
+        if (swaggerMethod.requestBody == null) {
+            return {
+                typeName: 'void',
+                nullable: false,
+                isVoid: true,
+            };
+        }
+        return this.computeSwaggerContentType(swaggerMethod.requestBody.content[contentTypeApplicationJson]);
+    }
+    computeSwaggerContentType(swaggerContent) {
+        try {
+            if (swaggerContent.schema.$ref != null)
+                return {
+                    typeName: this.getObjectName(swaggerContent.schema.$ref),
+                    nullable: false,
+                    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');
+            throw new Error(errorMessage);
+        }
+        if (swaggerContent.schema.type != null) {
+            let schema = swaggerContent.schema;
+            if (schema.type == 'array') {
+                if (schema.items.$ref != null) {
+                    return {
+                        typeName: `${this.getObjectName(schema.items.$ref)}`,
+                        nullable: false,
+                        isNativeType: false,
+                        isArray: true,
+                    };
+                }
+            }
+            else {
+                return {
+                    typeName: this.getNativeType(swaggerContent.schema),
+                    nullable: false,
+                    isNativeType: true,
+                };
+            }
+            // if (swaggerComponentProperty.items.$ref != null)
+            //   return `${this.getObjectName(swaggerComponentProperty.items.$ref)}[]`;
+        }
+        else {
+            return {
+                typeName: this.getNativeType(swaggerContent.schema),
+                nullable: false,
+                isNativeType: true,
+            };
+        }
+    }
+    retrieveType(swaggerComponentProperty) {
+        if (swaggerComponentProperty.$ref != null)
+            return {
+                typeName: swaggerComponentProperty.$ref.replace('#/components/schemas/', ''),
+                isTypeReference: true,
+                isNativeType: false,
+                nullable: swaggerComponentProperty.nullable ?? false,
+                isArray: false,
+                isVoid: false,
+            };
+        if (swaggerComponentProperty.type != null && swaggerComponentProperty.type == 'array')
+            if (swaggerComponentProperty.items.$ref != null)
+                return {
+                    typeName: `${this.getObjectName(swaggerComponentProperty.items.$ref)}`,
+                    isTypeReference: true,
+                    isNativeType: false,
+                    nullable: swaggerComponentProperty.nullable ?? false,
+                    isArray: true,
+                    isVoid: false,
+                };
+            else
+                return {
+                    typeName: this.getNativeType(swaggerComponentProperty),
+                    isTypeReference: false,
+                    isNativeType: true,
+                    nullable: swaggerComponentProperty.nullable ?? false,
+                    isArray: false,
+                    isVoid: false,
+                };
+        if (swaggerComponentProperty.type != null)
+            return {
+                typeName: this.getNativeType(swaggerComponentProperty),
+                isTypeReference: false,
+                isNativeType: true,
+                nullable: swaggerComponentProperty.nullable ?? false,
+                isArray: false,
+                isVoid: false,
+            };
+        if (swaggerComponentProperty.type == null)
+            return {
+                typeName: 'void',
+                isTypeReference: false,
+                isNativeType: false,
+                nullable: swaggerComponentProperty.nullable ?? false,
+                isArray: false,
+                isVoid: true,
+            };
+        console.error("unmanaged swaggerMethodInfo", swaggerComponentProperty);
+        throw new Error("unmanaged swaggerMethodInfo");
+    }
+    parametrizeObject(objectName) {
+        let component = this._swagger.components.schemas[this.getObjectName(objectName)];
+        if (component == null || component.properties == null)
+            return ``;
+        console.debug(component.properties);
+        return ``;
+    }
+    isEnum(objectName) {
+        let component = this._swagger.components.schemas[this.getObjectName(objectName)];
+        return component.enum != null;
+    }
+    isDate(schema) {
+        return schema.type == 'string' && schema.format == 'date-time';
+    }
+    getObjectName(ref) {
+        return ref.replace('#/components/schemas/', '');
+    }
+    retrieveComponentProperties(swaggerCopmponent) {
+        if (swaggerCopmponent.properties == null)
+            return [];
+        let properties = [];
+        for (let index = 0; index < Object.getOwnPropertyNames(swaggerCopmponent.properties).length; index++) {
+            const propertyName = Object.getOwnPropertyNames(swaggerCopmponent.properties)[index];
+            const type = this.retrieveType(swaggerCopmponent.properties[propertyName]);
+            properties.push({
+                ...type,
+                name: propertyName,
+                nullable: type.nullable,
+            });
+        }
+        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 values = [];
+        for (let index = 0; index < swaggerCopmponent.enum.length; index++) {
+            values.push({
+                name: swaggerCopmponent.enum[index].split('-')[0].trim(),
+                value: swaggerCopmponent.enum[index].split('-')[1].trim(),
+            });
+        }
+        return values;
+    }
+    retrieveNestedObjects(usedTypes) {
+        for (let i = 0; i < usedTypes.length; i++) {
+            const swaggerCopmponent = this._swagger.components.schemas[usedTypes[i].typeName];
+            this.retrieveNestedObjectsRecursive(swaggerCopmponent, usedTypes);
+        }
+    }
+    retrieveNestedObjectsRecursive(swaggerComponent, usedTypes) {
+        try {
+            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.typeName == nestedUsedType) == -1) {
+                    let nested = this._swagger.components.schemas[nestedUsedType];
+                    usedTypes.push({
+                        typeName: nestedUsedType,
+                        isTypeReference: nested.type == 'object',
+                        isNativeType: nested.type != 'object',
+                        nullable: false,
+                        isArray: false,
+                        isVoid: false,
+                        //potrebbe essere un enum
+                    });
+                    this.retrieveNestedObjectsRecursive(nested, usedTypes);
+                }
+            }
+        }
+        catch (error) {
+            debugger;
+        }
+    }
+    getNativeType(schema) {
+        let nativeType = 'n.d.';
+        if (schema.$ref != null) {
+            debugger;
+        }
+        else if (schema.type == 'array') {
+            nativeType = this.getNativeType(schema.items);
+            nativeType += '[]';
+        }
+        else {
+            if (schema.type == 'integer')
+                nativeType = 'number';
+            if (schema.type == 'string' && schema.format == null)
+                nativeType = 'string';
+            if (schema.type == 'string' && schema.format == 'date-time')
+                nativeType = this._dateLibrary == 'moment' ? 'moment.Moment' : 'Date';
+            if (schema.type == 'string' && schema.format == 'uuid')
+                nativeType = 'string';
+            if (schema.type == 'string' && schema.format == 'binary')
+                nativeType = 'File';
+            if (schema.type == 'number')
+                nativeType = 'number';
+            if (schema.type == 'boolean')
+                nativeType = 'boolean';
+            if (schema.type == 'object')
+                nativeType = 'any';
+        }
+        if (nativeType.indexOf('n.d') == -1) {
+            return nativeType;
+        }
+        else {
+            console.error("unmanaged schema type", schema);
+            throw new Error("unmanaged schema");
+        }
+    }
+    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,114 @@
+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 => {
+            const prefixType = parameter.isEnum || !parameter.isNativeType ? 'Models.' : '';
+            parametersString += `${parameter.name}${parameter.nullable ? '?' : ''}: ${prefixType}${parameter.typeName}, `;
+        });
+        if (api.parameters.length > 0)
+            parametersString = parametersString.substring(0, parametersString.length - 2);
+        return parametersString;
+    }
+    _returnType(api) {
+        const prefixType = !api.returnType?.isNativeType ? 'Models.' : '';
+        const isArray = api.returnType?.isArray ? '[]' : '';
+        return api.returnType ? `${prefixType}${api.returnType.typeName}${isArray}` : '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' });
+    }
+}

package/dist/generators-writers/angular/constants.js

@@ -0,0 +1,28 @@
+export const API_PRE = `import { HttpClient } from '@angular/common/http';
+import { Observable, catchError, map } from 'rxjs';
+import * as Models from './model.autogenerated';
+import { HttpHeaders } from "@angular/common/http";
+
+export const httpOptions = {
+  headers: new HttpHeaders({ 'Content-Type': 'application/json' }),
+};
+
+export const httpOptionsMultipart = {};
+
+export abstract class ApiAutogeneratedService {
+  constructor(
+    public _http: HttpClient,
+    public _baseUrl: string,
+  ) { }
+
+  protected abstract _momentToString(moment: moment.Moment): string;
+  protected abstract _handleRequest<T>(request: T): T;
+  protected abstract _handleMultipart<T>(request: T): FormData;
+  protected abstract _handleResponse<T>(response: T): T;
+  protected abstract _handleError(error: any, obs: any): Observable<never>;
+`;
+export const API_POST = `}`;
+export const MODEL_PRE = `import * as moment from 'moment';
+  `;
+export const MODEL_POST = `
+`;

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

@@ -0,0 +1,42 @@
+import fs from 'fs';
+import { MODEL_POST, MODEL_PRE } from './constants.js';
+export class ModelAngularWriter {
+    _outputDirectory;
+    constructor(_outputDirectory) {
+        this._outputDirectory = _outputDirectory;
+    }
+    write(models) {
+        let modelString = '';
+        models.forEach(model => {
+            modelString += this._modelString(model);
+        });
+        this._writeFile(modelString);
+    }
+    _modelString(model) {
+        let modelString = `
+export ${model.modelType} ${model.name} {
+${this._properties(model)}${this._enumValues(model)}
+}
+`;
+        return modelString;
+    }
+    _properties(model) {
+        let propertiesString = '';
+        model.properties.forEach(property => {
+            propertiesString += `  ${property.name}${property.nullable ? '?' : ''}: ${property.typeName};\n`;
+        });
+        return propertiesString.trimEnd();
+    }
+    _enumValues(model) {
+        let enumValuesString = '';
+        model.enumValues.forEach(enumValue => {
+            enumValuesString += `  ${enumValue.name} = ${enumValue.value},\n`;
+        });
+        return enumValuesString.trimEnd();
+    }
+    _writeFile(models) {
+        fs.writeFileSync(this._outputDirectory + "/model.autogenerated.ts", `${MODEL_PRE}
+  ${models}
+  ${MODEL_POST}`, { flag: 'w' });
+    }
+}