PHPackages tcds-io/php-jackson-symfony - PHPackages - PHPackages [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register) 1. [Directory](/) 2. / 3. [Parsing & Serialization](/categories/parsing) 4. / 5. tcds-io/php-jackson-symfony ActiveLibrary[Parsing & Serialization](/categories/parsing) tcds-io/php-jackson-symfony =========================== A Symfony bundle to inject and respond serializable objects in controllers 1.2.0(2mo ago)01MITPHPPHP >=8.4CI passing Since Jan 14Pushed 2mo agoCompare [ Source](https://github.com/tcds-io/php-jackson-symfony)[ Packagist](https://packagist.org/packages/tcds-io/php-jackson-symfony)[ RSS](/packages/tcds-io-php-jackson-symfony/feed)WikiDiscussions main Synced today READMEChangelog (2)Dependencies (12)Versions (4)Used By (0) PHP Jackson for Symfony ======================= [](#php-jackson-for-symfony) [![Integration Test](https://github.com/tcds-io/php-jackson-symfony/actions/workflows/integration.yml/badge.svg)](https://github.com/tcds-io/php-jackson-symfony/actions/workflows/integration.yml) Symfony integration for [tcds-io/php-jackson](https://github.com/tcds-io/php-jackson), a type-safe object mapper inspired by Jackson (Java). This package lets you: - Inject **typed objects** and collections directly into Symfony controllers - Deserialize from JSON body, query params, form data, and route params - Automatically serialize your return values back to JSON using PHP-Jackson - Opt into request and response mapping with PHP attributes --- Installation ------------ [](#installation) ``` composer require tcds-io/php-jackson-symfony ``` Enable the bundle if Symfony Flex did not add it automatically: ``` // config/bundles.php return [ // ... Tcds\Io\Jackson\Symfony\JacksonBundle::class => ['all' => true], ]; ``` No configuration file is needed for the attribute-based setup. Create one only when you need global mappers or custom params: ``` bin/console jackson:configure # creates config/jackson.php ``` --- How it works ------------ [](#how-it-works) 1. Mark request DTO parameters with `#[JacksonInject]`. 2. Mark return values that should be serialized with `#[JacksonResponse]`. 3. The bundle inspects your **method parameter types** and **PHPDoc generics**. 4. It builds those objects from: - Route params (`{id}`) - Query / form data - JSON body 5. Your return value is serialized using PHP-Jackson. --- Controller-based injection & response ----------------------------------------- [](#controller-based-injection--response) ``` use Symfony\Component\Routing\Attribute\Route; use Tcds\Io\Jackson\Symfony\Attributes\JacksonInject; use Tcds\Io\Jackson\Symfony\Attributes\JacksonResponse; class FooBarController { /** * @param list $items * @return list */ #[Route('/resource', methods: ['POST'])] #[JacksonResponse] public function list(#[JacksonInject] array $items): array { return $items; } #[Route('/resource/{id}', methods: ['POST'])] #[JacksonResponse] public function read(int $id, #[JacksonInject] Foo $foo): Foo { return new Foo( id: $id, a: $foo->a, b: $foo->b, type: $foo->type, ); } } ``` --- Invokable controllers --------------------- [](#invokable-controllers) Symfony routes usually point to controller services. For compact endpoints, use an invokable controller: ``` use Symfony\Component\Routing\Attribute\Route; use Tcds\Io\Jackson\Symfony\Attributes\JacksonInject; use Tcds\Io\Jackson\Symfony\Attributes\JacksonResponse; #[Route('/greet', methods: ['POST'])] final readonly class GreetController { #[JacksonResponse(status: 201, headers: ['X-Resource' => 'greeting'])] public function __invoke(#[JacksonInject] Greeting $greeting): Greeting { return $greeting; } } ``` --- Response status and headers --------------------------- [](#response-status-and-headers) ``` use Symfony\Component\Routing\Attribute\Route; use Tcds\Io\Jackson\Symfony\Attributes\JacksonInject; use Tcds\Io\Jackson\Symfony\Attributes\JacksonResponse; class GreetController { #[Route('/greet', methods: ['POST'])] #[JacksonResponse(status: 201, headers: ['X-Resource' => 'greeting'])] public function store(#[JacksonInject] Greeting $greeting): Greeting { return $greeting; } } ``` - **`#[JacksonInject]`** on a parameter forces php-jackson to deserialize the request payload into that type, even when the type is not registered in `mappers` or has been opted out via `reader: null`. - **`#[JacksonResponse(status: 201)]`** on a method serializes the return value via php-jackson and wraps it in a Symfony `Response` with the given status and headers. `status` defaults to `200`. --- Extending Jackson configuration ------------------------------- [](#extending-jackson-configuration) The attribute-based API is the default path for request and response mapping, but the bundle also has a central configuration file for application-wide behavior. Use it to add global serialization rules and inject custom params into mapped objects. ### Create config [](#create-config) Create the configuration file when you need global mappers or custom params: ``` bin/console jackson:configure # creates config/jackson.php ``` ### Add global mappers [](#add-global-mappers) Global mappers tell Jackson to always handle a type in requests and responses without adding attributes to every controller method. They are useful when a DTO is part of your app-wide API contract, or when you want to define custom read/write behavior once instead of repeating it at each endpoint. ``` use App\Services\AuthTokenService; use Psr\Container\ContainerInterface; use Tcds\Io\Jackson\ObjectMapper; return [ 'mappers' => [ // Simple automatic request and response mapping Address::class => [], // Custom readers and writers Foo::class => [ 'reader' => fn(array $data) => new Foo($data['a'], $data['b']), 'writer' => fn(Foo $foo) => ['a' => $foo->a, 'b' => $foo->b], ], // Control how sensitive objects are exposed in responses Account::class => [ 'writer' => fn(Account $account) => [ 'id' => $account->id, 'name' => $account->name, // 'apiKey' => $account->apiKey, // exclude sensitive fields ], ], ], 'params' => fn(ContainerInterface $container, ObjectMapper $mapper) => [ 'userId' => $container->get(AuthTokenService::class)->userId(), ], ]; ``` With a configured mapper, Jackson can read and write that type without `#[JacksonInject]` or `#[JacksonResponse]`: ``` use Symfony\Component\Routing\Attribute\Route; class FooBarController { #[Route('/resource/{id}', methods: ['POST'])] public function read(int $id, Foo $foo): Foo { return new Foo( id: $id, a: $foo->a, b: $foo->b, type: $foo->type, ); } } ``` Responses serialized this way use status `200` and do not support custom headers. Use `#[JacksonResponse]` when an endpoint needs a different status code or response headers. ### Inject custom params [](#inject-custom-params) Custom params let you add request-scoped values that do not come from the URL, query string, form data, or JSON body. This is useful for authenticated user IDs, tenant IDs, locale, feature flags, or any value you want available while Jackson builds a request object. ``` use App\Services\AuthTokenService; use Psr\Container\ContainerInterface; return [ 'params' => fn(ContainerInterface $container) => [ 'userId' => $container->get(AuthTokenService::class)->userId(), ], // ... ]; ``` Those values are merged into the data used to build Jackson objects, so a DTO can receive them like any other constructor field: ``` readonly class InvoiceQuery { public function __construct( public int $userId, public ?string $customer = null, ) {} } ``` --- Error handling -------------- [](#error-handling) If parsing fails, php-jackson-symfony converts a php-jackson `UnableToParseValue` exception into a `400 Bad Request` response by default: ``` { "message": "Unable to parse value at .type", "expected": ["AAA", "BBB"], "given": "string" } ``` Set `errors.request` when your API needs a different response shape or status code. The handler receives an `UnableToParseValue` exception and must return a Symfony `Response`. ``` use Symfony\Component\HttpFoundation\JsonResponse; use Symfony\Component\HttpFoundation\Response; use Tcds\Io\Jackson\Exception\UnableToParseValue; return [ 'errors' => [ 'request' => fn(UnableToParseValue $e) => new JsonResponse([ 'error' => $e->getMessage(), 'hint' => 'Check the request body format.', ], Response::HTTP_UNPROCESSABLE_ENTITY), ], // ... ]; ``` The `UnableToParseValue` exception exposes: - `$e->getMessage()` - human-readable description of the failure - `$e->expected` - list of accepted values or types - `$e->given` - the type or value that was received --- Development ----------- [](#development) ``` composer install composer tests # runs cs:check + phpstan composer cs:fix # auto-fix code style ``` End-to-end integration tests run a real Symfony app: ``` tests/install.sh cd tests/blog && vendor/bin/phpunit --testdox ``` --- Related packages ---------------- [](#related-packages) - Core mapper: - Laravel integration: - Guzzle integration: ### Health Score 39 — LowBetter than 84% of packages Maintenance88 Actively maintained with recent releases Popularity1 Limited adoption so far Community6 Small or concentrated contributor base Maturity54 Maturing project, gaining track record Bus Factor1 Top contributor holds 100% of commits — single point of failure How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window. **Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores. **Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement. **Maturity (30%)** — Project age, version count, PHP version support, and release stability. ### Release Activity Cadence Every ~111 days Total 2 Last Release 60d ago ### Community Maintainers ![](https://www.gravatar.com/avatar/c8ac1821d71c0ddddcc3494a165dc40cfa3e759a467d8a00956ceeae4b833bb3?d=identicon)[thiagocordeiro](/maintainers/thiagocordeiro) --- Top Contributors [![thiagocordeiro](https://avatars.githubusercontent.com/u/1073649?v=4)](https://github.com/thiagocordeiro "thiagocordeiro (6 commits)") ### Code Quality TestsPHPUnit Static AnalysisPHPStan Type Coverage Yes ### Embed Badge ![Health badge](/badges/tcds-io-php-jackson-symfony/health.svg) ``` [![Health](https://phpackages.com/badges/tcds-io-php-jackson-symfony/health.svg)](https://phpackages.com/packages/tcds-io-php-jackson-symfony) ``` ### Alternatives [easycorp/easyadmin-bundle Admin generator for Symfony applications 4.3k17.9M387](/packages/easycorp-easyadmin-bundle)[symfony/web-profiler-bundle Provides a development tool that gives detailed information about the execution of any request 2.3k160.5M1.2k](/packages/symfony-web-profiler-bundle)[rcsofttech/audit-trail-bundle Enterprise-grade, high-performance Symfony audit trail bundle. Automatically track Doctrine entity changes with split-phase architecture, multiple transports (HTTP, Queue, Doctrine), and sensitive data masking. 1189.8k](/packages/rcsofttech-audit-trail-bundle)[ahmed-bhs/doctrine-doctor Runtime analysis tool for Doctrine ORM integrated into Symfony Web Profiler. Unlike static linters, it analyzes actual query execution at runtime to detect performance bottlenecks, security vulnerabilities, and best practice violations during development with real execution context and data. 9410.8k](/packages/ahmed-bhs-doctrine-doctor)[ecotone/symfony-bundle Ecotone for Symfony — CQRS, Event Sourcing, Sagas, Durable Workflows, and Outbox on top of Symfony Messenger, via PHP attributes. 11249.0k1](/packages/ecotone-symfony-bundle)[2lenet/crudit-bundle The easy like Crud'it Bundle. 1616.4k14](/packages/2lenet-crudit-bundle) PHPackages © 2026 [Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)