Automatisierte Erstellung eines Draw.io-Datenbankdiagrammes für eine komplette TYPO3-Installation

Ein Kunde benötigte für ein gemeinsames Projekt mit einer anderen Agentur eine aktuelle Beschreibung der Datenbanktabellen einer spezifischen Extension. Anstatt die Relationen manuell zu analysieren, entstand die Idee, diesen Prozess zu automatisieren und ein entsprechendes Diagramm in Flowchart Maker & Online Diagram Software  zu generieren. Durch die Empfehlung eines Kollegen wurde dieser Ansatz erweitert, um nicht nur einzelne Extensions, sondern die gesamte TYPO3-Instanz abzudecken.​

TYPO3 verwaltet die Struktur und Konfiguration seiner Datenbanktabellen im sogenannten TCA. Dieses Array enthält detaillierte Informationen über alle Tabellen, Felder und Relationen. Durch das Auslesen des TCA können wir die notwendigen Daten extrahieren, um ein vollständiges ERD zu erstellen.​

1. Einrichten des Symfony Console Commands

Zunächst erstellen wir ein neues Symfony Console Command innerhalb unserer TYPO3-Extension. Dieses Command wird später die Logik zur Generierung des ERD enthalten.

namespace Vendor\Extension\Command;

use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

class GenerateERDCommand extends Command
{
    protected static $defaultName = 'extension:generate-erd';

    protected function configure(): void
    {
        $this->setDescription('Generiert ein Draw.io ERD aus den TYPO3-Datenbanktabellen.');
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        // Logik zur Generierung des ERD
        return Command::SUCCESS;
    }
}

­

2. Auslesen des TCA

Um die Struktur der Datenbanktabellen zu erhalten, iterieren wir über das globale $GLOBALS['TCA']-Array. Dabei extrahieren wir Informationen zu Tabellen, Feldern und Relationen.

 foreach (glob($extPath . '/Configuration/TCA/*.php') as $tcaFile) {
       $table = basename($tcaFile, '.php');
       $tca = include $tcaFile;
       if (!is_array($tca)) continue;
       $GLOBALS['TCA'][$table] = array_merge_recursive($GLOBALS['TCA'][$table] ?? [], $tca);
   }

   foreach (glob($extPath . '/Configuration/TCA/Overrides/*.php') as $overrideFile) {
       require_once $overrideFile;
   }

­

3. Erkennen von Relationen

Innerhalb der Feldkonfigurationen suchen wir nach Angaben zu Fremdschlüsseln (foreign_table). Diese Informationen sind entscheidend, um die Beziehungen zwischen den Tabellen im ERD darzustellen.

   foreach ($GLOBALS['TCA'] as $table => $config) {
       if (!is_array($config) || !isset($config['columns'])) continue;

       foreach ($config['columns'] as $field => $fieldConfig) {
           $columns[] = [
               'name' => $field,
               'type' => $fieldConfig['config']['type'] ?? 'unknown',
           ];

           if (!empty($fieldConfig['config']['foreign_table'])) {
               $relations[] = [
                   'from' => $field,
                   'to' => $fieldConfig['config']['foreign_table'],
               ];
           }
       }
   }

­

4. Generierung der Flowchart Maker & Online Diagram Software  XML-Struktur

Mit den gesammelten Daten erstellen wir eine XML-Datei im Format von Flowchart Maker & Online Diagram Software. Dabei definieren wir für jede Tabelle und jede Relation entsprechende XML-Knoten.

   $doc = new \DOMDocument('1.0', 'UTF-8');
   $root = $doc->createElement('root');

   $tableCell = $doc->createElement('mxCell');
   $tableCell->setAttribute('id', 'id2');
   $tableCell->setAttribute('value', '`tx_mytable`');
   $tableCell->setAttribute('style', 'swimlane;...');
   $root->appendChild($tableCell);

   $fieldCell = $doc->createElement('mxCell');
   $fieldCell->setAttribute('value', '`title` input');
   $fieldCell->setAttribute('style', 'align=left;...');
   $fieldCell->setAttribute('parent', 'id2');
   $root->appendChild($fieldCell);

Für Relationen sieht das z.B. so aus:

   $edge = $doc->createElement('mxCell');
   $edge->setAttribute('edge', '1');
   $edge->setAttribute('source', $columnIds[$from][$field]);
   $edge->setAttribute('target', $tableIds[$to]);
   $edge->setAttribute('style', 'edgeStyle=orthogonalEdgeStyle;...');
   $root->appendChild($edge);

Während der Entwicklung dieses Commands traten einige Herausforderungen auf:​

• Initialisierung von XML-Knoten: Ein häufiger Fehler war der Aufruf von appendChild() auf einer nicht initialisierten Variable. Dies wurde behoben, indem sichergestellt wurde, dass alle notwendigen Knoten vor deren Verwendung korrekt initialisiert wurden.

• Relationen in einer TYPO3-Instanz ermitteln: dass die Idee, einfach den Code aus einer ext_tables.sql in Flowchart Maker & Online Diagram Softwarezu kopieren und ein fertiges Datenbankdiagramm zu bekommen, völlig weltfremd ist, hat sich schnell gezeigt — es gibt ein paar Gründe, weshalb TYPO3 Relationen zu anderen Tabellen nicht fest im SQL-Code verdrahtet und stattdessen über den TCA, den Table Configuration Array, definiert. Das bedeutet allerdings, dass auch wir für ein korrektes Diagramm mit Relationen den TCA parsen und Verbindungen zu anderen Tabellen daraus ableiten müssen, wenn wir die Relationen nicht alle manuell ermitteln und setzen möchten (meine Vermutung: das möchte keiner!)​

• Anpassung des Verbindungsstils: Um die Darstellung der Relationen im Diagramm zu optimieren, wurde eine Option eingeführt, mit der zwischen verschiedenen Verbindungsstilen (z.B. entityRelation oder orthogonal) gewählt werden kann. Bis die Verbindungslinien richtig gesetzt waren, hat es einige Versuche gebraucht.​

• Vermeidung von überlappenden Linien: Bei der Darstellung mehrerer Relationen zwischen Tabellen kam es zu überlappenden Linien. Durch Anpassungen an den jettySize-Werten und der Verwendung von jumpStyle konnten die Linienführungen verbessert und Überschneidungen reduziert, aber nicht komplett vermieden werden.​

Die automatisierte Erstellung eines Draw.io-Datenbank-Diagramms für eine komplette TYPO3-Instanz bietet eine effiziente Möglichkeit, komplexe Datenbankstrukturen zu visualisieren und zu dokumentieren. Durch die Nutzung des TCA und die Implementierung eines entsprechenden Commands können Entwickler Zeit sparen und gleichzeitig die Qualität der Dokumentation erhöhen. Dieser Ansatz dient als Denkanstoß für Entwickler, ähnliche Automatisierungen in ihren Projekten zu implementieren und so den Entwicklungsprozess weiter zu optimieren.