JSON-To-TypeScript: merging types

k.golikov · k.golikov · commit 7d1633744908 · 2022-05-01T13:28:59.000+05:00
diff --git a/src/pages/jsonToTypeScriptPage/JsonToTypeScriptPage.tsx b/src/pages/jsonToTypeScriptPage/JsonToTypeScriptPage.tsx
@@ -31,7 +31,10 @@ const JsonToTypeScriptPage = () => {
             }
 
             const typeScriptType = getTypeScriptType('Root', parseJsonObject(JSON.parse(json)));
-            return getAllTypeScriptTypeDeclarations(typeScriptType, 'Root', ExportType.ES_MODULE);
+            return getAllTypeScriptTypeDeclarations(typeScriptType, 'Root', {
+                exportType: ExportType.ES_MODULE,
+                isReversedOrder: true
+            });
         },
         [json],
         50
diff --git a/src/pages/jsonToTypeScriptPage/types/TypeScriptDeclarationOptions.ts b/src/pages/jsonToTypeScriptPage/types/TypeScriptDeclarationOptions.ts
@@ -0,0 +1,8 @@
+import ExportType from './ExportType';
+
+interface TypeScriptDeclarationOptions {
+    exportType?: ExportType;
+    isReversedOrder?: boolean;
+}
+
+export default TypeScriptDeclarationOptions;
diff --git a/src/pages/jsonToTypeScriptPage/types/typescript.ts b/src/pages/jsonToTypeScriptPage/types/typescript.ts
@@ -2,6 +2,8 @@ import { JsonPrimitive } from './json';
 import getTypeScriptTypeReference from '../utils/getTypeScriptTypeReference';
 import mapObject from '../../../utils/mapObject';
 import ExportType from './ExportType';
+import { isObject, isString } from 'lodash';
+import TypeScriptDeclarationOptions from './TypeScriptDeclarationOptions';
 
 export interface ITypeScriptType {
     stringifyReference(): string;
@@ -12,8 +14,38 @@ export interface IDeclarable {
 }
 
 export interface IDeclarableTypeScriptType extends IDeclarable {
-    readonly name: string;
-    stringifyDeclaration(exportType?: ExportType): string;
+    name: string;
+    stringifyDeclaration(options: TypeScriptDeclarationOptions): string;
+}
+
+export class DeclarableTypeScriptType implements IDeclarableTypeScriptType {
+    constructor(name: string, type: IDeclarableTypeScriptType | TypeScriptType) {
+        this.name = name;
+        this.type = type;
+    }
+
+    public readonly name: string;
+    private readonly type: IDeclarableTypeScriptType | TypeScriptType;
+
+    stringifyDeclaration(options: TypeScriptDeclarationOptions): string {
+        if (isObject(this.type) && 'stringifyDeclaration' in this.type) {
+            return this.type.stringifyDeclaration(options);
+        }
+
+        return `${getExportKeyword(options.exportType)}type ${this.name} = ${this.stringifyDeclarationBody()}`;
+    }
+
+    stringifyDeclarationBody(): string {
+        if (isString(this.type)) {
+            return this.type;
+        }
+
+        return 'stringifyDeclarationBody' in this.type
+            ? this.type.stringifyDeclarationBody()
+            : 'stringifyReference' in this.type
+            ? this.type.stringifyReference()
+            : '';
+    }
 }
 
 export class TypeScriptUnknown implements ITypeScriptType {
@@ -33,9 +65,9 @@ export class TypeScriptObjectField implements IDeclarable {
 }
 
 export class TypeScriptInterface implements ITypeScriptType, IDeclarableTypeScriptType {
-    public constructor(public readonly name: string, public readonly fields: Record<string, TypeScriptObjectField>) {}
+    public constructor(public name: string, public readonly fields: Record<string, TypeScriptObjectField>) {}
 
-    stringifyDeclaration(exportType?: ExportType): string {
+    stringifyDeclaration({ exportType }: TypeScriptDeclarationOptions): string {
         return `${getExportKeyword(exportType)}interface ${this.name} ${this.stringifyDeclarationBody()}`;
     }
 
@@ -70,7 +102,7 @@ export class TypeScriptArray implements ITypeScriptType {
 
 export class TypeScriptUnion implements ITypeScriptType {
     //, IDeclarableTypeScriptType {
-    public constructor(public readonly name: string, public readonly types: TypeScriptType[]) {}
+    public constructor(public name: string, public readonly types: TypeScriptType[]) {}
 
     // stringifyDeclaration(exportType?: ExportType): string {
     //     return `${getExportKeyword(exportType)}type ${this.name} = ${this.stringifyDeclarationBody()};`;
@@ -87,7 +119,7 @@ export class TypeScriptUnion implements ITypeScriptType {
 
 //TODO add tuples support
 export class TypeScriptTuple implements ITypeScriptType {
-    public constructor(public readonly name: string, public readonly types: TypeScriptType[]) {}
+    public constructor(public name: string, public readonly types: TypeScriptType[]) {}
 
     stringifyDeclarationBody(): string {
         return '[' + this.types.map(getTypeScriptTypeReference).join(', ') + ']';
diff --git a/src/pages/jsonToTypeScriptPage/utils/getAllTypeScriptTypeDeclarableTypes.ts b/src/pages/jsonToTypeScriptPage/utils/getAllTypeScriptTypeDeclarableTypes.ts
diff --git a/src/pages/jsonToTypeScriptPage/utils/getAllTypeScriptTypeDeclarations.ts b/src/pages/jsonToTypeScriptPage/utils/getAllTypeScriptTypeDeclarations.ts
@@ -1,18 +1,46 @@
-import getAllTypeScriptTypeDeclarableTypes from './getAllTypeScriptTypeDeclarableTypes';
-import { TypeScriptType } from '../types/typescript';
-import getTypeScriptTypeDeclaration from './getTypeScriptTypeDeclaration';
-import ExportType from '../types/ExportType';
+import { getAllTypeScriptTypeDeclarableTypes } from './getAllTypeScriptTypeInnerDeclarableTypes';
+import { IDeclarableTypeScriptType, TypeScriptType } from '../types/typescript';
+import TypeScriptDeclarationOptions from '../types/TypeScriptDeclarationOptions';
 
-const getAllTypeScriptTypeDeclarations = (type: TypeScriptType, name: string, exportType?: ExportType) => {
-    const declarableTypes = getAllTypeScriptTypeDeclarableTypes(type);
+const renameConflictingType = (
+    type: IDeclarableTypeScriptType,
+    isConflicting: (type: IDeclarableTypeScriptType) => boolean
+): void => {
+    const match = /^(.*?)(\d+)$/.exec(type.name);
+    if (!match) {
+        type.name += '1';
+    } else {
+        const [, left, numericPart] = match;
+        const numeric = Number(numericPart);
+        type.name = `${left}${numeric + 1}`;
+    }
 
-    if (declarableTypes.length === 0) {
-        return getTypeScriptTypeDeclaration(type, name, exportType);
+    if (isConflicting(type)) {
+        renameConflictingType(type, isConflicting);
     }
+};
+
+const getAllTypeScriptTypeDeclarations = (
+    type: TypeScriptType,
+    name: string,
+    options: TypeScriptDeclarationOptions
+): string => {
+    const declarableTypes = getAllTypeScriptTypeDeclarableTypes(type, name, options);
+
+    const correctlyNamedDeclarableTypes: IDeclarableTypeScriptType[] = [];
+
+    declarableTypes.forEach((declarableType) => {
+        const isConflicting = (type: IDeclarableTypeScriptType) =>
+            correctlyNamedDeclarableTypes.some((value) => value.name === type.name);
+
+        if (isConflicting(declarableType)) {
+            renameConflictingType(declarableType, isConflicting);
+        }
+
+        correctlyNamedDeclarableTypes.push(declarableType);
+    });
 
-    return declarableTypes
-        .map((declarable) => getTypeScriptTypeDeclaration(declarable as TypeScriptType, name, exportType))
-        .join('\n\n');
+    return declarableTypes.map((declarable) => declarable.stringifyDeclaration(options)).join('\n\n');
 };
 
 export default getAllTypeScriptTypeDeclarations;
diff --git a/src/pages/jsonToTypeScriptPage/utils/getAllTypeScriptTypeInnerDeclarableTypes.ts b/src/pages/jsonToTypeScriptPage/utils/getAllTypeScriptTypeInnerDeclarableTypes.ts
@@ -0,0 +1,64 @@
+import {
+    DeclarableTypeScriptType,
+    IDeclarableTypeScriptType,
+    TypeScriptArray,
+    TypeScriptType,
+    TypeScriptUnion,
+    TypeScriptUnknown
+} from '../types/typescript';
+import { isObject, isString } from 'lodash';
+import mapObject from '../../../utils/mapObject';
+import TypeScriptDeclarationOptions from '../types/TypeScriptDeclarationOptions';
+
+const getAllTypeScriptTypeInnerDeclarableTypes = (
+    type: TypeScriptType,
+    options: TypeScriptDeclarationOptions,
+    includeSelf = false
+): IDeclarableTypeScriptType[] => {
+    if (isString(type) || type instanceof TypeScriptUnknown) {
+        return []; //getTypeScriptTypeDeclaration(type, name, exportType)
+    }
+
+    if (type instanceof TypeScriptUnion) {
+        return type.types.flatMap((innerType) => getAllTypeScriptTypeInnerDeclarableTypes(innerType, options, true));
+    }
+
+    if (type instanceof TypeScriptArray) {
+        return getAllTypeScriptTypeInnerDeclarableTypes(type.type, options, true);
+    }
+
+    const result = mapObject(type.fields, (fieldName, field) =>
+        getAllTypeScriptTypeInnerDeclarableTypes(field.type, options, true)
+    ).flatMap((value) => value);
+
+    if (includeSelf) {
+        if (options.isReversedOrder) {
+            result.unshift(type);
+        } else {
+            result.push(type);
+        }
+    }
+
+    return result;
+};
+
+export const getAllTypeScriptTypeDeclarableTypes = (
+    type: TypeScriptType,
+    name: string,
+    options: TypeScriptDeclarationOptions
+): IDeclarableTypeScriptType[] => {
+    const declarableTypes: IDeclarableTypeScriptType[] = getAllTypeScriptTypeInnerDeclarableTypes(type, options);
+
+    const declarableSelf: IDeclarableTypeScriptType =
+        isObject(type) && 'stringifyDeclaration' in type ? type : new DeclarableTypeScriptType(name, type);
+
+    if (options.isReversedOrder) {
+        declarableTypes.unshift(declarableSelf);
+    } else {
+        declarableTypes.push(declarableSelf);
+    }
+
+    return declarableTypes;
+};
+
+export default getAllTypeScriptTypeInnerDeclarableTypes;
diff --git a/src/pages/jsonToTypeScriptPage/utils/getTypeScriptTypeDeclaration.ts b/src/pages/jsonToTypeScriptPage/utils/getTypeScriptTypeDeclaration.ts
@@ -1,14 +1,19 @@
-import { TypeScriptType } from '../types/typescript';
+import { DeclarableTypeScriptType, TypeScriptType } from '../types/typescript';
 import { isObject } from 'lodash';
-import ExportType from '../types/ExportType';
-import getTypeScriptTypeReference from './getTypeScriptTypeReference';
+import TypeScriptDeclarationOptions from '../types/TypeScriptDeclarationOptions';
 
-const getTypeScriptTypeDeclaration = (type: TypeScriptType, name: string, exportType?: ExportType): string => {
+const getTypeScriptTypeDeclaration = (
+    type: TypeScriptType,
+    name: string,
+    options: TypeScriptDeclarationOptions
+): string => {
     if (isObject(type) && 'stringifyDeclaration' in type) {
-        return type.stringifyDeclaration(exportType);
+        return type.stringifyDeclaration(options);
     }
 
-    return `type ${name} = ${getTypeScriptTypeReference(type)};`;
+    return new DeclarableTypeScriptType(name, type).stringifyDeclaration(options);
+    //
+    // return `type ${name} = ${getTypeScriptTypeReference(type)};`;
 };
 
 export default getTypeScriptTypeDeclaration;
diff --git a/src/pages/jsonToTypeScriptPage/utils/getTypeScriptUnion.ts b/src/pages/jsonToTypeScriptPage/utils/getTypeScriptUnion.ts
@@ -0,0 +1,14 @@
+import { TypeScriptType, TypeScriptUnion, TypeScriptUnknown } from '../types/typescript';
+
+const getTypeScriptUnion = (name: string, types: TypeScriptType[]): TypeScriptType => {
+    if (types.length === 0) {
+        return new TypeScriptUnknown();
+    }
+    if (types.length === 1) {
+        return types[0];
+    }
+
+    return new TypeScriptUnion(name, types);
+};
+
+export default getTypeScriptUnion;
diff --git a/src/pages/jsonToTypeScriptPage/utils/mergeTypeScriptTypes.ts b/src/pages/jsonToTypeScriptPage/utils/mergeTypeScriptTypes.ts
@@ -1,14 +1,11 @@
 import { chain, isString } from 'lodash';
 import { TypeScriptInterface, TypeScriptObjectField, TypeScriptType, TypeScriptUnion } from '../types/typescript';
+import mergeTypeScriptTypesList from './mergeTypeScriptTypesList';
 
 const mergeTypeScriptTypes = (a: TypeScriptType, b: TypeScriptType): TypeScriptType[] => {
     const singleType = [a];
     const bothTypes = [a, b];
 
-    if (a.constructor !== b.constructor) {
-        return bothTypes;
-    }
-
     if (isString(a) && isString(b)) {
         return a === b ? singleType : bothTypes;
     }
@@ -44,22 +41,35 @@ const mergeTypeScriptTypes = (a: TypeScriptType, b: TypeScriptType): TypeScriptT
 
                 //has both keys
 
+                const isOptional = aField.isOptional || bField.isOptional;
+
                 const mergedFieldTypes = mergeTypeScriptTypes(aField.type, bField.type);
                 if (mergedFieldTypes.length === 0) {
                     return result;
                 }
                 if (mergedFieldTypes.length === 1) {
-                    result[fieldKey] = new TypeScriptObjectField(mergedFieldTypes[0], false);
+                    result[fieldKey] = new TypeScriptObjectField(mergedFieldTypes[0], isOptional);
+                    return result;
                 }
 
-                result[fieldKey] = new TypeScriptObjectField(new TypeScriptUnion(fieldKey, mergedFieldTypes));
+                result[fieldKey] = new TypeScriptObjectField(
+                    new TypeScriptUnion(fieldKey, mergedFieldTypes),
+                    isOptional
+                );
                 return result;
             }, {} as Record<string, TypeScriptObjectField>)
             .value();
 
         return [new TypeScriptInterface(a.name, mergedFields)];
     }
 
+    if (a instanceof TypeScriptUnion || b instanceof TypeScriptUnion) {
+        const aTypes = a instanceof TypeScriptUnion ? a.types : [a];
+        const bTypes = b instanceof TypeScriptUnion ? b.types : [b];
+
+        return mergeTypeScriptTypesList([...aTypes, ...bTypes]);
+    }
+
     return bothTypes; //TODO
 };
 

Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,10 @@ const JsonToTypeScriptPage = () => {`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`const typeScriptType = getTypeScriptType('Root', parseJsonObject(JSON.parse(json)));`
`34`		`- return getAllTypeScriptTypeDeclarations(typeScriptType, 'Root', ExportType.ES_MODULE);`
	`34`	`+ return getAllTypeScriptTypeDeclarations(typeScriptType, 'Root', {`
	`35`	`+ exportType: ExportType.ES_MODULE,`
	`36`	`+ isReversedOrder: true`
	`37`	`+ });`
`35`	`38`	`},`
`36`	`39`	`[json],`
`37`	`40`	`50`