1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
<?php
declare(strict_types=1);
namespace Doctrine\ORM;
use Doctrine\ORM\Mapping\AssociationMapping;
use Doctrine\ORM\Mapping\ClassMetadata;
use InvalidArgumentException;
use Stringable;
use function array_map;
use function count;
use function get_debug_type;
use function gettype;
use function implode;
use function is_scalar;
use function reset;
use function spl_object_id;
use function sprintf;
/**
* Contains exception messages for all invalid lifecycle state exceptions inside UnitOfWork
*/
class ORMInvalidArgumentException extends InvalidArgumentException
{
public static function scheduleInsertForManagedEntity(object $entity): self
{
return new self('A managed+dirty entity ' . self::objToStr($entity) . ' can not be scheduled for insertion.');
}
public static function scheduleInsertForRemovedEntity(object $entity): self
{
return new self('Removed entity ' . self::objToStr($entity) . ' can not be scheduled for insertion.');
}
public static function scheduleInsertTwice(object $entity): self
{
return new self('Entity ' . self::objToStr($entity) . ' can not be scheduled for insertion twice.');
}
public static function entityWithoutIdentity(string $className, object $entity): self
{
return new self(
"The given entity of type '" . $className . "' (" . self::objToStr($entity) . ') has no identity/no ' .
'id values set. It cannot be added to the identity map.',
);
}
public static function readOnlyRequiresManagedEntity(object $entity): self
{
return new self('Only managed entities can be marked or checked as read only. But ' . self::objToStr($entity) . ' is not');
}
/** @param non-empty-list<array{AssociationMapping, object}> $newEntitiesWithAssociations */
public static function newEntitiesFoundThroughRelationships(array $newEntitiesWithAssociations): self
{
$errorMessages = array_map(
static function (array $newEntityWithAssociation): string {
[$associationMapping, $entity] = $newEntityWithAssociation;
return self::newEntityFoundThroughRelationshipMessage($associationMapping, $entity);
},
$newEntitiesWithAssociations,
);
if (count($errorMessages) === 1) {
return new self(reset($errorMessages));
}
return new self(
'Multiple non-persisted new entities were found through the given association graph:'
. "\n\n * "
. implode("\n * ", $errorMessages),
);
}
public static function newEntityFoundThroughRelationship(AssociationMapping $associationMapping, object $entry): self
{
return new self(self::newEntityFoundThroughRelationshipMessage($associationMapping, $entry));
}
public static function detachedEntityFoundThroughRelationship(AssociationMapping $assoc, object $entry): self
{
return new self('A detached entity of type ' . $assoc->targetEntity . ' (' . self::objToStr($entry) . ') '
. " was found through the relationship '" . $assoc->sourceEntity . '#' . $assoc->fieldName . "' "
. 'during cascading a persist operation.');
}
public static function entityNotManaged(object $entity): self
{
return new self('Entity ' . self::objToStr($entity) . ' is not managed. An entity is managed if its fetched ' .
'from the database or registered as new through EntityManager#persist');
}
public static function entityHasNoIdentity(object $entity, string $operation): self
{
return new self('Entity has no identity, therefore ' . $operation . ' cannot be performed. ' . self::objToStr($entity));
}
public static function entityIsRemoved(object $entity, string $operation): self
{
return new self('Entity is removed, therefore ' . $operation . ' cannot be performed. ' . self::objToStr($entity));
}
public static function detachedEntityCannot(object $entity, string $operation): self
{
return new self('Detached entity ' . self::objToStr($entity) . ' cannot be ' . $operation);
}
public static function invalidObject(string $context, mixed $given, int $parameterIndex = 1): self
{
return new self($context . ' expects parameter ' . $parameterIndex .
' to be an entity object, ' . gettype($given) . ' given.');
}
public static function invalidCompositeIdentifier(): self
{
return new self('Binding an entity with a composite primary key to a query is not supported. ' .
'You should split the parameter into the explicit fields and bind them separately.');
}
public static function invalidIdentifierBindingEntity(string $class): self
{
return new self(sprintf(
<<<'EXCEPTION'
Binding entities to query parameters only allowed for entities that have an identifier.
Class "%s" does not have an identifier.
EXCEPTION
,
$class,
));
}
public static function invalidAssociation(ClassMetadata $targetClass, AssociationMapping $assoc, mixed $actualValue): self
{
$expectedType = $targetClass->getName();
return new self(sprintf(
'Expected value of type "%s" for association field "%s#$%s", got "%s" instead.',
$expectedType,
$assoc->sourceEntity,
$assoc->fieldName,
get_debug_type($actualValue),
));
}
public static function invalidAutoGenerateMode(mixed $value): self
{
return new self(sprintf('Invalid auto generate mode "%s" given.', is_scalar($value) ? (string) $value : get_debug_type($value)));
}
public static function missingPrimaryKeyValue(string $className, string $idField): self
{
return new self(sprintf('Missing value for primary key %s on %s', $idField, $className));
}
public static function proxyDirectoryRequired(): self
{
return new self('You must configure a proxy directory. See docs for details');
}
public static function proxyNamespaceRequired(): self
{
return new self('You must configure a proxy namespace');
}
public static function proxyDirectoryNotWritable(string $proxyDirectory): self
{
return new self(sprintf('Your proxy directory "%s" must be writable', $proxyDirectory));
}
/**
* Helper method to show an object as string.
*/
private static function objToStr(object $obj): string
{
return $obj instanceof Stringable ? (string) $obj : get_debug_type($obj) . '@' . spl_object_id($obj);
}
private static function newEntityFoundThroughRelationshipMessage(AssociationMapping $associationMapping, object $entity): string
{
return 'A new entity was found through the relationship \''
. $associationMapping->sourceEntity . '#' . $associationMapping->fieldName . '\' that was not'
. ' configured to cascade persist operations for entity: ' . self::objToStr($entity) . '.'
. ' To solve this issue: Either explicitly call EntityManager#persist()'
. ' on this unknown entity or configure cascade persist'
. ' this association in the mapping for example #[ORM\ManyToOne(..., cascade: [\'persist\'])].'
. ($entity instanceof Stringable
? ''
: ' If you cannot find out which entity causes the problem implement \''
. $associationMapping->targetEntity . '#__toString()\' to get a clue.'
);
}
}
|
