ts-poet

What is ts-poet?

The ts-poet npm package is a TypeScript code generation library that allows you to programmatically create TypeScript code. It is particularly useful for generating code based on some input data or schema, such as generating TypeScript types from a GraphQL schema or a protobuf definition.

What are ts-poet's main functionalities?

Generating TypeScript Interfaces

This feature allows you to generate TypeScript interfaces programmatically. The code sample demonstrates how to create a 'User' interface with properties 'id', 'name', and 'email'.

const { Code, InterfaceSpec } = require('ts-poet');

const userInterface = InterfaceSpec.create('User')
  .addProperty('id', 'number')
  .addProperty('name', 'string')
  .addProperty('email', 'string');

const code = Code.create(userInterface);
console.log(code.toString());

Generating TypeScript Classes

This feature allows you to generate TypeScript classes programmatically. The code sample demonstrates how to create a 'User' class with properties 'id', 'name', and 'email', and a constructor method.

const { Code, ClassSpec } = require('ts-poet');

const userClass = ClassSpec.create('User')
  .addProperty('id', 'number')
  .addProperty('name', 'string')
  .addProperty('email', 'string')
  .addMethod('constructor', 'constructor(id: number, name: string, email: string) { this.id = id; this.name = name; this.email = email; }');

const code = Code.create(userClass);
console.log(code.toString());

Generating TypeScript Functions

This feature allows you to generate TypeScript functions programmatically. The code sample demonstrates how to create a 'greet' function that takes a 'name' parameter and returns a greeting string.

const { Code, FunctionSpec } = require('ts-poet');

const greetFunction = FunctionSpec.create('greet')
  .addParameter('name', 'string')
  .setReturnType('string')
  .setBody('return `Hello, ${name}!`;');

const code = Code.create(greetFunction);
console.log(code.toString());

Other packages similar to ts-poet

typescript

The 'typescript' package is the official TypeScript compiler and language service. While it does not focus on code generation, it provides the necessary tools to parse, analyze, and transform TypeScript code, which can be used for code generation tasks.

ts-morph

The 'ts-morph' package is a TypeScript compiler API wrapper that simplifies working with the TypeScript AST (Abstract Syntax Tree). It provides a higher-level API for creating, navigating, and manipulating TypeScript code, making it a powerful tool for code generation and transformation tasks.

codegen

The 'codegen' package is a general-purpose code generation library that supports multiple languages, including TypeScript. It provides a flexible API for generating code structures, making it a versatile alternative to ts-poet for various code generation needs.

README

ts-poet

This is a TypeScript port of the Square JavaPoet code generation DSL.

Specifically it's a port of Outfoxx's typescriptpoet, which is a Kotlin DSL for generating TypeScript output (e.g. in JVM-based build/codegen pipelines), to TypeScript for both the DSL-input and source-output.

Example Output

Here's a HelloWorld file:

import {Observable} from 'rxjs/Observable';
import 'rxjs/add/observable/from';

class Greeter {

  private name: string;

  constructor(private name: string) {
  }

  greet(): Observable<string> {
    return Observable.from(`Hello $name`)};
  }
}

And this is the code to generate it with TypeScriptPoet:

const observableTypeName = TypeNames.importedType("@rxjs/Observable")

val testClass = ClassSpec.create("Greeter")
   .addProperty("name", TypeName.STRING, false, Modifier.PRIVATE)
   .constructor(
      FunctionSpec.constructorBuilder()
         .addParameter("name", TypeName.STRING, false, Modifier.PRIVATE)
   )
   .addFunction(
      FunctionSpec.create("greet")
         .returns(TypeNames.parameterizedType(observableTypeName, TypeName.STRING))
         .addCode("return %T.%N(`Hello \$name`)", observableTypeName, SymbolSpec.from("+rxjs/add/observable/from#Observable"))
   )

FileSpec.create("Greeter").addClass(testClass).toString()

Notes

• The original JavaPoet and TypeScriptPoet both heavily use the builder API; this is idiomatic in Java, but felt heavy in TypeScript, so the FunctionSpec, ClassSpec, etc., classes are themselves directly immutable and the addProperty methods return copies.