Liform Bundle Laravel Package

Technical Evaluation

Architecture Fit

• Symfony Alignment: The package is a Symfony bundle, leveraging Symfony Forms and Dependency Injection (DI), making it a natural fit for Symfony-based applications. It aligns with Symfony’s ecosystem (e.g., FormType, Serializer, HttpKernel).
• JSON Schema as a Bridge: The core value proposition—automating JSON Schema generation from Symfony Forms—addresses a critical pain point in decoupling backend forms from frontend frameworks (React, Vue, etc.). This reduces manual synchronization efforts and improves maintainability.
• Extensibility: The package supports custom transformers and extensions, allowing TPMs to tailor JSON Schema output for specific use cases (e.g., adding submit_url, custom validation rules, or UI hints).
• Frontend Agnostic: While designed for liform-react, the output is JSON Schema, which is framework-agnostic, enabling reuse with tools like json-editor, Formik, or custom solutions.

Integration Feasibility

• Low Friction for Symfony Apps: Requires minimal setup (Composer install + bundle enablement). The example sandbox (symfony-react-sandbox) provides a reference implementation, reducing integration risk.
• Frontend Dependency: Assumes a compatible frontend stack (e.g., React with liform-react). If the frontend is non-JS or uses a different form library (e.g., Angular, Alpine.js), additional adapters may be needed.
• Symfony Version Constraints:
  • Drops support for Symfony <5.4 (BC break in v0.18.0).
  • Supports Symfony 7 (as of v0.20.0), but no explicit Symfony 8 support (check compatibility if targeting newer versions).
  • PHP 7.4+ required (aligns with modern Symfony stacks).

Technical Risk

Key Questions for TPM

1. Frontend Strategy:
   • Is the frontend JS-based (React/Vue) or another framework? If not, how will JSON Schema be consumed?
   • Are we using liform-react or a different JSON Schema tool (e.g., json-editor)?
2. Form Complexity:
   • Do forms include dynamic fields, custom widgets, or Symfony UX components? If yes, will Liform cover them, or will extensions be needed?
3. Performance:
   • Will JSON Schema generation be called on every request (e.g., for API docs) or pre-generated (e.g., at build time)?
   • What’s the expected form size? Large forms may need optimization (e.g., caching schemas).
4. Maintenance:
   • Who will own extensions/transformers? Will they be version-locked or updated with Liform?
   • How will breaking changes (e.g., Symfony 8 support) be managed?
5. Alternatives:
   • Have we evaluated manual JSON Schema or other tools (e.g., Symfony Serializer + custom mapping)?
   • Is API Platform or Mercure an alternative for form-driven APIs?
6. Testing:
   • How will we validate schema accuracy against frontend rendering?
   • Are there automated tests for schema generation in CI?

Integration Approach

Stack Fit

• Backend: Symfony 5.4+ (core requirement). Works with Symfony 7/8 (tested) but may need updates for newer versions.
• Frontend:
  • Primary: React with liform-react (official integration).
  • Secondary: Any JSON Schema-compatible frontend (e.g., json-editor, Vue, Angular).
  • Non-JS: Possible but requires custom adapters (e.g., GraphQL schemas, mobile apps).
• Infrastructure:
  • Composer-based: No additional runtime dependencies beyond Symfony.
  • Build Tools: If using liform-react, ensure Webpack/Vite is configured for JS interop.

Migration Path

Compatibility

• Symfony:
  • Supported: 5.4–8.0 (as of v0.20.0). Symfony 4.x unsupported (BC break).
  • Components: Uses Form, Serializer, DependencyInjection—standard Symfony features.
• PHP:
  • Minimum: PHP 7.4 (due to Liform dependency).
  • Recommended: PHP 8.1+ for performance and type safety.
• Frontend:
  • React: liform-react (official).
  • Other JS Frameworks: Requires JSON Schema parser (e.g., @json-schema).
  • Non-JS: Possible but not natively supported (e.g., mobile apps may need REST/GraphQL wrappers).

Sequencing

1. Phase 1: Proof of Concept

   • Integrate bundle into a non-critical form (e.g., admin panel).
   • Verify schema generation and frontend rendering.
   • Test edge cases (nested forms, validation errors).

2. Phase 2: Core Forms Migration

   • Prioritize high-maintenance forms (e.g., complex CRUD interfaces).
   • Replace manual frontend forms with schema-driven ones.
   • Implement custom transformers for unsupported form types.

3. Phase 3: Frontend Rollout

   • Gradually replace frontend form logic with JSON Schema-based validation.
   • Use liform-react for React apps; adapt for other frameworks.
   • Add real-time error feedback (using serialized errors).

4. Phase 4: Optimization

   • Cache JSON schemas for static forms (e.g., settings pages).
   • Monitor performance impact on large forms (e.g., >100 fields).
   • Document extension points for future teams.

5. Phase 5: Deprecation

   • Phase out legacy form templates (HTML/JS) in favor of schema-driven approaches.
   • Update CI/CD to test schema changes against frontend.

Operational Impact

Maintenance

• Pros:
  • Reduced Duplication: Single source of truth for forms (Symfony → JSON Schema).
  • Easier Documentation: JSON Schema serves as self-documenting API.
  • Lower Frontend Bug Risk: Validation rules and UI hints are auto-sync’d from backend.
• Cons:
  • Dependency on Liform: Future changes to Liform may require bundle updates.
  • Custom Extensions: Overriding transformers/extensions adds