refactor: move toTypeScriptAst() method out of types

Refactor `toTypeScriptAst()` methods to use centralized router pattern

Author: streamich

src/type/classes/AbstractType.ts

@@ -288,9 +288,10 @@ export abstract class AbstractType<S extends schema.Schema> implements BaseType<
     return random(this);
   }
 
-  public toTypeScriptAst(): ts.TsNode {
-    const node: ts.TsUnknownKeyword = {node: 'UnknownKeyword'};
-    return node;
+  public toTypeScriptAst(): ts.TsType {
+    // Use dynamic import to avoid circular dependency
+    const converter = require('../../typescript/converter');
+    return converter.toTypeScriptAst(this.getSchema());
   }
 
   public toJson(value: unknown, system: TypeSystem | undefined = this.system): json_string<unknown> {

src/type/classes/AnyType.ts

@@ -70,8 +70,4 @@ export class AnyType extends AbstractType<schema.AnySchema> {
   public codegenJsonEncoder(ctx: JsonEncoderCodegenContext, value: JsExpression): void {
     this.codegenBinaryEncoder(ctx, value);
   }
-
-  public toTypeScriptAst(): ts.TsType {
-    return {node: 'AnyKeyword'};
-  }
 }

src/type/classes/ArrayType.ts

@@ -143,13 +143,6 @@ export class ArrayType<T extends Type> extends AbstractType<schema.ArraySchema<S
     );
   }
 
-  public toTypeScriptAst(): ts.TsArrayType {
-    return {
-      node: 'ArrayType',
-      elementType: this.type.toTypeScriptAst() as ts.TsType,
-    };
-  }
-
   public toJson(value: unknown, system: TypeSystem | undefined = this.system): json_string<unknown> {
     const length = (value as unknown[]).length;
     if (!length) return '[]' as json_string<unknown>;

src/type/classes/BinaryType.ts

@@ -103,16 +103,6 @@ export class BinaryType<T extends Type> extends AbstractType<schema.BinarySchema
     this.codegenBinaryEncoder(ctx, value);
   }
 
-  public toTypeScriptAst(): ts.TsGenericTypeAnnotation {
-    return {
-      node: 'GenericTypeAnnotation',
-      id: {
-        node: 'Identifier',
-        name: 'Uint8Array',
-      },
-    };
-  }
-
   public toJson(value: unknown, system: TypeSystem | undefined = this.system): json_string<unknown> {
     return ('"' + stringifyBinary(value as Uint8Array) + '"') as json_string<unknown>;
   }

src/type/classes/BooleanType.ts

@@ -52,10 +52,6 @@ export class BooleanType extends AbstractType<schema.BooleanSchema> {
     this.codegenBinaryEncoder(ctx, value);
   }
 
-  public toTypeScriptAst(): ts.TsBooleanKeyword {
-    return {node: 'BooleanKeyword'};
-  }
-
   public toJson(value: unknown, system: TypeSystem | undefined = this.system) {
     return (value ? 'true' : 'false') as json_string<boolean>;
   }

src/type/classes/ConstType.ts

@@ -70,41 +70,6 @@ export class ConstType<V = any> extends AbstractType<schema.ConstSchema<V>> {
     this.codegenBinaryEncoder(ctx, value);
   }
 
-  public toTypeScriptAst() {
-    const value = this.schema.value;
-    if (value === null) {
-      const node: ts.TsNullKeyword = {node: 'NullKeyword'};
-      return node;
-    }
-    switch (typeof value) {
-      case 'string': {
-        const node: ts.TsStringLiteral = {node: 'StringLiteral', text: value};
-        return node;
-      }
-      case 'number': {
-        const node: ts.TsNumericLiteral = {
-          node: 'NumericLiteral',
-          text: value.toString(),
-        };
-        return node;
-      }
-      case 'boolean': {
-        const node: ts.TsTrueKeyword | ts.TsFalseKeyword = {
-          node: value ? 'TrueKeyword' : 'FalseKeyword',
-        };
-        return node;
-      }
-      case 'object': {
-        const node: ts.TsObjectKeyword = {node: 'ObjectKeyword'};
-        return node;
-      }
-      default: {
-        const node: ts.TsUnknownKeyword = {node: 'UnknownKeyword'};
-        return node;
-      }
-    }
-  }
-
   public toJson(value: unknown, system: TypeSystem | undefined = this.system) {
     return this.__json;
   }

src/type/classes/FunctionType.ts

@@ -56,31 +56,6 @@ export class FunctionType<Req extends Type, Res extends Type> extends AbstractTy
     return this;
   }
 
-  public toTypeScriptAst(): ts.TsFunctionType {
-    const node: ts.TsFunctionType = {
-      node: 'FunctionType',
-      parameters: [
-        {
-          node: 'Parameter',
-          name: {
-            node: 'Identifier',
-            name: 'request',
-          },
-          type: this.req.toTypeScriptAst(),
-        },
-      ],
-      type: {
-        node: 'TypeReference',
-        typeName: {
-          node: 'Identifier',
-          name: 'Promise',
-        },
-        typeArguments: [this.res.toTypeScriptAst()],
-      },
-    };
-    return node;
-  }
-
   public toString(tab: string = ''): string {
     return super.toString(tab) + toStringTree(tab, this);
   }
@@ -124,38 +99,6 @@ export class FunctionStreamingType<Req extends Type, Res extends Type> extends A
     return this;
   }
 
-  public toTypeScriptAst(): ts.TsFunctionType {
-    const node: ts.TsFunctionType = {
-      node: 'FunctionType',
-      parameters: [
-        {
-          node: 'Parameter',
-          name: {
-            node: 'Identifier',
-            name: 'request$',
-          },
-          type: {
-            node: 'TypeReference',
-            typeName: {
-              node: 'Identifier',
-              name: 'Observable',
-            },
-            typeArguments: [this.req.toTypeScriptAst()],
-          },
-        },
-      ],
-      type: {
-        node: 'TypeReference',
-        typeName: {
-          node: 'Identifier',
-          name: 'Observable',
-        },
-        typeArguments: [this.res.toTypeScriptAst()],
-      },
-    };
-    return node;
-  }
-
   public toString(tab: string = ''): string {
     return super.toString(tab) + toStringTree(tab, this);
   }

src/type/classes/MapType.ts

@@ -134,16 +134,6 @@ export class MapType<T extends Type> extends AbstractType<schema.MapSchema<Schem
     ctx.blob(objEndBlob);
   }
 
-  public toTypeScriptAst(): ts.TsTypeReference {
-    const node: ts.TsTypeReference = {
-      node: 'TypeReference',
-      typeName: 'Record',
-      typeArguments: [{node: 'StringKeyword'}, this.type.toTypeScriptAst()],
-    };
-    // augmentWithComment(this.schema, node);
-    return node;
-  }
-
   public toJson(value: unknown, system: TypeSystem | undefined = this.system): json_string<unknown> {
     const map = value as Record<string, unknown>;
     const keys = Object.keys(map);

src/type/classes/NumberType.ts

@@ -114,10 +114,6 @@ export class NumberType extends AbstractType<schema.NumberSchema> {
     this.codegenBinaryEncoder(ctx, value);
   }
 
-  public toTypeScriptAst(): ts.TsNumberKeyword {
-    return {node: 'NumberKeyword'};
-  }
-
   public toJson(value: unknown, system: TypeSystem | undefined = this.system) {
     return ('' + value) as json_string<number>;
   }

src/type/classes/ObjectType.ts

@@ -460,31 +460,6 @@ if (${rLength}) {
     }
   }
 
-  public toTypeScriptAst(): ts.TsTypeLiteral {
-    const node: ts.TsTypeLiteral = {
-      node: 'TypeLiteral',
-      members: [],
-    };
-    const fields = this.fields;
-    for (const field of fields) {
-      const member: ts.TsPropertySignature = {
-        node: 'PropertySignature',
-        name: field.key,
-        type: field.value.toTypeScriptAst(),
-      };
-      if (field instanceof ObjectOptionalFieldType) member.optional = true;
-      augmentWithComment(field.getSchema(), member);
-      node.members.push(member);
-    }
-    if (this.schema.unknownFields || this.schema.encodeUnknownFields)
-      node.members.push({
-        node: 'IndexSignature',
-        type: {node: 'UnknownKeyword'},
-      });
-    augmentWithComment(this.schema, node);
-    return node;
-  }
-
   public toJson(value: unknown, system: TypeSystem | undefined = this.system): json_string<unknown> {
     const fields = this.fields;
     const length = fields.length;