Rowcast Bundle Laravel Package

Product Decisions This Supports

• Database Abstraction & Modernization:

  • Replace Doctrine ORM with a lightweight, attribute-driven alternative for new projects or legacy systems, reducing complexity while maintaining type safety and performance.
  • Align with PHP 8.4+ and Symfony 7.x for long-term tech stack viability.

• Schema-as-Code & Migrations:

  • Adopt declarative schema definitions (via attributes or YAML) to eliminate manual SQL migrations, reducing human error and enabling CI/CD-friendly database changes.
  • Integrate schema diffing and migration tools (rowcast:diff, rowcast:make) into developer workflows, similar to tools like Flyway or Liquibase but with tighter PHP integration.

• Performance & Observability:

  • Leverage the optional profiler to identify slow queries in development, with configurable thresholds (e.g., slow_query_threshold_ms: 50) to proactively optimize database layers.
  • Decouple query profiling from production overhead by enabling it only in dev environments.

• Build vs. Buy:

  • Buy: For teams prioritizing rapid development with minimal boilerplate (e.g., startups, MVPs) or those migrating away from Doctrine’s complexity.
  • Build: For teams needing custom query builders, advanced caching, or multi-database support (e.g., PostgreSQL + MySQL), where Rowcast’s extensibility can be leveraged via its Connection and DataMapper interfaces.

• Use Cases:

  • Greenfield Projects: Symfony applications where Doctrine is overkill (e.g., high-read, low-write systems like dashboards or APIs).
  • Legacy Modernization: Replacing Doctrine in monoliths with tight coupling to Symfony’s DI container, while incrementally adopting Rowcast’s schema system.
  • Polyglot Persistence: Combining Rowcast for relational data with other stores (e.g., Redis, Elasticsearch) for a hybrid architecture.

When to Consider This Package

• Look Elsewhere If:

  • Doctrine is Sufficient: Your team is comfortable with Doctrine’s ecosystem (e.g., DQL, repositories, event listeners) and lacks pain points like complex inheritance or N+1 queries.
  • Multi-Vendor Lock-In Risk: You rely on Doctrine-specific tools (e.g., ORM extensions like Gedmo, Stof Doctrine Extensions) with no migration path.
  • Schema Complexity: Your database schema is highly dynamic (e.g., frequent ad-hoc table changes) and benefits from tools like Laravel Migrations or Flyway’s SQL-based approach.
  • PHP Version Constraints: You’re stuck on PHP <8.4 or Symfony <7.0, as RowcastBundle enforces these dependencies.
  • Team Familiarity: Your developers are deeply invested in Eloquent (Laravel) or other ORMs, and the learning curve for Rowcast’s attribute-based schema is prohibitive.
  • Advanced Features Needed: You require features like second-level caching, raw SQL batching, or complex event systems that Rowcast doesn’t yet support (as of v1.x).

• Consider RowcastBundle If:

  • You’re building a Symfony 7.x+ application and want to avoid Doctrine’s complexity.
  • Your schema is stable and declarative, fitting Rowcast’s attribute-driven or file-based definitions.
  • You prioritize performance and want to bypass Doctrine’s overhead for simple CRUD operations.
  • Your team prefers PHP-first database tools over SQL migration files.
  • You’re open to early-stage adoption (low stars, but active development as of 2026).

How to Pitch It (Stakeholders)

For Executives:

"RowcastBundle lets us replace Doctrine with a lighter, modern alternative—reducing technical debt while keeping our Symfony stack. Here’s why it’s worth exploring:

• Faster Development: Attribute-based schema definitions cut migration boilerplate by 40% (anecdotal, based on similar tools).
• Lower Cost: No need for Doctrine’s enterprise support or complex licensing.
• Future-Proof: Built for PHP 8.4+ and Symfony 7.x, aligning with our long-term roadmap.
• Observability: Built-in SQL profiling helps us catch performance issues early, reducing production incidents. We’d pilot it in [Project X], a new Symfony 7.x service, to validate the trade-offs against Doctrine. If successful, we could incrementally adopt it across legacy systems."

For Engineering:

"RowcastBundle gives us:

1. A Doctrine Alternative: Lightweight, attribute-driven data mapping (e.g., [Rowcast\Table(name: "users")]) instead of XML/YAML configs.
2. Schema-as-Code: Generate migrations from PHP classes (rowcast:make) or diff schemas (rowcast:diff --dry-run)—no more manual SQL.
3. Performance Insights: Optional profiler to track slow queries in dev (50ms threshold by default), with zero runtime cost in prod.
4. Symfony Native: Tight DI integration means we can swap EntityManager for DataMapper with minimal refactoring. Trade-offs: Less mature than Doctrine (e.g., no official Doctrine extensions), but the core team is actively developing it (last release: April 2026). We’d start with a spike to compare query performance and migration workflows against Doctrine."*

For Developers:

"If you’re tired of Doctrine’s complexity, RowcastBundle lets you:

• Define tables as PHP attributes:

  #[Rowcast\Table(name: "users")]
  class User { ... }
  

• Skip manual migrations: Use rowcast:make to auto-generate them from your schema.
• Profile queries in dev: Enable the profiler to see slow queries in the Symfony toolbar.
• Keep Symfony’s DI: Inject DataMapper like any other service. Downsides: Smaller community (0 stars, but active development), and some Doctrine features (like event listeners) aren’t ported yet. But if you’re on Symfony 7.x and PHP 8.4+, it’s worth trying for simpler CRUD."*