SQL → Sequelize TS
Datenbank- & ORM-Codegenerierung

SQL DDL zu Sequelize TypeScript Modell Generator

Vollständige Entwicklerdokumentation zur Konvertierung von SQL CREATE TABLE DDL-Anweisungen in typsichere Sequelize-TypeScript-Modelle, DataTypes-Definitionen, CreationOptional-Attribute und Model.init-Deklarationen.

100% clientseitige Privatsphäre
Null Serverübertragung
Voreinstellungen:
SQL-Compiler-Optionen & Schema-Zuordnung
postgres•Model.init
PostgreSQL5 Tabellen
SQL CREATE TABLE DDL EingabePostgreSQL
Lines: 56Chars: 1944Size: 1.9 KB
5 Tabellen analysiert|34 Spalten
import { DataTypes, Model, Optional, Sequelize } from 'sequelize';

// ============================================================================
// Sequelize TypeScript Models Generated by ToolsAA
// Dialect: POSTGRES | Syntax: Model.init
// ============================================================================

UserAttributes {
  id?: string;
  email: string;
  fullName?: string | null;
  role?: 'CUSTOMER' | 'ADMIN' | 'VENDOR';
  isActive?: boolean;
  metadata?: Record<string, any> | null;
  createdAt?: Date;
  updatedAt?: Date;
}

UserCreationAttributes extends Optional<UserAttributes, 'id' | 'fullName' | 'role' | 'isActive' | 'metadata' | 'createdAt' | 'updatedAt'> {}

export class User extends Model<UserAttributes, UserCreationAttributes> implements UserAttributes {
  public id!: string;
  public email!: string;
  public fullName!: string | null;
  public role!: 'CUSTOMER' | 'ADMIN' | 'VENDOR';
  public isActive!: boolean;
  public metadata!: Record<string, any> | null;
  public readonly createdAt!: Date;
  public readonly updatedAt!: Date;
}

initUser(sequelize: Sequelize): typeof User {
  User.init(
    {
      id: {
        type: DataTypes.UUID,
        primaryKey: true,
        allowNull: false,
        defaultValue: DataTypes.UUIDV4,
      },
      email: {
        type: DataTypes.STRING(255),
        allowNull: false,
        unique: true,
      },
      fullName: {
        type: DataTypes.STRING(120),
        allowNull: true,
        field: 'full_name',
      },
      role: {
        type: DataTypes.ENUM('CUSTOMER', 'ADMIN', 'VENDOR'),
        allowNull: false,
        defaultValue: 'CUSTOMER',
      },
      isActive: {
        type: DataTypes.BOOLEAN,
        allowNull: false,
        defaultValue: true,
        field: 'is_active',
      },
      metadata: {
        type: DataTypes.JSONB,
        allowNull: true,
      },
      createdAt: {
        type: DataTypes.DATE,
        allowNull: false,
        defaultValue: DataTypes.NOW,
        field: 'created_at',
      },
      updatedAt: {
        type: DataTypes.DATE,
        allowNull: false,
        defaultValue: DataTypes.NOW,
        field: 'updated_at',
      },
    },
    {
      sequelize,
      tableName: 'users',
      modelName: 'User',
      timestamps: true,
      underscored: true,
    }
  );
  return User;
}

UserProfileAttributes {
  id?: string;
  userId: string;
  avatarUrl?: string | null;
  phone?: string | null;
  shippingAddress?: string | null;
  taxIdentifier?: string | null;
}

UserProfileCreationAttributes extends Optional<UserProfileAttributes, 'id' | 'avatarUrl' | 'phone' | 'shippingAddress' | 'taxIdentifier'> {}

export class UserProfile extends Model<UserProfileAttributes, UserProfileCreationAttributes> implements UserProfileAttributes {
  public id!: string;
  public userId!: string;
  public avatarUrl!: string | null;
  public phone!: string | null;
  public shippingAddress!: string | null;
  public taxIdentifier!: string | null;

  // Association Mixin Placeholders
  // public getUser!: BelongsToGetAssociationMixin<User>;
}

initUserProfile(sequelize: Sequelize): typeof UserProfile {
  UserProfile.init(
    {
      id: {
        type: DataTypes.UUID,
        primaryKey: true,
        allowNull: false,
        defaultValue: DataTypes.UUIDV4,
      },
      userId: {
        type: DataTypes.UUID,
        allowNull: false,
        unique: true,
        field: 'user_id',
        references: {
          model: 'users',
          key: 'id',
        },
        onDelete: 'CASCADE',
      },
      avatarUrl: {
        type: DataTypes.STRING(500),
        allowNull: true,
        field: 'avatar_url',
      },
      phone: {
        type: DataTypes.STRING(30),
        allowNull: true,
      },
      shippingAddress: {
        type: DataTypes.TEXT,
        allowNull: true,
        field: 'shipping_address',
      },
      taxIdentifier: {
        type: DataTypes.STRING(50),
        allowNull: true,
        field: 'tax_identifier',
      },
    },
    {
      sequelize,
      tableName: 'user_profiles',
      modelName: 'UserProfile',
      timestamps: true,
      underscored: true,
    }
  );
  return UserProfile;
}

ProductAttributes {
  id?: number;
  sku: string;
  title: string;
  description?: string | null;
  price?: number;
  inventory?: number;
  isPublished?: boolean;
  createdAt?: Date;
}

ProductCreationAttributes extends Optional<ProductAttributes, 'id' | 'description' | 'price' | 'inventory' | 'isPublished' | 'createdAt'> {}

export class Product extends Model<ProductAttributes, ProductCreationAttributes> implements ProductAttributes {
  public id!: number;
  public sku!: string;
  public title!: string;
  public description!: string | null;
  public price!: number;
  public inventory!: number;
  public isPublished!: boolean;
  public readonly createdAt!: Date;
}

initProduct(sequelize: Sequelize): typeof Product {
  Product.init(
    {
      id: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
        allowNull: false,
      },
      sku: {
        type: DataTypes.STRING(64),
        allowNull: false,
        unique: true,
      },
      title: {
        type: DataTypes.STRING(200),
        allowNull: false,
      },
      description: {
        type: DataTypes.TEXT,
        allowNull: true,
      },
      price: {
        type: DataTypes.DECIMAL(10, 2),
        allowNull: false,
        defaultValue: 0.00,
      },
      inventory: {
        type: DataTypes.INTEGER,
        allowNull: false,
        defaultValue: 0,
      },
      isPublished: {
        type: DataTypes.BOOLEAN,
        allowNull: false,
        defaultValue: true,
        field: 'is_published',
      },
      createdAt: {
        type: DataTypes.DATE,
        allowNull: false,
        defaultValue: DataTypes.NOW,
        field: 'created_at',
      },
    },
    {
      sequelize,
      tableName: 'products',
      modelName: 'Product',
      timestamps: true,
      underscored: true,
      indexes: [
        {
          name: 'idx_products_sku',
          fields: ['sku'],
        },
      ],
    }
  );
  return Product;
}

OrderAttributes {
  id?: string;
  customerId: string;
  orderNumber: string;
  status?: 'PENDING' | 'PAID' | 'PROCESSING' | 'SHIPPED' | 'DELIVERED' | 'CANCELLED';
  totalAmount?: number;
  notes?: string | null;
  createdAt?: Date;
}

OrderCreationAttributes extends Optional<OrderAttributes, 'id' | 'status' | 'totalAmount' | 'notes' | 'createdAt'> {}

export class Order extends Model<OrderAttributes, OrderCreationAttributes> implements OrderAttributes {
  public id!: string;
  public customerId!: string;
  public orderNumber!: string;
  public status!: 'PENDING' | 'PAID' | 'PROCESSING' | 'SHIPPED' | 'DELIVERED' | 'CANCELLED';
  public totalAmount!: number;
  public notes!: string | null;
  public readonly createdAt!: Date;

  // Association Mixin Placeholders
  // public getUser!: BelongsToGetAssociationMixin<User>;
}

initOrder(sequelize: Sequelize): typeof Order {
  Order.init(
    {
      id: {
        type: DataTypes.UUID,
        primaryKey: true,
        allowNull: false,
        defaultValue: DataTypes.UUIDV4,
      },
      customerId: {
        type: DataTypes.UUID,
        allowNull: false,
        field: 'customer_id',
        references: {
          model: 'users',
          key: 'id',
        },
        onDelete: 'RESTRICT',
      },
      orderNumber: {
        type: DataTypes.STRING(64),
        allowNull: false,
        unique: true,
        field: 'order_number',
      },
      status: {
        type: DataTypes.ENUM('PENDING', 'PAID', 'PROCESSING', 'SHIPPED', 'DELIVERED', 'CANCELLED'),
        allowNull: false,
        defaultValue: 'PENDING',
      },
      totalAmount: {
        type: DataTypes.DECIMAL(12, 2),
        allowNull: false,
        defaultValue: 0.00,
        field: 'total_amount',
      },
      notes: {
        type: DataTypes.TEXT,
        allowNull: true,
      },
      createdAt: {
        type: DataTypes.DATE,
        allowNull: false,
        defaultValue: DataTypes.NOW,
        field: 'created_at',
      },
    },
    {
      sequelize,
      tableName: 'orders',
      modelName: 'Order',
      timestamps: true,
      underscored: true,
      indexes: [
        {
          name: 'idx_orders_customer',
          fields: ['customer_id'],
        },
      ],
    }
  );
  return Order;
}

OrderItemAttributes {
  id?: number;
  orderId: string;
  productId: number;
  quantity?: number;
  unitPrice: number;
}

OrderItemCreationAttributes extends Optional<OrderItemAttributes, 'id' | 'quantity'> {}

export class OrderItem extends Model<OrderItemAttributes, OrderItemCreationAttributes> implements OrderItemAttributes {
  public id!: number;
  public orderId!: string;
  public productId!: number;
  public quantity!: number;
  public unitPrice!: number;

  // Association Mixin Placeholders
  // public getOrder!: BelongsToGetAssociationMixin<Order>;
  // public getProduct!: BelongsToGetAssociationMixin<Product>;
}

initOrderItem(sequelize: Sequelize): typeof OrderItem {
  OrderItem.init(
    {
      id: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
        allowNull: false,
      },
      orderId: {
        type: DataTypes.UUID,
        allowNull: false,
        field: 'order_id',
        references: {
          model: 'orders',
          key: 'id',
        },
        onDelete: 'CASCADE',
      },
      productId: {
        type: DataTypes.INTEGER,
        allowNull: false,
        field: 'product_id',
        references: {
          model: 'products',
          key: 'id',
        },
        onDelete: 'RESTRICT',
      },
      quantity: {
        type: DataTypes.INTEGER,
        allowNull: false,
        defaultValue: 1,
      },
      unitPrice: {
        type: DataTypes.DECIMAL(10, 2),
        allowNull: false,
        field: 'unit_price',
      },
    },
    {
      sequelize,
      tableName: 'order_items',
      modelName: 'OrderItem',
      timestamps: true,
      underscored: true,
    }
  );
  return OrderItem;
}

// ============================================================================
// Unified Model Registry & Associations Initializer
// ============================================================================

DatabaseModels {
  User: typeof User;
  UserProfile: typeof UserProfile;
  Product: typeof Product;
  Order: typeof Order;
  OrderItem: typeof OrderItem;
}

initModels(sequelize: Sequelize): DatabaseModels {
  initUser(sequelize);
  initUserProfile(sequelize);
  initProduct(sequelize);
  initOrder(sequelize);
  initOrderItem(sequelize);

  // Setup Relationships
  UserProfile.belongsTo(User, { foreignKey: 'userId', as: 'user' });
  User.hasMany(UserProfile, { foreignKey: 'userId', as: 'userProfiles' });
  Order.belongsTo(User, { foreignKey: 'customerId', as: 'user' });
  User.hasMany(Order, { foreignKey: 'customerId', as: 'orders' });
  OrderItem.belongsTo(Order, { foreignKey: 'orderId', as: 'order' });
  Order.hasMany(OrderItem, { foreignKey: 'orderId', as: 'orderItems' });
  OrderItem.belongsTo(Product, { foreignKey: 'productId', as: 'product' });
  Product.hasMany(OrderItem, { foreignKey: 'productId', as: 'orderItems' });

  return {
    User,
    UserProfile,
    Product,
    Order,
    OrderItem,
  };
}
Ausgabezeilen: 449Dialect: POSTGRESMode: init
Sequelize v6 / v7 Compatible

Erkannte Tabellen & Architektur (5)

usersUser
Spalten8
Primärschlüssel:id
Fremdschlüssel:0
user_profilesUserProfile
Spalten6
Primärschlüssel:id
Fremdschlüssel:1
productsProduct
Spalten8
Primärschlüssel:id
Fremdschlüssel:0
ordersOrder
Spalten7
Primärschlüssel:id
Fremdschlüssel:1
order_itemsOrderItem
Spalten5
Primärschlüssel:id
Fremdschlüssel:2

Vollständige Lokale Privatsphäre

Alle SQL-DDL-Analysen und Sequelize-Modellgenerierungen laufen zu 100% lokal in Ihrer Browser-Sandbox. Ihre Datenbankschemata verlassen niemals Ihren Rechner.

Duale TypeScript-Architektur

Erzeugt standardmäßige Sequelize v6/v7 Model.init Deklarationen mit vollständigen TypeScript-Interfaces oder moderne sequelize-typescript Klassendekoratoren.

Assoziationen & Migrationen

Erkennt automatisch 1:1, 1:N und N:M Fremdschlüsselbeziehungen und erstellt passgenaue hasMany-, belongsTo- und CLI-Migrationsdateien.

Technische Referenz & Architektur-Leitfaden

SQL-DDL zu Sequelize-TypeScript-Modell-Generator — Referenz-Leitfaden

Vollständige Entwicklerdokumentation zur Konvertierung von SQL CREATE TABLE DDL-Anweisungen in typsichere Sequelize-TypeScript-Modelle, DataTypes-Definitionen, CreationOptional-Attribute und Model.init-Deklarationen.

Wichtige Parameter & Steuerelemente

ddlInputstring

Reine SQL-CREATE TABLE-Anweisungen mit Spaltendefinitionen, Primärschlüsseln, Nullable-Attributen, Standardwerten und Fremdschlüssel-Constraints.

Standard: CREATE TABLE users (...)
dialectenum ('postgres' | 'mysql' | 'sqlite' | 'mssql')

Ziel-SQL-Datenbankdialekt zur Bestimmung dialektspezifischer Sequelize-DataTypes (z. B. JSONB, UUID, ENUM, INET).

Standard: postgres
tsSyntaxenum ('v6-infer' | 'decorators' | 'interface')

TypeScript-Modellsyntax: Sequelize v6 InferAttributes/InferCreationAttributes, sequelize-typescript Dekoratoren oder klassische typisierte Interfaces.

Standard: v6-infer
camelCaseboolean

Konvertiert snake_case SQL-Spaltennamen automatisch in camelCase TypeScript-Modellattribute mit expliziter field-Zuordnung.

Standard: true

Profi-Tipps & Best Practices

In modernem Sequelize v6+ sollten

In modernem Sequelize v6+ sollten Auto-Increment-Primärschlüssel, Spalten mit DEFAULT-Klausel und Zeitstempel mit `declare id: CreationOptional<number>;` deklariert werden. So erfordert `Model.create()` diese Felder nicht zwingend, während sie in Instanzen typsicher vorhanden sind.

Aktivieren Sie die

Aktivieren Sie die camelCase-Konvertierung, um in TypeScript mit sauberen Attributen wie createdAt zu arbeiten, während Sequelize diese über die Eigenschaft `field: 'created_at'` transparent auf die Datenbankschicht abbildet.

Aus SQL-Fremdschlüsseln werden

Aus SQL-Fremdschlüsseln werden automatisch Sequelize-Fremdschlüsselattribute erzeugt. In Kombination mit typisierten Schnittstellen lassen sich Assoziationen wie hasMany und belongsTo ohne zirkuläre Typkonflikte aufbauen.

Häufige Fallstricke & Fehlerbehebung

TypeScript-Fehler: Die Eigenschaft 'id' hat keinen Initialisierer und ist nicht definitiv im Konstruktor zugewiesen (TS2564)

Verwenden Sie bei aktivierter TypeScript-Compiler-Option `useDefineForClassFields: true` das Schlüsselwort `declare` für Klassenattribute (z. B. `declare id: CreationOptional<number>;`).

Nicht unterstützter DataType-Fehler beim Dialektwechsel (z. B. DataTypes.JSONB in MySQL)

Wählen Sie vor der Konvertierung den passenden Ziel-Dialekt aus. Der Generator ersetzt dialektspezifische Typen wie JSONB oder ARRAY automatisch durch universelle Entsprechungen wie `DataTypes.JSON` oder `DataTypes.TEXT`.

Häufig gestellte Fragen (FAQ)

Wie werden SQL-Datentypen auf Sequelize-DataTypes abgebildet?▼

Der Parser konvertiert SQL-Typen wie VARCHAR, INT, BIGINT, TIMESTAMP, BOOLEAN, TEXT, DECIMAL und JSON präzise in die entsprechenden Sequelize-DataTypes (STRING, INTEGER, BIGINT, DATE, BOOLEAN, TEXT, DECIMAL, JSON). Dialektspezifische Typen wie PostgreSQL UUID oder JSONB bleiben erhalten, wenn der passende Dialekt gewählt ist.

Werden sowohl Sequelize v6 InferAttributes als auch sequelize-typescript unterstützt?▼

Ja. Sie können flexibel zwischen dem Sequelize v6 Standard-Syntax (`Model<InferAttributes<T>, InferCreationAttributes<T>>` mit `Model.init`) und dekoratorbasierten Modellen für sequelize-typescript (`@Table`, `@Column`, `@PrimaryKey`) wählen.

Wie werden DEFAULT-Werte und NOT NULL-Constraints behandelt?▼

Spalten mit `NOT NULL` erhalten `allowNull: false`. Definierte Standardwerte werden zu `defaultValue: ...` konvertiert und im TypeScript-Modell mit `CreationOptional<T>` getypt, was die Handhabung bei Datensatzerstellung erleichtert.

Werden SQL-DDL-Anweisungen oder Schemadaten an externe Server übertragen?▼

Nein. Das Parsing, die Analyse und die TypeScript-Generierung laufen zu 100 % clientseitig im Webbrowser über lokale Web-Worker ab. Es werden keinerlei Daten oder Schemata übertragen oder gespeichert.

Verwandte Werkzeuge & Dienstprogramme

Alle Werkzeuge →
Json To Elixir Ecto Entwickler-ReferenzEntwickler

Architektur- und Konfigurationsleitfaden für die Kompilierung von JSON-Nutzdaten in produktionsreife Elixir-Ecto-Schemas, Migrationen, Changesets und Dialyzer-Typespecs.

Werkzeug öffnen→
JSON zu Scala 3 & Scala 2 Case Class Generator Entwickler-HandbuchEntwickler

Konvertieren Sie JSON-Nutzdaten in typsichere Scala-Case-Classes mit automatischer Ableitung von Circe-, Play JSON- oder zio-json-Codecs.

Werkzeug öffnen→
JSON zu PHP 8.2+ Typed Readonly DTO Generator Entwickler-HandbuchEntwickler

Konvertieren Sie JSON-Daten in moderne PHP 8.2+ readonly class DTOs mit Constructor Promotion und fromArray-Deserialisierern.

Werkzeug öffnen→
TypeScript zu GraphQL SDL CheatsheetEntwickler

Entwickler-Referenz zur Konvertierung von TypeScript-Schnittstellen, Typen und Enums in produktionsreife GraphQL-Schema-Definition-Language-(SDL)-Schemata.

Werkzeug öffnen→
TypeScript Interface zu Protocol Buffers proto3 Konverter Entwickler-HandbuchEntwickler

Konvertieren Sie TypeScript Interfaces und Typdefinitionen in Protobuf 3 Nachrichten mit fortlaufenden Feld-Tags und Enums.

Werkzeug öffnen→
GitLab CI Pipeline-Generator ReferenzEntwickler

Autoritative technische Referenz zur Erstellung produktionsreifer GitLab CI/CD-Pipelines (.gitlab-ci.yml) für Node.js, Python, Go, Rust und Kaniko-Container.

Werkzeug öffnen→