@kemdict/json-to-ts 0.1.0

package/src/get-type-structure.ts

@@ -0,0 +1,308 @@
+import { hash } from "node:crypto";
+
+import type { TypeGroup, TypeDescription, TypeStructure } from "./model.ts";
+import { isHash, getTypeDescriptionGroup, findTypeById, isArray, isObject, onlyUnique, isDate } from "./util.ts";
+
+function createTypeDescription(typeObj: any | string[], isUnion: boolean): TypeDescription {
+  if (isArray(typeObj)) {
+    return {
+      id: Hash(JSON.stringify([...typeObj, isUnion])),
+      arrayOfTypes: typeObj,
+      isUnion,
+    };
+  } else {
+    return {
+      id: Hash(JSON.stringify(typeObj)),
+      typeObj,
+    };
+  }
+}
+
+function getIdByType(typeObj: any | string[], types: TypeDescription[], isUnion: boolean = false): string {
+  let typeDesc = types.find((el) => {
+    return typeObjectMatchesTypeDesc(typeObj, el, isUnion);
+  });
+
+  if (!typeDesc) {
+    typeDesc = createTypeDescription(typeObj, isUnion);
+    types.push(typeDesc);
+  }
+
+  return typeDesc.id;
+}
+
+function Hash(content: string): string {
+  return hash("sha1", content);
+}
+
+function typeObjectMatchesTypeDesc(typeObj: any | string[], typeDesc: TypeDescription, isUnion: boolean): boolean {
+  if (isArray(typeObj)) {
+    return arraysContainSameElements(typeObj, typeDesc.arrayOfTypes!) && typeDesc.isUnion === isUnion;
+  } else {
+    return objectsHaveSameEntries(typeObj, typeDesc.typeObj);
+  }
+}
+
+function arraysContainSameElements(arr1: any[], arr2: any[]): boolean {
+  if (arr1 === undefined || arr2 === undefined) return false;
+
+  return arr1.sort().join("") === arr2.sort().join("");
+}
+
+function objectsHaveSameEntries(obj1: any, obj2: any): boolean {
+  if (obj1 === undefined || obj2 === undefined) return false;
+
+  const entries1 = Object.entries(obj1);
+  const entries2 = Object.entries(obj2);
+
+  const sameLength = entries1.length === entries2.length;
+
+  const sameTypes = entries1.every(([key, value]) => {
+    return obj2[key] === value;
+  });
+
+  return sameLength && sameTypes;
+}
+
+function getSimpleTypeName(value: any): string {
+  if (value === null) {
+    return "null";
+  } else if (value instanceof Date) {
+    return "Date";
+  } else {
+    return typeof value;
+  }
+}
+
+function getTypeGroup(value: any): TypeGroup {
+  if (isDate(value)) {
+    return "date";
+  } else if (isArray(value)) {
+    return "array";
+  } else if (isObject(value)) {
+    return "object";
+  } else {
+    return "primitive";
+  }
+}
+
+function createTypeObject(obj: any, types: TypeDescription[]): any {
+  return Object.entries(obj).reduce((typeObj, [key, value]) => {
+    const { rootTypeId } = getTypeStructure(value, types);
+
+    return {
+      ...typeObj,
+      [key]: rootTypeId,
+    };
+  }, {});
+}
+
+function getMergedObjects(typesOfArray: TypeDescription[], types: TypeDescription[]): string {
+  const typeObjects = typesOfArray.map((typeDesc) => typeDesc.typeObj);
+
+  const allKeys = typeObjects
+    .map((typeObj) => Object.keys(typeObj!))
+    .reduce((a, b) => [...a, ...b], [])
+    .filter(onlyUnique);
+
+  const commonKeys = typeObjects.reduce((commonKeys: string[], typeObj) => {
+    const keys = Object.keys(typeObj!);
+    return commonKeys.filter((key) => keys.includes(key));
+  }, allKeys) as string[];
+
+  const getKeyType = (key: string) => {
+    const typesOfKey = typeObjects
+      .filter((typeObj) => {
+        return Object.keys(typeObj!).includes(key);
+      })
+      .map((typeObj) => typeObj![key])
+      .filter(onlyUnique);
+
+    if (typesOfKey.length === 1) {
+      return typesOfKey.pop();
+    } else {
+      return getInnerArrayType(typesOfKey, types);
+    }
+  };
+
+  const typeObj = allKeys.reduce((obj: object, key: string) => {
+    const isMandatory = commonKeys.includes(key);
+    const type = getKeyType(key);
+
+    const keyValue = isMandatory ? key : toOptionalKey(key);
+
+    return {
+      ...obj,
+      [keyValue]: type,
+    };
+  }, {});
+  return getIdByType(typeObj, types, true);
+}
+
+function toOptionalKey(key: string): string {
+  return key.endsWith("--?") ? key : `${key}--?`;
+}
+
+function getMergedArrays(typesOfArray: TypeDescription[], types: TypeDescription[]): string {
+  const idsOfArrayTypes = typesOfArray
+    .map((typeDesc) => typeDesc.arrayOfTypes!)
+    .reduce((a, b) => [...a, ...b], [])
+    .filter(onlyUnique);
+
+  if (idsOfArrayTypes.length === 1) {
+    return getIdByType([idsOfArrayTypes.pop()], types);
+  } else {
+    return getIdByType([getInnerArrayType(idsOfArrayTypes, types)], types);
+  }
+}
+
+// we merge union types example: (number | string), null -> (number | string | null)
+function getMergedUnion(typesOfArray: string[], types: TypeDescription[]): string {
+  const innerUnionsTypes = typesOfArray
+    .map((id) => {
+      return findTypeById(id, types);
+    })
+    .filter((_) => !!_ && _.isUnion)
+    .map((_) => _!.arrayOfTypes!)
+    .reduce((a, b) => [...a, ...b], []);
+
+  const primitiveTypes = typesOfArray.filter((id) => !findTypeById(id, types) || !findTypeById(id, types)?.isUnion); // primitives or not union
+  return getIdByType([...innerUnionsTypes, ...primitiveTypes], types, true);
+}
+
+function getInnerArrayType(typesOfArray: string[], types: TypeDescription[]): string {
+  // return inner array type
+
+  const containsUndefined = typesOfArray.includes("undefined");
+
+  const arrayTypesDescriptions = typesOfArray.map((id) => findTypeById(id, types)).filter((_) => !!_);
+
+  const allArrayType =
+    arrayTypesDescriptions.filter((typeDesc) => getTypeDescriptionGroup(typeDesc).group === "array").length ===
+    typesOfArray.length;
+
+  const allArrayTypeWithUndefined =
+    arrayTypesDescriptions.filter((typeDesc) => getTypeDescriptionGroup(typeDesc).group === "array").length + 1 ===
+      typesOfArray.length && containsUndefined;
+
+  const allObjectTypeWithUndefined =
+    arrayTypesDescriptions.filter((typeDesc) => getTypeDescriptionGroup(typeDesc).group === "object").length + 1 ===
+      typesOfArray.length && containsUndefined;
+
+  const allObjectType =
+    arrayTypesDescriptions.filter((typeDesc) => getTypeDescriptionGroup(typeDesc).group === "object").length ===
+    typesOfArray.length;
+
+  if (typesOfArray.length === 0) {
+    // no types in array -> empty union type
+    return getIdByType([], types, true);
+  }
+
+  if (typesOfArray.length === 1) {
+    // one type in array -> that will be our inner type
+    return typesOfArray.pop() as (typeof typesOfArray)[number];
+  }
+
+  if (typesOfArray.length > 1) {
+    // multiple types in merge array
+    // if all are object we can merge them and return merged object as inner type
+    if (allObjectType) return getMergedObjects(arrayTypesDescriptions, types);
+    // if all are array we can merge them and return merged array as inner type
+    if (allArrayType) return getMergedArrays(arrayTypesDescriptions, types);
+
+    // all array types with posibble undefined, result type = undefined | (*mergedArray*)[]
+    if (allArrayTypeWithUndefined) {
+      return getMergedUnion([getMergedArrays(arrayTypesDescriptions, types), "undefined"], types);
+    }
+
+    // all object types with posibble undefined, result type = undefined | *mergedObject*
+    if (allObjectTypeWithUndefined) {
+      return getMergedUnion([getMergedObjects(arrayTypesDescriptions, types), "undefined"], types);
+    }
+
+    // if they are mixed or all primitive we cant merge them so we return as mixed union type
+    return getMergedUnion(typesOfArray, types);
+  }
+  throw new Error("Failed to get inner array type");
+}
+
+export function getTypeStructure(
+  targetObj: any, // object that we want to create types for
+  types: TypeDescription[] = []
+): TypeStructure {
+  switch (getTypeGroup(targetObj)) {
+    case "array":
+      const typesOfArray = (targetObj as any[]).map((_) => getTypeStructure(_, types).rootTypeId).filter(onlyUnique);
+      const arrayInnerTypeId = getInnerArrayType(typesOfArray, types); // create "union type of array types"
+      const typeId = getIdByType([arrayInnerTypeId], types); // create type "array of union type"
+
+      return {
+        rootTypeId: typeId,
+        types,
+      };
+
+    case "object":
+      const typeObj = createTypeObject(targetObj, types);
+      const objType = getIdByType(typeObj, types);
+
+      return {
+        rootTypeId: objType,
+        types,
+      };
+
+    case "primitive":
+      return {
+        rootTypeId: getSimpleTypeName(targetObj),
+        types,
+      };
+
+    case "date":
+      const dateType = getSimpleTypeName(targetObj);
+
+      return {
+        rootTypeId: dateType,
+        types,
+      };
+  }
+}
+
+function getAllUsedTypeIds({ rootTypeId, types }: TypeStructure): string[] | undefined {
+  const typeDesc = types.find((_) => _.id === rootTypeId);
+
+  function subTypes(typeDesc: TypeDescription | undefined): string[] | undefined {
+    const { group, desc } = getTypeDescriptionGroup(typeDesc);
+    switch (group) {
+      case "array":
+        const arrSubTypes = desc.arrayOfTypes
+          .filter(isHash)
+          .map((typeId) => {
+            const typeDesc = types.find((_) => _.id === typeId);
+            return subTypes(typeDesc);
+          })
+          .reduce((a, b) => [...a!, ...b!], []);
+        return [desc.id, ...arrSubTypes!];
+
+      case "object":
+        const objSubTypes = Object.values(desc.typeObj)
+          .filter(isHash)
+          .map((typeId) => {
+            const typeDesc = types.find((_) => _.id === typeId);
+            return subTypes(typeDesc);
+          })
+          .reduce((a, b) => [...a!, ...b!], []);
+        return [desc.id, ...objSubTypes!];
+    }
+  }
+
+  const result = subTypes(typeDesc);
+  if (!result) throw new Error("Failed to get all used type Ids");
+  return result;
+}
+
+export function optimizeTypeStructure(typeStructure: TypeStructure) {
+  const usedTypeIds = getAllUsedTypeIds(typeStructure);
+
+  const optimizedTypes = typeStructure.types.filter((typeDesc) => usedTypeIds?.includes(typeDesc.id));
+
+  typeStructure.types = optimizedTypes;
+}

package/src/index.ts

@@ -0,0 +1,39 @@
+import { getTypeStructure, optimizeTypeStructure } from "./get-type-structure.ts";
+import type { Options, State } from "./model.ts";
+import { getInterfaceDescriptions, getInterfaceStringFromDescription } from "./get-interfaces.ts";
+import { getNames } from "./get-names.ts";
+import { isArray, isObject } from "./util.ts";
+
+export function JsonToTS(json: any, options?: Options): string[] {
+  const state = {
+    keyName: options?.rootName ?? "RootObject",
+    export: !!options?.export,
+    useTypeAlias: !!options?.useTypeAlias,
+    lvl: 0,
+  } satisfies State;
+
+  /**
+   * Parsing currently works with (Objects) and (Array of Objects) not and primitive types and mixed arrays etc..
+   * so we shall validate, so we dont start parsing non Object type
+   */
+  const isArrayOfObjects = isArray(json) && json.length > 0 && json.reduce((a: any, b: any) => a && isObject(b), true);
+
+  if (!(isObject(json) || isArrayOfObjects)) {
+    throw new Error("Only (Object) and (Array of Object) are supported");
+  }
+
+  const typeStructure = getTypeStructure(json);
+  /**
+   * due to merging array types some types are switched out for merged ones
+   * so we delete the unused ones here
+   */
+  optimizeTypeStructure(typeStructure);
+
+  const names = getNames(typeStructure, state);
+
+  return getInterfaceDescriptions(typeStructure, names).map((description) =>
+    getInterfaceStringFromDescription({ ...description, state })
+  );
+}
+
+export default JsonToTS;

package/src/model.ts

@@ -0,0 +1,65 @@
+export type TypeGroup = "primitive" | "array" | "object" | "date";
+
+export type TypeGroupWithDescription =
+  | {
+      group: "primitive";
+      desc: undefined;
+    }
+  | { group: "array"; desc: TypeDescriptionWithArrayOfTypes }
+  | { group: "object"; desc: TypeDescriptionWithTypeObj };
+
+export interface TypeDescription {
+  id: string;
+  isUnion?: boolean;
+  typeObj?: { [index: string]: string };
+  arrayOfTypes?: string[];
+}
+
+export interface TypeDescriptionWithArrayOfTypes extends TypeDescription {
+  arrayOfTypes: string[];
+}
+export interface TypeDescriptionWithTypeObj extends TypeDescription {
+  typeObj: { [index: string]: string };
+}
+
+export interface TypeStructure {
+  rootTypeId: string;
+  types: TypeDescription[];
+}
+
+export interface NameEntry {
+  id: string;
+  name: string;
+}
+
+export interface NameStructure {
+  rootName: string;
+  names: NameEntry[];
+}
+
+export interface InterfaceDescription {
+  name: string;
+  typeMap: object;
+}
+
+export interface Options {
+  /** The name of the generated root type */
+  rootName?: string;
+  /** Whether to export the root type. */
+  export?: boolean;
+  /** Whether to generate `type Foo = { ... }` instead of interface */
+  useTypeAlias?: boolean;
+}
+
+export interface State {
+  keyName: string;
+  export: boolean;
+  useTypeAlias: boolean;
+  // Nested level (0+ integer), used to make sure we don't singularize the root object
+  lvl: number;
+}
+
+export interface KeyMetaData {
+  keyValue: string;
+  isOptional: boolean;
+}

package/src/util.ts

@@ -0,0 +1,63 @@
+import type {
+  KeyMetaData,
+  TypeDescription,
+  TypeDescriptionWithArrayOfTypes,
+  TypeGroupWithDescription,
+  TypeDescriptionWithTypeObj,
+} from "./model.ts";
+
+export function isHash(str: string) {
+  return str.length === 40;
+}
+
+export function onlyUnique<T>(value: T, index: number, self: T[]) {
+  return self.indexOf(value) === index;
+}
+
+export function isArray(x: any) {
+  return Object.prototype.toString.call(x) === "[object Array]";
+}
+
+export function isNonArrayUnion(typeName: string) {
+  const arrayUnionRegex = /^\(.*\)\[\]$/;
+
+  return typeName.includes(" | ") && !arrayUnionRegex.test(typeName);
+}
+
+export function isObject(x: any) {
+  return Object.prototype.toString.call(x) === "[object Object]" && x !== null;
+}
+
+export function isDate(x: any) {
+  return x instanceof Date;
+}
+
+export function parseKeyMetaData(key: string): KeyMetaData {
+  const isOptional = key.endsWith("--?");
+
+  if (isOptional) {
+    return {
+      isOptional,
+      keyValue: key.slice(0, -3),
+    };
+  } else {
+    return {
+      isOptional,
+      keyValue: key,
+    };
+  }
+}
+
+export function getTypeDescriptionGroup(desc: TypeDescription | undefined): TypeGroupWithDescription {
+  if (desc === undefined) {
+    return { group: "primitive", desc };
+  } else if (desc.arrayOfTypes !== undefined) {
+    return { group: "array", desc: desc as TypeDescriptionWithArrayOfTypes };
+  } else {
+    return { group: "object", desc: desc as TypeDescriptionWithTypeObj };
+  }
+}
+
+export function findTypeById(id: string, types: TypeDescription[]): TypeDescription | undefined {
+  return types.find((_) => _.id === id);
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "types": ["*"],
+    "module": "nodenext",
+    "target": "esnext",
+    "strict": true,
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+    "allowImportingTsExtensions": true,
+    "rewriteRelativeImportExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true
+  }
+}