Automatisiere TYPO3 Upgrades: Vollständig Rector Leitfaden 2025

Automatisiere TYPO3 Upgrades: Vollständig Rector Leitfaden 2025

FYI. This blog is translated by machine. Please ignore any spelling and grammar errors; sorry for such inconvenience. We appreciate your understanding and support.

Hör auf, Tage mit manuellen TYPO3 Upgrades zu verschwenden. TYPO3 Rector automatisiert Code-Migrationen, verarbeitet Deprecations und aktualisiert TCA-Konfigurationen automatisch. Konzentriere dich auf das Testen, statt auf mühsame Copy-Paste Arbeit.

TYPO3 Upgrades tagelange manuelle Code-Änderungen. Copy-Paste aus den Changelogs. Veraltete Methoden einzeln suchen. Alles doppelt testen.

Nicht mehr.

TYPO3 Rector automatisiert die langweiligen Aufgaben. Es liest die TYPO3-Changelogs und schreibt deinen Code automatisch um. Du konzentrierst dich aufs Testen statt auf die mühsame Suche nach veralteten Funktionen.

Ein schnelles Dankeschön;

Danke an Sebastian Schreiber (@sabbelasichon) und die TYPO3-Rector-Community für die Entwicklung dieses Tools. Ihr habt aus schmerzhaften TYPO3-Upgrades etwas Handhabbares gemacht. Diesen Blog möchte ich dem Team TYPO3 Rector widmen.

Dieses Handbuch ist für alle Entwickler gedacht, die ihre Wochenenden damit verbracht haben, veralteten Code manuell zu reparieren.
Ihr verdient bessere Werkzeuge.

TYPO3 Rector erweitert das Rector-Projekt, um sofortige Upgrades und Refaktorierungen für TYPO3-Websites und Erweiterungscode bereitzustellen. Es erleichtert die Migration zwischen TYPO3-Versionen, indem es deinen Code frei von Deprecations hält.

Stell es dir wie deinen persönlichen Assistenten für Code-Migration vor. Es kennt jede Breaking Change in der TYPO3-Historie und kann sie automatisch beheben.

Das übernimmt es:

  • PHP Code Updates
  • TCA Konfigurationsänderungen
  • Klassennamen Ersetzungen
  • Aktualisierungen von Methodensignaturen
  • Änderungen im Konfigurationsformat

Manuelle TYPO3-Upgrades sind mühsam. Du verbringst Stunden damit, Changelogs zu lesen, betroffenen Code zu finden und wiederholte Änderungen vorzunehmen.

TYPO3 Rector eliminiert den Großteil dieser Arbeit:

Zeitersparnis: Was früher Tage dauerte, braucht jetzt nur Minuten Fehlerreduzierung: Keine übersehenen Deprecations mehr Konsistenz: Überall werden dieselben Regeln angewendet Dokumentation: Änderungen basieren auf den offiziellen TYPO3 Changelogs Testfokus: Verbringe Zeit mit dem Testen von Features, nicht mit der Fehlersuche

Bevor du beginnst, überprüfe deine Umgebung:

PHP Anforderungen:

  • PHP 7.4 Mindestversion (PHP 8.1+ empfohlen)
  • Composer installiert
  • Git Versionskontrolle (essentiell für die Sicherheit)

TYPO3 Kompatibilität:

  • TYPO3 v7 bis v13 unterstützt
  • Funktioniert mit individuellen Erweiterungen
  • Kompatibel mit Drittanbieter-Erweiterungen

Wichtiger Sicherheitshinweis: Führe dieses Tool niemals in der Produktion aus! Verwende es immer in einer Entwicklungsumgebung, in der der Code unter Versionskontrolle steht. Überprüfe und teste Änderungen, bevor du sie in die Produktion übernimmst.

Methode 1: Globale Installation (Empfohlen)

Installiere TYPO3 Rector global, um es in mehreren Projekten zu verwenden:

composer global require ssch/typo3-rector

Füge das globale Bin-Verzeichnis von Composer zu deinem PATH hinzu:

# Add to your ~/.bashrc or ~/.zshrc
export PATH="$PATH:$HOME/.composer/vendor/bin"

Verifizieren Installation:

typo3-rector --version

Methode 2: Projektspezifische Installation

Für projektspezifische Verwendung:

composer require --dev ssch/typo3-rector

Methode 3: PHAR Download

Laden Sie die eigenständige PHAR-Datei herunter:

wget https://github.com/sabbelasichon/typo3-rector/releases/latest/download/typo3-rector.phar
chmod +x typo3-rector.phar

Erstelle eine rector.php Konfigurationsdatei im Projektstammverzeichnis:

<?php

declare(strict_types=1);

use Rector\Config\RectorConfig;
use Ssch\TYPO3Rector\Set\Typo3SetList;

return RectorConfig::configure()
    ->withPaths([
        __DIR__ . '/typo3conf/ext/your_extension',
        // Add more paths as needed
    ])
    ->withSets([
        Typo3SetList::TYPO3_95,
        Typo3SetList::TYPO3_104,
        Typo3SetList::TYPO3_11,
        Typo3SetList::TYPO3_12,
    ])
    ->withSkip([
        // Skip specific files or directories
        __DIR__ . '/typo3conf/ext/your_extension/Resources',
    ]);

Konfigurationsoptionen

Pfade: Definiere, welche Verzeichnisse verarbeitet werden sollen.

->withPaths([
    __DIR__ . '/typo3conf/ext',
    __DIR__ . '/packages',
    __DIR__ . '/src',
])

Sätze: Wähle TYPO3-Version-spezifische Regel Sets aus.

->withSets([
    Typo3SetList::TYPO3_76,      // For v7.6 migrations
    Typo3SetList::TYPO3_87,      // For v8.7 migrations  
    Typo3SetList::TYPO3_95,      // For v9.5 migrations
    Typo3SetList::TYPO3_104,     // For v10.4 migrations
    Typo3SetList::TYPO3_11,      // For v11 migrations
    Typo3SetList::TYPO3_12,      // For v12 migrations
    Typo3SetList::TYPO3_13,      // For v13 migrations
])

Überspringen: Schließe Dateien oder Verzeichnisse aus.

->withSkip([
    __DIR__ . '/vendor',
    __DIR__ . '/typo3',
    '*/Resources/Private/Vendor/*',
])

Schritt 1: Sicherung deinen Code

Arbeite immer mit Versionskontrolle:

git add .
git commit -m "Backup before Rector migration"

Schritt 2: Trockentest

Sieh dir an, welche Änderungen Rector vornehmen würde, ohne sie anzuwenden:

typo3-rector process --dry-run

Dies zeigt dir genau, was sich ändern wird. Überprüfe die Ausgabe sorgfältig.

Schritt 3: Änderungen anwenden

Laufen die tatsächliche Migration aus:

typo3-rector process

Schritt 4: Änderungen überprüfen

Überprüfe, was geändert wurde:

git diff

Schritt 5: Alles testen

Führe deine Tests aus und überprüfe manuell, ob die kritische Funktionalität funktioniert.

Upgrade von TYPO3 v10 auf v11

// rector.php
return RectorConfig::configure()
    ->withPaths([
        __DIR__ . '/typo3conf/ext/your_extension',
    ])
    ->withSets([
        Typo3SetList::TYPO3_11,
    ]);

Häufige Änderungen, die es behandelt:

  • Änderungen des Parameters von GeneralUtility::getFileAbsFileName()
  • TCA renderType Updates
  • Signal/Slot zu PSR-14 Ereignis Konvertierung

Migration von individuellen Erweiterungen

// rector.php for extension development
return RectorConfig::configure()
    ->withPaths([
        __DIR__ . '/Classes',
        __DIR__ . '/Configuration',
    ])
    ->withSets([
        Typo3SetList::TYPO3_12,
        Typo3SetList::TYPO3_13,
    ])
    ->withSkip([
        __DIR__ . '/Resources',
        __DIR__ . '/Documentation',
    ]);

Vollständige Projektmigration

Für vollständige Site-Migrationen:

return RectorConfig::configure()
    ->withPaths([
        __DIR__ . '/typo3conf/ext',
        __DIR__ . '/packages',
    ])
    ->withSets([
        Typo3SetList::TYPO3_95,
        Typo3SetList::TYPO3_104,
        Typo3SetList::TYPO3_11,
        Typo3SetList::TYPO3_12,
    ])
    ->withSkip([
        '*/Resources/Private/Vendor/*',
        '*/node_modules/*',
        '*/Resources/Public/JavaScript/Contrib/*',
    ]);

Benutzerdefinierte Regeln

Füge spezifische Rector-Regeln über die TYPO3-Sätze hinaus hinzu:

use Rector\Php74\Rector\Property\TypedPropertyRector;
use Rector\DeadCode\Rector\ClassMethod\RemoveUnusedPromotedPropertyRector;

return RectorConfig::configure()
    ->withRules([
        TypedPropertyRector::class,
        RemoveUnusedPromotedPropertyRector::class,
    ])
    ->withSets([
        Typo3SetList::TYPO3_12,
    ]);

Parallelverarbeitung

Beschleunige die Verarbeitung mit paralleler Ausführung:

return RectorConfig::configure()
    ->withParallel()
    ->withPaths([
        __DIR__ . '/typo3conf/ext',
    ]);

Speicherlimits

Erhöhe den Speicher für große Projekte:

return RectorConfig::configure()
    ->withMemoryLimit('2G')
    ->withPaths([
        __DIR__ . '/typo3conf/ext',
    ]);

1. Inkrementelle Migrationen

Springe nicht mehrere Versionen auf einmal. Migriere Schritt für Schritt:

#Falsch: typo3-rector process --set=typo3-95,typo3-12

#Richtig: typo3-rector process --set=typo3-95

#Testen, committen, dann fortfahren: typo3-rector process --set=typo3-104

#Testen, committen, dann fortfahren: typo3-rector process --set=typo3-11

2. Trennung von TCA  und Code Regeln

Die nicht-TCA-Regeln sind oft spezifischer und sollten in einem separaten Schritt mit dem entsprechenden Set angewendet werden.

Führe TCA Migrationen separat aus:

// First: TCA migrations
return RectorConfig::configure()
    ->withSets([
        Typo3SetList::TCA_120,
    ]);

Dann Code Migrationen:

// Second: Code migrations  
return RectorConfig::configure()
    ->withSets([
        Typo3SetList::TYPO3_12,
    ]);

3. Versionskontrolle effektiv nutzen

Erstelle aussagekräftige Commits:

git add .
git commit -m "Apply TYPO3 v11 Rector rules"

git add .
git commit -m "Apply TYPO3 v12 Rector rules"

4. Nach jedem Schritt testen

Wende niemals mehrere Regel-Sets an, ohne zu testen:

  • Wende ein Regel-Set an
  • Führe Tests durch
  • Behebe etwaige Probleme
  • Commite die Änderungen
  • Wiederhole mit dem nächsten Regel Set

Häufige Probleme

Speicherüberlauf-Fehler:

php -d memory_limit=2G vendor/bin/typo3-rector process

Zeitüberschreitung bei großen Projekten:

return RectorConfig::configure()
    ->withMemoryLimit('2G')
    ->withParallel(4); // Adjust based on CPU cores

Falsch Positive:
Überspringe problematische Regeln:

return RectorConfig::configure()
    ->withSkip([
        SpecificRectorRule::class,
        SpecificRectorRule::class => [
            __DIR__ . '/specific/file.php',
        ],
    ]);

Debug Modus

Erhalte detaillierte Informationen darüber, was Rector gerade tut:

typo3-rector process --debug

Xdebug Integration

Für Entwicklung und Debugging:

php -d xdebug.mode=debug vendor/bin/typo3-rector process

Beispiel 1: Signal/Slot zu PSR-14-Ereignissen

Vorher (TYPO3 v10):

$dispatcher = GeneralUtility::makeInstance(Dispatcher::class);
$dispatcher->connect(
    DataHandler::class,
    'processDatamap_afterDatabaseOperations',
    MyClass::class,
    'handleAfterDatabaseOperations'
);

Nachher (TYPO3 v11):

// In Services.yaml
services:
  MyVendor\MyExtension\EventListener\AfterDatabaseOperationsEventListener:
    tags:
      - name: event.listener
        identifier: 'my-after-database-operations'
        event: TYPO3\CMS\Core\DataHandling\Event\AfterDatabaseOperationsEvent

Beispiel 2: TCA-Änderungen

Vorher:

$GLOBALS['TCA']['pages']['columns']['doktype']['items'][] = [
    'LLL:EXT:my_extension/Resources/Private/Language/locallang.xlf:pages.doktype.custom',
    123,
    'EXT:my_extension/Resources/Public/Icons/custom.svg'
];

Nachher:

$GLOBALS['TCA']['pages']['columns']['doktype']['items'][] = [
    'label' => 'LLL:EXT:my_extension/Resources/Private/Language/locallang.xlf:pages.doktype.custom',
    'value' => 123,
    'icon' => 'EXT:my_extension/Resources/Public/Icons/custom.svg'
];

Beispiel 3: Änderungen an Utility-Methoden

Vorher (TYPO3 v11):

$absPath = GeneralUtility::getFileAbsFileName('EXT:my_extension/Resources/Private/Templates/');

Nachher (TYPO3 v12):

$absPath = GeneralUtility::getFileAbsFileName('EXT:my_extension/Resources/Private/Templates/') ?: '';

GitHub Actions

name: TYPO3 Rector Check
on: [push, pull_request]

jobs:
  rector:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Setup PHP
        uses: shivammathur/setup-php@v2
        with:
          php-version: 8.1
          
      - name: Install dependencies
        run: composer install --no-dev --optimize-autoloader
        
      - name: Run Rector
        run: vendor/bin/typo3-rector process --dry-run

GitLab CI

rector:
  image: php:8.1
  script:
    - composer install --no-dev
    - vendor/bin/typo3-rector process --dry-run
  only:
    - merge_requests

Große Projekte

Für Projekte mit Tausenden von Dateien:

return RectorConfig::configure()
    ->withParallel(8)
    ->withMemoryLimit('4G')
    ->withPaths([
        __DIR__ . '/typo3conf/ext',
    ])
    ->withSkip([
        '*/Tests/*',
        '*/Documentation/*',
        '*/Resources/Public/*',
    ]);

Selektive Verarbeitung

Verarbeite nur geänderte Dateien:

# Get list of changed PHP files
CHANGED_FILES=$(git diff --name-only --diff-filter=AM main...HEAD | grep '\.php$')

# Run Rector only on changed files
typo3-rector process $CHANGED_FILES

TYPO3 Rector aktuell halten

composer global update ssch/typo3-rector

Auf neue Regeln überprüfen

Neue Regeln werden regelmäßig hinzugefügt. Überprüfe das Changelog:

typo3-rector --version

Besuche die GitHub releases für Update Notizen.

 

Andere Dateitypen wie TypoScript, XML (FlexForm) und composer.json werden von Fractor unterstützt, das gut mit TYPO3 Rector zusammenarbeitet.

Installiere Fractor für Nicht-PHP-Dateien:

composer require --dev a-r-m-i-n/fractor

Beispiel Fractor-Konfiguration:

// fractor.php
use TYPO3\Fractor\Configuration\FractorConfiguration;

return FractorConfiguration::configure()
    ->withFileExtensions(['typoscript', 'ts', 'txt'])
    ->withPaths([
        __DIR__ . '/Configuration/TypoScript',
    ]);

Datenbankverbindungs Updates

Regel: DatabaseConnectionToEntityManagerRector

Konvertiert alte Datenbankverbindungen zu Doctrine DBAL:

// Before
$GLOBALS['TYPO3_DB']->exec_SELECTquery(/* ... */);

// After  
GeneralUtility::makeInstance(ConnectionPool::class)
    ->getConnectionForTable('pages')
    ->select(/* ... */);

Hook  zu Event-Konvertierung

Regel: Verschiedene Ereignismigrationsregeln

Konvertiert Hooks zu PSR-14-Ereignissen:

// Before
$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_tcemain.php']['processDatamapClass'][] = 'MyClass';

// After
// Event listener registration in Services.yaml

TCA Migrationsregeln

Regel: TcaItemsArrayToAssociativeArrayRector

Modernisiert die TCA Konfiguration:

// Before
'items' => [
    ['Label', 'value'],
]

// After
'items' => [
    ['label' => 'Label', 'value' => 'value'],
]

Benutzerdefinierte Regeln

Erstelle benutzerdefinierte Regeln für projektspezifische Migrationen:

<?php

namespace MyVendor\MyExtension\Rector;

use Rector\Core\Rector\AbstractRector;
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;

final class MyCustomRector extends AbstractRector
{
    public function getRuleDefinition(): RuleDefinition
    {
        return new RuleDefinition(
            'Replace custom deprecated method',
            [/* examples */]
        );
    }

    public function getNodeTypes(): array
    {
        return [MethodCall::class];
    }

    public function refactor(Node $node): ?Node
    {
        // Your custom refactoring logic
        return $node;
    }
}

Beitragen von Regeln

Hilf der Community, indem du Regeln beiträgst:

TYPO3 Rector verändert, wie du TYPO3-Upgrades handhabst. Statt manueller Migrationen, die Tage in Anspruch nehmen, erhältst du automatisierte Code-Updates in Minuten.

Das Tool ist nicht perfekt. Du musst trotzdem gründlich testen und Randfälle manuell bearbeiten. Aber es eliminiert 80-90% der mühsamen Arbeit.

Fange klein an. Wähle eine Erweiterung aus und führe einen Trockentest durch. Sieh dir an, was es findet. Erweitere dann schrittweise dein gesamtes Projekt.

Dein zukünftiges Ich wird dir danken, dass du das jetzt einrichtest. Jedes TYPO3-Upgrade wird zur Routine, anstatt ein mehrtägiges Projekt zu sein.

Erinnere dich an die goldenen Regeln:

  • Verwende immer Versionskontrolle
  • Führe es niemals in der Produktion aus
  • Teste alles nach der Migration
  • Wende Änderungen inkrementell an
  • Halte TYPO3 Rector aktuell

Verwende TYPO3 Rector für automatisierte Code-Upgrades deiner TYPO3-Website basierend auf den offiziellen TYPO3-Changelogs. Konzentriere dich auf das Testen, statt auf Copy-and-Paste.

Zuletzt aktualisiert: August 2025. TYPO3 Rector wird aktiv weiterentwickelt und regelmäßig mit Updates für neue TYPO3 Versionen versehen.

TYPO3 Rector ist ein Tool zur automatisierten Code-Migration, das TYPO3-PHP-Code sofort aktualisiert und refaktoriert. Es liest die offiziellen TYPO3-Changelogs und behebt automatisch veraltete Methoden, aktualisiert die TCA-Konfiguration und verarbeitet Breaking Changes zwischen TYPO3-Versionen. Anstatt manuell nach veraltetem Code zu suchen, übernimmt TYPO3 Rector diese Arbeit für dich.

Installiere TYPO3 Rector global mit Composer: composer global require ssch/typo3-rector. Füge anschließend das globale Bin-Verzeichnis von Composer zu deinem PATH hinzu. Alternativ installiere es pro Projekt mit:
composer require --dev ssch/typo3-rector. Erstelle im Projektstammverzeichnis eine rector.php-Konfigurationsdatei, definiere Pfade und TYPO3-Versions-Sets und führe dann aus: typo3-rector process.

TYPO3 Rector ist sicher, wenn es ordnungsgemäß mit Versionskontrolle verwendet wird. Führe es niemals direkt auf Produktionscode aus.
Verwende es immer in Entwicklungsumgebungen, in denen der Code unter Git-Versionskontrolle steht. Führe zuerst mit --dry-run aus, um zu sehen, welche Änderungen vorgenommen werden. Überprüfe alle Änderungen sorgfältig, teste gründlich und commite inkrementell nach jedem Migrationsschritt.

TYPO3 Rector unterstützt Migrationen von TYPO3 v7.6 bis v13. Verfügbare Versions-Sets sind TYPO3_76, TYPO3_87, TYPO3_95, TYPO3_104, TYPO3_11, TYPO3_12 und TYPO3_13. Du solltest Version für Version schrittweise migrieren, statt mehrere Versionen auf einmal zu überspringen. Jedes Set behandelt die spezifischen Breaking Changes und Deprecations der jeweiligen TYPO3-Version.

Nein, setze TYPO3 Rector niemals direkt auf Produktionsservern ein.
TYPO3 Rector verändert Code-Dateien und sollte nur in Entwicklungsumgebungen laufen. Verwende es lokal oder auf Staging-Servern mit vollständiger Versionskontrolle. Nachdem du die Änderungen gründlich getestet hast, stelle den aktualisierten Code über deinen normalen Deployment-Prozess in der Produktion bereit. Das gewährleistet Sicherheit und ermöglicht ein Rollback, falls Probleme auftreten.

Get hassle-free upgrade service from a certified TYPO3 Developer

  • 350+ Extensions upgrade to TYPO3 LTS versions
  • 150+ Completed TYPO3 upgrade sites (from v6 to current LTS)
  • 35+ Team of TYPO3 developers
  • 13+ Years of TYPO3 experience
  • 3 Package plans are available for the TYPO3 upgrade
  • 2 Days of quick support (reaction and resolution time)
TYPO3 Upgrade Gig
upgrade

Post a Comment

×