vendor/symfony/maker-bundle/src/Maker/MakeEntity.php line 318

  1. <?php
  3. /*
  4.  * This file is part of the Symfony MakerBundle package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Bundle\MakerBundle\Maker;
  14. use ApiPlatform\Core\Annotation\ApiResource as LegacyApiResource;
  15. use ApiPlatform\Metadata\ApiResource;
  16. use Doctrine\DBAL\Types\Type;
  17. use Symfony\Bundle\MakerBundle\ConsoleStyle;
  18. use Symfony\Bundle\MakerBundle\DependencyBuilder;
  19. use Symfony\Bundle\MakerBundle\Doctrine\DoctrineHelper;
  20. use Symfony\Bundle\MakerBundle\Doctrine\EntityClassGenerator;
  21. use Symfony\Bundle\MakerBundle\Doctrine\EntityRegenerator;
  22. use Symfony\Bundle\MakerBundle\Doctrine\EntityRelation;
  23. use Symfony\Bundle\MakerBundle\Doctrine\ORMDependencyBuilder;
  24. use Symfony\Bundle\MakerBundle\Exception\RuntimeCommandException;
  25. use Symfony\Bundle\MakerBundle\FileManager;
  26. use Symfony\Bundle\MakerBundle\Generator;
  27. use Symfony\Bundle\MakerBundle\InputAwareMakerInterface;
  28. use Symfony\Bundle\MakerBundle\InputConfiguration;
  29. use Symfony\Bundle\MakerBundle\Str;
  30. use Symfony\Bundle\MakerBundle\Util\ClassDetails;
  31. use Symfony\Bundle\MakerBundle\Util\ClassSourceManipulator;
  32. use Symfony\Bundle\MakerBundle\Util\PhpCompatUtil;
  33. use Symfony\Bundle\MakerBundle\Validator;
  34. use Symfony\Component\Console\Command\Command;
  35. use Symfony\Component\Console\Input\InputArgument;
  36. use Symfony\Component\Console\Input\InputInterface;
  37. use Symfony\Component\Console\Input\InputOption;
  38. use Symfony\Component\Console\Question\ConfirmationQuestion;
  39. use Symfony\Component\Console\Question\Question;
  40. use Symfony\UX\Turbo\Attribute\Broadcast;
  42. /**
  43.  * @author Javier Eguiluz <javier.eguiluz@gmail.com>
  44.  * @author Ryan Weaver <weaverryan@gmail.com>
  45.  * @author Kévin Dunglas <dunglas@gmail.com>
  46.  */
  47. final class MakeEntity extends AbstractMaker implements InputAwareMakerInterface
  48. {
  49.     private Generator $generator;
  50.     private EntityClassGenerator $entityClassGenerator;
  51.     private PhpCompatUtil $phpCompatUtil;
  53.     public function __construct(
  54.         private FileManager $fileManager,
  55.         private DoctrineHelper $doctrineHelper,
  56.         string $projectDirectory = null,
  57.         Generator $generator = null,
  58.         EntityClassGenerator $entityClassGenerator = null,
  59.         PhpCompatUtil $phpCompatUtil = null,
  60.     ) {
  61.         if (null !== $projectDirectory) {
  62.             @trigger_error('The $projectDirectory constructor argument is no longer used since 1.41.0', \E_USER_DEPRECATED);
  63.         }
  65.         if (null === $generator) {
  66.             @trigger_error(sprintf('Passing a "%s" instance as 4th argument is mandatory since version 1.5.', Generator::class), \E_USER_DEPRECATED);
  67.             $this->generator = new Generator($fileManager, 'App\\');
  68.         } else {
  69.             $this->generator = $generator;
  70.         }
  72.         if (null === $entityClassGenerator) {
  73.             @trigger_error(sprintf('Passing a "%s" instance as 5th argument is mandatory since version 1.15.1', EntityClassGenerator::class), \E_USER_DEPRECATED);
  74.             $this->entityClassGenerator = new EntityClassGenerator($generator, $this->doctrineHelper);
  75.         } else {
  76.             $this->entityClassGenerator = $entityClassGenerator;
  77.         }
  79.         if (null === $phpCompatUtil) {
  80.             @trigger_error(sprintf('Passing a "%s" instance as 6th argument is mandatory since version 1.41.0', PhpCompatUtil::class), \E_USER_DEPRECATED);
  81.             $this->phpCompatUtil = new PhpCompatUtil($this->fileManager);
  82.         } else {
  83.             $this->phpCompatUtil = $phpCompatUtil;
  84.         }
  85.     }
  87.     public static function getCommandName(): string
  88.     {
  89.         return 'make:entity';
  90.     }
  92.     public static function getCommandDescription(): string
  93.     {
  94.         return 'Creates or updates a Doctrine entity class, and optionally an API Platform resource';
  95.     }
  97.     public function configureCommand(Command $command, InputConfiguration $inputConfig): void
  98.     {
  99.         $command
  100.             ->addArgument('name', InputArgument::OPTIONAL, sprintf('Class name of the entity to create or update (e.g. <fg=yellow>%s</>)', Str::asClassName(Str::getRandomTerm())))
  101.             ->addOption('api-resource', 'a', InputOption::VALUE_NONE, 'Mark this class as an API Platform resource (expose a CRUD API for it)')
  102.             ->addOption('broadcast', 'b', InputOption::VALUE_NONE, 'Add the ability to broadcast entity updates using Symfony UX Turbo?')
  103.             ->addOption('regenerate', null, InputOption::VALUE_NONE, 'Instead of adding new fields, simply generate the methods (e.g. getter/setter) for existing fields')
  104.             ->addOption('overwrite', null, InputOption::VALUE_NONE, 'Overwrite any existing getter/setter methods')
  105.             ->setHelp(file_get_contents(__DIR__.'/../Resources/help/MakeEntity.txt'))
  106.         ;
  108.         $inputConfig->setArgumentAsNonInteractive('name');
  109.     }
  111.     public function interact(InputInterface $input, ConsoleStyle $io, Command $command): void
  112.     {
  113.         if ($input->getArgument('name')) {
  114.             return;
  115.         }
  117.         if ($input->getOption('regenerate')) {
  118.             $io->block([
  119.                 'This command will generate any missing methods (e.g. getters & setters) for a class or all classes in a namespace.',
  120.                 'To overwrite any existing methods, re-run this command with the --overwrite flag',
  121.             ], null, 'fg=yellow');
  122.             $classOrNamespace = $io->ask('Enter a class or namespace to regenerate', $this->getEntityNamespace(), [Validator::class, 'notBlank']);
  124.             $input->setArgument('name', $classOrNamespace);
  126.             return;
  127.         }
  129.         $argument = $command->getDefinition()->getArgument('name');
  130.         $question = $this->createEntityClassQuestion($argument->getDescription());
  131.         $entityClassName = $io->askQuestion($question);
  133.         $input->setArgument('name', $entityClassName);
  135.         if (
  136.             !$input->getOption('api-resource') &&
  137.             (class_exists(ApiResource::class) || class_exists(LegacyApiResource::class)) &&
  138.             !class_exists($this->generator->createClassNameDetails($entityClassName, 'Entity\\')->getFullName())
  139.         ) {
  140.             $description = $command->getDefinition()->getOption('api-resource')->getDescription();
  141.             $question = new ConfirmationQuestion($description, false);
  142.             $isApiResource = $io->askQuestion($question);
  144.             $input->setOption('api-resource', $isApiResource);
  145.         }
  147.         if (
  148.             !$input->getOption('broadcast') &&
  149.             class_exists(Broadcast::class) &&
  150.             !class_exists($this->generator->createClassNameDetails($entityClassName, 'Entity\\')->getFullName())
  151.         ) {
  152.             $description = $command->getDefinition()->getOption('broadcast')->getDescription();
  153.             $question = new ConfirmationQuestion($description, false);
  154.             $isBroadcast = $io->askQuestion($question);
  156.             $input->setOption('broadcast', $isBroadcast);
  157.         }
  158.     }
  160.     public function generate(InputInterface $input, ConsoleStyle $io, Generator $generator): void
  161.     {
  162.         $overwrite = $input->getOption('overwrite');
  164.         // the regenerate option has entirely custom behavior
  165.         if ($input->getOption('regenerate')) {
  166.             $this->regenerateEntities($input->getArgument('name'), $overwrite, $generator);
  167.             $this->writeSuccessMessage($io);
  169.             return;
  170.         }
  172.         $entityClassDetails = $generator->createClassNameDetails(
  173.             $input->getArgument('name'),
  174.             'Entity\\'
  175.         );
  177.         $classExists = class_exists($entityClassDetails->getFullName());
  178.         if (!$classExists) {
  179.             $broadcast = $input->getOption('broadcast');
  180.             $entityPath = $this->entityClassGenerator->generateEntityClass(
  181.                 $entityClassDetails,
  182.                 $input->getOption('api-resource'),
  183.                 false,
  184.                 true,
  185.                 $broadcast
  186.             );
  188.             if ($broadcast) {
  189.                 $shortName = $entityClassDetails->getShortName();
  190.                 $generator->generateTemplate(
  191.                     sprintf('broadcast/%s.stream.html.twig', $shortName),
  192.                     'doctrine/broadcast_twig_template.tpl.php',
  193.                     [
  194.                         'class_name' => Str::asSnakeCase($shortName),
  195.                         'class_name_plural' => Str::asSnakeCase(Str::singularCamelCaseToPluralCamelCase($shortName)),
  196.                     ]
  197.                 );
  198.             }
  200.             $generator->writeChanges();
  201.         }
  203.         if (!$this->doesEntityUseAttributeMapping($entityClassDetails->getFullName())) {
  204.             throw new RuntimeCommandException(sprintf('Only attribute mapping is supported by make:entity, but the <info>%s</info> class uses a different format. If you would like this command to generate the properties & getter/setter methods, add your mapping configuration, and then re-run this command with the <info>--regenerate</info> flag.', $entityClassDetails->getFullName()));
  205.         }
  207.         if ($classExists) {
  208.             $entityPath = $this->getPathOfClass($entityClassDetails->getFullName());
  209.             $io->text([
  210.                 'Your entity already exists! So let\'s add some new fields!',
  211.             ]);
  212.         } else {
  213.             $io->text([
  214.                 '',
  215.                 'Entity generated! Now let\'s add some fields!',
  216.                 'You can always add more fields later manually or by re-running this command.',
  217.             ]);
  218.         }
  220.         $currentFields = $this->getPropertyNames($entityClassDetails->getFullName());
  221.         $manipulator = $this->createClassManipulator($entityPath, $io, $overwrite);
  223.         $isFirstField = true;
  224.         while (true) {
  225.             $newField = $this->askForNextField($io, $currentFields, $entityClassDetails->getFullName(), $isFirstField);
  226.             $isFirstField = false;
  228.             if (null === $newField) {
  229.                 break;
  230.             }
  232.             $fileManagerOperations = [];
  233.             $fileManagerOperations[$entityPath] = $manipulator;
  235.             if (\is_array($newField)) {
  236.                 $annotationOptions = $newField;
  237.                 unset($annotationOptions['fieldName']);
  238.                 $manipulator->addEntityField($newField['fieldName'], $annotationOptions);
  240.                 $currentFields[] = $newField['fieldName'];
  241.             } elseif ($newField instanceof EntityRelation) {
  242.                 // both overridden below for OneToMany
  243.                 $newFieldName = $newField->getOwningProperty();
  244.                 if ($newField->isSelfReferencing()) {
  245.                     $otherManipulatorFilename = $entityPath;
  246.                     $otherManipulator = $manipulator;
  247.                 } else {
  248.                     $otherManipulatorFilename = $this->getPathOfClass($newField->getInverseClass());
  249.                     $otherManipulator = $this->createClassManipulator($otherManipulatorFilename, $io, $overwrite);
  250.                 }
  251.                 switch ($newField->getType()) {
  252.                     case EntityRelation::MANY_TO_ONE:
  253.                         if ($newField->getOwningClass() === $entityClassDetails->getFullName()) {
  254.                             // THIS class will receive the ManyToOne
  255.                             $manipulator->addManyToOneRelation($newField->getOwningRelation());
  257.                             if ($newField->getMapInverseRelation()) {
  258.                                 $otherManipulator->addOneToManyRelation($newField->getInverseRelation());
  259.                             }
  260.                         } else {
  261.                             // the new field being added to THIS entity is the inverse
  262.                             $newFieldName = $newField->getInverseProperty();
  263.                             $otherManipulatorFilename = $this->getPathOfClass($newField->getOwningClass());
  264.                             $otherManipulator = $this->createClassManipulator($otherManipulatorFilename, $io, $overwrite);
  266.                             // The *other* class will receive the ManyToOne
  267.                             $otherManipulator->addManyToOneRelation($newField->getOwningRelation());
  268.                             if (!$newField->getMapInverseRelation()) {
  269.                                 throw new \Exception('Somehow a OneToMany relationship is being created, but the inverse side will not be mapped?');
  270.                             }
  271.                             $manipulator->addOneToManyRelation($newField->getInverseRelation());
  272.                         }
  274.                         break;
  275.                     case EntityRelation::MANY_TO_MANY:
  276.                         $manipulator->addManyToManyRelation($newField->getOwningRelation());
  277.                         if ($newField->getMapInverseRelation()) {
  278.                             $otherManipulator->addManyToManyRelation($newField->getInverseRelation());
  279.                         }
  281.                         break;
  282.                     case EntityRelation::ONE_TO_ONE:
  283.                         $manipulator->addOneToOneRelation($newField->getOwningRelation());
  284.                         if ($newField->getMapInverseRelation()) {
  285.                             $otherManipulator->addOneToOneRelation($newField->getInverseRelation());
  286.                         }
  288.                         break;
  289.                     default:
  290.                         throw new \Exception('Invalid relation type');
  291.                 }
  293.                 // save the inverse side if it's being mapped
  294.                 if ($newField->getMapInverseRelation()) {
  295.                     $fileManagerOperations[$otherManipulatorFilename] = $otherManipulator;
  296.                 }
  297.                 $currentFields[] = $newFieldName;
  298.             } else {
  299.                 throw new \Exception('Invalid value');
  300.             }
  302.             foreach ($fileManagerOperations as $path => $manipulatorOrMessage) {
  303.                 if (\is_string($manipulatorOrMessage)) {
  304.                     $io->comment($manipulatorOrMessage);
  305.                 } else {
  306.                     $this->fileManager->dumpFile($path, $manipulatorOrMessage->getSourceCode());
  307.                 }
  308.             }
  309.         }
  311.         $this->writeSuccessMessage($io);
  312.         $io->text([
  313.             'Next: When you\'re ready, create a migration with <info>php bin/console make:migration</info>',
  314.             '',
  315.         ]);
  316.     }
  318.     public function configureDependencies(DependencyBuilder $dependencies, InputInterface $input = null): void
  319.     {
  320.         if (null !== $input && $input->getOption('api-resource')) {
  321.             if (class_exists(ApiResource::class)) {
  322.                 $dependencies->addClassDependency(
  323.                     ApiResource::class,
  324.                     'api'
  325.                 );
  326.             } else {
  327.                 $dependencies->addClassDependency(
  328.                     LegacyApiResource::class,
  329.                     'api'
  330.                 );
  331.             }
  332.         }
  334.         if (null !== $input && $input->getOption('broadcast')) {
  335.             $dependencies->addClassDependency(
  336.                 Broadcast::class,
  337.                 'ux-turbo-mercure'
  338.             );
  339.         }
  341.         ORMDependencyBuilder::buildDependencies($dependencies);
  342.     }
  344.     private function askForNextField(ConsoleStyle $io, array $fields, string $entityClass, bool $isFirstField): EntityRelation|array|null
  345.     {
  346.         $io->writeln('');
  348.         if ($isFirstField) {
  349.             $questionText = 'New property name (press <return> to stop adding fields)';
  350.         } else {
  351.             $questionText = 'Add another property? Enter the property name (or press <return> to stop adding fields)';
  352.         }
  354.         $fieldName = $io->ask($questionText, null, function ($name) use ($fields) {
  355.             // allow it to be empty
  356.             if (!$name) {
  357.                 return $name;
  358.             }
  360.             if (\in_array($name, $fields)) {
  361.                 throw new \InvalidArgumentException(sprintf('The "%s" property already exists.', $name));
  362.             }
  364.             return Validator::validateDoctrineFieldName($name, $this->doctrineHelper->getRegistry());
  365.         });
  367.         if (!$fieldName) {
  368.             return null;
  369.         }
  371.         $defaultType = 'string';
  372.         // try to guess the type by the field name prefix/suffix
  373.         // convert to snake case for simplicity
  374.         $snakeCasedField = Str::asSnakeCase($fieldName);
  376.         if ('_at' === $suffix = substr($snakeCasedField, -3)) {
  377.             $defaultType = 'datetime_immutable';
  378.         } elseif ('_id' === $suffix) {
  379.             $defaultType = 'integer';
  380.         } elseif (str_starts_with($snakeCasedField, 'is_')) {
  381.             $defaultType = 'boolean';
  382.         } elseif (str_starts_with($snakeCasedField, 'has_')) {
  383.             $defaultType = 'boolean';
  384.         } elseif ('uuid' === $snakeCasedField) {
  385.             $defaultType = Type::hasType('uuid') ? 'uuid' : 'guid';
  386.         } elseif ('guid' === $snakeCasedField) {
  387.             $defaultType = 'guid';
  388.         }
  390.         $type = null;
  391.         $types = $this->getTypesMap();
  393.         $allValidTypes = array_merge(
  394.             array_keys($types),
  395.             EntityRelation::getValidRelationTypes(),
  396.             ['relation']
  397.         );
  398.         while (null === $type) {
  399.             $question = new Question('Field type (enter <comment>?</comment> to see all types)', $defaultType);
  400.             $question->setAutocompleterValues($allValidTypes);
  401.             $type = $io->askQuestion($question);
  403.             if ('?' === $type) {
  404.                 $this->printAvailableTypes($io);
  405.                 $io->writeln('');
  407.                 $type = null;
  408.             } elseif (!\in_array($type, $allValidTypes)) {
  409.                 $this->printAvailableTypes($io);
  410.                 $io->error(sprintf('Invalid type "%s".', $type));
  411.                 $io->writeln('');
  413.                 $type = null;
  414.             }
  415.         }
  417.         if ('relation' === $type || \in_array($type, EntityRelation::getValidRelationTypes())) {
  418.             return $this->askRelationDetails($io, $entityClass, $type, $fieldName);
  419.         }
  421.         // this is a normal field
  422.         $data = ['fieldName' => $fieldName, 'type' => $type];
  423.         if ('string' === $type) {
  424.             // default to 255, avoid the question
  425.             $data['length'] = $io->ask('Field length', 255, [Validator::class, 'validateLength']);
  426.         } elseif ('decimal' === $type) {
  427.             // 10 is the default value given in \Doctrine\DBAL\Schema\Column::$_precision
  428.             $data['precision'] = $io->ask('Precision (total number of digits stored: 100.00 would be 5)', 10, [Validator::class, 'validatePrecision']);
  430.             // 0 is the default value given in \Doctrine\DBAL\Schema\Column::$_scale
  431.             $data['scale'] = $io->ask('Scale (number of decimals to store: 100.00 would be 2)', 0, [Validator::class, 'validateScale']);
  432.         }
  434.         if ($io->confirm('Can this field be null in the database (nullable)', false)) {
  435.             $data['nullable'] = true;
  436.         }
  438.         return $data;
  439.     }
  441.     private function printAvailableTypes(ConsoleStyle $io): void
  442.     {
  443.         $allTypes = $this->getTypesMap();
  445.         if ('Hyper' === getenv('TERM_PROGRAM')) {
  446.             $wizard = 'wizard ðŸ§™';
  447.         } else {
  448.             $wizard = '\\' === \DIRECTORY_SEPARATOR ? 'wizard' : 'wizard ðŸ§™';
  449.         }
  451.         $typesTable = [
  452.             'main' => [
  453.                 'string' => [],
  454.                 'text' => [],
  455.                 'boolean' => [],
  456.                 'integer' => ['smallint', 'bigint'],
  457.                 'float' => [],
  458.             ],
  459.             'relation' => [
  460.                 'relation' => 'a '.$wizard.' will help you build the relation',
  461.                 EntityRelation::MANY_TO_ONE => [],
  462.                 EntityRelation::ONE_TO_MANY => [],
  463.                 EntityRelation::MANY_TO_MANY => [],
  464.                 EntityRelation::ONE_TO_ONE => [],
  465.             ],
  466.             'array_object' => [
  467.                 'array' => ['simple_array'],
  468.                 'json' => [],
  469.                 'object' => [],
  470.                 'binary' => [],
  471.                 'blob' => [],
  472.             ],
  473.             'date_time' => [
  474.                 'datetime' => ['datetime_immutable'],
  475.                 'datetimetz' => ['datetimetz_immutable'],
  476.                 'date' => ['date_immutable'],
  477.                 'time' => ['time_immutable'],
  478.                 'dateinterval' => [],
  479.             ],
  480.         ];
  482.         $printSection = static function (array $sectionTypes) use ($io, &$allTypes) {
  483.             foreach ($sectionTypes as $mainType => $subTypes) {
  484.                 unset($allTypes[$mainType]);
  485.                 $line = sprintf('  * <comment>%s</comment>', $mainType);
  487.                 if (\is_string($subTypes) && $subTypes) {
  488.                     $line .= sprintf(' (%s)', $subTypes);
  489.                 } elseif (\is_array($subTypes) && !empty($subTypes)) {
  490.                     $line .= sprintf(' (or %s)', implode(', ', array_map(
  491.                         static fn ($subType) => sprintf('<comment>%s</comment>', $subType), $subTypes))
  492.                     );
  494.                     foreach ($subTypes as $subType) {
  495.                         unset($allTypes[$subType]);
  496.                     }
  497.                 }
  499.                 $io->writeln($line);
  500.             }
  502.             $io->writeln('');
  503.         };
  505.         $io->writeln('<info>Main Types</info>');
  506.         $printSection($typesTable['main']);
  508.         $io->writeln('<info>Relationships/Associations</info>');
  509.         $printSection($typesTable['relation']);
  511.         $io->writeln('<info>Array/Object Types</info>');
  512.         $printSection($typesTable['array_object']);
  514.         $io->writeln('<info>Date/Time Types</info>');
  515.         $printSection($typesTable['date_time']);
  517.         $io->writeln('<info>Other Types</info>');
  518.         // empty the values
  519.         $allTypes = array_map(static fn () => [], $allTypes);
  520.         $printSection($allTypes);
  521.     }
  523.     private function createEntityClassQuestion(string $questionText): Question
  524.     {
  525.         $question = new Question($questionText);
  526.         $question->setValidator([Validator::class, 'notBlank']);
  527.         $question->setAutocompleterValues($this->doctrineHelper->getEntitiesForAutocomplete());
  529.         return $question;
  530.     }
  532.     private function askRelationDetails(ConsoleStyle $io, string $generatedEntityClass, string $type, string $newFieldName): EntityRelation
  533.     {
  534.         // ask the targetEntity
  535.         $targetEntityClass = null;
  536.         while (null === $targetEntityClass) {
  537.             $question = $this->createEntityClassQuestion('What class should this entity be related to?');
  539.             $answeredEntityClass = $io->askQuestion($question);
  541.             // find the correct class name - but give priority over looking
  542.             // in the Entity namespace versus just checking the full class
  543.             // name to avoid issues with classes like "Directory" that exist
  544.             // in PHP's core.
  545.             if (class_exists($this->getEntityNamespace().'\\'.$answeredEntityClass)) {
  546.                 $targetEntityClass = $this->getEntityNamespace().'\\'.$answeredEntityClass;
  547.             } elseif (class_exists($answeredEntityClass)) {
  548.                 $targetEntityClass = $answeredEntityClass;
  549.             } else {
  550.                 $io->error(sprintf('Unknown class "%s"', $answeredEntityClass));
  551.                 continue;
  552.             }
  553.         }
  555.         // help the user select the type
  556.         if ('relation' === $type) {
  557.             $type = $this->askRelationType($io, $generatedEntityClass, $targetEntityClass);
  558.         }
  560.         $askFieldName = fn (string $targetClass, string $defaultValue) => $io->ask(
  561.             sprintf('New field name inside %s', Str::getShortClassName($targetClass)),
  562.             $defaultValue,
  563.             function ($name) use ($targetClass) {
  564.                 // it's still *possible* to create duplicate properties - by
  565.                 // trying to generate the same property 2 times during the
  566.                 // same make:entity run. property_exists() only knows about
  567.                 // properties that *originally* existed on this class.
  568.                 if (property_exists($targetClass, $name)) {
  569.                     throw new \InvalidArgumentException(sprintf('The "%s" class already has a "%s" property.', $targetClass, $name));
  570.                 }
  572.                 return Validator::validateDoctrineFieldName($name, $this->doctrineHelper->getRegistry());
  573.             }
  574.         );
  576.         $askIsNullable = static fn (string $propertyName, string $targetClass) => $io->confirm(sprintf(
  577.             'Is the <comment>%s</comment>.<comment>%s</comment> property allowed to be null (nullable)?',
  578.             Str::getShortClassName($targetClass),
  579.             $propertyName
  580.         ));
  582.         $askOrphanRemoval = static function (string $owningClass, string $inverseClass) use ($io) {
  583.             $io->text([
  584.                 'Do you want to activate <comment>orphanRemoval</comment> on your relationship?',
  585.                 sprintf(
  586.                     'A <comment>%s</comment> is "orphaned" when it is removed from its related <comment>%s</comment>.',
  587.                     Str::getShortClassName($owningClass),
  588.                     Str::getShortClassName($inverseClass)
  589.                 ),
  590.                 sprintf(
  591.                     'e.g. <comment>$%s->remove%s($%s)</comment>',
  592.                     Str::asLowerCamelCase(Str::getShortClassName($inverseClass)),
  593.                     Str::asCamelCase(Str::getShortClassName($owningClass)),
  594.                     Str::asLowerCamelCase(Str::getShortClassName($owningClass))
  595.                 ),
  596.                 '',
  597.                 sprintf(
  598.                     'NOTE: If a <comment>%s</comment> may *change* from one <comment>%s</comment> to another, answer "no".',
  599.                     Str::getShortClassName($owningClass),
  600.                     Str::getShortClassName($inverseClass)
  601.                 ),
  602.             ]);
  604.             return $io->confirm(sprintf('Do you want to automatically delete orphaned <comment>%s</comment> objects (orphanRemoval)?', $owningClass), false);
  605.         };
  607.         $askInverseSide = function (EntityRelation $relation) use ($io) {
  608.             if ($this->isClassInVendor($relation->getInverseClass())) {
  609.                 $relation->setMapInverseRelation(false);
  611.                 return;
  612.             }
  614.             // recommend an inverse side, except for OneToOne, where it's inefficient
  615.             $recommendMappingInverse = EntityRelation::ONE_TO_ONE !== $relation->getType();
  617.             $getterMethodName = 'get'.Str::asCamelCase(Str::getShortClassName($relation->getOwningClass()));
  618.             if (EntityRelation::ONE_TO_ONE !== $relation->getType()) {
  619.                 // pluralize!
  620.                 $getterMethodName = Str::singularCamelCaseToPluralCamelCase($getterMethodName);
  621.             }
  622.             $mapInverse = $io->confirm(
  623.                 sprintf(
  624.                     'Do you want to add a new property to <comment>%s</comment> so that you can access/update <comment>%s</comment> objects from it - e.g. <comment>$%s->%s()</comment>?',
  625.                     Str::getShortClassName($relation->getInverseClass()),
  626.                     Str::getShortClassName($relation->getOwningClass()),
  627.                     Str::asLowerCamelCase(Str::getShortClassName($relation->getInverseClass())),
  628.                     $getterMethodName
  629.                 ),
  630.                 $recommendMappingInverse
  631.             );
  632.             $relation->setMapInverseRelation($mapInverse);
  633.         };
  635.         switch ($type) {
  636.             case EntityRelation::MANY_TO_ONE:
  637.                 $relation = new EntityRelation(
  638.                     EntityRelation::MANY_TO_ONE,
  639.                     $generatedEntityClass,
  640.                     $targetEntityClass
  641.                 );
  642.                 $relation->setOwningProperty($newFieldName);
  644.                 $relation->setIsNullable($askIsNullable(
  645.                     $relation->getOwningProperty(),
  646.                     $relation->getOwningClass()
  647.                 ));
  649.                 $askInverseSide($relation);
  650.                 if ($relation->getMapInverseRelation()) {
  651.                     $io->comment(sprintf(
  652.                         'A new property will also be added to the <comment>%s</comment> class so that you can access the related <comment>%s</comment> objects from it.',
  653.                         Str::getShortClassName($relation->getInverseClass()),
  654.                         Str::getShortClassName($relation->getOwningClass())
  655.                     ));
  656.                     $relation->setInverseProperty($askFieldName(
  657.                         $relation->getInverseClass(),
  658.                         Str::singularCamelCaseToPluralCamelCase(Str::getShortClassName($relation->getOwningClass()))
  659.                     ));
  661.                     // orphan removal only applies if the inverse relation is set
  662.                     if (!$relation->isNullable()) {
  663.                         $relation->setOrphanRemoval($askOrphanRemoval(
  664.                             $relation->getOwningClass(),
  665.                             $relation->getInverseClass()
  666.                         ));
  667.                     }
  668.                 }
  670.                 break;
  671.             case EntityRelation::ONE_TO_MANY:
  672.                 // we *actually* create a ManyToOne, but populate it differently
  673.                 $relation = new EntityRelation(
  674.                     EntityRelation::MANY_TO_ONE,
  675.                     $targetEntityClass,
  676.                     $generatedEntityClass
  677.                 );
  678.                 $relation->setInverseProperty($newFieldName);
  680.                 $io->comment(sprintf(
  681.                     'A new property will also be added to the <comment>%s</comment> class so that you can access and set the related <comment>%s</comment> object from it.',
  682.                     Str::getShortClassName($relation->getOwningClass()),
  683.                     Str::getShortClassName($relation->getInverseClass())
  684.                 ));
  685.                 $relation->setOwningProperty($askFieldName(
  686.                     $relation->getOwningClass(),
  687.                     Str::asLowerCamelCase(Str::getShortClassName($relation->getInverseClass()))
  688.                 ));
  690.                 $relation->setIsNullable($askIsNullable(
  691.                     $relation->getOwningProperty(),
  692.                     $relation->getOwningClass()
  693.                 ));
  695.                 if (!$relation->isNullable()) {
  696.                     $relation->setOrphanRemoval($askOrphanRemoval(
  697.                         $relation->getOwningClass(),
  698.                         $relation->getInverseClass()
  699.                     ));
  700.                 }
  702.                 break;
  703.             case EntityRelation::MANY_TO_MANY:
  704.                 $relation = new EntityRelation(
  705.                     EntityRelation::MANY_TO_MANY,
  706.                     $generatedEntityClass,
  707.                     $targetEntityClass
  708.                 );
  709.                 $relation->setOwningProperty($newFieldName);
  711.                 $askInverseSide($relation);
  712.                 if ($relation->getMapInverseRelation()) {
  713.                     $io->comment(sprintf(
  714.                         'A new property will also be added to the <comment>%s</comment> class so that you can access the related <comment>%s</comment> objects from it.',
  715.                         Str::getShortClassName($relation->getInverseClass()),
  716.                         Str::getShortClassName($relation->getOwningClass())
  717.                     ));
  718.                     $relation->setInverseProperty($askFieldName(
  719.                         $relation->getInverseClass(),
  720.                         Str::singularCamelCaseToPluralCamelCase(Str::getShortClassName($relation->getOwningClass()))
  721.                     ));
  722.                 }
  724.                 break;
  725.             case EntityRelation::ONE_TO_ONE:
  726.                 $relation = new EntityRelation(
  727.                     EntityRelation::ONE_TO_ONE,
  728.                     $generatedEntityClass,
  729.                     $targetEntityClass
  730.                 );
  731.                 $relation->setOwningProperty($newFieldName);
  733.                 $relation->setIsNullable($askIsNullable(
  734.                     $relation->getOwningProperty(),
  735.                     $relation->getOwningClass()
  736.                 ));
  738.                 $askInverseSide($relation);
  739.                 if ($relation->getMapInverseRelation()) {
  740.                     $io->comment(sprintf(
  741.                         'A new property will also be added to the <comment>%s</comment> class so that you can access the related <comment>%s</comment> object from it.',
  742.                         Str::getShortClassName($relation->getInverseClass()),
  743.                         Str::getShortClassName($relation->getOwningClass())
  744.                     ));
  745.                     $relation->setInverseProperty($askFieldName(
  746.                         $relation->getInverseClass(),
  747.                         Str::asLowerCamelCase(Str::getShortClassName($relation->getOwningClass()))
  748.                     ));
  749.                 }
  751.                 break;
  752.             default:
  753.                 throw new \InvalidArgumentException('Invalid type: '.$type);
  754.         }
  756.         return $relation;
  757.     }
  759.     private function askRelationType(ConsoleStyle $io, string $entityClass, string $targetEntityClass)
  760.     {
  761.         $io->writeln('What type of relationship is this?');
  763.         $originalEntityShort = Str::getShortClassName($entityClass);
  764.         $targetEntityShort = Str::getShortClassName($targetEntityClass);
  765.         $rows = [];
  766.         $rows[] = [
  767.             EntityRelation::MANY_TO_ONE,
  768.             sprintf("Each <comment>%s</comment> relates to (has) <info>one</info> <comment>%s</comment>.\nEach <comment>%s</comment> can relate to (can have) <info>many</info> <comment>%s</comment> objects.", $originalEntityShort, $targetEntityShort, $targetEntityShort, $originalEntityShort),
  769.         ];
  770.         $rows[] = ['', ''];
  771.         $rows[] = [
  772.             EntityRelation::ONE_TO_MANY,
  773.             sprintf("Each <comment>%s</comment> can relate to (can have) <info>many</info> <comment>%s</comment> objects.\nEach <comment>%s</comment> relates to (has) <info>one</info> <comment>%s</comment>.", $originalEntityShort, $targetEntityShort, $targetEntityShort, $originalEntityShort),
  774.         ];
  775.         $rows[] = ['', ''];
  776.         $rows[] = [
  777.             EntityRelation::MANY_TO_MANY,
  778.             sprintf("Each <comment>%s</comment> can relate to (can have) <info>many</info> <comment>%s</comment> objects.\nEach <comment>%s</comment> can also relate to (can also have) <info>many</info> <comment>%s</comment> objects.", $originalEntityShort, $targetEntityShort, $targetEntityShort, $originalEntityShort),
  779.         ];
  780.         $rows[] = ['', ''];
  781.         $rows[] = [
  782.             EntityRelation::ONE_TO_ONE,
  783.             sprintf("Each <comment>%s</comment> relates to (has) exactly <info>one</info> <comment>%s</comment>.\nEach <comment>%s</comment> also relates to (has) exactly <info>one</info> <comment>%s</comment>.", $originalEntityShort, $targetEntityShort, $targetEntityShort, $originalEntityShort),
  784.         ];
  786.         $io->table([
  787.             'Type',
  788.             'Description',
  789.         ], $rows);
  791.         $question = new Question(sprintf(
  792.             'Relation type? [%s]',
  793.             implode(', ', EntityRelation::getValidRelationTypes())
  794.         ));
  795.         $question->setAutocompleterValues(EntityRelation::getValidRelationTypes());
  796.         $question->setValidator(function ($type) {
  797.             if (!\in_array($type, EntityRelation::getValidRelationTypes())) {
  798.                 throw new \InvalidArgumentException(sprintf('Invalid type: use one of: %s', implode(', ', EntityRelation::getValidRelationTypes())));
  799.             }
  801.             return $type;
  802.         });
  804.         return $io->askQuestion($question);
  805.     }
  807.     private function createClassManipulator(string $path, ConsoleStyle $io, bool $overwrite): ClassSourceManipulator
  808.     {
  809.         $manipulator = new ClassSourceManipulator(
  810.             sourceCode: $this->fileManager->getFileContents($path),
  811.             overwrite: $overwrite,
  812.         );
  814.         $manipulator->setIo($io);
  816.         return $manipulator;
  817.     }
  819.     private function getPathOfClass(string $class): string
  820.     {
  821.         return (new ClassDetails($class))->getPath();
  822.     }
  824.     private function isClassInVendor(string $class): bool
  825.     {
  826.         $path = $this->getPathOfClass($class);
  828.         return $this->fileManager->isPathInVendor($path);
  829.     }
  831.     private function regenerateEntities(string $classOrNamespace, bool $overwrite, Generator $generator): void
  832.     {
  833.         $regenerator = new EntityRegenerator($this->doctrineHelper, $this->fileManager, $generator, $this->entityClassGenerator, $overwrite);
  834.         $regenerator->regenerateEntities($classOrNamespace);
  835.     }
  837.     private function getPropertyNames(string $class): array
  838.     {
  839.         if (!class_exists($class)) {
  840.             return [];
  841.         }
  843.         $reflClass = new \ReflectionClass($class);
  845.         return array_map(static fn (\ReflectionProperty $prop) => $prop->getName(), $reflClass->getProperties());
  846.     }
  848.     /** @legacy Drop when Annotations are no longer supported */
  849.     private function doesEntityUseAttributeMapping(string $className): bool
  850.     {
  851.         if (!class_exists($className)) {
  852.             $otherClassMetadatas = $this->doctrineHelper->getMetadata(Str::getNamespace($className).'\\', true);
  854.             // if we have no metadata, we should assume this is the first class being mapped
  855.             if (empty($otherClassMetadatas)) {
  856.                 return false;
  857.             }
  859.             $className = reset($otherClassMetadatas)->getName();
  860.         }
  862.         return $this->doctrineHelper->doesClassUsesAttributes($className);
  863.     }
  865.     private function getEntityNamespace(): string
  866.     {
  867.         return $this->doctrineHelper->getEntityNamespace();
  868.     }
  870.     private function getTypesMap(): array
  871.     {
  872.         $types = Type::getTypesMap();
  874.         // remove deprecated json_array if it exists
  875.         if (\defined(sprintf('%s::JSON_ARRAY', Type::class))) {
  876.             unset($types[Type::JSON_ARRAY]);
  877.         }
  879.         return $types;
  880.     }
  881. }