Liform Bundle Laravel Package

Product Decisions This Supports

• Unified Form Management: Eliminates duplication between Symfony forms (backend) and frontend form libraries (e.g., React, Vue, or JSON-based editors) by auto-generating JSON Schema from Symfony forms. Reduces manual sync efforts and errors.
• Self-Documenting APIs: Generates machine-readable schemas that serve as API documentation for frontend teams, reducing ambiguity in form validation rules, UI hints (e.g., placeholders, defaults), and required fields.
• Frontend Agnosticism: Enables decoupled frontend development by providing a single source of truth for form definitions. Works seamlessly with:
  • React/Vue: Via liform-react or similar libraries.
  • Low-Code Tools: Integrates with JSON Schema-based editors (e.g., JSON Editor) for dynamic form generation.
• Validation & Error Handling: Serializes form errors into a standardized format compatible with frontend libraries, improving UX consistency.
• Customization & Extensibility:
  • Domain-Specific Transformers: Override default behavior for custom form types (e.g., file uploads, nested objects) via liform.transformer tags.
  • Schema Extensions: Add metadata (e.g., submit_url, API endpoints) to schemas via liform.extension tags, bridging backend and frontend concerns.
• Roadmap Priorities:
  • API-First Development: Accelerate adoption of GraphQL/Symfony UX by aligning form definitions with API contracts.
  • Low-Code Platforms: Enable non-developers to configure forms via JSON Schema editors, reducing backend dependency.
  • Multi-Tenant Apps: Dynamically generate tenant-specific schemas (e.g., conditional fields based on user roles).

When to Consider This Package

• Avoid If:
  • Your frontend doesn’t use JSON Schema (e.g., relies on hardcoded HTML forms or proprietary libraries).
  • You need real-time form validation without a frontend framework (Liform focuses on schema generation, not client-side validation).
  • Your team lacks Symfony expertise—this package requires familiarity with Symfony forms and dependency injection.
  • You’re using Symfony < 5.4 or PHP < 7.4 (see BC breaks).
  • You prioritize minimal dependencies—this adds liform + Symfony bundles to your stack.
• Consider If:
  • You maintain complex, cross-team forms (e.g., admin panels, multi-step workflows) where backend/frontend sync is error-prone.
  • Your frontend uses React/Vue + JSON Schema (e.g., for dynamic forms or form builders).
  • You need self-documenting APIs for forms, reducing onboarding time for frontend teams.
  • You’re building a low-code platform where forms are configured via UI (schema-driven).
  • You want to reduce boilerplate for form validation/error handling on both ends.

How to Pitch It (Stakeholders)

For Executives:

*"This package solves a critical pain point in our stack: form definitions exist in two places—Symfony backend and frontend code—leading to sync errors, technical debt, and slower iterations. By auto-generating JSON Schema from Symfony forms, we can:

• Cut frontend/backend sync time by 50% (no more manual updates to React/Vue forms).
• Enable non-developers to configure forms via JSON editors (e.g., for marketing teams).
• Future-proof our APIs by aligning form contracts with our frontend tools. Example: Our user onboarding flow could be managed entirely via JSON Schema, reducing backend tickets by 30%."*

For Engineering:

*"LiformBundle lets us treat Symfony forms as the single source of truth for frontend form generation. Key wins:

• Zero Duplication: Frontend forms auto-generated from Symfony FormType classes (e.g., CarType → JSON Schema).
• Extensible: Customize schema output for edge cases (e.g., file uploads, nested objects) via transformers/extensions.
• Error Handling: Standardized form error serialization for consistent UX across React/Vue.
• Low Risk: MIT-licensed, actively maintained (Symfony 7 support), and backed by a sandbox project for quick prototyping. Tradeoff: Adds a dependency, but saves hundreds of hours/year in form maintenance. Start with the React sandbox to validate fit."*

For Frontend Teams:

*"Say goodbye to out-of-sync forms. This package lets backend define forms once, and we get:

• Auto-generated JSON Schema for our React/Vue forms (no manual title, type, required fields).
• Live validation rules (e.g., regex patterns, min/max lengths) from Symfony constraints.
• Dynamic forms: Use tools like JSON Editor to tweak forms without backend tickets. Example: The ‘Create Order’ form will now auto-update if the backend adds a new field—no more ‘works on my machine’ bugs."*