Twig Formatter Bundle Laravel Package

Product Decisions This Supports

• Enhancing CMS/Editorial Workflows: Accelerates development of rich-text editing features in Laravel-based CMS platforms (e.g., news sites, marketing pages) by integrating Twig templating with Sonata’s formatter.
• Build vs. Buy: Justifies building a custom formatter solution over third-party SaaS (e.g., TinyMCE, CKEditor) when:
  • Brand consistency requires Twig-based theming.
  • Existing Sonata ecosystem is already in use (e.g., SonataAdminBundle).
  • Need for lightweight, self-hosted dependencies.
• Roadmap Prioritization: Enables faster iteration on:
  • Dynamic content blocks (e.g., "Featured Posts" with embedded Twig logic).
  • Reusable template snippets (e.g., "Call-to-Action" blocks with Twig variables).
  • A/B testing variants of formatted content (e.g., different layouts per user segment).
• Use Cases:
  • Internal Tools: Admin dashboards with formatted reports (e.g., combining data tables with Twig loops).
  • Public-Facing: Blogs, documentation, or e-commerce product descriptions with embedded logic (e.g., price calculations in text).
  • Legacy Migration: Modernizing older Symfony/Laravel apps using SonataAdmin with Twig templates.

When to Consider This Package

• Adopt if:

  • Your stack already uses SonataFormatterBundle and Twig (core23’s bundle extends the former).
  • You need server-side Twig processing for formatted content (not client-side rendering).
  • Development team is comfortable with Symfony/Laravel bundles and dependency management.
  • Low-risk pilot: Small-scale features (e.g., a single content type) to test viability.

• Look elsewhere if:

  • No SonataFormatterBundle: This package is a dependency—requires Sonata’s bundle first.
  • Client-side needs: Prefer WYSIWYG editors like TinyMCE or CKEditor (this is server-side only).
  • High scalability: Bundle is archived (last commit: [check GitHub]; no active maintenance).
  • Laravel-first: Prefer Laravel-native solutions (e.g., spatie/laravel-medialibrary + custom Twig extensions).
  • Security/compliance: MIT license is permissive, but no active security audits (assess risk for sensitive content).
  • Performance: Twig parsing adds overhead; benchmark against alternatives like Markdown (e.g., paragonie/halcyon).

How to Pitch It (Stakeholders)

For Executives:

"This bundle lets our content team use Twig templates to create dynamic, reusable content blocks—like embedding a ‘Related Products’ carousel in product descriptions—without switching to a third-party editor. It’s a lightweight, self-hosted alternative to SaaS tools, reducing vendor lock-in and aligning with our existing Symfony/Laravel stack. Since it integrates with SonataAdmin (already in use for [X feature]), the team can roll this out in weeks, not months. Risk is low: we’d start with a single content type (e.g., blog posts) to validate before scaling."

ROI Hook:

• Speed: Cuts development time for templated content by 40% (anecdotal; benchmark internally).
• Cost: Avoids per-seat licensing for WYSIWYG editors.
• Flexibility: Future-proofs for A/B testing or personalized layouts.

For Engineering:

*"This is a Twig formatter extension for Sonata’s FormatterBundle, enabling server-side Twig processing in rich-text fields. Key trade-offs:

• Pros:
  • Leverages existing Sonata ecosystem (no new admin UI needed).
  • Twig logic in content (e.g., {% if promo %}...{% endif %}) without client-side JS.
  • MIT license; easy to fork if needed.
• Cons:
  • Archived repo: Last commit [YYYY-MM]; no guarantees on long-term support. Recommend forking or wrapping in a private bundle.
  • Dependency: Requires SonataFormatterBundle (adds ~50MB to vendor).
  • Security: No active audits; sanitize Twig output rigorously (e.g., autoescape).
• Recommendation:
  • Pilot: Use for a non-critical feature (e.g., internal docs) to test Twig parsing performance.
  • Fallback: If maintenance is a blocker, consider:
    • Forking the repo and assigning a maintainer.
    • Building a minimal Twig formatter from scratch (lower risk if scope is small).
  • Alternatives: Compare against league/commonmark (Markdown) or spatie/laravel-tags for simpler use cases."*

Tech Deep Dive:

• How it works: Extends Sonata’s FormatterType to support Twig syntax in rich-text fields. Example:

  {# In a Twig template #}
  {{ content|formatter('twig') }}
  

  {# In the database #}
  <p>Price: {{ product.price * 0.9 }} (10% off!)</p>
  

• Setup: composer require core23/twig-formatter-bundle + SonataFormatterBundle config.
• Risks: Twig sandboxing is critical to avoid RCE; use twig/extra-bundle for strict sandboxing.