Symfony Config Schema Gen Laravel Package

Technical Evaluation

Architecture Fit

• Symfony-Centric: The package is tightly coupled with Symfony’s configuration system, making it ideal for Symfony-based applications (e.g., Symfony Flex projects, legacy Symfony 4/5/6/7). For Laravel or non-Symfony PHP projects, the fit is low unless abstracted via a middleware layer (e.g., a Symfony microkernel or API platform).
• Schema Generation Use Case: Excels at runtime schema validation and documentation generation for Symfony configurations (e.g., config/packages/*.yaml). Useful for:
  • IDE autocompletion (e.g., PHPStorm, VSCode with Symfony plugins).
  • API-driven config validation (e.g., validating user-uploaded config files).
  • CI/CD pipelines (e.g., enforcing schema compliance in PR checks).
• Laravel Workaround: Laravel’s config system (.env + config/*.php) is fundamentally different. Integration would require:
  • Reverse-engineering Laravel’s config structure into Symfony-compatible YAML/XML.
  • Custom adapters to bridge Symfony’s ConfigurationNode system with Laravel’s ConfigRepository.

Integration Feasibility

• Symfony Projects: High feasibility—drop-in via Composer, minimal config changes. Works seamlessly with Symfony’s dependency injection and configuration components.
• Laravel Projects: Medium feasibility—requires significant abstraction:
  • Option 1: Use Symfony’s Config component standalone (without the full framework) to parse Laravel configs.
  • Option 2: Build a proxy layer to translate Laravel’s config() calls into Symfony’s ConfigurationNode format.
  • Option 3: Generate schemas post-hoc by analyzing Laravel’s config files (e.g., using reflection or static analysis tools like PHPStan).
• Hybrid Stacks: For projects using Symfony components in Laravel (e.g., API Platform, Mercure), feasibility improves but still requires custom glue code.

Technical Risk

Key Questions

1. Symfony Projects:

   • Does the project use Symfony’s configuration system (e.g., config/packages/)? If not, is the value proposition (schema generation) worth the effort?
   • Will schemas be used for runtime validation (e.g., Symfony\Component\Config\Loader\LoaderInterface) or just documentation?
   • Are there existing tools (e.g., Symfony’s built-in config:dump-reference) that overlap with this package’s functionality?

2. Laravel Projects:

   • What is the primary use case? (e.g., validating .env files, generating OpenAPI specs from config, or IDE support?)
   • Is there a subset of Laravel configs that could be converted to Symfony-compatible format (e.g., YAML-based configs)?
   • Would a custom schema generator (e.g., using JsonSchema PHP library) be simpler than integrating this package?
   • Are there Symfony components already in use (e.g., API Platform, Mercure) that could leverage this package natively?

3. Cross-Stack:

   • Could this package be wrapped in a Laravel service provider to abstract Symfony dependencies?
   • Is there a long-term roadmap for Laravel/Symfony interop (e.g., Symfony UX, Laravel Symfony Bridge)?

Integration Approach

Stack Fit

Migration Path

Symfony Projects

1. Installation:

   composer require adamwojs/symfony-config-schema-gen --dev
   

2. Enable Bundle:

   // config/bundles.php
   AdamWojs\SymfonyConfigGenBundle\SymfonyConfigSchemaGenBundle::class => ['dev' => true],
   

3. Generate Schema:

   php bin/console config:dump-schema > schema.json
   

4. Integrate:
   • Use schema in Symfony’s Configuration component for validation.
   • Feed into IDE plugins or API documentation tools.

Laravel Projects

1. Option A: Symfony Component Standalone (High Risk)

   • Install Symfony’s Config component:

     composer require symfony/config --dev
     

   • Create a custom loader to parse Laravel configs into ConfigurationNode.
   • Use SymfonyConfigSchemaGenBundle in a dev-only command.

2. Option B: Custom Schema Generator (Recommended for Laravel)

   • Use justinrainbow/json-schema to generate schemas from Laravel’s config() structure.
   • Example workflow:

     // app/Console/Commands/GenerateConfigSchema.php
     use JustinRainbowJsonSchema\Validator;
     use Symfony\Component\Console\Command\Command;
     
     class GenerateConfigSchema extends Command {
         protected function execute(InputInterface $input, OutputInterface $output) {
             $config = config()->all();
             $schema = $this->generateSchemaFromArray($config);
             file_put_contents(base_path('schema.json'), json_encode($schema, JSON_PRETTY_PRINT));
         }
     
         private function generateSchemaFromArray(array $data): array {
             // Implement logic to infer schema from $data
             return [
                 'type' => 'object',
                 'properties' => $this->mapConfigToSchema($data),
             ];
         }
     }
     

3. Option C: Hybrid Approach (For Laravel + Symfony)

   • Isolate Symfony-dependent configs (e.g., API Platform routes) in YAML files.
   • Use symfony-config-schema-gen for those files only.
   • Generate separate schemas for Laravel-native configs.

Compatibility

• Symfony: Compatible with Symfony 4.4+ (tested up to 7.x). May require adjustments for older versions.
• PHP: Requires PHP 8.0+ (due to Symfony 6/7 dependencies). Laravel projects must align PHP versions.
• Output Formats: Supports JSON (default) and YAML. Extensible to other formats via custom commands.
• Extensions: Whitelist/blacklist Symfony bundles to control schema scope.

Sequencing

1. Assess Value: Confirm schema generation solves a specific pain point (e.g., config validation, IDE support).
2. Symfony Projects:
   • Install → Enable → Generate → Integrate.
3. Laravel Projects:
   • Option A: Prototype Symfony component integration.
   • Option B: Build custom schema generator (lower risk).
   • Option C: Segment configs and apply hybrid approach.
4. CI/CD Integration:
   • Add schema generation to build pipelines (e.g., validate PRs against schema).
5. Tooling Integration:
   • Configure PHPStorm/VSCode to use generated schemas.
   • Integrate with OpenAPI/Swagger tools if schemas describe API configs.

Operational Impact

Maintenance

Support