SQL para TypeORM

Gerador de Entidades TypeORM a partir de SQL DDL (TypeScript)

Converta instruções SQL CREATE TABLE DDL em classes de entidade TypeORM em TypeScript com decoradores @Column, @PrimaryGeneratedColumn, relações e índices.

Predefinições:
Dialeto de Banco:Nomenclatura:Estilo de propriedade:
Entrada SQL DDL(5 tables)
/**
 * TypeORM Entity Definitions (Generated by ToolsAA)
 * Target Dialect: POSTGRES
 * Date: 2026-10-21
 */

import {
  Column,
  CreateDateColumn,
  Entity,
  Index,
  JoinColumn,
  ManyToOne,
  OneToMany,
  OneToOne,
  PrimaryGeneratedColumn,
  Unique,
  UpdateDateColumn,
} from 'typeorm';

OrderStatusEnum {
  PENDING = 'PENDING',
  PAID = 'PAID',
  PROCESSING = 'PROCESSING',
  SHIPPED = 'SHIPPED',
  DELIVERED = 'DELIVERED',
  CANCELLED = 'CANCELLED',
}

UserRoleEnum {
  ADMIN = 'ADMIN',
  CUSTOMER = 'CUSTOMER',
  VENDOR = 'VENDOR',
}

@Entity('users')
User {
  @PrimaryGeneratedColumn('uuid', { name: 'id' })
  id!: string;

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

  @Column({ type: 'varchar', length: 150, name: 'full_name', nullable: true })
  fullName: string | null;

  @Column({ type: 'enum', enum: UserRoleEnum, default: UserRoleEnum.CUSTOMER, name: 'role' })
  role!: UserRoleEnum;

  @Column({ type: 'boolean', name: 'is_verified', default: false })
  isVerified!: boolean;

  @Column({ type: 'jsonb', name: 'metadata', nullable: true })
  metadata: Record<string, any> | null;

  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
  createdAt!: Date;

  @UpdateDateColumn({ name: 'updated_at', type: 'timestamptz' })
  updatedAt!: Date;

  @OneToOne(() => UserProfile, (userProfile) => userProfile.user)
  userProfile?: UserProfile | null;

  @OneToMany(() => Order, (order) => order.customer)
  orders!: Order[];
}

@Entity('user_profiles')
UserProfile {
  @PrimaryGeneratedColumn('uuid', { name: 'id' })
  id!: string;

  @Column({ type: 'uuid', name: 'user_id', unique: true })
  userId!: string;

  @Column({ type: 'varchar', length: 500, name: 'avatar_url', nullable: true })
  avatarUrl: string | null;

  @Column({ type: 'varchar', length: 32, name: 'phone_number', nullable: true })
  phoneNumber: string | null;

  @Column({ type: 'text', name: 'shipping_address', nullable: true })
  shippingAddress: string | null;

  @Column({ type: 'varchar', length: 64, name: 'tax_identifier', nullable: true })
  taxIdentifier: string | null;

  @OneToOne(() => User, (user) => user.userProfile, { onDelete: 'CASCADE' })
  @JoinColumn({ name: 'user_id' })
  user!: User;
}

@Entity('products')
@Index('idx_products_sku', ['sku'])
Product {
  @PrimaryGeneratedColumn({ name: 'id' })
  id!: number;

  @Column({ type: 'varchar', length: 64, name: 'sku', unique: true })
  sku!: string;

  @Column({ type: 'varchar', length: 200, name: 'title' })
  title!: string;

  @Column({ type: 'text', name: 'description', nullable: true })
  description: string | null;

  @Column({ type: 'decimal', precision: 12, scale: 2, name: 'unit_price', default: 0.00 })
  unitPrice!: string;

  @Column({ type: 'int', name: 'inventory_count', default: 0 })
  inventoryCount!: number;

  @Column({ type: 'boolean', name: 'is_active', default: true })
  isActive!: boolean;

  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
  createdAt!: Date;

  @OneToMany(() => OrderItem, (orderItem) => orderItem.product)
  orderItems!: OrderItem[];
}

@Entity('orders')
@Index('idx_orders_status', ['status'])
Order {
  @PrimaryGeneratedColumn('uuid', { name: 'id' })
  id!: string;

  @Column({ type: 'uuid', name: 'customer_id' })
  customerId!: string;

  @Column({ type: 'varchar', length: 64, name: 'order_number', unique: true })
  orderNumber!: string;

  @Column({ type: 'enum', enum: OrderStatusEnum, default: OrderStatusEnum.PENDING, name: 'status' })
  status!: OrderStatusEnum;

  @Column({ type: 'decimal', precision: 12, scale: 2, name: 'total_amount', default: 0.00 })
  totalAmount!: string;

  @Column({ type: 'decimal', precision: 10, scale: 2, name: 'tax_amount', default: 0.00 })
  taxAmount!: string;

  @Column({ type: 'text', name: 'shipping_notes', nullable: true })
  shippingNotes: string | null;

  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
  createdAt!: Date;

  @UpdateDateColumn({ name: 'updated_at', type: 'timestamptz' })
  updatedAt!: Date;

  @ManyToOne(() => User, (user) => user.orders, { onDelete: 'RESTRICT' })
  @JoinColumn({ name: 'customer_id' })
  customer!: User;

  @OneToMany(() => OrderItem, (orderItem) => orderItem.order)
  orderItems!: OrderItem[];
}

@Entity('order_items')
@Unique('uq_order_product', ['orderId', 'productId'])
OrderItem {
  @PrimaryGeneratedColumn({ name: 'id' })
  id!: number;

  @Column({ type: 'uuid', name: 'order_id' })
  orderId!: string;

  @Column({ type: 'int', name: 'product_id' })
  productId!: number;

  @Column({ type: 'int', name: 'quantity', default: 1 })
  quantity!: number;

  @Column({ type: 'decimal', precision: 12, scale: 2, name: 'unit_price' })
  unitPrice!: string;

  @Column({ type: 'decimal', precision: 12, scale: 2, name: 'subtotal' })
  subtotal!: string;

  @ManyToOne(() => Order, (order) => order.orderItems, { onDelete: 'CASCADE' })
  @JoinColumn({ name: 'order_id' })
  order!: Order;

  @ManyToOne(() => Product, (product) => product.orderItems, { onDelete: 'RESTRICT' })
  @JoinColumn({ name: 'product_id' })
  product!: Product;
}

Entidades TypeORM5 entidades geradas
Relações Mapeadas4 chaves estrangeiras mapeadas
Colunas Processadas37 colunas convertidas

Privacidade 100% no Cliente

Zero uploads para servidores ou conexões diretas. Toda a análise sintática de SQL e a compilação TypeORM ocorrem dentro do seu navegador.

Decoradores TypeORM Inteligentes

Gera automaticamente chaves primárias (@PrimaryGeneratedColumn, @PrimaryColumn), tipos nativos, @CreateDateColumn, @UpdateDateColumn, @Index e @Unique.

Multi-Dialeto e Relações Bidirecionais

Compatível com PostgreSQL, MySQL, SQLite e SQL Server com anotações @ManyToOne, @OneToMany e @OneToOne bidirecionais e regras de cascata.

Referência técnica e guia de arquitetura

Guia do Desenvolvedor: Gerador de Entidades TypeORM a partir de SQL DDL (Entidades TypeScript) — Guia de referência

Converta instruções SQL CREATE TABLE DDL em classes de entidade TypeORM em TypeScript com decoradores @Column, @PrimaryGeneratedColumn, relações e índices.

Parâmetros principais e controles

Dialeto SQLEnum (PostgreSQL | MySQL | SQLite | SQL Server | Oracle)

Especifica a sintaxe do banco de dados SQL utilizada para analisar tipos de dados de colunas, limites de caracteres, cláusulas padrão e chaves primárias autoincrementais.

Padrão: PostgreSQL
Convenção de Nomes de PropriedadesEnum (camelCase com @Column({ name }) | Preservar snake_case do SQL)

Define se as colunas em snake_case do banco de dados são transformadas em propriedades idiomáticas camelCase no TypeScript com mapeamentos explícitos @Column({ name: 'nome_coluna' }).

Padrão: camelCase com @Column({ name })
Estratégia de Geração de RelaçõesEnum (Bidirecional (@ManyToOne e @OneToMany) | Apenas Chaves Estrangeiras Escalares)

Configura se as restrições de chave estrangeira SQL geram decoradores de relação completos no TypeORM com @JoinColumn ou mantêm campos escalares sem propriedades de navegação.

Padrão: Bidirecional (@ManyToOne e @OneToMany)
Decoradores de Data/HoraEnum (Automático @CreateDateColumn e @UpdateDateColumn | Padrão @Column)

Detecta colunas canônicas de auditoria (como created_at e updated_at) e aplica as anotações especializadas de ciclo de vida automático do TypeORM.

Padrão: Automático @CreateDateColumn e @UpdateDateColumn

Dicas profissionais e melhores práticas

Adote sempre a estratégia camelCase

Adote sempre a estratégia camelCase com mapeamentos explícitos @Column({ name: 'db_col_name' }). Isso mantém seu código TypeScript limpo e idiomático, garantindo que as tabelas existentes permaneçam 100% compatíveis sem a necessidade de migrações estruturais.

Tipos SQL como DECIMAL

Tipos SQL como DECIMAL(18,4) e BIGINT excedem o limite de precisão inteira segura do JavaScript. O TypeORM mapeia DECIMAL para string no TypeScript por padrão; use bibliotecas como decimal.js ou tipos BigInt para cálculos monetários precisos.

Ao configurar relacionamentos

Ao configurar relacionamentos @ManyToOne e @OneToMany entre arquivos de entidade distintos, declare a entidade de destino como função lambda (ex: @ManyToOne(() => Author, (author) => author.posts)) para evitar falhas de importação circular no Node.js.

Problemas comuns e solução de problemas

Erro do TypeORM: 'Missing @JoinColumn on entity relation'

No TypeORM, o decorador @JoinColumn() é obrigatório no lado proprietário de uma relação @OneToOne e no lado da chave estrangeira de uma relação @ManyToOne. Garanta que @JoinColumn({ name: 'author_id' }) esteja posicionado na propriedade que armazena a chave física.

Erro do compilador TypeScript: 'Property has no initializer and is not definitely assigned in the constructor'

Com a opção strictPropertyInitialization ativa, as propriedades da classe precisam de inicialização. Nas entidades TypeORM, adicione a exclamação de asserção definitiva (ex: 'title!: string;') para indicar ao compilador que o TypeORM preenche os valores.

Perguntas frequentes (FAQ)

Como o conversor mapeia tipos de colunas SQL para TypeScript e decoradores TypeORM?▼

O mapeamento ocorre em dois níveis: o decorador define o tipo físico no banco (ex: @Column({ type: 'varchar', length: 255 })), enquanto a propriedade recebe o tipo primitivo correspondente do TypeScript (string, number, boolean, Date ou object para JSONB).

Como as chaves primárias e sequências autoincrementais são traduzidas?▼

Colunas com PRIMARY KEY e cláusulas AUTO_INCREMENT, SERIAL ou IDENTITY são convertidas em @PrimaryGeneratedColumn('increment'). Chaves UUID utilizam @PrimaryGeneratedColumn('uuid'), e chaves compostas manuais utilizam @PrimaryColumn().

As entidades geradas podem ser usadas diretamente em projetos NestJS?▼

Sim. O código gerado cria classes TypeScript convencionais decoradas com @Entity(), @Column() e anotações de relação, prontas para inclusão direta em TypeOrmModule.forFeature([Entity]) do @nestjs/typeorm.

Meus scripts SQL DDL são enviados para algum servidor externo?▼

Não. Todo o processo de interpretação sintática e síntese das entidades TypeScript roda 100% no cliente dentro do seu navegador via JavaScript local. Suas definições de banco de dados confidenciais jamais deixam sua máquina.

Ferramentas e utilitários relacionados

Todas as ferramentas →
Guia do Desenvolvedor do Conversor de SQL CREATE TABLE DDL para Esquema ZodDesenvolvimento

Converta esquemas de tabelas SQL, tipos de dados, restrições e colunas anuláveis em esquemas de objetos Zod estritamente tipados em TypeScript.

Abrir ferramenta→
Conversor de Docker Compose para Manifestos Kubernetes (Compose para K8s)Desenvolvimento

Converta serviços, variáveis de ambiente, portas e volumes de docker-compose.yml em manifestos YAML de Deployment e Service prontos para Kubernetes.

Abrir ferramenta→
Guia do Desenvolvedor: Conversor de JSON para Variáveis de Ambiente .env (Aplanar e Exportar)Desenvolvimento

Aplana estruturas JSON aninhadas em variáveis .env em SNAKE_CASE maiúsculo com delimitadores e opções de prefixo personalizáveis.

Abrir ferramenta→
Gerador de Esquemas SQL DDL para Drizzle ORM (PostgreSQL, MySQL, SQLite)Desenvolvimento

Converta instruções SQL CREATE TABLE em esquemas fortemente tipados do Drizzle ORM com definições pgTable, mysqlTable e sqliteTable.

Abrir ferramenta→
Guia do Desenvolvedor: Gerador de Schemas Valibot a partir de JSON (Validação Modular TypeScript)Desenvolvimento

Converta dados JSON em esquemas Valibot leves e compatíveis com tree-shaking utilizando v.object, v.string, v.number e validadores de array.

Abrir ferramenta→
Gerador de Esquema JSON para TypeBox (Provedor rápido de tipos JSON Schema)Desenvolvimento

Converta estruturas JSON em definições TypeBox Type.Object de alta performance para Fastify, Ajv e validação em tempo de execução com TypeScript.

Abrir ferramenta→