opportus/object-mapper-bundle
Symfony bundle that integrates the opportus/object-mapper library, registering mapper services and configuration in the dependency injection container to simplify object-to-object mapping. Helps reduce boilerplate when converting DTOs, entities, and domain objects in PHP applications.
Architecture fit. The bundle is a thin Symfony integration around an object-to-object mapper, wired through the DI container and configured per mapping pair. Architecturally it targets a narrow but common need: copying state between differently typed objects (entity → DTO, domain → read model, request payload → command). It fits Symfony applications that want declarative mapping without hand-written assemblers, and it keeps mapping logic out of domain code if configured as a service. It is not a serializer, an ORM, or a validation layer; treat it as a narrow utility with a small blast radius.
Integration feasibility. Installation is standard Composer plus bundle registration. The hard part is not wiring but confirming the package still composes with the target stack. Signals are weak: 2 stars, 0 dependents, last release 2022-05-25, and a composite score of 0.07. There is no evidence of production usage to borrow confidence from, so feasibility must be established by direct source review and a time-boxed spike, not by reputation.
Technical risk. Dominant risk is staleness and abandonment, not code complexity. A 2022 release likely targets Symfony 5.4/6.0 and PHP 8.0/8.1; Symfony 6.4/7.x and PHP 8.2/8.3 compatibility is unproven and may fail on deprecations, container compilation, or attribute/annotation handling. Reflection-based mapping also carries edge-case risk: uninitialized typed properties, constructor promotion, readonly classes, circular references, null semantics, and silent partial mappings. MIT license and a small dependency surface limit legal and supply-chain exposure, but "small and stable" is only an asset if the code is actually tested — verify coverage before assuming so.
Key questions. Who maintains it and will they respond to issues/PRs? What is the declared Symfony/PHP support matrix, and does composer why-not pass against our pinned versions? Is the mapping core a separate library we could use without the bundle? What are the semantics on missing source fields, type mismatches, and nested/collection mapping — throw, skip, or coerce? Is there a test suite, static analysis, and CI we can inspect? Are there known CVEs or abandoned transitive dependencies? What is the migration cost to a maintained alternative (JoliCode AutoMapper, Symfony Serializer, hand-written mappers)?
Stack fit. Adopt only if the service is Symfony and the use case is bounded (DTO assembly at API/application boundaries). If the codebase is framework-agnostic, Laravel, or mixed, this bundle is the wrong shape — either use the underlying mapper library directly or skip it. Confirm composer constraints against the actual symfony/* and php versions before any design work.
Migration path. Treat the mapper as an implementation detail behind an internal ObjectMapperInterface owned by our codebase. Consumers depend on our interface, not the bundle's API. This makes a later swap to JoliCode AutoMapper or Symfony Serializer a one-adapter change rather than a cross-cutting refactor, and it gives us a fork point if upstream goes quiet.
Compatibility. Run a spike in a branch: install with --prefer-lowest and --prefer-stable, boot the kernel, compile the container, exercise mappings for nested objects, collections, nulls, and readonly/promoted properties. Add static analysis (PHPStan/Psalm at the project's level) and a deprecation gate. If it fails on the current Symfony LTS, stop and evaluate alternatives rather than patching speculatively.
Sequencing.
Maintenance. Plan to own it. With 2 stars and no recent release, upstream maintenance is effectively zero; budget for periodic compatibility patches (Symfony majors, PHP minors) and dependency bumps. A fork with CI and a smoke test suite is the realistic steady state — cheap because the surface is small, but non-zero and permanent.
Support. No vendor, no community depth, no dependents to consult. Incident resolution depends entirely on internal engineers reading the source. Document the mapping semantics we rely on and keep the adapter contract tested so behavior is pinned regardless of upstream.
Scaling. Reflection and per-call mapping have CPU cost; for high-throughput paths, cache mapping metadata and benchmark against hand-written assemblers. Large object graphs, deep nesting, and collections need explicit recursion/depth handling. Memory is usually fine, but mapping inside hot loops or per-row in batch jobs should be measured before adoption.
Failure modes. Expect silent or partial mappings (missing source fields mapping to defaults), type-coercion surprises, null-handling gaps, uninitialized-property errors on typed DTOs, and circular-reference blowups. Mitigate with strict/validated mapping modes where available, contract tests per mapping pair, and fail-fast assertions in non-production environments.
Ramp-up. The API is small, so onboarding is days, not weeks. The real cost is institutional knowledge about edge cases, which lives only with the engineers who wrote the mappings. Keep mapping definitions centralized and reviewed, and pair the adapter interface with a short internal guide covering conventions, error behavior, and the fork/upgrade process.
How can I help you explore Laravel packages today?