SQL to TypeORM Entity Converter

What is SQL to TypeORM Entity Converter?

TypeORM is the most widely used ORM in the Node.js and TypeScript ecosystem, and it is the default ORM bundled with the NestJS framework. Unlike schema-first tools such as Prisma — where a separate .prisma file is the source of truth — TypeORM is code-first and decorator-driven: your entity is a plain TypeScript class annotated with decorators like @Entity, @Column, @PrimaryGeneratedColumn, and @ManyToOne. The class itself defines both the runtime shape of your data and the database schema, and TypeORM reads those decorators at startup (via reflect-metadata) to build the schema and generate SQL. One of TypeORM's defining features is that it supports two distinct persistence patterns. In the Active Record pattern, your entity extends BaseEntity and you call methods directly on the model: User.find(), user.save(), user.remove(). In the Data Mapper pattern, you keep entities as pure data and perform all persistence through a Repository obtained from the DataSource: dataSource.getRepository(User).find(). NestJS projects almost always use the Data Mapper pattern with @InjectRepository, while smaller scripts often prefer Active Record for brevity. The same entity class works with both patterns; only how you query changes. Compared to Prisma, TypeORM gives you more direct control over decorators, lazy/eager relation loading, and custom column options, but it does not generate a fully type-safe query client the way Prisma does — its query builder and find options are typed but looser. When you are migrating an existing SQL database to a NestJS or Express + TypeORM project, this converter turns your CREATE TABLE DDL into the decorated entity classes so you do not have to hand-translate every column type and constraint.

How to Use

1. Select your database dialect (PostgreSQL, MySQL, or SQLite). This controls both the TypeORM column "type" option string and how SERIAL vs AUTO_INCREMENT primary keys are emitted.
2. Paste your SQL CREATE TABLE statements. Each table becomes one TypeScript class annotated with @Entity("table_name").
3. Click "Generate TypeORM Entity" to produce the decorated entity classes with @Column, @PrimaryGeneratedColumn, and relation decorators.
4. Save each class into its own file under src/entity/ (TypeORM convention is one entity per file, e.g. User.ts), and register them in your DataSource entities array or set entities: ["src/entity/**/*.ts"].
5. Ensure "emitDecoratorMetadata": true and "experimentalDecorators": true are set in tsconfig.json, and import "reflect-metadata" at the top of your entry file — without these, decorators silently fail.

Tips & Best Practices

• Always add the inverse @OneToMany side manually. The converter generates the @ManyToOne owning side (the table that holds the FK column), but the parent entity needs posts: Post[] with @OneToMany(() => Post, post => post.user) for the relation to be queryable from both directions.
• Beware nullable inference: in TypeORM a column is NOT NULL by default, but a TypeScript property is non-optional by default too. For a nullable SQL column you must set both @Column({ nullable: true }) AND make the TS type string | null, otherwise strict mode complains and migrations generate the wrong DDL.
• Do not rely on synchronize: true in production. It is convenient in development but will drop and recreate columns to match entities, causing data loss. Use typeorm migration:generate to produce reviewable migration files instead.
• For DECIMAL/NUMERIC columns, pass precision and scale explicitly: @Column("decimal", { precision: 10, scale: 2 }). TypeORM returns decimals as strings in JavaScript to avoid float precision loss — do not assume you get a number.
• PostgreSQL enum columns map best to @Column({ type: "enum", enum: MyEnum }) using a TypeScript enum; a plain VARCHAR with check constraints will not give you type-safe enum values, so convert those manually after generation.

Frequently Asked Questions

Real-world Examples

CREATE TABLE users (
  id SERIAL PRIMARY KEY,
  email VARCHAR(255) UNIQUE NOT NULL,
  display_name VARCHAR(100) NOT NULL,
  bio TEXT,
  is_active BOOLEAN NOT NULL DEFAULT true,
  created_at TIMESTAMP NOT NULL DEFAULT NOW()
);

import { Entity, PrimaryGeneratedColumn, Column } from "typeorm";

@Entity("users")
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column({ type: "varchar", length: 255, unique: true })
  email: string;

  @Column({ type: "varchar", length: 100 })
  displayName: string;

  @Column({ type: "text", nullable: true })
  bio: string | null;

  @Column({ type: "boolean", default: true })
  isActive: boolean;

  @Column({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
  createdAt: Date;
}

CREATE TABLE posts (
  id SERIAL PRIMARY KEY,
  user_id INTEGER NOT NULL REFERENCES users(id),
  title VARCHAR(255) NOT NULL,
  body TEXT,
  published BOOLEAN NOT NULL DEFAULT false,
  view_count INTEGER NOT NULL DEFAULT 0
);

import { Entity, PrimaryGeneratedColumn, Column, ManyToOne, JoinColumn, OneToMany } from "typeorm";
import { User } from "./User";

@Entity("posts")
export class Post {
  @PrimaryGeneratedColumn()
  id: number;

  @Column({ name: "user_id" })
  userId: number;

  @ManyToOne(() => User, (user) => user.posts)
  @JoinColumn({ name: "user_id" })
  user: User;

  @Column({ type: "varchar", length: 255 })
  title: string;

  @Column({ type: "text", nullable: true })
  body: string | null;

  @Column({ type: "boolean", default: false })
  published: boolean;

  @Column({ type: "int", default: 0 })
  viewCount: number;
}

// Add the inverse side to User.ts manually:
//   @OneToMany(() => Post, (post) => post.user)
//   posts: Post[];

Related Tools