add discriminator support

Luxoft · Mar 25, 2024 · b892859 · b892859
1 parent b5d6b50
commit b892859
Show file tree

Hide file tree

Showing 16 changed files with 426 additions and 92 deletions.
diff --git a/.snapshot/all/models.ts b/.snapshot/all/models.ts
@@ -2,17 +2,35 @@ import { Guid } from './Guid';
 import { toDateIn, toDateOut } from './date-converters';
 import type * as $types from './types';
 
+export enum CategoryUnionTypes {
+    CategoryElectronicsDto = '1',
+    CategoryMotorsDto = '2'
+}
+
 export enum ProductStatus {
     InStock = 0,
     OutOfStock = -1,
     UnderTheOrder = 1
 }
 
+interface ICategoryElectronicsDtoBaseInterface {
+    syntheticTest: $types.TypeOrUndefinedNullable<number>;
+}
+
+interface ICategoryMotorsDtoBaseInterface {
+    volume: $types.TypeOrUndefinedNullable<number>;
+}
+
 export interface ICategory {
     name: $types.TypeOrUndefinedNullable<string>;
+    type: $types.TypeOrUndefined<string>;
 }
 
+export type ICategoryElectronicsDto = ICategoryElectronicsDtoBaseInterface & ICategory;
+export type ICategoryMotorsDto = ICategoryMotorsDtoBaseInterface & ICategory;
+
 export interface IProduct {
+    categories: $types.TypeOrUndefinedNullable<ICategory[]>;
     category: $types.TypeOrUndefinedNullable<ICategory>;
     colors: $types.TypeOrUndefined<string[]>;
     expireDate: $types.TypeOrUndefined<string>;
@@ -27,6 +45,47 @@ export interface IProductIdentityDTO {
     id: $types.TypeOrUndefined<string>;
 }
 
+export type CategoryUnion = Category | CategoryElectronicsDto | CategoryMotorsDto;
+export type ICategoryUnion = ICategory | ICategoryElectronicsDto | ICategoryMotorsDto;
+
+export class CategoryUnionClass {
+    public static fromDTO(dto: ICategoryUnion): CategoryUnion {
+        if (this.isCategoryElectronicsDto(dto)) {
+            return CategoryElectronicsDto.fromDTO(dto);
+        }
+        if (this.isCategoryMotorsDto(dto)) {
+            return CategoryMotorsDto.fromDTO(dto);
+        }
+        return Category.fromDTO(dto);
+    }
+
+    public static toDTO(model: CategoryUnion): ICategoryUnion {
+        if (this.isICategoryElectronicsDto(model)) {
+            return CategoryElectronicsDto.toDTO(model);
+        }
+        if (this.isICategoryMotorsDto(model)) {
+            return CategoryMotorsDto.toDTO(model);
+        }
+        return Category.toDTO(model);
+    }
+
+    private static isCategoryElectronicsDto(dto: ICategoryUnion): dto is ICategoryElectronicsDto {
+        return dto.type === CategoryUnionTypes.CategoryElectronicsDto;
+    }
+
+    private static isCategoryMotorsDto(dto: ICategoryUnion): dto is ICategoryMotorsDto {
+        return dto.type === CategoryUnionTypes.CategoryMotorsDto;
+    }
+
+    private static isICategoryElectronicsDto(dto: CategoryUnion): dto is CategoryElectronicsDto {
+        return dto.type === CategoryUnionTypes.CategoryElectronicsDto;
+    }
+
+    private static isICategoryMotorsDto(dto: CategoryUnion): dto is CategoryMotorsDto {
+        return dto.type === CategoryUnionTypes.CategoryMotorsDto;
+    }
+}
+
 export class ProductIdentityDTO {
     public id: Guid;
     private __productIdentityDTO!: string;
@@ -42,23 +101,73 @@ export class ProductIdentityDTO {
 
 export class Category {
     public name: $types.TypeOrUndefinedNullable<string> = undefined;
+    public type: $types.TypeOrUndefined<string> = undefined;
     private __category!: string;
 
     public static toDTO(model: Partial<Category>): ICategory {
         return {
             name: model.name,
+            type: model.type,
         };
     }
 
     public static fromDTO(dto: ICategory): Category {
         const model = new Category();
         model.name = dto.name;
+        model.type = dto.type;
+        return model;
+    }
+}
+
+export class CategoryElectronicsDto {
+    public name: $types.TypeOrUndefinedNullable<string> = undefined;
+    public type: $types.TypeOrUndefined<string> = undefined;
+    public syntheticTest: $types.TypeOrUndefinedNullable<number> = undefined;
+    private __categoryElectronicsDto!: string;
+
+    public static toDTO(model: Partial<CategoryElectronicsDto>): ICategoryElectronicsDto {
+        return {
+            syntheticTest: model.syntheticTest,
+            name: model.name,
+            type: model.type,
+        };
+    }
+
+    public static fromDTO(dto: ICategoryElectronicsDto): CategoryElectronicsDto {
+        const model = new CategoryElectronicsDto();
+        model.syntheticTest = dto.syntheticTest;
+        model.name = dto.name;
+        model.type = dto.type;
+        return model;
+    }
+}
+
+export class CategoryMotorsDto {
+    public name: $types.TypeOrUndefinedNullable<string> = undefined;
+    public type: $types.TypeOrUndefined<string> = undefined;
+    public volume: $types.TypeOrUndefinedNullable<number> = undefined;
+    private __categoryMotorsDto!: string;
+
+    public static toDTO(model: Partial<CategoryMotorsDto>): ICategoryMotorsDto {
+        return {
+            volume: model.volume,
+            name: model.name,
+            type: model.type,
+        };
+    }
+
+    public static fromDTO(dto: ICategoryMotorsDto): CategoryMotorsDto {
+        const model = new CategoryMotorsDto();
+        model.volume = dto.volume;
+        model.name = dto.name;
+        model.type = dto.type;
         return model;
     }
 }
 
 export class Product {
-    public category: $types.TypeOrUndefinedNullable<Category> = undefined;
+    public categories: CategoryUnionClass[] = [];
+    public category: $types.TypeOrUndefinedNullable<CategoryUnionClass> = undefined;
     public colors: string[] = [];
     public expireDate: $types.TypeOrUndefined<Date> = undefined;
     public externalId: $types.TypeOrUndefinedNullable<Guid> = undefined;
@@ -70,6 +179,7 @@ export class Product {
 
     public static toDTO(model: Partial<Product>): IProduct {
         return {
+            categories: model.categories ? model.categories.map(x => Category.toDTO(x)) : undefined,
             category: model.category ? Category.toDTO(model.category) : undefined,
             colors: model.colors,
             expireDate: toDateOut(model.expireDate),
@@ -83,6 +193,7 @@ export class Product {
 
     public static fromDTO(dto: IProduct): Product {
         const model = new Product();
+        model.categories = dto.categories ? dto.categories.map(x => Category.fromDTO(x)) : [];
         model.category = dto.category ? Category.fromDTO(dto.category) : undefined;
         model.colors = dto.colors ? dto.colors : [];
         model.expireDate = toDateIn(dto.expireDate);

diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "@luxbss/gengen",
-    "version": "1.2.6",
+    "version": "1.2.7",
     "description": "Tool for generating models and Angular services based on OpenAPIs and Swagger's JSON",
     "bin": {
         "gengen": "./bin/index.js"

diff --git a/src/generators/ModelsGenerator.ts b/src/generators/ModelsGenerator.ts
@@ -12,13 +12,13 @@ import {
 } from 'ts-morph';
 import { IEnumModel } from '../models/EnumModel';
 import { IIdentityModel } from '../models/IdentityModel';
-import { IInterfaceModel } from '../models/InterfaceModel';
+import { IInterfaceModel, IInterfaceUnionModel } from '../models/InterfaceModel';
 import { IModelsContainer } from '../models/ModelsContainer';
 import { IObjectModel, IObjectPropertyModel } from '../models/ObjectModel';
 import { PropertyKind } from '../models/kinds/PropertyKind';
 import { IOptions } from '../options';
 import { PathBuilder } from '../services/PathBuilder';
-import { lowerFirst } from '../utils';
+import { getInterfaceName, lowerFirst } from '../utils';
 import { InterfacesGenerator } from './models-generator/InterfacesGenerator';
 import { TypeSerializer } from './utils/TypeSerializer';
 import { ARRAY_STRING, NULL_STRING, TYPES_NAMESPACE, UNDEFINED_STRING } from './utils/consts';
@@ -37,6 +37,8 @@ export class ModelsGenerator {
             ...this.getImports(),
             ...this.getEnums(models.enums),
             ...this.interfaceGenerator.getCodeStructure(models.interfaces),
+            ...this.interfaceGenerator.getCodeUnionsStructure(models.unionInterfaces),
+            ...this.getUnionObjects(models.unionInterfaces),
             ...this.getIdentities(models.identities, models.interfaces),
             ...this.getObjects(models.objects)
         ];
@@ -120,6 +122,71 @@ export class ModelsGenerator {
             })
         );
     }
+    private getUnionObjects(objects: IInterfaceUnionModel[]): ClassDeclarationStructure[] {
+        return objects.map((z) => ({
+            kind: StructureKind.Class,
+            isExported: true,
+            name: z.name + 'Class',
+            properties: [],
+            methods: [
+                {
+                    scope: Scope.Public,
+                    isStatic: true,
+                    name: FROM_DTO_METHOD,
+                    parameters: [{ name: 'dto', type: getInterfaceName(z.name) }],
+                    returnType: z.name,
+                    statements: (x) => {
+                        z.unionInterfaces.forEach((i) => {
+                            x.writeLine('if (this.is' + i + '(dto)){');
+                            x.writeLine('return ' + i + '.fromDTO(dto);');
+                            x.writeLine('}');
+                        });
+
+                        x.writeLine('return ' + z.parentInterface + '.fromDTO(dto);');
+                    }
+                },
+
+                {
+                    scope: Scope.Public,
+                    isStatic: true,
+                    name: TO_DTO_METHOD,
+                    parameters: [{ name: 'model', type: z.name }],
+                    returnType: getInterfaceName(z.name),
+                    statements: (x) => {
+                        z.unionInterfaces.forEach((i) => {
+                            x.writeLine('if (this.is' + getInterfaceName(i) + '(model)){');
+                            x.writeLine('return ' + i + '.toDTO(model);');
+                            x.writeLine('}');
+                        });
+
+                        x.writeLine('return ' + z.parentInterface + '.toDTO(model);');
+                    }
+                },
+
+                ...z.unionInterfaces.map((i) => ({
+                    scope: Scope.Private,
+                    isStatic: true,
+                    name: 'is' + i,
+                    parameters: [{ name: 'dto', type: getInterfaceName(z.name) }],
+                    returnType: 'dto is ' + getInterfaceName(i),
+                    statements: (x: CodeBlockWriter) => {
+                        x.writeLine('return dto.type === ' + z.name + 'Types.' + i + ';');
+                    }
+                })),
+
+                ...z.unionInterfaces.map((i) => ({
+                    scope: Scope.Private,
+                    isStatic: true,
+                    name: 'is' + getInterfaceName(i),
+                    parameters: [{ name: 'dto', type: z.name }],
+                    returnType: 'dto is ' + i,
+                    statements: (x: CodeBlockWriter) => {
+                        x.writeLine('return dto.type === ' + z.name + 'Types.' + i + ';');
+                    }
+                }))
+            ]
+        }));
+    }
 
     private getObjects(objects: IObjectModel[]): ClassDeclarationStructure[] {
         return objects.map((z) => ({
@@ -191,7 +258,7 @@ export class ModelsGenerator {
             scope: Scope.Public,
             name: objectProperty.name,
             type: new TypeSerializer({
-                type: { name: objectProperty.type },
+                type: { name: objectProperty.typeAlias ?? objectProperty.type },
                 isNullable: objectProperty.isNullable,
                 isCollection: objectProperty.isCollection
             }).toString(),
@@ -239,7 +306,9 @@ export class ModelsGenerator {
 
             case PropertyKind.Object:
                 if (property.isCollection) {
-                    return `${modelProperty} ? ${modelProperty}.map(x => ${property.type}.${TO_DTO_METHOD}(x)) : ${UNDEFINED_STRING}`;
+                    return `${modelProperty} ? ${modelProperty}.map(x => ${
+                        property.dtoTypeAlias ?? property.type
+                    }.${TO_DTO_METHOD}(x)) : ${UNDEFINED_STRING}`;
                 }
 
                 return `${modelProperty} ? ${property.type}.${TO_DTO_METHOD}(${modelProperty}) : ${UNDEFINED_STRING}`;
@@ -279,7 +348,9 @@ export class ModelsGenerator {
 
             case PropertyKind.Object:
                 if (property.isCollection) {
-                    return `${dtoProperty} ? ${dtoProperty}.map(x => ${property.type}.${FROM_DTO_METHOD}(x)) : ${ARRAY_STRING}`;
+                    return `${dtoProperty} ? ${dtoProperty}.map(x => ${
+                        property.dtoTypeAlias ?? property.type
+                    }.${FROM_DTO_METHOD}(x)) : ${ARRAY_STRING}`;
                 }
 
                 return `${dtoProperty} ? ${property.type}.${FROM_DTO_METHOD}(${dtoProperty}) : ${UNDEFINED_STRING}`;

diff --git a/src/generators/models-generator/InterfacesGenerator.ts b/src/generators/models-generator/InterfacesGenerator.ts
@@ -6,8 +6,9 @@ import {
     TypeAliasDeclarationStructure
 } from 'ts-morph';
 
-import { IInterfaceModel, IInterfacePropertyModel } from '../../models/InterfaceModel';
+import { IInterfaceModel, IInterfacePropertyModel, IInterfaceUnionModel } from '../../models/InterfaceModel';
 import { TypeSerializer } from '../utils/TypeSerializer';
+import { getInterfaceName } from '../../utils';
 
 export class InterfacesGenerator {
     public getCodeStructure(interfaces: IInterfaceModel[]): (InterfaceDeclarationStructure | TypeAliasDeclarationStructure)[] {
@@ -39,6 +40,26 @@ export class InterfacesGenerator {
         return [...baseInterfaces, ...types];
     }
 
+    public getCodeUnionsStructure(interfaces: IInterfaceUnionModel[]): TypeAliasDeclarationStructure[] {
+        const classUnion: TypeAliasDeclarationStructure[] = interfaces.map((z) => {
+            return {
+                kind: StructureKind.TypeAlias,
+                type: z.parentInterface + '|' + z.unionInterfaces.join(' | '),
+                name: z.name,
+                isExported: true
+            };
+        });
+        const interfacesUnion: TypeAliasDeclarationStructure[] = interfaces.map((z) => {
+            return {
+                kind: StructureKind.TypeAlias,
+                type: getInterfaceName(z.parentInterface) + '|' + z.unionInterfaces.map((x) => getInterfaceName(x)).join(' | '),
+                name: getInterfaceName(z.name),
+                isExported: true
+            };
+        });
+        return [...classUnion, ...interfacesUnion];
+    }
+
     protected getInterfaceProperty(model: IInterfacePropertyModel): OptionalKind<PropertySignatureStructure> {
         return {
             name: model.name,

diff --git a/src/models/EnumModel.ts b/src/models/EnumModel.ts
@@ -1,5 +1,5 @@
 export interface IEnumModel {
     name: string;
     isNullable: boolean;
-    items: { key: string; value: number }[];
+    items: { key: string; value: number | string }[];
 }
diff --git a/src/models/InterfaceModel.ts b/src/models/InterfaceModel.ts
@@ -10,3 +10,9 @@ export interface IInterfaceModel {
     properties: IInterfacePropertyModel[];
     combineInterfaces: string[];
 }
+
+export interface IInterfaceUnionModel {
+    name: string;
+    parentInterface: string;
+    unionInterfaces: string[];
+}