SQL para MikroORM

Gerador de Entidades MikroORM TypeScript a partir de SQL DDL

Converta instruções SQL CREATE TABLE em classes de entidade MikroORM com decoradores @Entity, @PrimaryKey, @Property, @Index e relações.

Predefinições:
Dialeto SQL:Nomenclatura de Classes:Estilo de Propriedades:
Entrada SQL DDL (CREATE TABLE)
Lines: 85•Chars: 3,256•3.2 KB
Inferred: PostgreSQL
/**
 * MikroORM TypeScript Entities
 * Generated automatically by ToolsAA SQL to MikroORM Generator
 * Dialect: POSTGRES | Entities: 7
 */

import {
  Cascade,
  Collection,
  Entity,
  Enum,
  ManyToOne,
  OneToMany,
  OneToOne,
  PrimaryKey,
  Property,
  Unique,
} from '@mikro-orm/core';

// ============================================================================
// Database Enums
// ============================================================================

UserStatusEnum {
  ACTIVE = 'active',
  PENDING = 'pending',
  SUSPENDED = 'suspended',
  ARCHIVED = 'archived',
}

OrderStatusEnum {
  DRAFT = 'draft',
  PENDING = 'pending',
  PAID = 'paid',
  SHIPPED = 'shipped',
  CANCELLED = 'cancelled',
}

@Entity({ tableName: 'tenants' })
export class Tenant {
  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
  id!: string;

  @Property({ unique: true, length: 64 })
  slug!: string;

  @Property({ length: 120, fieldName: 'company_name' })
  companyName!: string;

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

  @Property({ onCreate: () => new Date() })
  createdAt: Date = new Date();

  @Property({ onUpdate: () => new Date() })
  updatedAt: Date = new Date();

  @OneToMany(() => User, (user) => user.tenant, { cascade: [Cascade.ALL], orphanRemoval: true })
  users = new Collection<User>(this);

  @OneToMany(() => Category, (category) => category.tenant, { cascade: [Cascade.ALL], orphanRemoval: true })
  categories = new Collection<Category>(this);

  @OneToMany(() => Product, (product) => product.tenant, { cascade: [Cascade.ALL], orphanRemoval: true })
  products = new Collection<Product>(this);

  @OneToMany(() => Order, (order) => order.tenant, { cascade: [Cascade.ALL], orphanRemoval: true })
  orders = new Collection<Order>(this);
}

@Entity({ tableName: 'users' })
@Unique({ properties: ['tenant', 'email'] })
export class User {
  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
  id!: string;

  @Property({ length: 255 })
  email!: string;

  @Property({ length: 255, fieldName: 'password_hash' })
  passwordHash!: string;

  @Property({ length: 100, fieldName: 'display_name' })
  displayName!: string;

  @Enum(() => UserStatusEnum)
  status!: UserStatusEnum = UserStatusEnum.ACTIVE;

  @Property({ onCreate: () => new Date() })
  createdAt: Date = new Date();

  @Property({ onUpdate: () => new Date() })
  updatedAt: Date = new Date();

  @ManyToOne(() => Tenant, { fieldName: 'tenant_id', deleteRule: 'cascade' })
  tenant!: Tenant;

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

  @OneToMany(() => Order, (order) => order.user, { cascade: [Cascade.ALL], orphanRemoval: true })
  orders = new Collection<Order>(this);
}

@Entity({ tableName: 'user_profiles' })
export class UserProfile {
  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
  id!: string;

  @Property({ length: 500, nullable: true, fieldName: 'avatar_url' })
  avatarUrl?: string;

  @Property({ type: 'text', nullable: true })
  bio?: string;

  @Property({ length: 32, nullable: true, fieldName: 'phone_number' })
  phoneNumber?: string;

  @Property({ type: 'json', nullable: true })
  preferences?: Record<string, unknown>;

  @Property({ onCreate: () => new Date() })
  createdAt: Date = new Date();

  @OneToOne(() => User, { fieldName: 'user_id', deleteRule: 'cascade', owner: true })
  user!: User;
}

@Entity({ tableName: 'categories' })
@Unique({ properties: ['tenant', 'slug'] })
export class Category {
  @PrimaryKey({ autoincrement: true })
  id!: number;

  @Property({ length: 100 })
  name!: string;

  @Property({ length: 120 })
  slug!: string;

  @Property({ fieldName: 'sort_order', default: 0 })
  sortOrder!: number;

  @ManyToOne(() => Tenant, { fieldName: 'tenant_id', deleteRule: 'cascade' })
  tenant!: Tenant;

  @ManyToOne(() => Category, { fieldName: 'parent_id', deleteRule: 'set null', nullable: true })
  parent?: Category;

  @OneToMany(() => Category, (category) => category.parent, { cascade: [Cascade.ALL], orphanRemoval: true })
  children = new Collection<Category>(this);

  @OneToMany(() => Product, (product) => product.category, { cascade: [Cascade.ALL], orphanRemoval: true })
  products = new Collection<Product>(this);
}

@Entity({ tableName: 'products' })
@Unique({ properties: ['tenant', 'sku'] })
export class Product {
  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
  id!: string;

  @Property({ length: 64 })
  sku!: string;

  @Property({ length: 200 })
  title!: string;

  @Property({ type: 'decimal', precision: 12, scale: 2 })
  price!: string;

  @Property({ fieldName: 'inventory_count', default: 0 })
  inventoryCount!: number;

  @Property({ type: 'json', nullable: true })
  attributes?: Record<string, unknown>;

  @Property({ type: 'array', nullable: true })
  tags?: string[];

  @Property({ type: 'boolean', fieldName: 'is_published', default: false })
  isPublished!: boolean;

  @Property({ onCreate: () => new Date() })
  createdAt: Date = new Date();

  @Property({ onUpdate: () => new Date() })
  updatedAt: Date = new Date();

  @ManyToOne(() => Tenant, { fieldName: 'tenant_id', deleteRule: 'cascade' })
  tenant!: Tenant;

  @ManyToOne(() => Category, { fieldName: 'category_id', deleteRule: 'set null', nullable: true })
  category?: Category;

  @OneToMany(() => OrderItem, (orderItem) => orderItem.product, { cascade: [Cascade.ALL], orphanRemoval: true })
  orderItems = new Collection<OrderItem>(this);
}

@Entity({ tableName: 'orders' })
export class Order {
  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
  id!: string;

  @Property({ unique: true, length: 32, fieldName: 'order_number' })
  orderNumber!: string;

  @Enum(() => OrderStatusEnum)
  status!: OrderStatusEnum = OrderStatusEnum.DRAFT;

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

  @Property({ type: 'decimal', precision: 12, scale: 2, fieldName: 'tax_amount', default: 0.00 })
  taxAmount!: string;

  @Property({ type: 'decimal', precision: 12, scale: 2, fieldName: 'shipping_cost', default: 0.00 })
  shippingCost!: string;

  @Property({ type: 'decimal', precision: 12, scale: 2, fieldName: 'total_amount' })
  totalAmount!: string;

  @Property({ type: 'text', nullable: true })
  notes?: string;

  @Property({ onCreate: () => new Date() })
  createdAt: Date = new Date();

  @Property({ onUpdate: () => new Date() })
  updatedAt: Date = new Date();

  @ManyToOne(() => Tenant, { fieldName: 'tenant_id', deleteRule: 'cascade' })
  tenant!: Tenant;

  @ManyToOne(() => User, { fieldName: 'user_id', deleteRule: 'restrict' })
  user!: User;

  @OneToMany(() => OrderItem, (orderItem) => orderItem.order, { cascade: [Cascade.ALL], orphanRemoval: true })
  orderItems = new Collection<OrderItem>(this);
}

@Entity({ tableName: 'order_items' })
export class OrderItem {
  @PrimaryKey({ autoincrement: true })
  id!: string;

  @Property()
  quantity!: number;

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

  @Property({ type: 'decimal', precision: 12, scale: 2, fieldName: 'line_total' })
  lineTotal!: string;

  @Property({ onCreate: () => new Date() })
  createdAt: Date = new Date();

  @ManyToOne(() => Order, { fieldName: 'order_id', deleteRule: 'cascade' })
  order!: Order;

  @ManyToOne(() => Product, { fieldName: 'product_id', deleteRule: 'restrict' })
  product!: Product;
}
Entities: 7•Columns: 58•Relations: 10
7,515 caracteres • 7.3 KB
Entidades MikroORM7 entidades geradas
Relações Mapeadas10 chaves estrangeiras resolvidas
Colunas Convertidas58 colunas tipadas

100% Privacidade no Cliente

Sem envios para servidores ou conexões de banco de dados. Toda a conversão ocorre localmente no navegador.

Ecossistema de Decoradores MikroORM v5 & v6

Mapeamento completo de @PrimaryKey, @Property (tipos, nullable, defaultRaw), @Index, @Unique, @Enum e hooks onCreate/onUpdate.

Relações Tipadas & Suporte Multi-Dialeto

Detecta chaves estrangeiras para gerar @ManyToOne, @OneToMany com Collection<T> e @OneToOne para PostgreSQL, MySQL, SQLite e MSSQL.

Referência técnica e guia de arquitetura

Guia do Desenvolvedor do Gerador de Entidades MikroORM TypeScript a partir de SQL DDL — Guia de referência

Converta instruções SQL CREATE TABLE em classes de entidade MikroORM com decoradores @Entity, @PrimaryKey, @Property, @Index e relações.

Parâmetros principais e controles

Dialeto SQL (SQL Dialect)Enum (PostgreSQL | MySQL | SQLite | MSSQL)

Especifica a sintaxe do banco de dados para analisar tipos de dados, valores padrão de sequências (SERIAL, AUTO_INCREMENT, IDENTITY) e definições de índices.

Padrão: PostgreSQL
Estratégia de Nomes de Classes (Class Naming Strategy)Enum (PascalCase Singular | Manter Nome da Tabela)

Controla a conversão de nomes de tabelas SQL para classes TypeScript, transformando nomes no plural (ex.: 'user_accounts') em identificadores no singular em PascalCase ('UserAccount').

Padrão: PascalCase Singular
Estilo de Propriedades (Property Naming Strategy)Enum (camelCase | Manter snake_case)

Determina se as colunas do banco de dados serão convertidas para camelCase com @Property({ fieldName: 'nome_coluna' }) explícito ou mantidas no padrão snake_case original.

Padrão: camelCase
Geração de Relações (Relation Generation)Enum (Bidirecional (@ManyToOne e @OneToMany) | Apenas Chaves Estrangeiras Escalares)

Configura se restrições de chave estrangeira devem produzir relações completas do MikroORM com Collection<T> ou campos escalares simples.

Padrão: Bidirecional (@ManyToOne e @OneToMany)

Dicas profissionais e melhores práticas

No MikroORM

No MikroORM, propriedades de coleção inversa em @OneToMany e @ManyToMany devem ser inicializadas como 'new Collection<T>(this)'. Isso evita erros de propriedade indefinida e viabiliza operações de lazy loading como .init() e .getItems().

Ao estruturar entidades em arquivos

Ao estruturar entidades em arquivos separados com @ManyToOne(() => Author) e @OneToMany(() => Book, b => b.author), utilize sempre arrow functions para referenciar a classe alvo, prevenindo deadlocks de carregamento no Node.js.

Ao converter colunas snake_case em

Ao converter colunas snake_case em propriedades TypeScript camelCase, utilize @Property({ fieldName: 'coluna_original' }). Isso garante compatibilidade total com bancos legados e evita divergências em migrações automáticas.

Problemas comuns e solução de problemas

Erro de compilação TypeScript: 'Property has no initializer and is not definitely assigned in constructor' (TS2564)

Com strictPropertyInitialization ativado, inclua a asserção de atribuição definitiva '!' nos atributos da entidade (ex.: 'name!: string;'). O MikroORM hidratará essas propriedades dinamicamente através do EntityManager.

Tipo não inferido corretamente no @Property com emitDecoratorMetadata

Caso o compilador TypeScript não consiga inferir tipos complexos ou uniões, declare explicitamente a opção type no decorador, como @Property({ type: 'text', nullable: true }) ou @Property({ type: 'json' }).

Perguntas frequentes (FAQ)

Como as chaves primárias SQL são traduzidas em decoradores MikroORM?▼

Colunas com PRIMARY KEY e AUTO_INCREMENT ou SERIAL são convertidas em @PrimaryKey({ autoincrement: true }). Chaves UUID recebem @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' }), e chaves compostas são representadas aplicando @PrimaryKey() a cada propriedade que compõe a chave.

Como chaves estrangeiras (FOREIGN KEY) são mapeadas para relacionamentos?▼

Instruções SQL REFERENCES geram decoradores @ManyToOne(() => TargetEntity, { nullable: ... }). Com a opção bidirecional ativa, a entidade de destino recebe o correspondente @OneToMany(() => CurrentEntity, c => c.target) com Collection<CurrentEntity>(this).

O gerador suporta as versões MikroORM v5 e v6?▼

Sim. O código gerado adota os padrões modernos do MikroORM, incluindo importações limpas de '@mikro-orm/core', instanciação de Collection<T> e modelos de configuração para o arquivo mikro-orm.config.ts.

Meus esquemas SQL ou estruturas de tabelas são enviados para a internet?▼

Não. Todo o processo de interpretação DDL e sintetização de código TypeScript acontece 100% no navegador do cliente de maneira offline e segura. Nenhum dado transita por servidores remotos.

Ferramentas e utilitários relacionados

Todas as ferramentas →
Guia do Desenvolvedor: Gerador de Esquemas Mongoose e Modelos TypeScript a partir de JSONDesenvolvimento

Infira e gere esquemas MongoDB Mongoose, interfaces Document de TypeScript, subdocumentos aninhados, timestamps e exportações de modelos a partir de JSON.

Abrir ferramenta→
Guia do Desenvolvedor do Gerador de Esquemas de Validação Yup a partir de JSONDesenvolvimento

Converta amostras JSON em esquemas de validação de objetos Yup com segurança de tipos, yup.string(), yup.number(), yup.array() e regras obrigatórias.

Abrir ferramenta→
Guia do Desenvolvedor: Gerador de Esquemas de Validação Joi a partir de JSONDesenvolvimento

Converta estruturas de dados JSON em esquemas de validação Joi robustos com restrições Joi.object(), Joi.string(), Joi.number() e Joi.array().

Abrir ferramenta→
Guia do Desenvolvedor do Conversor de JSON para Esquema Apache Avro (.avsc)Desenvolvimento

Converta payloads JSON em esquemas Apache Avro (.avsc) para produção com namespaces personalizados, tipos primitivos e lógicos, campos union anuláveis e regras de compatibilidade.

Abrir ferramenta→
Guia do Desenvolvedor: Gerador de Esquemas de Validação Zod a partir de GraphQL SDLDesenvolvimento

Converta tipos, consultas e entradas GraphQL SDL em esquemas de validação Zod para tempo de execução (z.object, z.string, z.array) com gestão precisa de nulabilidade.

Abrir ferramenta→
Guia do Desenvolvedor do Conversor de GraphQL SDL para Tipos e Interfaces TypeScriptDesenvolvimento

Converta definições GraphQL SDL, tipos, inputs e enums diretamente em interfaces e tipos TypeScript limpos e sem dependências no navegador.

Abrir ferramenta→