JSON-To-TypeScript: merging types, WIP

k.golikov · k.golikov · commit fd573eeda317 · 2022-05-01T11:49:05.000+05:00
diff --git a/src/pages/jsonToTypeScriptPage/types/typescript.ts b/src/pages/jsonToTypeScriptPage/types/typescript.ts
@@ -1,5 +1,4 @@
 import { JsonPrimitive } from './json';
-import { IObject } from './common';
 import getTypeScriptTypeReference from '../utils/getTypeScriptTypeReference';
 import mapObject from '../../../utils/mapObject';
 import ExportType from './ExportType';
@@ -8,10 +7,13 @@ export interface ITypeScriptType {
     stringifyReference(): string;
 }
 
-export interface IDeclarableTypeScriptType {
+export interface IDeclarable {
+    stringifyDeclarationBody(): string;
+}
+
+export interface IDeclarableTypeScriptType extends IDeclarable {
     readonly name: string;
     stringifyDeclaration(exportType?: ExportType): string;
-    stringifyDeclarationBody(): string;
 }
 
 export class TypeScriptUnknown implements ITypeScriptType {
@@ -22,10 +24,16 @@ export class TypeScriptUnknown implements ITypeScriptType {
     }
 }
 
-export class TypeScriptInterface extends IObject<TypeScriptType> implements ITypeScriptType, IDeclarableTypeScriptType {
-    public constructor(public readonly name: string, public readonly fields: Record<string, TypeScriptType>) {
-        super(fields);
+export class TypeScriptObjectField implements IDeclarable {
+    public constructor(public readonly type: TypeScriptType, public readonly isOptional = false) {}
+
+    stringifyDeclarationBody(): string {
+        return `${this.isOptional ? '?' : ''}: ${getTypeScriptTypeReference(this.type)}`;
     }
+}
+
+export class TypeScriptInterface implements ITypeScriptType, IDeclarableTypeScriptType {
+    public constructor(public readonly name: string, public readonly fields: Record<string, TypeScriptObjectField>) {}
 
     stringifyDeclaration(exportType?: ExportType): string {
         return `${getExportKeyword(exportType)}interface ${this.name} ${this.stringifyDeclarationBody()}`;
@@ -34,8 +42,8 @@ export class TypeScriptInterface extends IObject<TypeScriptType> implements ITyp
     stringifyDeclarationBody(): string {
         return (
             '{\n' +
-            mapObject(this.fields, (key, value) => {
-                return `    ${key}: ${getTypeScriptTypeReference(value)};`;
+            mapObject(this.fields, (key, field) => {
+                return `    ${key}${field.stringifyDeclarationBody()};`;
             }).join('\n') +
             '\n}'
         );
diff --git a/src/pages/jsonToTypeScriptPage/utils/getAllTypeScriptTypeDeclarableTypes.ts b/src/pages/jsonToTypeScriptPage/utils/getAllTypeScriptTypeDeclarableTypes.ts
@@ -22,7 +22,7 @@ const getAllTypeScriptTypeDeclarableTypes = (type: TypeScriptType): IDeclarableT
     }
 
     return [
-        ...mapObject(type.fields, (fieldName, fieldType) => getAllTypeScriptTypeDeclarableTypes(fieldType)).flatMap(
+        ...mapObject(type.fields, (fieldName, field) => getAllTypeScriptTypeDeclarableTypes(field.type)).flatMap(
             (value) => value
         ),
         type
diff --git a/src/pages/jsonToTypeScriptPage/utils/getTypeScriptType.ts b/src/pages/jsonToTypeScriptPage/utils/getTypeScriptType.ts
@@ -2,13 +2,15 @@ import { JsonArray, JsonType } from '../types/json';
 import {
     TypeScriptArray,
     TypeScriptInterface,
+    TypeScriptObjectField,
     TypeScriptType,
     TypeScriptUnion,
     TypeScriptUnknown
 } from '../types/typescript';
 import { camelCase, isString, mapValues } from 'lodash';
 import { singular } from 'pluralize';
 import capitalizeFirst from '../../../utils/capitalizeFirst';
+import getMergedTypeScriptTypes from './mergeTypeScriptTypesList';
 
 const getTypeScriptType = (name: string, jsonObject: JsonType): TypeScriptType => {
     // const parsedJson = parseJsonType(object);
@@ -25,24 +27,22 @@ const getTypeScriptType = (name: string, jsonObject: JsonType): TypeScriptType =
     }
 
     if (jsonObject instanceof JsonArray) {
-        if (jsonObject.types.length === 0) {
+        const typeScriptTypes = jsonObject.types.map((type) => getTypeScriptType(arrayElementName, type));
+        const mergedTypeScriptTypes = getMergedTypeScriptTypes(typeScriptTypes);
+
+        if (mergedTypeScriptTypes.length === 0) {
             return new TypeScriptArray(new TypeScriptUnknown());
         }
-        if (jsonObject.types.length === 1) {
-            return new TypeScriptArray(getTypeScriptType(arrayElementName, jsonObject.types[0]));
+        if (mergedTypeScriptTypes.length === 1) {
+            return new TypeScriptArray(mergedTypeScriptTypes[0]);
         }
 
-        return new TypeScriptArray(
-            new TypeScriptUnion(
-                arrayElementName,
-                jsonObject.types.map((type) => getTypeScriptType(arrayElementName, type))
-            )
-        );
+        return new TypeScriptArray(new TypeScriptUnion(arrayElementName, mergedTypeScriptTypes));
     }
 
     return new TypeScriptInterface(
         typeName,
-        mapValues(jsonObject.fields, (field, name) => getTypeScriptType(name, field))
+        mapValues(jsonObject.fields, (field, name) => new TypeScriptObjectField(getTypeScriptType(name, field)))
     );
 };
 
diff --git a/src/pages/jsonToTypeScriptPage/utils/mergeTypeScriptTypes.ts b/src/pages/jsonToTypeScriptPage/utils/mergeTypeScriptTypes.ts
@@ -0,0 +1,66 @@
+import { chain, isString } from 'lodash';
+import { TypeScriptInterface, TypeScriptObjectField, TypeScriptType, TypeScriptUnion } from '../types/typescript';
+
+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;
+    }
+
+    if (a instanceof TypeScriptInterface && b instanceof TypeScriptInterface) {
+        const aKeys = Object.keys(a.fields);
+        const bKeys = Object.keys(b.fields);
+
+        const allKeys = chain([aKeys, bKeys]).flatMap().uniq().value();
+
+        const mergedFields = chain(allKeys)
+            .reduce((result, fieldKey) => {
+                const aHasKey = aKeys.includes(fieldKey);
+                const bHasKey = bKeys.includes(fieldKey);
+
+                const aField = a.fields[fieldKey];
+                const bField = b.fields[fieldKey];
+
+                if (!aHasKey && !bHasKey) {
+                    console.error('Both keys are undefined');
+                    return result;
+                }
+
+                if (aHasKey && !bHasKey) {
+                    result[fieldKey] = new TypeScriptObjectField(aField.type, true);
+                    return result;
+                }
+
+                if (!aHasKey && bHasKey) {
+                    result[fieldKey] = new TypeScriptObjectField(bField.type, true);
+                    return result;
+                }
+
+                //has both keys
+
+                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(new TypeScriptUnion(fieldKey, mergedFieldTypes));
+                return result;
+            }, {} as Record<string, TypeScriptObjectField>)
+            .value();
+
+        return [new TypeScriptInterface(a.name, mergedFields)];
+    }
+
+    return bothTypes; //TODO
+};
+
+export default mergeTypeScriptTypes;
diff --git a/src/pages/jsonToTypeScriptPage/utils/mergeTypeScriptTypesList.ts b/src/pages/jsonToTypeScriptPage/utils/mergeTypeScriptTypesList.ts
@@ -0,0 +1,18 @@
+import { TypeScriptType } from '../types/typescript';
+import mergeTypeScriptTypes from './mergeTypeScriptTypes';
+import { last } from 'lodash';
+
+//TODO
+const getMergedTypeScriptTypes = (types: TypeScriptType[]): TypeScriptType[] => {
+    return types.reduce((result, value) => {
+        const previous = last(result);
+
+        if (previous === undefined) {
+            return [value];
+        }
+
+        return mergeTypeScriptTypes(previous, value);
+    }, [] as TypeScriptType[]);
+};
+
+export default getMergedTypeScriptTypes;
diff --git a/src/pages/jsonToTypeScriptPage/utils/parseJsonObject.ts b/src/pages/jsonToTypeScriptPage/utils/parseJsonObject.ts
@@ -4,7 +4,7 @@ import { chain, isArray, isBoolean, isNil, isObject, isString, mapValues } from
 const parseJsonObject = (object: unknown): JsonType => {
     if (isObject(object)) {
         if (isArray(object)) {
-            return new JsonArray(chain(object).map(parseJsonObject).uniq().value());
+            return new JsonArray(chain(object).map(parseJsonObject).uniq().value()); //TODO remove `uniq` here?
         }
 
         return new JsonObject(

Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ const getAllTypeScriptTypeDeclarableTypes = (type: TypeScriptType): IDeclarableT`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`return [`
`25`		`- ...mapObject(type.fields, (fieldName, fieldType) => getAllTypeScriptTypeDeclarableTypes(fieldType)).flatMap(`
	`25`	`+ ...mapObject(type.fields, (fieldName, field) => getAllTypeScriptTypeDeclarableTypes(field.type)).flatMap(`
`26`	`26`	`(value) => value`
`27`	`27`	`),`
`28`	`28`	`type`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ import { chain, isArray, isBoolean, isNil, isObject, isString, mapValues } from`
`4`	`4`	`const parseJsonObject = (object: unknown): JsonType => {`
`5`	`5`	`if (isObject(object)) {`
`6`	`6`	`if (isArray(object)) {`
`7`		`- return new JsonArray(chain(object).map(parseJsonObject).uniq().value());`
	`7`	+ return new JsonArray(chain(object).map(parseJsonObject).uniq().value()); //TODO remove `uniq` here?
`8`	`8`	`}`
`9`	`9`
`10`	`10`	`return new JsonObject(`