SQL DDL zu MikroORM TypeScript Entity Generator

SQL DDL zu MikroORM TypeScript Entity Generator

Konvertieren Sie SQL CREATE TABLE-Definitionen in MikroORM-Entitätsklassen mit @Entity, @PrimaryKey, @Property, @Index und Beziehungs-Dekoratoren.

Voreinstellungen:
SQL-Dialekt:Klassenbenennung:Eigenschaftsstil:
SQL DDL Eingabe (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 Zeichen • 7.3 KB
MikroORM Entitäten7 Entitäten generiert
Beziehungen zugeordnet10 Fremdschlüssel aufgelöst
Spalten konvertiert58 Spalten typisiert

100% Client-Seitige Privatsphäre

Keine Server-Uploads oder externe Datenbankverbindungen. Das Parsen und Generieren geschieht vollständig lokal im Browser.

MikroORM v5 & v6 Dekorator-Unterstützung

Mappt @PrimaryKey, @Property (Typen, Nullable, DefaultRaw), @Index, @Unique, @Enum und Lebenszyklus-Hooks wie onCreate/onUpdate.

Typsichere Relationen & Multi-Dialekt

Erkennt Fremdschlüssel und generiert @ManyToOne, @OneToMany mit Collection<T> sowie @OneToOne für PostgreSQL, MySQL, SQLite und MSSQL.

Technische Referenz & Architektur-Leitfaden

SQL DDL zu MikroORM TypeScript Entity Generator — Referenz-Leitfaden

Konvertieren Sie SQL CREATE TABLE-Definitionen in MikroORM-Entitätsklassen mit @Entity, @PrimaryKey, @Property, @Index und Beziehungs-Dekoratoren.

Wichtige Parameter & Steuerelemente

SQL-Dialekt (SQL Dialect)Enum (PostgreSQL | MySQL | SQLite | MSSQL)

Bestimmt die SQL-Datenbanksyntax zur präzisen Analyse von Datentypen, Sequenz-Defaults (wie SERIAL, AUTO_INCREMENT oder IDENTITY) und Indexklauseln.

Standard: PostgreSQL
Klassenbenennungsstrategie (Class Naming Strategy)Enum (PascalCase Singular | Tabellenname beibehalten)

Steuert die Konvertierung von SQL-Tabellennamen in TypeScript-Klassennamen, wobei pluralisierte Tabellennamen (z. B. 'user_accounts') in singuläre PascalCase-Bezeichner ('UserAccount') überführt werden.

Standard: PascalCase Singular
Eigenschafts-Benennung (Property Naming Strategy)Enum (camelCase | snake_case beibehalten)

Legt fest, ob Datenbankspalten in idiomatische camelCase-Eigenschaften mit explizitem @Property({ fieldName: 'spalten_name' }) umgewandelt oder im originalen snake_case belassen werden.

Standard: camelCase
Relationserzeugung (Relation Generation)Enum (Bidirektional (@ManyToOne & @OneToMany) | Reine Fremdschlüsselfelder)

Konfiguriert, ob SQL-Fremdschlüsselbeschränkungen vollwertige MikroORM-Beziehungsdekoratoren mit Collection<T> erzeugen oder als skalare Fremdschlüsselfelder belassen werden.

Standard: Bidirektional (@ManyToOne & @OneToMany)

Profi-Tipps & Best Practices

In MikroORM müssen inverse Sammlungen

In MikroORM müssen inverse Sammlungen in @OneToMany- oder @ManyToMany-Relationen direkt als 'new Collection<T>(this)' deklariert werden. Dies verhindert Laufzeitfehler und stellt sicher, dass Methoden wie .init() und .getItems() zuverlässig funktionieren.

Verwenden Sie bei

Verwenden Sie bei Beziehungsdekoratoren wie @ManyToOne(() => Author) und @OneToMany(() => Book, b => b.author) immer Pfeilfunktionen zur Entitätsreferenz. Dies verhindert zyklische Importblockaden beim Starten von Node.js.

Geben Sie bei der Umwandlung von

Geben Sie bei der Umwandlung von snake_case-Spalten in TypeScript camelCase stets @Property({ fieldName: 'original_spalte' }) an. Dadurch bleibt die vollständige Kompatibilität mit bestehenden Produktionsdatenbanken ohne unerwünschte Migrationsdifferenzen gewahrt.

Häufige Fallstricke & Fehlerbehebung

TypeScript-Fehler: 'Property has no initializer and is not definitely assigned in the constructor' (TS2564)

Fügen Sie bei aktiviertem strictPropertyInitialization das Ausrufezeichen für definite Zuweisung hinzu (z. B. 'name!: string;'). MikroORM lädt diese Eigenschaften zur Laufzeit über den EntityManager und die Identity Map.

Typ kann bei emitDecoratorMetadata für @Property nicht automatisch aufgelöst werden

Falls TypeScript komplexe Typen oder Unions nicht fehlerfrei als Metadaten emittieren kann, deklarieren Sie den Typ explizit im Dekorator, etwa @Property({ type: 'text', nullable: true }) oder @Property({ type: 'json' }).

Häufig gestellte Fragen (FAQ)

Wie werden SQL-Primärschlüssel in MikroORM-Dekoratoren übersetzt?▼

Spalten mit PRIMARY KEY und AUTO_INCREMENT bzw. SERIAL werden als @PrimaryKey({ autoincrement: true }) übersetzt. UUID-Primärschlüssel erhalten @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' }), und zusammengesetzte Primärschlüssel werden durch Annotation jedes Teilschlüssels mit @PrimaryKey() abgebildet.

Wie werden SQL-Fremdschlüssel in Beziehungsdekorationen umgewandelt?▼

SQL REFERENCES-Klauseln werden zu @ManyToOne(() => ZielEntitaet, { nullable: ... }). Ist die bidirektionale Option aktiv, erhält die Zielentität ein entsprechendes @OneToMany(() => QuellEntitaet, q => q.ziel) mit initialisierter Collection<QuellEntitaet>(this).

Unterstützt der Generator MikroORM v5 und v6 Standards?▼

Ja. Der erzeugte Code verwendet aktuelle Best Practices von MikroORM, darunter saubere Importe aus '@mikro-orm/core', typisierte Collection<T>-Initialisierer und gebrauchsfertige Konfigurationsvorlagen für mikro-orm.config.ts.

Werden meine SQL-Tabellendefinitionen an externe Server übertragen?▼

Nein. Die gesamte Verarbeitung und Codegenerierung läuft zu 100 % clientseitig in Ihrem Browser. Es werden keinerlei DDL-Skripte oder vertrauliche Schemadaten über das Netzwerk übertragen.

Verwandte Werkzeuge & Dienstprogramme

Alle Werkzeuge →
JSON zu Mongoose Schema & TypeScript Model GeneratorEntwickler

Erkennen und generieren Sie MongoDB Mongoose-Schemas, TypeScript Document-Interfaces, Subdokumente, Timestamps und Modell-Exporte aus JSON.

Werkzeug öffnen→
JSON zu Yup Validierungsschema-GeneratorEntwickler

Konvertieren Sie JSON-Muster in typsichere Yup-Objekt-Validierungsschemas mit yup.string(), yup.number(), yup.array() und Pflichtfeldregeln.

Werkzeug öffnen→
Entwicklerhandbuch: JSON zu Joi Schema GeneratorEntwickler

Konvertieren Sie JSON-Datenstrukturen in präzise Joi-Validierungsschemas mit Joi.object(), Joi.string(), Joi.number() und Joi.array()-Regeln.

Werkzeug öffnen→
JSON-zu-Apache-Avro-Schema (.avsc) KonverterEntwickler

Konvertieren Sie JSON-Nutzdaten in produktionsreife Apache Avro-Schemadefinitionen (.avsc) mit Namespaces, primitiven und logischen Typen, nullfähigen Union-Feldern und Schemakompatibilitätsregeln.

Werkzeug öffnen→
Entwicklerhandbuch: GraphQL SDL zu Zod-Validierungsschema-GeneratorEntwickler

Konvertieren Sie GraphQL-SDL-Typen, Queries und Inputs präzise in Laufzeit-Zod-Validierungsschemata (z.object, z.string, z.array) inklusive Nullability-Mapping.

Werkzeug öffnen→
GraphQL SDL zu TypeScript Typen & Interfaces KonverterEntwickler

Konvertieren Sie GraphQL Schema Definition Language (SDL) Typen, Inputs und Enums direkt im Browser in saubere, abhängigkeitsfreie TypeScript-Interfaces.

Werkzeug öffnen→