Symfony Jsonapi Bundle Laravel Package

Product Decisions This Supports

• Adoption of JSON:API Standard: Enables consistent API design across microservices, reducing client-side complexity and improving developer experience.
• Roadmap for API Modernization: Accelerates migration from REST to JSON:API for new or legacy Symfony 7 projects, with minimal refactoring overhead.
• Build vs. Buy Decision: Avoids reinventing JSON:API compliance (98.5% spec coverage) while leveraging Symfony’s ecosystem (Doctrine, Twig, etc.).
• Use Cases:
  • Headless CMS/APIs: Structured content delivery with sparse fieldsets and efficient pagination.
  • Multi-Tenant SaaS: Role-based field filtering and relationship inclusion for granular data access.
  • Mobile/Web Apps: Optimized payloads via fields and include parameters to reduce bandwidth.
  • GraphQL Migration Path: JSON:API’s declarative nature simplifies future GraphQL adoption (shared resolvers, types).

When to Consider This Package

Adopt if:

• Your Symfony 7 project requires JSON:API 1.1 compliance (e.g., replacing REST or GraphQL).
• You need production-ready validation (100% MUST, 95% SHOULD spec coverage) with minimal custom code.
• Your team prioritizes developer experience (DX-first design, comprehensive docs, and 98.5% test coverage).
• You’re building scalable APIs with sparse fieldsets, pagination, or complex relationships (e.g., nested include).
• You want to avoid reinventing JSON:API while keeping Symfony’s flexibility (Doctrine, events, hooks).

Look elsewhere if:

• You’re not using Symfony 7 (compatibility limited to Symfony 7.1+).
• Your API requires cursor-based pagination (deferred as optional; use knp/paginator or api-platform instead).
• You need real-time updates (WebSockets/subscriptions; consider mercure or api-platform).
• Your use case demands GraphQL (use api-platform or graphql-php).
• You require highly custom error formats (JSON:API errors are standardized; extend via hooks if needed).

How to Pitch It (Stakeholders)

For Executives: *"This package lets us launch a JSON:API-compliant backend in weeks, not months. It’s like using Symfony’s built-in security or validation—98.5% of the JSON:API spec is handled out of the box, so our team can focus on business logic. For example:

• Reduce mobile app payloads by 30% with sparse fieldsets (fields[articles]=title,createdAt).
• Unify APIs across teams with a standardized format (no more REST vs. GraphQL debates).
• Cut API development time by 50% compared to building from scratch. It’s MIT-licensed, battle-tested (100% MUST compliance), and integrates seamlessly with Symfony’s ecosystem—just like how we’d use Doctrine or Twig."*

For Engineers: *"This is the Swiss Army knife for JSON:API in Symfony 7. Key perks:

• Zero reinvention: 133/135 spec requirements covered (only 2 gaps, both optional).
• DX-first: Clean API, great docs, and a test suite that proves it works (mutation testing, property-based tests).
• Symfony-native: Works with Doctrine, Twig, events, and hooks—no framework lock-in.
• Performance: Optimized for sparse fieldsets, pagination, and relationship inclusion.
• Future-proof: Deferred features (cursor pagination) are on the roadmap.

Example: To expose a Post resource with relationships:

// src/Controller/PostController.php
use AlexFigures\Symfony\JsonApi\Action\CollectionAction;
use AlexFigures\Symfony\JsonApi\Action\ResourceAction;

class PostController extends AbstractJsonApiController
{
    #[CollectionAction] public function collection(): JsonApiCollection { ... }
    #[ResourceAction]    public function resource(Post $post): JsonApiResource { ... }
}

No annotations, no boilerplate—just JSON:API. Start with make install and make test to verify compliance."*