Collection Field Bundle Laravel Package

Technical Evaluation

Architecture fit

• This is a Symfony bundle, not a Laravel package. It implements Unite CMS's field-type plugin contract (abstract field type, field-type registry, GraphQL schema extension, Doctrine-backed persistence). Laravel has no equivalent extension point — service providers and Eloquent do not map onto Symfony compiler passes and tagged services.
• Consequence: the code cannot be installed into a Laravel application. It can only run inside a Unite CMS installation, with the Laravel app as an API consumer of that CMS.
• The concept — an ordered, repeatable group of subfields — maps very cleanly to native Laravel primitives (a json column with a custom cast, nested-array validation rules, and a repeater UI component in Filament/Nova). The idea transfers; the implementation does not.

Integration feasibility

• Low as a library dependency. A working install requires: a compatible Unite CMS core major, a matching Symfony version, Doctrine, and the CMS's GraphQL layer all aligned.
• Zero stars and zero dependents means no reference implementations, no issue history to mine, and no community validation. The source is the documentation.
• Key questions to resolve before any spike:
  1. Which Unite CMS major/PHP/Symfony constraints does composer.json declare?
  2. Is Unite CMS itself actively maintained, or is this bundle sitting on a dormant platform?
  3. How is collection data persisted — JSON blob or child table? This determines indexing, filtering, and migration cost.
  4. Does it support nesting (collection inside collection), and what are the GraphQL depth/complexity limits?
  5. What is the license, and is there any upgrade or deprecation guidance?
  6. Who is the maintainer, and what is the bus factor?

Technical risk

High. The risk is concentrated in the schema/persistence layer, where breakage is most expensive. An unmaintained dependency that defines stored content shape creates a long-tailed migration liability, and nested/repeatable fields amplify both payload size and migration complexity.

Integration Approach

Stack fit

Poor to nil for a Laravel monolith. The only coherent topology is:

Laravel app ◄── GraphQL/HTTP ──► Unite CMS (with this bundle)

i.e. the CMS becomes a headless content service and Laravel owns everything else.

Migration path

• Already running Unite CMS: pin the bundle, commit composer.lock, and add contract tests around the GraphQL queries the Laravel app issues. Wrap CMS access in a thin content-client interface so the backend is swappable.
• Not running Unite CMS: do not adopt this package. Reimplement the feature natively in Laravel — a json column, an AsCollection/custom cast, FormRequest rules for nested arrays, and a repeatable form component. Days of work, no new runtime, no new vendor.
• If a repeatable-field CMS is the actual requirement: evaluate maintained options (Statamic, Filament repeaters, a hosted CMS) before Unite.

Compatibility

Gate everything on PHP version, Symfony LTS, and Unite CMS major. Verify composer.json constraints before committing to a spike. Treat the CMS as a black box behind an interface to contain version drift.

Sequencing

1. Confirm Unite CMS is already in the estate (if not, stop here).
2. Timeboxed spike, 3–5 days: install, define a collection field, push nested data through GraphQL, measure payload size and query cost.
3. Vendor-risk review against the key questions above.
4. Explicit build-vs-buy decision with the native-Laravel estimate on the table.
5. If adopted: pinned versions, contract tests, documented exit plan.

Operational Impact

Maintenance

You inherit the code. Zero stars, zero dependents, and no visible release cadence mean you are the de facto maintainer for any PHP upgrade or security issue. Budget recurring fork-maintenance time, not a one-off integration cost.

Support

No vendor, no community, no SLA. Knowledge must be written down; a single engineer holding the CMS internals is a real operational hazard.

Scaling

Repeatable fields inflate row size and GraphQL response size. Watch payload growth, query depth/complexity limits, and N+1 behaviour on nested resolution. A JSON-blob storage model keeps writes simple but blocks indexing and filtering on nested values — a problem the moment anyone wants to query inside a collection.

Failure modes

• Silent schema drift on CMS upgrade corrupting or orphaning stored collections.
• Partial/malformed nested writes with no transactional guarantee across siblings.
• Orphaned field data when a field type is removed from a content type.
• Availability coupling: the Laravel app now depends on a third-party service's uptime and latency.
• Bus factor of one on an unmaintained bundle.

Ramp-up

A Laravel team needs Symfony bundle conventions (DI compiler passes, tagged services, configuration trees) plus Unite CMS's field-type and GraphQL extension model. Realistically 1–2 weeks before productive work, more for the CMS core. That is a significant multiple of the few days required to build the equivalent natively.

Recommendation: do not adopt. A score of 0 with 0 dependents is the signal, and the Symfony/Laravel mismatch makes the cost asymmetric — you pay integration and ownership costs for a feature Laravel can express in an afternoon.