Extbaser Bundle Laravel Package

Technical Evaluation

Architecture Fit

• Purpose Alignment: The bundle bridges Symfony applications with TYPO3 Extbase, enabling reuse of domain logic (models, repositories, services) in a TYPO3 CMS context. This is valuable for monolithic Symfony-to-TYPO3 integration or gradual migration of legacy Symfony apps to TYPO3.
• Symfony Compatibility: Leverages Symfony’s dependency injection, console commands, and configuration system, ensuring seamless integration with existing Symfony apps (v4.4+). However, no native Symfony UX (e.g., Twig, SensioFrameworkExtra) is exposed—this is purely a backend/data-layer tool.
• TYPO3 Extbase Fit: Targets Extbase’s MVC structure (Domain Models, Repositories, Controllers), but assumes prior TYPO3/Extbase familiarity. The bundle does not handle frontend rendering (Fluid) or TYPO3-specific features (e.g., TCA, Page TS).

Integration Feasibility

• Low-Coupling Design: The extbaser:export command generates standalone Extbase extensions, minimizing direct runtime coupling between Symfony and TYPO3. However, shared domain models must be manually synchronized (e.g., via Doctrine migrations or shared Composer packages).
• Dependency Overhead: Requires:
  • Symfony Console component (already present in Symfony).
  • TYPO3 Extbase (not a Symfony dependency) in the target environment.
  • Extbaser core (dependency of this bundle), which may introduce versioning constraints.
• Data Layer Focus: Only handles model/repo/service export; controllers must be manually adapted to Extbase’s ActionController or rewritten.

Technical Risk

Key Questions

1. Why Extbase?

   • Is TYPO3’s Extbase the only CMS target, or could this be adapted for other PHP MVC frameworks (e.g., Laminas, CakePHP)?
   • Are there alternatives (e.g., direct API integration, shared Doctrine entities) with lower risk?

2. Migration Strategy

   • Will this be used for full migration or incremental feature parity (e.g., moving Symfony services to TYPO3)?
   • How will authentication/authorization (Symfony’s security vs. TYPO3’s BE/FE) be handled post-integration?

3. Long-Term Viability

   • What’s the backup plan if this package is abandoned? Can the export logic be replicated with custom scripts?
   • Are there plans to support reverse sync (TYPO3 → Symfony)?

4. Performance

   • How will Doctrine entity hydration differ between Symfony and TYPO3 Extbase? Are there N+1 query risks?
   • Will the generated Extbase extensions support lazy-loading or custom repository methods from Symfony?

5. Testing

   • How will you verify data consistency between Symfony and TYPO3 after export?
   • Are there unit/integration test templates for the generated Extbase code?

Integration Approach

Stack Fit

• Symfony Side:

  • Prerequisites: Symfony 4.4+ with Doctrine ORM, Console component.
  • Fit: Excellent for apps already using Symfony’s domain layer. The bundle reuses existing:
    • Entities (mapped to Extbase models).
    • Repositories (converted to Extbase repositories).
    • Services (exported as Extbase service classes).
  • Non-Fit: Symfony-specific features (e.g., API Platform, SensioFrameworkExtra) won’t translate and must be rewritten.

• TYPO3 Side:

  • Prerequisites: TYPO3 with Extbase installed (v9+ recommended).
  • Fit: Ideal for headless TYPO3 backends or apps where Symfony logic is reused in TYPO3’s frontend.
  • Non-Fit:
    • No frontend integration: Fluid templates must be written separately.
    • TYPO3-specific features (e.g., TCA, Page TS, BE modules) require manual setup.
    • Authentication: TYPO3’s BE/FE auth won’t auto-map to Symfony’s security system.

Migration Path

1. Assessment Phase:

   • Audit Symfony app for Extbase-compatible components (entities, repos, services).
   • Identify non-portable features (e.g., Symfony-specific annotations, API resources).
   • Test extbaser:export on a subset of entities to validate output.

2. Pilot Export:

   • Export one domain model and manually:
     • Verify Extbase model generation.
     • Test repository CRUD operations in TYPO3.
     • Adapt Symfony controllers to Extbase actions (or rewrite).
   • Document gaps (e.g., missing associations, type mismatches).

3. Incremental Rollout:

   • Phase 1: Export core domain models/repos to TYPO3.
   • Phase 2: Migrate Symfony services to Extbase service classes.
   • Phase 3: Build TYPO3-specific layers (TCA, Fluid templates, BE modules).
   • Phase 4: Deprecate Symfony endpoints in favor of TYPO3 Extbase routes.

4. Fallback Plan:

   • If the bundle fails, manually generate Extbase extensions using:
     • Custom scripts to parse Symfony entities/repos.
     • TYPO3’s ext:create command as a template.
   • Consider shared Doctrine entities (via Composer) to avoid duplication.

Compatibility

Sequencing

1. Pre-Export:

   • Standardize Symfony entities/repos (e.g., use consistent annotations).
   • Resolve circular dependencies between entities.
   • Backup Symfony database and codebase.

2. Export Execution:

   # Export a single extension (e.g., "symfony_to_typo3")
   php bin/console extbaser:export symfony_to_typo3
   

   • Verify generated files in src/SymfonyToTypo3/Extension/.

3. Post-Export:

   • Step 1: Upload to TYPO3 (ext:create or manual upload).
   • Step 2: Configure TCA and Fluid templates.
   • Step 3: Adapt Symfony controllers to Extbase or build new ones.
   • Step 4: Test CRUD operations in TYPO3 backend/frontend.

4. Cutover:

   • Gradually replace Symfony API calls with TYPO3 Extbase routes.
   • Use feature flags to toggle between old/new endpoints.

Operational Impact

Maintenance

• Bundle Dependency:
  • Risk: Zero-maintenance package. Vendorize immediately (copy to vendor/) to avoid supply chain issues.
  • Mitigation: Fork the repo and submit PRs for critical fixes (e.g., PHP 8.1+ support).
• Generated Code:
  • Extbase extensions will require ongoing TYPO3-specific maintenance (e.g., TCA updates, Fluid template fixes).
  • Symfony and TYPO3 versions must stay in sync for shared entities.
• Tooling:
  • No built-in hot-reload or live sync between Symfony and TYPO3. Changes require re-export.

Support

• No Community:
  • Zero stars/issues imply