Rowcast Bundle Laravel Package

Product Decisions This Supports

• Architectural Shift to Lightweight ORM:

  • Replace Doctrine ORM with a minimalist, attribute-based solution to reduce complexity in CRUD-heavy applications (e.g., APIs, admin panels, or internal tools).
  • Align with Symfony 7.x and PHP 8.4+ to eliminate legacy dependencies while maintaining compatibility with modern Symfony features.

• Developer Productivity:

  • Schema-as-Code: Use PHP attributes (e.g., #[Rowcast\Table]) or YAML files to define schemas, enabling Git-friendly database changes and reducing manual SQL migration errors.
  • CLI-First Workflow: Integrate rowcast:diff, rowcast:make, and rowcast:migrate into CI/CD pipelines for automated, auditable database migrations.
  • Reduced Boilerplate: Eliminate Doctrine’s repository classes, DQL queries, and entity listeners in favor of type-safe DataMapper for simpler, more maintainable code.

• Performance Optimization:

  • Target high-read, low-write systems (e.g., analytics dashboards, reporting tools) where Doctrine’s overhead is unnecessary.
  • Leverage Rowcast’s Connection and DataMapper for direct PDO interactions with minimal abstraction, improving query performance.

• Build vs. Buy Decision:

  • Buy: Ideal for teams prioritizing rapid development over customization (e.g., startups, MVPs) or those migrating from Doctrine-heavy monoliths.
  • Build: Justify for teams needing custom query builders, multi-database support, or advanced caching—Rowcast’s interfaces are extensible but require upfront investment.
  • Hybrid Approach: Use Rowcast for new microservices while gradually replacing Doctrine in legacy systems via strangler pattern.

• Use Cases:

  • Greenfield Symfony Projects: Avoid Doctrine entirely for new applications with simple data models.
  • Legacy Modernization: Replace Doctrine in monolithic apps by incrementally adopting Rowcast’s schema system (e.g., start with DataMapper, then migrate to attributes).
  • Polyglot Persistence: Combine Rowcast for relational data with Redis/Elasticsearch for a hybrid architecture (e.g., caching layers, search).

When to Consider This Package

• Adopt RowcastBundle If:

  • You’re building a Symfony 7.x+ application and want to eliminate Doctrine’s complexity (e.g., DQL, repositories, event listeners).
  • Your schema is stable and declarative, fitting Rowcast’s attribute-driven or file-based definitions (e.g., no dynamic table changes).
  • You prioritize performance and want to bypass Doctrine’s overhead for CRUD operations (e.g., APIs, dashboards).
  • Your team prefers PHP-first database tools over SQL migration files (e.g., Flyway, Liquibase).
  • You’re open to early-stage adoption (active development as of 2026, but low community stars).

• Look Elsewhere If:

  • Doctrine is Sufficient: Your team is comfortable with Doctrine’s ecosystem (e.g., Gedmo extensions, Stof Doctrine) and lacks pain points like N+1 queries or complex inheritance.
  • Multi-Vendor Lock-In Risk: You rely on Doctrine-specific tools (e.g., Behat extensions, legacy integrations) with no migration path.
  • Schema Complexity: Your database is highly dynamic (e.g., frequent ad-hoc changes) and benefits from SQL-based migration tools (e.g., Laravel Migrations, Flyway).
  • PHP/Symfony 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 system is prohibitive.
  • Advanced Features Needed: You require second-level caching, raw SQL batching, or complex event systems not yet supported in Rowcast (as of v1.x).

How to Pitch It (Stakeholders)

For Executives:

"RowcastBundle lets us replace Doctrine with a modern, lightweight alternative—reducing technical debt while keeping our Symfony stack. Here’s the business case:

• Faster Development: Attribute-based schema definitions cut migration boilerplate by ~40%, accelerating feature delivery.
• Lower Costs: Open-source with no licensing fees, and no need for Doctrine’s enterprise support.
• Future-Proof: Built for PHP 8.4+ and Symfony 7.x, aligning with our long-term roadmap.
• Proactive Performance: Built-in SQL profiling helps us catch and fix slow queries early, reducing production incidents. Proposal: Pilot in [Project X], a new Symfony 7.x service, to validate trade-offs vs. Doctrine. If successful, we could incrementally adopt it across legacy systems, starting with high-read services (e.g., APIs, dashboards)."

For Engineering Leaders:

"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 (configurable 50ms threshold), with zero runtime cost in prod.
4. Symfony Native: Tight DI integration means we can swap EntityManager for DataMapper with minimal refactoring.
5. CLI-Driven Workflows: rowcast:query for ad-hoc SQL, rowcast:migrate for automated deployments—all in one bundle. Trade-offs: Early-stage adoption (low stars, but active development). Recommend starting with a proof-of-concept in a non-critical service."

For Developers:

"RowcastBundle simplifies database interactions in Symfony:

• No More DQL: Write raw SQL or use DataMapper for type-safe entity hydration.
• Attributes Over XML: Define tables/columns with PHP attributes (e.g., #[Rowcast\Column(type: "string")]).
• Built-in Profiler: Debug slow queries in dev without touching production.
• Migration Automation: rowcast:make generates migrations from your schema—no manual SQL. Example:

#[Rowcast\Table(name: "users")]
class User {
    #[Rowcast\Column(type: "string")]
    public string $name;
}

Perfect for: New projects, legacy Doctrine cleanup, or performance-critical APIs."