update providing

__tests__/services/ModelMappingService.spec.ts

@@ -1,6 +1,7 @@
 import { MockOpenAPIService } from '../../__mocks__/MockOpenAPIService';
 import { defaultOptions } from '../../src/options';
 import { ModelMappingService } from '../../src/services/ModelMappingService';
+import { NameService } from '../../src/services/NameService';
 import { TypesService } from '../../src/services/TypesService';
 import { OpenAPITypesGuard } from '../../src/swagger/OpenAPITypesGuard';
 import { OpenAPI3SchemaContainer } from '../../src/swagger/v3/schemas/schema';
@@ -11,8 +12,9 @@ describe('ModelMappingService tests', () => {
 
     beforeEach(() => {
         const guard = new OpenAPITypesGuard();
+        const nameService = new NameService();
         const openAPIService = new MockOpenAPIService(guard);
-        service = new ModelMappingService(openAPIService, guard, new TypesService(guard, defaultOptions));
+        service = new ModelMappingService(openAPIService, guard, new TypesService(guard, defaultOptions), nameService);
     });
 
     describe('toModelsContainer', () => {

src/generators/ModelsGenerator.ts

@@ -14,14 +14,15 @@ export const TO_DTO_METHOD = 'toDTO';
 export const FROM_DTO_METHOD = 'fromDTO';
 
 export class ModelsGenerator {
-    private interfaceGenerator = new InterfacesGenerator();
-    private unionGenerator = new UnionGenerator();
-    private identitiesGenerator = new IdentitiesGenerator(this.settings);
-    private objectGenerator = new ObjectGenerator();
-
     private pathBuilder = new PathBuilder();
 
-    constructor(private settings: IOptions) {}
+    constructor(
+        private settings: IOptions,
+        private readonly interfaceGenerator: InterfacesGenerator,
+        private readonly unionGenerator: UnionGenerator,
+        private readonly identitiesGenerator: IdentitiesGenerator,
+        private readonly objectGenerator: ObjectGenerator
+    ) {}
 
     public getModelsCodeStructure(models: IModelsContainer): StatementStructures[] {
         return [

src/generators/models-generator/IdentitiesGenerator.ts

@@ -16,9 +16,11 @@ import { TypeSerializer } from '../utils/TypeSerializer';
 import { PropertiesGenerator } from './PropertiesGenerator';
 
 export class IdentitiesGenerator {
-    private propertiesGenerator = new PropertiesGenerator();
+    constructor(
+        private readonly propertiesGenerator: PropertiesGenerator,
+        private readonly settings: IOptions
+    ) {}
 
-    constructor(private settings: IOptions) {}
     public getIdentities(identities: IIdentityModel[], interfaces: InterfaceModel[]): StatementStructures[] {
         return identities.map(
             (z): ClassDeclarationStructure => ({

src/generators/models-generator/InterfacesGenerator.ts

@@ -7,7 +7,7 @@ import { PropertiesGenerator } from './PropertiesGenerator';
 type InterfacesStructures = InterfaceDeclarationStructure | TypeAliasDeclarationStructure;
 
 export class InterfacesGenerator {
-    private propertiesGenerator = new PropertiesGenerator();
+    constructor(private readonly propertiesGenerator: PropertiesGenerator) {}
 
     public getCodeStructure(interfaces: InterfaceModel[], unions: IUnionModel[]): InterfacesStructures[] {
         const unionStructures = unions.flatMap((curr) => this.propertiesGenerator.getUnionTypeAliases(curr));

src/generators/models-generator/ObjectGenerator.ts

@@ -2,15 +2,17 @@ import { ClassDeclarationStructure, CodeBlockWriter, PropertyDeclarationStructur
 
 import { PropertyKind } from '../../models/kinds/PropertyKind';
 import { IExtendedObjectModel, IObjectPropertyModel, ObjectModel } from '../../models/ObjectModel';
-import { NameService } from '../../swagger/nameService';
+import { NameService } from '../../services/NameService';
 import { FROM_DTO_METHOD, TO_DTO_METHOD } from '../ModelsGenerator';
 import { ARRAY_STRING, NULL_STRING, UNDEFINED_STRING } from '../utils/consts';
 import { TypeSerializer } from '../utils/TypeSerializer';
 import { PropertiesGenerator } from './PropertiesGenerator';
 
 export class ObjectGenerator {
-    private nameService = new NameService();
-    private propertiesGenerator = new PropertiesGenerator();
+    constructor(
+        private readonly nameService: NameService,
+        private readonly propertiesGenerator: PropertiesGenerator
+    ) {}
 
     public getObjects(objects: ObjectModel[]): ClassDeclarationStructure[] {
         return objects.map((z) => ({

src/generators/models-generator/PropertiesGenerator.ts

@@ -11,13 +11,12 @@ import {
 import { IExtendedInterfaceModel, IInterfaceModel, IInterfacePropertyModel } from '../../models/InterfaceModel';
 import { IObjectPropertyModel } from '../../models/ObjectModel';
 import { IUnionModel } from '../../models/UnionModel';
-import { NameService } from '../../swagger/nameService';
+import { NameService } from '../../services/NameService';
 import { lowerFirst } from '../../utils';
 import { TypeSerializer } from '../utils/TypeSerializer';
 
 export class PropertiesGenerator {
-    private nameService = new NameService();
-
+    constructor(private readonly nameService: NameService) {}
     public getGuardProperty(name: string): PropertyDeclarationStructure {
         return {
             kind: StructureKind.Property,

src/generators/models-generator/UnionsGenerator.ts

@@ -1,11 +1,12 @@
 import { ClassDeclarationStructure, CodeBlockWriter, Scope, StructureKind } from 'ts-morph';
 
 import { IUnionModel } from '../../models/UnionModel';
-import { NameService } from '../../swagger/nameService';
+import { NameService } from '../../services/NameService';
 import { FROM_DTO_METHOD, TO_DTO_METHOD } from '../ModelsGenerator';
 
 export class UnionGenerator {
-    private nameService = new NameService();
+    constructor(private readonly nameService: NameService) {}
+
     public getUnionObjects(objects: IUnionModel[]): ClassDeclarationStructure[] {
         return objects.map((z) => ({
             kind: StructureKind.Class,

src/gengen/GenGenCodeGenInjector.ts

@@ -16,6 +16,12 @@ import { UriBuilder } from '../services/UriBuilder';
 import { OpenAPIService } from '../swagger/OpenAPIService';
 import { OpenAPITypesGuard } from '../swagger/OpenAPITypesGuard';
 import { IOpenAPI3 } from '../swagger/v3/open-api';
+import { NameService } from '../services/NameService';
+import { InterfacesGenerator } from '../generators/models-generator/InterfacesGenerator';
+import { UnionGenerator } from '../generators/models-generator/UnionsGenerator';
+import { IdentitiesGenerator } from '../generators/models-generator/IdentitiesGenerator';
+import { ObjectGenerator } from '../generators/models-generator/ObjectGenerator';
+import { PropertiesGenerator } from '../generators/models-generator/PropertiesGenerator';
 
 export abstract class EndpointsToken {
     public abstract getEndpoints(): Promise<Set<string>> | Set<string>;
@@ -61,7 +67,17 @@ export class GenGenCodeGenInjector {
             )
             .provide(OpenAPITypesGuard)
             .provide(EndpointNameResolver)
-            .provide(ModelsGenerator, () => new ModelsGenerator(this.options))
+            .provide(
+                ModelsGenerator,
+                (x) =>
+                    new ModelsGenerator(
+                        this.options,
+                        x.get(InterfacesGenerator),
+                        x.get(UnionGenerator),
+                        x.get(IdentitiesGenerator),
+                        x.get(ObjectGenerator)
+                    )
+            )
             .provide(UriBuilder)
             .provide(ServicesMethodGeneratorToken, (x) => new AngularServicesMethodGenerator(x.get(UriBuilder)))
             .provide(AliasResolver, () => new AliasResolver(this.options))
@@ -85,10 +101,20 @@ export class GenGenCodeGenInjector {
             )
             .provide(
                 ModelMappingService,
-                (x) => new ModelMappingService(x.get(OpenAPIService), x.get(OpenAPITypesGuard), x.get(TypesService))
+                (x) => new ModelMappingService(x.get(OpenAPIService), x.get(OpenAPITypesGuard), x.get(TypesService), x.get(NameService))
             )
             .provide(TypesService, (x) => new TypesService(x.get(OpenAPITypesGuard), this.options))
             .provide(OpenAPIService, (x) => new OpenAPIService(this.spec, x.get(OpenAPITypesGuard)))
+
+            .provide(InterfacesGenerator, (x) => new InterfacesGenerator(x.get(PropertiesGenerator)))
+            .provide(ObjectGenerator, (x) => new ObjectGenerator(x.get(NameService), x.get(PropertiesGenerator)))
+            .provide(UnionGenerator, (x) => new UnionGenerator(x.get(NameService)))
+            .provide(IdentitiesGenerator, (x) => new IdentitiesGenerator(x.get(PropertiesGenerator), this.options))
+            .provide(PropertiesGenerator, (x) => new PropertiesGenerator(x.get(NameService)))
+            .provide(NameService)
     );
-    constructor(private options: IOptions, private spec: IOpenAPI3) {}
+    constructor(
+        private options: IOptions,
+        private spec: IOpenAPI3
+    ) {}
 }

src/services/ModelMappingService.ts

@@ -5,7 +5,7 @@ import { PropertyKind } from '../models/kinds/PropertyKind';
 import { IModelsContainer } from '../models/ModelsContainer';
 import { IExtendedObjectModel, IObjectModel, IObjectPropertyModel, ObjectModel } from '../models/ObjectModel';
 import { IUnionModel } from '../models/UnionModel';
-import { NameService } from '../swagger/nameService';
+import { NameService } from './NameService';
 import { OpenAPIService } from '../swagger/OpenAPIService';
 import { OpenAPITypesGuard } from '../swagger/OpenAPITypesGuard';
 import { IOpenAPI3Reference } from '../swagger/v3/reference';
@@ -23,12 +23,12 @@ const IGNORE_PROPERTIES = ['startRow', 'rowCount'];
 export class ModelMappingService {
     public additionalEnums: IEnumModel[] = [];
     public unions: IUnionModel[] = [];
-    private nameService = new NameService();
 
     constructor(
         private readonly openAPIService: OpenAPIService,
         private readonly typesGuard: OpenAPITypesGuard,
-        private readonly typesService: TypesService
+        private readonly typesService: TypesService,
+        private readonly nameService: NameService
     ) {}
 
     public toModelsContainer(schemas: OpenAPI3SchemaContainer): IModelsContainer {