├── docker-compose.yaml
├── src
    ├── Aggregation
    │   ├── Stage
    │   │   ├── Search
    │   │   │   ├── SupportsRangeOperator.php
    │   │   │   ├── SupportsRegexOperator.php
    │   │   │   ├── SupportsTextOperator.php
    │   │   │   ├── SupportsPhraseOperator.php
    │   │   │   ├── SupportsCompoundOperator.php
    │   │   │   ├── SupportsWildcardOperator.php
    │   │   │   ├── SupportsExistsOperator.php
    │   │   │   ├── SupportsGeoWithinOperator.php
    │   │   │   ├── SupportsAutocompleteOperator.php
    │   │   │   ├── SupportsEmbeddedDocumentOperator.php
    │   │   │   ├── SupportsQueryStringOperator.php
    │   │   │   ├── SupportsMoreLikeThisOperator.php
    │   │   │   ├── ScoredSearchOperator.php
    │   │   │   ├── SupportsEqualsOperator.php
    │   │   │   ├── SearchOperator.php
    │   │   │   ├── SupportsNearOperator.php
    │   │   │   ├── SupportsEmbeddableSearchOperators.php
    │   │   │   ├── SupportsGeoShapeOperator.php
    │   │   │   ├── SupportsCompoundableSearchOperators.php
    │   │   │   ├── SupportsAllSearchOperators.php
    │   │   │   ├── Compound
    │   │   │   │   ├── CompoundedNear.php
    │   │   │   │   ├── CompoundedText.php
    │   │   │   │   ├── CompoundedEquals.php
    │   │   │   │   ├── CompoundedExists.php
    │   │   │   │   ├── CompoundedPhrase.php
    │   │   │   │   ├── CompoundedRange.php
    │   │   │   │   ├── CompoundedRegex.php
    │   │   │   │   ├── CompoundedGeoShape.php
    │   │   │   │   ├── CompoundedWildcard.php
    │   │   │   │   ├── CompoundedGeoWithin.php
    │   │   │   │   ├── CompoundedQueryString.php
    │   │   │   │   ├── CompoundedAutocomplete.php
    │   │   │   │   ├── CompoundedMoreLikeThis.php
    │   │   │   │   └── CompoundedEmbeddedDocument.php
    │   │   │   ├── Exists.php
    │   │   │   ├── MoreLikeThis.php
    │   │   │   ├── ScoredSearchOperatorTrait.php
    │   │   │   ├── Phrase.php
    │   │   │   ├── QueryString.php
    │   │   │   ├── Regex.php
    │   │   │   ├── Wildcard.php
    │   │   │   ├── Equals.php
    │   │   │   ├── CompoundedSearchOperatorTrait.php
    │   │   │   └── EmbeddedDocument.php
    │   │   ├── ReplaceWith.php
    │   │   ├── IndexStats.php
    │   │   ├── Redact.php
    │   │   ├── Set.php
    │   │   ├── AddFields.php
    │   │   ├── ReplaceRoot.php
    │   │   ├── Skip.php
    │   │   ├── Limit.php
    │   │   ├── Count.php
    │   │   ├── Sample.php
    │   │   ├── UnsetStage.php
    │   │   ├── Group.php
    │   │   ├── SortByCount.php
    │   │   ├── Project.php
    │   │   └── Bucket
    │   │   │   └── BucketAutoOutput.php
    │   └── Operator
    │   │   ├── TimestampOperators.php
    │   │   ├── DataSizeOperators.php
    │   │   └── BooleanOperators.php
    ├── Mapping
    │   ├── Annotations
    │   │   ├── Annotation.php
    │   │   ├── EncryptQuery.php
    │   │   ├── Lock.php
    │   │   ├── AbstractField.php
    │   │   ├── AbstractIndex.php
    │   │   ├── Version.php
    │   │   ├── AbstractDocument.php
    │   │   ├── View.php
    │   │   ├── ShardKey.php
    │   │   ├── Id.php
    │   │   ├── Field.php
    │   │   ├── ReadPreference.php
    │   │   ├── Validation.php
    │   │   ├── EmbedOne.php
    │   │   ├── EmbedMany.php
    │   │   ├── PreLoad.php
    │   │   ├── File.php
    │   │   ├── PostLoad.php
    │   │   ├── PreFlush.php
    │   │   ├── QueryResultDocument.php
    │   │   ├── File
    │   │   │   ├── Length.php
    │   │   │   ├── Filename.php
    │   │   │   ├── Metadata.php
    │   │   │   ├── ChunkSize.php
    │   │   │   └── UploadDate.php
    │   │   ├── PreRemove.php
    │   │   ├── PreUpdate.php
    │   │   ├── PostRemove.php
    │   │   ├── PostUpdate.php
    │   │   ├── PrePersist.php
    │   │   ├── Document.php
    │   │   ├── Index.php
    │   │   ├── PostPersist.php
    │   │   ├── TimeSeries.php
    │   │   ├── Indexes.php
    │   │   ├── ReferenceOne.php
    │   │   ├── AlsoLoad.php
    │   │   ├── HasLifecycleCallbacks.php
    │   │   ├── InheritanceType.php
    │   │   ├── ReferenceMany.php
    │   │   ├── DiscriminatorValue.php
    │   │   ├── DiscriminatorField.php
    │   │   ├── UniqueIndex.php
    │   │   ├── ChangeTrackingPolicy.php
    │   │   ├── DiscriminatorMap.php
    │   │   ├── EmbeddedDocument.php
    │   │   ├── MappedSuperclass.php
    │   │   ├── Encrypt.php
    │   │   ├── DefaultDiscriminatorValue.php
    │   │   ├── VectorSearchIndex.php
    │   │   └── SearchIndex.php
    │   ├── Attribute
    │   │   ├── MappingAttribute.php
    │   │   ├── QueryResultDocument.php
    │   │   ├── Lock.php
    │   │   ├── PostLoad.php
    │   │   ├── PreFlush.php
    │   │   ├── PreLoad.php
    │   │   ├── Version.php
    │   │   ├── PreRemove.php
    │   │   ├── PreUpdate.php
    │   │   ├── PostPersist.php
    │   │   ├── PostRemove.php
    │   │   ├── PostUpdate.php
    │   │   ├── PrePersist.php
    │   │   ├── Index.php
    │   │   ├── AbstractDocument.php
    │   │   ├── HasLifecycleCallbacks.php
    │   │   ├── DiscriminatorValue.php
    │   │   ├── InheritanceType.php
    │   │   ├── ChangeTrackingPolicy.php
    │   │   ├── DiscriminatorField.php
    │   │   ├── AlsoLoad.php
    │   │   ├── File
    │   │   │   ├── Length.php
    │   │   │   ├── ChunkSize.php
    │   │   │   ├── Filename.php
    │   │   │   ├── UploadDate.php
    │   │   │   └── Metadata.php
    │   │   ├── EmbeddedDocument.php
    │   │   ├── ReadPreference.php
    │   │   ├── DiscriminatorMap.php
    │   │   ├── DefaultDiscriminatorValue.php
    │   │   ├── MappedSuperclass.php
    │   │   ├── ShardKey.php
    │   │   ├── VectorSearchIndex.php
    │   │   ├── Id.php
    │   │   ├── TimeSeries.php
    │   │   ├── View.php
    │   │   ├── Field.php
    │   │   ├── UniqueIndex.php
    │   │   ├── Validation.php
    │   │   ├── AbstractField.php
    │   │   ├── SearchIndex.php
    │   │   ├── Document.php
    │   │   ├── File.php
    │   │   ├── EmbedOne.php
    │   │   └── Encrypt.php
    │   ├── TimeSeries
    │   │   └── Granularity.php
    │   ├── EncryptQuery.php
    │   ├── Driver
    │   │   ├── SimplifiedXmlDriver.php
    │   │   └── AnnotationDriver.php
    │   ├── PropertyAccessors
    │   │   ├── PropertyAccessor.php
    │   │   ├── PropertyAccessorFactory.php
    │   │   ├── ReflectionReadonlyProperty.php
    │   │   └── ReadonlyAccessor.php
    │   └── ClassMetadataFactoryInterface.php
    ├── Event
    │   ├── OnFlushEventArgs.php
    │   ├── PreFlushEventArgs.php
    │   ├── PostFlushEventArgs.php
    │   ├── ManagerEventArgs.php
    │   ├── LoadClassMetadataEventArgs.php
    │   ├── PreLoadEventArgs.php
    │   ├── PostCollectionLoadEventArgs.php
    │   ├── LifecycleEventArgs.php
    │   ├── OnClassMetadataNotFoundEventArgs.php
    │   └── DocumentNotFoundEventArgs.php
    ├── Types
    │   ├── IntIdType.php
    │   ├── VectorInt8Type.php
    │   ├── BinDataFuncType.php
    │   ├── VectorFloat32Type.php
    │   ├── VectorPackedBitType.php
    │   ├── BinDataCustomType.php
    │   ├── BinDataUUIDRFC4122Type.php
    │   ├── InvalidTypeException.php
    │   ├── BinDataByteArrayType.php
    │   ├── Incrementable.php
    │   ├── BinDataUUIDType.php
    │   ├── BinDataMD5Type.php
    │   ├── Versionable.php
    │   ├── ClosureToPHP.php
    │   ├── RawType.php
    │   ├── CustomIdType.php
    │   ├── Int64Type.php
    │   ├── BooleanType.php
    │   ├── KeyType.php
    │   ├── StringType.php
    │   ├── HashType.php
    │   ├── FloatType.php
    │   ├── CollectionType.php
    │   ├── TimestampType.php
    │   ├── IntType.php
    │   ├── ObjectIdType.php
    │   ├── DateImmutableType.php
    │   ├── IdType.php
    │   ├── Decimal128Type.php
    │   └── BinDataType.php
    ├── Id
    │   ├── AbstractIdGenerator.php
    │   ├── IdGenerator.php
    │   ├── ObjectIdGenerator.php
    │   ├── AutoGenerator.php
    │   └── SymfonyUuidGenerator.php
    ├── Repository
    │   ├── UploadOptions.php
    │   ├── ViewRepository.php
    │   ├── RepositoryFactory.php
    │   ├── DefaultRepositoryFactory.php
    │   └── GridFSRepository.php
    ├── Iterator
    │   ├── Iterator.php
    │   └── IterableResult.php
    ├── Proxy
    │   ├── InternalProxy.php
    │   ├── Resolver
    │   │   ├── ClassNameResolver.php
    │   │   ├── LazyGhostProxyClassNameResolver.php
    │   │   ├── CachingClassNameResolver.php
    │   │   └── ProxyManagerClassNameResolver.php
    │   ├── FileLocator.php
    │   └── Factory
    │   │   └── ProxyFactory.php
    ├── LockMode.php
    ├── PersistentCollection
    │   ├── DefaultPersistentCollectionFactory.php
    │   ├── PersistentCollectionGenerator.php
    │   ├── PersistentCollectionFactory.php
    │   └── AbstractPersistentCollectionFactory.php
    ├── APM
    │   └── CommandLoggerInterface.php
    ├── Hydrator
    │   ├── HydratorInterface.php
    │   └── HydratorException.php
    ├── Tools
    │   └── Console
    │   │   ├── Command
    │   │       ├── Schema
    │   │       │   └── AbstractCommandCompatibility.php
    │   │       └── CommandCompatibility.php
    │   │   └── Helper
    │   │       └── DocumentManagerHelper.php
    ├── DocumentNotFoundException.php
    ├── SchemaException.php
    ├── PersistentCollection.php
    ├── Query
    │   └── CriteriaMerger.php
    └── LockException.php
├── UPGRADE-2.7.md
├── UPGRADE-2.5.md
├── UPGRADE-2.1.md
├── UPGRADE-2.6.md
├── README.markdown
├── LICENSE
├── UPGRADE-2.3.md
└── UPGRADE-2.2.md


/docker-compose.yaml:
--------------------------------------------------------------------------------
1 | version: '3.8'
2 | 
3 | services:
4 |   mongodb-atlas-local:
5 |     image: mongodb/mongodb-atlas-local
6 |     ports:
7 |       - "27018:27017"
8 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/SupportsRangeOperator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | interface SupportsRangeOperator
 8 | {
 9 |     public function range(): Range;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/SupportsRegexOperator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | interface SupportsRegexOperator
 8 | {
 9 |     public function regex(): Regex;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/SupportsTextOperator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | interface SupportsTextOperator
 8 | {
 9 |     public function text(): Text;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/SupportsPhraseOperator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | interface SupportsPhraseOperator
 8 | {
 9 |     public function phrase(): Phrase;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/Annotation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | /** @deprecated Annotation classes are deprecated, {@see MappingAttribute} */
 8 | interface Annotation
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/SupportsCompoundOperator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | interface SupportsCompoundOperator
 8 | {
 9 |     public function compound(): Compound;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/SupportsWildcardOperator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | interface SupportsWildcardOperator
 8 | {
 9 |     public function wildcard(): Wildcard;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Event/OnFlushEventArgs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Event;
 6 | 
 7 | /**
 8 |  * Provides event arguments for the onFlush event.
 9 |  */
10 | final class OnFlushEventArgs extends ManagerEventArgs
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Event/PreFlushEventArgs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Event;
 6 | 
 7 | /**
 8 |  * Provides event arguments for the preFlush event.
 9 |  */
10 | final class PreFlushEventArgs extends ManagerEventArgs
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/SupportsExistsOperator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | interface SupportsExistsOperator
 8 | {
 9 |     public function exists(string $path): Exists;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Event/PostFlushEventArgs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Event;
 6 | 
 7 | /**
 8 |  * Provides event arguments for the postFlush event.
 9 |  */
10 | final class PostFlushEventArgs extends ManagerEventArgs
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/MappingAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | /**
 8 |  * A marker interface for mapping attributes.
 9 |  *
10 |  * @internal
11 |  */
12 | interface MappingAttribute
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/SupportsGeoWithinOperator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | interface SupportsGeoWithinOperator
 8 | {
 9 |     public function geoWithin(string ...$path): GeoWithin;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Mapping/TimeSeries/Granularity.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\TimeSeries;
 6 | 
 7 | enum Granularity: string
 8 | {
 9 |     case Seconds = 'seconds';
10 |     case Minutes = 'minutes';
11 |     case Hours   = 'hours';
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/QueryResultDocument.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /** @final */
10 | #[Attribute(Attribute::TARGET_CLASS)]
11 | class QueryResultDocument extends AbstractDocument
12 | {
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/SupportsAutocompleteOperator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | interface SupportsAutocompleteOperator
 8 | {
 9 |     public function autocomplete(string $path = '', string ...$query): Autocomplete;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/SupportsEmbeddedDocumentOperator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | interface SupportsEmbeddedDocumentOperator
 8 | {
 9 |     public function embeddedDocument(string $path = ''): EmbeddedDocument;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/SupportsQueryStringOperator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | interface SupportsQueryStringOperator
 8 | {
 9 |     public function queryString(string $query = '', string $defaultPath = ''): QueryString;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Types/IntIdType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | /**
 8 |  * The Integer Id type.
 9 |  *
10 |  * @deprecated IntIdType was deprecated in doctrine/mongodb-odm 2.1 and will be removed in 3.0. Use IntType instead.
11 |  */
12 | class IntIdType extends IntType
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Id/AbstractIdGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Id;
 6 | 
 7 | /** @deprecated AbstractIdGenerator was deprecated in doctrine/mongodb-odm 2.1 and will be removed in 3.0. Implement IdGenerator interface instead. */
 8 | abstract class AbstractIdGenerator implements IdGenerator
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Types/VectorInt8Type.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | use MongoDB\BSON\VectorType;
 8 | 
 9 | final class VectorInt8Type extends AbstractVectorType
10 | {
11 |     protected function getVectorType(): VectorType
12 |     {
13 |         return VectorType::Int8;
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Repository/UploadOptions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Repository;
 6 | 
 7 | final class UploadOptions
 8 | {
 9 |     /** @var mixed */
10 |     public $id;
11 | 
12 |     /** @var int|null */
13 |     public $chunkSizeBytes;
14 | 
15 |     /** @var object|null */
16 |     public $metadata;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/SupportsMoreLikeThisOperator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | interface SupportsMoreLikeThisOperator
 8 | {
 9 |     /** @param array<string, mixed>|object $documents */
10 |     public function moreLikeThis(...$documents): MoreLikeThis;
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/Lock.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Specifies a field to use for pessimistic locking
11 |  *
12 |  * @final
13 |  */
14 | #[Attribute(Attribute::TARGET_PROPERTY)]
15 | class Lock implements MappingAttribute
16 | {
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Types/BinDataFuncType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | use MongoDB\BSON\Binary;
 8 | 
 9 | /**
10 |  * The BinData type for function data.
11 |  */
12 | class BinDataFuncType extends BinDataType
13 | {
14 |     /** @var int */
15 |     protected $binDataType = Binary::TYPE_FUNCTION;
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Types/VectorFloat32Type.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | use MongoDB\BSON\VectorType;
 8 | 
 9 | final class VectorFloat32Type extends AbstractVectorType
10 | {
11 |     protected function getVectorType(): VectorType
12 |     {
13 |         return VectorType::Float32;
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/PostLoad.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Marks a method as a postLoad lifecycle callback
11 |  *
12 |  * @final
13 |  */
14 | #[Attribute(Attribute::TARGET_METHOD)]
15 | class PostLoad implements MappingAttribute
16 | {
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/PreFlush.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Marks a method as a preFlush lifecycle callback
11 |  *
12 |  * @final
13 |  */
14 | #[Attribute(Attribute::TARGET_METHOD)]
15 | class PreFlush implements MappingAttribute
16 | {
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/PreLoad.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Marks a method as a preLoad lifecycle callback
11 |  *
12 |  * @final
13 |  */
14 | #[Attribute(Attribute::TARGET_METHOD)]
15 | class PreLoad implements MappingAttribute
16 | {
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/Version.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Specifies a field to use for optimistic locking
11 |  *
12 |  * @final
13 |  */
14 | #[Attribute(Attribute::TARGET_PROPERTY)]
15 | class Version implements MappingAttribute
16 | {
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Types/VectorPackedBitType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | use MongoDB\BSON\VectorType;
 8 | 
 9 | final class VectorPackedBitType extends AbstractVectorType
10 | {
11 |     protected function getVectorType(): VectorType
12 |     {
13 |         return VectorType::PackedBit;
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Iterator/Iterator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Iterator;
 6 | 
 7 | /**
 8 |  * @template-covariant TValue
 9 |  * @template-extends \Iterator<mixed, TValue>
10 |  */
11 | interface Iterator extends \Iterator
12 | {
13 |     /** @return array<mixed, TValue> */
14 |     public function toArray(): array;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/PreRemove.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Marks a method as a preRemove lifecycle callback
11 |  *
12 |  * @final
13 |  */
14 | #[Attribute(Attribute::TARGET_METHOD)]
15 | class PreRemove implements MappingAttribute
16 | {
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/PreUpdate.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Marks a method as a preUpdate lifecycle callback
11 |  *
12 |  * @final
13 |  */
14 | #[Attribute(Attribute::TARGET_METHOD)]
15 | class PreUpdate implements MappingAttribute
16 | {
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/PostPersist.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Marks a method as a postPersist lifecycle callback
11 |  *
12 |  * @final
13 |  */
14 | #[Attribute(Attribute::TARGET_METHOD)]
15 | class PostPersist implements MappingAttribute
16 | {
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/PostRemove.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Marks a method as a postRemove lifecycle callback
11 |  *
12 |  * @final
13 |  */
14 | #[Attribute(Attribute::TARGET_METHOD)]
15 | class PostRemove implements MappingAttribute
16 | {
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/PostUpdate.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Marks a method as a postUpdate lifecycle callback
11 |  *
12 |  * @final
13 |  */
14 | #[Attribute(Attribute::TARGET_METHOD)]
15 | class PostUpdate implements MappingAttribute
16 | {
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/PrePersist.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Marks a method as a prePersist lifecycle callback
11 |  *
12 |  * @final
13 |  */
14 | #[Attribute(Attribute::TARGET_METHOD)]
15 | class PrePersist implements MappingAttribute
16 | {
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Types/BinDataCustomType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | use MongoDB\BSON\Binary;
 8 | 
 9 | /**
10 |  * The BinData type for custom binary data.
11 |  */
12 | class BinDataCustomType extends BinDataType
13 | {
14 |     /** @var int */
15 |     protected $binDataType = Binary::TYPE_USER_DEFINED;
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/ScoredSearchOperator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | interface ScoredSearchOperator
 8 | {
 9 |     public function boostScore(?float $value = null, ?string $path = null, ?float $undefined = null): static;
10 | 
11 |     public function constantScore(float $value): static;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Id/IdGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Id;
 6 | 
 7 | use Doctrine\ODM\MongoDB\DocumentManager;
 8 | 
 9 | interface IdGenerator
10 | {
11 |     /**
12 |      * Generates an identifier for a document.
13 |      *
14 |      * @return mixed
15 |      */
16 |     public function generate(DocumentManager $dm, object $document);
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Proxy/InternalProxy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Proxy;
 6 | 
 7 | use Doctrine\Persistence\Proxy;
 8 | 
 9 | /**
10 |  * @internal
11 |  *
12 |  * @template T of object
13 |  * @template-extends Proxy<T>
14 |  */
15 | interface InternalProxy extends Proxy
16 | {
17 |     public function __setInitialized(bool $initialized): void;
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Types/BinDataUUIDRFC4122Type.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | use MongoDB\BSON\Binary;
 8 | 
 9 | /**
10 |  * The BinData type for binary UUID data, which follows RFC 4122.
11 |  */
12 | class BinDataUUIDRFC4122Type extends BinDataType
13 | {
14 |     /** @var int */
15 |     protected $binDataType = Binary::TYPE_UUID;
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/Index.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Defines an index on a field
11 |  *
12 |  * @final
13 |  */
14 | #[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
15 | class Index extends AbstractIndex implements MappingAttribute
16 | {
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/SupportsEqualsOperator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | use MongoDB\BSON\ObjectId;
 8 | use MongoDB\BSON\UTCDateTime;
 9 | 
10 | interface SupportsEqualsOperator
11 | {
12 |     /** @param string|int|float|ObjectId|UTCDateTime|null $value */
13 |     public function equals(string $path = '', $value = null): Equals;
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Id/ObjectIdGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Id;
 6 | 
 7 | use Doctrine\ODM\MongoDB\DocumentManager;
 8 | use MongoDB\BSON\ObjectId;
 9 | 
10 | /** @internal */
11 | final class ObjectIdGenerator extends AbstractIdGenerator
12 | {
13 |     public function generate(DocumentManager $dm, object $document): ObjectId
14 |     {
15 |         return new ObjectId();
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/AbstractDocument.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use function class_alias;
 8 | 
 9 | /** @internal */
10 | abstract class AbstractDocument implements MappingAttribute
11 | {
12 | }
13 | 
14 | // @phpstan-ignore class.notFound
15 | class_alias(AbstractDocument::class, \Doctrine\ODM\MongoDB\Mapping\Annotations\AbstractDocument::class);
16 | 


--------------------------------------------------------------------------------
/src/LockMode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB;
 6 | 
 7 | /**
 8 |  * Contains all MongoDB ODM LockModes
 9 |  */
10 | final class LockMode
11 | {
12 |     public const NONE              = 0;
13 |     public const OPTIMISTIC        = 1;
14 |     public const PESSIMISTIC_READ  = 2;
15 |     public const PESSIMISTIC_WRITE = 4;
16 | 
17 |     private function __construct()
18 |     {
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Types/InvalidTypeException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | use InvalidArgumentException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class InvalidTypeException extends InvalidArgumentException
12 | {
13 |     public static function invalidTypeName(string $name): self
14 |     {
15 |         return new self(sprintf('Invalid type specified: "%s"', $name));
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/HasLifecycleCallbacks.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Must be set on a document class to instruct Doctrine to check for lifecycle
11 |  * callback annotations on public methods.
12 |  *
13 |  * @final
14 |  */
15 | #[Attribute(Attribute::TARGET_CLASS)]
16 | class HasLifecycleCallbacks implements MappingAttribute
17 | {
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/EncryptQuery.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Mapping\EncryptQuery;
 8 | 
 9 | use function class_exists;
10 | use function trigger_deprecation;
11 | 
12 | trigger_deprecation('doctrine/mongodb-odm', '2.16', 'Enum %s\\EncryptQuery is deprecated, use %s instead.', __NAMESPACE__, EncryptQuery::class);
13 | 
14 | class_exists(EncryptQuery::class);
15 | 


--------------------------------------------------------------------------------
/src/Proxy/Resolver/ClassNameResolver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Proxy\Resolver;
 6 | 
 7 | /** @deprecated Deprecated in favor of Doctrine\Persistence\Mapping\ProxyClassNameResolver */
 8 | interface ClassNameResolver
 9 | {
10 |     /**
11 |      * Gets the real class name of a class name that could be a proxy.
12 |      *
13 |      * @param class-string $class
14 |      */
15 |     public function getRealClass(string $class): string;
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Mapping/EncryptQuery.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping;
 6 | 
 7 | use MongoDB\Driver\ClientEncryption;
 8 | 
 9 | use function class_alias;
10 | 
11 | enum EncryptQuery: string
12 | {
13 |     case Equality = ClientEncryption::QUERY_TYPE_EQUALITY;
14 |     case Range    = ClientEncryption::QUERY_TYPE_RANGE;
15 | }
16 | 
17 | // @phpstan-ignore-next-line class.notFound
18 | class_alias(EncryptQuery::class, Annotations\EncryptQuery::class);
19 | 


--------------------------------------------------------------------------------
/src/Types/BinDataByteArrayType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | use MongoDB\BSON\Binary;
 8 | 
 9 | /**
10 |  * The BinData type for byte array data.
11 |  *
12 |  * Per the BSON specification, this sub-type is deprecated in favor of the
13 |  * generic sub-type (BinDataType class).
14 |  */
15 | class BinDataByteArrayType extends BinDataType
16 | {
17 |     /** @var int */
18 |     protected $binDataType = Binary::TYPE_OLD_BINARY;
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Types/Incrementable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | /**
 8 |  * Types implementing this interface can have the `increment` storage strategy.
 9 |  */
10 | interface Incrementable
11 | {
12 |     /**
13 |      * Calculates PHP-based difference between given values.
14 |      *
15 |      * @param mixed $old
16 |      * @param mixed $new
17 |      *
18 |      * @return mixed
19 |      */
20 |     public function diff($old, $new);
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Types/BinDataUUIDType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | use MongoDB\BSON\Binary;
 8 | 
 9 | /**
10 |  * The BinData type for binary UUID data.
11 |  *
12 |  * Per the BSON specification, this sub-type is deprecated in favor of the
13 |  * RFC 4122 UUID sub-type (BinDataUUIDRFC4122Type class).
14 |  */
15 | class BinDataUUIDType extends BinDataType
16 | {
17 |     /** @var int */
18 |     protected $binDataType = Binary::TYPE_OLD_UUID;
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Types/BinDataMD5Type.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | use MongoDB\BSON\Binary;
 8 | 
 9 | /**
10 |  * The BinData type for binary MD5 data.
11 |  *
12 |  * Note: This sub-type is intended to store binary MD5 data. Considering using
13 |  * the basic string field type for storing hexadecimal MD5 strings.
14 |  */
15 | class BinDataMD5Type extends BinDataType
16 | {
17 |     /** @var int */
18 |     protected $binDataType = Binary::TYPE_MD5;
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Types/Versionable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | /**
 8 |  * Types implementing this interface can be used for version fields.
 9 |  */
10 | interface Versionable
11 | {
12 |     /**
13 |      * Calculates next version.
14 |      *
15 |      * @param mixed $current version currently in use, null if not versioned yet (i.e. first version)
16 |      *
17 |      * @return mixed
18 |      */
19 |     public function getNextVersion($current);
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Id/AutoGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Id;
 6 | 
 7 | use Doctrine\ODM\MongoDB\DocumentManager;
 8 | use MongoDB\BSON\ObjectId;
 9 | 
10 | /**
11 |  * AutoGenerator generates a native ObjectId
12 |  *
13 |  * @deprecated use ObjectIdGenerator instead
14 |  */
15 | final class AutoGenerator extends AbstractIdGenerator
16 | {
17 |     public function generate(DocumentManager $dm, object $document)
18 |     {
19 |         return new ObjectId();
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/SearchOperator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | /** @internal */
 8 | interface SearchOperator
 9 | {
10 |     /**
11 |      * @internal
12 |      *
13 |      * @return array<string, object>
14 |      */
15 |     public function getExpression(): array;
16 | 
17 |     /** @internal */
18 |     public function getOperatorName(): string;
19 | 
20 |     /** @internal */
21 |     public function getOperatorParams(): object;
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/Lock.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\ODM\MongoDB\Mapping\Attribute\Lock as LockAttribute;
 9 | 
10 | /**
11 |  * Specifies a field to use for pessimistic locking
12 |  *
13 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\Lock instead
14 |  *
15 |  * @Annotation
16 |  */
17 | #[Attribute(Attribute::TARGET_PROPERTY)]
18 | final class Lock extends LockAttribute implements Annotation
19 | {
20 | }
21 | 


--------------------------------------------------------------------------------
/UPGRADE-2.7.md:
--------------------------------------------------------------------------------
 1 | # UPGRADE FROM 2.6 to 2.7
 2 | 
 3 | ## Backward compatibility breaks
 4 | 
 5 | * `Doctrine\ODM\MongoDB\Mapping\Driver\AttributeDriver` no longer extends
 6 |   `Doctrine\ODM\MongoDB\Mapping\Driver\AnnotationDriver`.
 7 | 
 8 | ## doctrine/persistence
 9 | 
10 | * MongoDB ODM 2.7 requires `doctrine/persistence` 3.2 or newer.
11 | 
12 | ## `doctrine/annotations` is optional
13 | 
14 | ODM no longer requires `doctrine/annotations` to be installed. If you're using
15 | annotations for mapping, you will need to install `doctrine/annotations`.
16 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/DiscriminatorValue.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Use the specified discriminator for this class
11 |  *
12 |  * @final
13 |  */
14 | #[Attribute(Attribute::TARGET_CLASS)]
15 | class DiscriminatorValue implements MappingAttribute
16 | {
17 |     /** @var string */
18 |     public $value;
19 | 
20 |     public function __construct(string $value)
21 |     {
22 |         $this->value = $value;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/InheritanceType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Specifies which inheritance type to use for a document
11 |  *
12 |  * @final
13 |  */
14 | #[Attribute(Attribute::TARGET_CLASS)]
15 | class InheritanceType implements MappingAttribute
16 | {
17 |     /** @var string */
18 |     public $value;
19 | 
20 |     public function __construct(string $value)
21 |     {
22 |         $this->value = $value;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/SupportsNearOperator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | use GeoJson\Geometry\Point;
 8 | use MongoDB\BSON\UTCDateTime;
 9 | 
10 | interface SupportsNearOperator
11 | {
12 |     /**
13 |      * @param int|float|UTCDateTime|array<string, mixed>|Point|null $origin
14 |      * @param int|float|null                                        $pivot
15 |      */
16 |     public function near($origin = null, $pivot = null, string ...$path): Near;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/AbstractField.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use function class_exists;
 8 | 
 9 | class_exists(\Doctrine\ODM\MongoDB\Mapping\Attribute\AbstractField::class);
10 | 
11 | // @phpstan-ignore-next-line if.alwaysFalse
12 | if (false) {
13 |     /** @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\AbstractField instead */
14 |     abstract class AbstractField extends \Doctrine\ODM\MongoDB\Mapping\Attribute\AbstractField
15 |     {
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/AbstractIndex.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use function class_exists;
 8 | 
 9 | class_exists(\Doctrine\ODM\MongoDB\Mapping\Attribute\AbstractIndex::class);
10 | 
11 | // @phpstan-ignore-next-line if.alwaysFalse
12 | if (false) {
13 |     /** @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\AbstractIndex instead */
14 |     abstract class AbstractIndex extends \Doctrine\ODM\MongoDB\Mapping\Attribute\AbstractIndex
15 |     {
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/ChangeTrackingPolicy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Specifies the change tracking policy for a document
11 |  *
12 |  * @final
13 |  */
14 | #[Attribute(Attribute::TARGET_CLASS)]
15 | class ChangeTrackingPolicy implements MappingAttribute
16 | {
17 |     /** @var string */
18 |     public $value;
19 | 
20 |     public function __construct(string $value)
21 |     {
22 |         $this->value = $value;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/DiscriminatorField.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Specify a field name to store a discriminator value
11 |  *
12 |  * @final
13 |  */
14 | #[Attribute(Attribute::TARGET_CLASS)]
15 | class DiscriminatorField implements MappingAttribute
16 | {
17 |     /** @var string */
18 |     public $value;
19 | 
20 |     public function __construct(string $value)
21 |     {
22 |         $this->value = $value;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Repository/ViewRepository.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Repository;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Builder;
 8 | use Doctrine\Persistence\ObjectRepository;
 9 | 
10 | /**
11 |  * @template T of object
12 |  * @template-extends ObjectRepository<T>
13 |  */
14 | interface ViewRepository extends ObjectRepository
15 | {
16 |     /**
17 |      * Appends the aggregation pipeline to the given builder
18 |      */
19 |     public function createViewAggregation(Builder $builder): void;
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/Version.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\ODM\MongoDB\Mapping\Attribute\Version as VersionAttribute;
 9 | 
10 | /**
11 |  * Specifies a field to use for optimistic locking
12 |  *
13 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\Version instead
14 |  *
15 |  * @Annotation
16 |  */
17 | #[Attribute(Attribute::TARGET_PROPERTY)]
18 | final class Version extends VersionAttribute implements Annotation
19 | {
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/AlsoLoad.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Loads data from a different field if the original field is not set
11 |  *
12 |  * @final
13 |  */
14 | #[Attribute(Attribute::TARGET_PROPERTY | Attribute::TARGET_METHOD)]
15 | class AlsoLoad implements MappingAttribute
16 | {
17 |     /** @param string|string[] $value */
18 |     public function __construct(public $value, public ?string $name = null)
19 |     {
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/SupportsEmbeddableSearchOperators.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | interface SupportsEmbeddableSearchOperators extends SupportsAutocompleteOperator, SupportsCompoundOperator, SupportsEqualsOperator, SupportsExistsOperator, SupportsGeoShapeOperator, SupportsGeoWithinOperator, SupportsNearOperator, SupportsPhraseOperator, SupportsQueryStringOperator, SupportsRangeOperator, SupportsRegexOperator, SupportsTextOperator, SupportsWildcardOperator
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/SupportsGeoShapeOperator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | use GeoJson\Geometry\LineString;
 8 | use GeoJson\Geometry\MultiPolygon;
 9 | use GeoJson\Geometry\Point;
10 | use GeoJson\Geometry\Polygon;
11 | 
12 | interface SupportsGeoShapeOperator
13 | {
14 |     /** @param LineString|Point|Polygon|MultiPolygon|array<string, mixed>|null $geometry */
15 |     public function geoShape($geometry = null, string $relation = '', string ...$path): GeoShape;
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/AbstractDocument.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use function class_exists;
 8 | 
 9 | class_exists(\Doctrine\ODM\MongoDB\Mapping\Attribute\AbstractDocument::class);
10 | 
11 | // @phpstan-ignore-next-line if.alwaysFalse
12 | if (false) {
13 |     /** @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\AbstractDocument instead */
14 |     abstract class AbstractDocument extends \Doctrine\ODM\MongoDB\Mapping\Attribute\AbstractDocument
15 |     {
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/File/Length.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute\File;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\ODM\MongoDB\Mapping\Attribute\AbstractField;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\MappingAttribute;
10 | 
11 | /** @final */
12 | #[Attribute(Attribute::TARGET_PROPERTY)]
13 | class Length extends AbstractField implements MappingAttribute
14 | {
15 |     public function __construct()
16 |     {
17 |         parent::__construct('length', 'int', false, [], null, true);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/UPGRADE-2.5.md:
--------------------------------------------------------------------------------
 1 | # UPGRADE FROM 2.4 to 2.5
 2 | 
 3 | ## PHP requirements
 4 | 
 5 | * MongoDB ODM 2.5 requires PHP 7.4 or newer. If you're not running PHP 7.4 yet,
 6 |   it's recommended that you upgrade to PHP 7.4 before upgrading ODM.
 7 | 
 8 | ## `doctrine/collections` v2 compatibility
 9 | 
10 | ODM supports doctrine/collections 2.x along 1.x. Please note that we added
11 | `findFirst(...)` and `reduce(...)` methods to comply with the new `Collection`
12 | interface. Make sure signatures of new methods comply with your own ones,
13 | should you have implemented such methods before.
14 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/View.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\View as ViewAttribute;
10 | 
11 | /**
12 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\View instead
13 |  *
14 |  * @Annotation
15 |  * @NamedArgumentConstructor
16 |  */
17 | #[Attribute(Attribute::TARGET_CLASS)]
18 | final class View extends ViewAttribute implements Annotation
19 | {
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/File/ChunkSize.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute\File;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\ODM\MongoDB\Mapping\Attribute\AbstractField;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\MappingAttribute;
10 | 
11 | /** @final */
12 | #[Attribute(Attribute::TARGET_PROPERTY)]
13 | class ChunkSize extends AbstractField implements MappingAttribute
14 | {
15 |     public function __construct()
16 |     {
17 |         parent::__construct('chunkSize', 'int', false, [], null, true);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/File/Filename.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute\File;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\ODM\MongoDB\Mapping\Attribute\AbstractField;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\MappingAttribute;
10 | 
11 | /** @final */
12 | #[Attribute(Attribute::TARGET_PROPERTY)]
13 | class Filename extends AbstractField implements MappingAttribute
14 | {
15 |     public function __construct()
16 |     {
17 |         parent::__construct('filename', 'string', false, [], null, true);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/UPGRADE-2.1.md:
--------------------------------------------------------------------------------
 1 | # UPGRADE FROM 2.0 to 2.1
 2 | 
 3 | ## ID generators
 4 | 
 5 | The `Doctrine\ODM\MongoDB\Id\AbstractIdGenerator` class has been deprecated.
 6 | Custom ID generators must implement the `Doctrine\ODM\MongoDB\Id\IdGenerator`
 7 | interface.
 8 | 
 9 | ## Metadata
10 | 
11 | The `Doctrine\ODM\MongoDB\Mapping\ClassMetadata` class has been marked final and
12 | will no longer be extendable in 3.0.
13 | 
14 | The `boolean`, `integer`, and `int_id` mapping types have been deprecated. Use
15 | the `bool`, `int`, and `int` types, respectively. These types behave exactly the
16 | same.
17 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/File/UploadDate.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute\File;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\ODM\MongoDB\Mapping\Attribute\AbstractField;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\MappingAttribute;
10 | 
11 | /** @final */
12 | #[Attribute(Attribute::TARGET_PROPERTY)]
13 | class UploadDate extends AbstractField implements MappingAttribute
14 | {
15 |     public function __construct()
16 |     {
17 |         parent::__construct('uploadDate', 'date', false, [], null, true);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/PersistentCollection/DefaultPersistentCollectionFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\PersistentCollection;
 6 | 
 7 | use Doctrine\Common\Collections\Collection as BaseCollection;
 8 | 
 9 | /**
10 |  * Default factory class for persistent collection classes.
11 |  */
12 | final class DefaultPersistentCollectionFactory extends AbstractPersistentCollectionFactory
13 | {
14 |     protected function createCollectionClass(string $collectionClass): BaseCollection
15 |     {
16 |         return new $collectionClass();
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Event/ManagerEventArgs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Event;
 6 | 
 7 | use Doctrine\ODM\MongoDB\DocumentManager;
 8 | use Doctrine\Persistence\Event\ManagerEventArgs as BaseManagerEventArgs;
 9 | 
10 | /**
11 |  * Provides event arguments for the flush events.
12 |  *
13 |  * @template-extends BaseManagerEventArgs<DocumentManager>
14 |  */
15 | class ManagerEventArgs extends BaseManagerEventArgs
16 | {
17 |     public function getDocumentManager(): DocumentManager
18 |     {
19 |         return $this->getObjectManager();
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Types/ClosureToPHP.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | use function sprintf;
 8 | 
 9 | /** This trait will be deprecated in 3.0 as this behavior will be used by default */
10 | trait ClosureToPHP
11 | {
12 |     /** @return string Redirects to the method convertToPHPValue from child class */
13 |     final public function closureToPHP(): string
14 |     {
15 |         return sprintf('
16 |             $type = \%s::getType($typeIdentifier);
17 |             $return = $type->convertToPHPValue($value);', Type::class);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/UPGRADE-2.6.md:
--------------------------------------------------------------------------------
 1 | # UPGRADE FROM to 2.6
 2 | 
 3 | ## PHP requirements
 4 | 
 5 | * MongoDB ODM 2.6 requires PHP 8.1 or newer. If you're not running PHP 8.1 yet,
 6 |   it's recommended that you upgrade to PHP 8.1 before upgrading ODM.
 7 | 
 8 | ## `Match` classes were removed
 9 | 
10 | Minimal requirement of PHP 8.1 has rendered `Match` classes useless as one may
11 | not use them for backward compatibility purposes as `match` is a reserved keyword.
12 | 
13 | Following classes were removed:
14 | - `\Doctrine\ODM\MongoDB\Aggregation\Stage\GraphLookup\Match`
15 | - `\Doctrine\ODM\MongoDB\Aggregation\Stage\Match`
16 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/SupportsCompoundableSearchOperators.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | interface SupportsCompoundableSearchOperators extends SupportsAutocompleteOperator, SupportsEmbeddedDocumentOperator, SupportsEqualsOperator, SupportsExistsOperator, SupportsGeoShapeOperator, SupportsGeoWithinOperator, SupportsMoreLikeThisOperator, SupportsNearOperator, SupportsPhraseOperator, SupportsQueryStringOperator, SupportsRangeOperator, SupportsRegexOperator, SupportsTextOperator, SupportsWildcardOperator
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/ShardKey.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\ShardKey as ShardKeyAttribute;
10 | 
11 | /**
12 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\ShardKey instead
13 |  *
14 |  * @Annotation
15 |  * @NamedArgumentConstructor
16 |  */
17 | #[Attribute(Attribute::TARGET_CLASS)]
18 | final class ShardKey extends ShardKeyAttribute implements Annotation
19 | {
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/ReplaceWith.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Expr;
 8 | 
 9 | /**
10 |  * @phpstan-import-type OperatorExpression from Expr
11 |  * @phpstan-type ReplaceWithStageExpression array{"$replaceWith": OperatorExpression|string}
12 |  */
13 | class ReplaceWith extends AbstractReplace
14 | {
15 |     /** @return ReplaceWithStageExpression */
16 |     public function getExpression(): array
17 |     {
18 |         return ['$replaceWith' => $this->getReplaceExpression()];
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/SupportsAllSearchOperators.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | interface SupportsAllSearchOperators extends SupportsAutocompleteOperator, SupportsCompoundOperator, SupportsEmbeddedDocumentOperator, SupportsEqualsOperator, SupportsExistsOperator, SupportsGeoShapeOperator, SupportsGeoWithinOperator, SupportsMoreLikeThisOperator, SupportsNearOperator, SupportsPhraseOperator, SupportsQueryStringOperator, SupportsRangeOperator, SupportsRegexOperator, SupportsTextOperator, SupportsWildcardOperator
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/EmbeddedDocument.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Identifies a class as a document that can be embedded but not stored by itself
11 |  *
12 |  * @final
13 |  */
14 | #[Attribute(Attribute::TARGET_CLASS)]
15 | class EmbeddedDocument extends AbstractDocument
16 | {
17 |     /** @var Index[] */
18 |     public $indexes;
19 | 
20 |     /** @param Index[] $indexes */
21 |     public function __construct(array $indexes = [])
22 |     {
23 |         $this->indexes = $indexes;
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/APM/CommandLoggerInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\APM;
 6 | 
 7 | use MongoDB\Driver\Monitoring\CommandSubscriber;
 8 | 
 9 | interface CommandLoggerInterface extends CommandSubscriber
10 | {
11 |     /**
12 |      * Registers this command logger instance with the MongoDB library so it can receive command events
13 |      */
14 |     public function register(): void;
15 | 
16 |     /**
17 |      * Unregisters this command logger instance with the MongoDB library so it no longer receives command events
18 |      */
19 |     public function unregister(): void;
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/ReadPreference.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /** @final */
10 | #[Attribute(Attribute::TARGET_CLASS)]
11 | class ReadPreference implements MappingAttribute
12 | {
13 |     /** @var string */
14 |     public $value;
15 | 
16 |     /** @var string[][]|null */
17 |     public $tags;
18 | 
19 |     /** @param string[][]|null $tags */
20 |     public function __construct(string $value, ?array $tags = null)
21 |     {
22 |         $this->value = $value;
23 |         $this->tags  = $tags;
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/Id.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\Id as IdAttribute;
10 | 
11 | /**
12 |  * Special field mapping to map document identifiers
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\Id instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_PROPERTY)]
20 | final class Id extends IdAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/DiscriminatorMap.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Specify a map of discriminator values and classes
11 |  *
12 |  * @final
13 |  */
14 | #[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_PROPERTY)]
15 | class DiscriminatorMap implements MappingAttribute
16 | {
17 |     /** @var array<class-string> */
18 |     public $value;
19 | 
20 |     /** @param array<class-string> $value */
21 |     public function __construct(array $value)
22 |     {
23 |         $this->value = $value;
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/Field.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\Field as FieldAttribute;
10 | 
11 | /**
12 |  * Specifies a generic field mapping
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\Field instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_PROPERTY)]
20 | final class Field extends FieldAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/ReadPreference.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\ReadPreference as ReadPreferenceAttribute;
10 | 
11 | /**
12 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\ReadPreference instead
13 |  *
14 |  * @Annotation
15 |  * @NamedArgumentConstructor
16 |  */
17 | #[Attribute(Attribute::TARGET_CLASS)]
18 | final class ReadPreference extends ReadPreferenceAttribute implements Annotation
19 | {
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/Validation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\Validation as ValidationAttribute;
10 | 
11 | /**
12 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\Validation instead
13 |  *
14 |  * @Annotation
15 |  * @NamedArgumentConstructor
16 |  * @Target({"CLASS"})
17 |  */
18 | #[Attribute(Attribute::TARGET_CLASS)]
19 | final class Validation extends ValidationAttribute implements Annotation
20 | {
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Types/RawType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | /**
 8 |  * Raw data type.
 9 |  */
10 | class RawType extends Type
11 | {
12 |     public function convertToDatabaseValue($value)
13 |     {
14 |         return $value;
15 |     }
16 | 
17 |     public function convertToPHPValue($value)
18 |     {
19 |         return $value;
20 |     }
21 | 
22 |     public function closureToMongo(): string
23 |     {
24 |         return '$return = $value;';
25 |     }
26 | 
27 |     public function closureToPHP(): string
28 |     {
29 |         return '$return = $value;';
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/EmbedOne.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\EmbedOne as EmbedOneAttribute;
10 | 
11 | /**
12 |  * Embeds a single document
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\EmbedOne instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_PROPERTY)]
20 | final class EmbedOne extends EmbedOneAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Types/CustomIdType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | /**
 8 |  * The Id type.
 9 |  */
10 | class CustomIdType extends Type
11 | {
12 |     public function convertToDatabaseValue($value)
13 |     {
14 |         return $value;
15 |     }
16 | 
17 |     public function convertToPHPValue($value)
18 |     {
19 |         return $value;
20 |     }
21 | 
22 |     public function closureToMongo(): string
23 |     {
24 |         return '$return = $value;';
25 |     }
26 | 
27 |     public function closureToPHP(): string
28 |     {
29 |         return '$return = $value;';
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/DefaultDiscriminatorValue.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Specifies a default discriminator value to be used when the discriminator
11 |  * field is not set in a document
12 |  *
13 |  * @final
14 |  */
15 | #[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_PROPERTY)]
16 | class DefaultDiscriminatorValue implements MappingAttribute
17 | {
18 |     /** @var string */
19 |     public $value;
20 | 
21 |     public function __construct(string $value)
22 |     {
23 |         $this->value = $value;
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Proxy/FileLocator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Proxy;
 6 | 
 7 | use ProxyManager\FileLocator\FileLocator as BaseFileLocator;
 8 | 
 9 | use function mkdir;
10 | use function realpath;
11 | 
12 | /** @internal */
13 | final class FileLocator extends BaseFileLocator
14 | {
15 |     public function __construct(string $proxiesDirectory)
16 |     {
17 |         $absolutePath = realpath($proxiesDirectory);
18 | 
19 |         if ($absolutePath === false) {
20 |             mkdir($proxiesDirectory, 0775, true);
21 |         }
22 | 
23 |         parent::__construct($proxiesDirectory);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/IndexStats.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Stage;
 8 | use stdClass;
 9 | 
10 | /**
11 |  * Fluent interface for adding a $indexStats stage to an aggregation pipeline.
12 |  *
13 |  * @phpstan-type IndexStatsStageExpression array{"$indexStats": object}
14 |  */
15 | class IndexStats extends Stage
16 | {
17 |     /** @phpstan-return IndexStatsStageExpression */
18 |     public function getExpression(): array
19 |     {
20 |         return [
21 |             '$indexStats' => new stdClass(),
22 |         ];
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/EmbedMany.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\EmbedMany as EmbedManyAttribute;
10 | 
11 | /**
12 |  * Embeds multiple documents
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\EmbedMany instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_PROPERTY)]
20 | final class EmbedMany extends EmbedManyAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Redact.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Expr;
 8 | 
 9 | /**
10 |  * Fluent interface for adding a $redact stage to an aggregation pipeline.
11 |  *
12 |  * @phpstan-import-type OperatorExpression from Expr
13 |  * @phpstan-type SetStageExpression array{"$redact": array<string, OperatorExpression|mixed>}
14 |  */
15 | class Redact extends Operator
16 | {
17 |     public function getExpression(): array
18 |     {
19 |         return [
20 |             '$redact' => $this->expr->getExpression(),
21 |         ];
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/PreLoad.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\PreLoad as PreLoadAttribute;
10 | 
11 | /**
12 |  * Marks a method as a preLoad lifecycle callback
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\PreLoad instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_METHOD)]
20 | final class PreLoad extends PreLoadAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/File.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\File as FileAttribute;
10 | 
11 | /**
12 |  * Identifies a class as a GridFS file that can be stored in the database
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\File instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_CLASS)]
20 | final class File extends FileAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/PostLoad.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\PostLoad as PostLoadAttribute;
10 | 
11 | /**
12 |  * Marks a method as a postLoad lifecycle callback
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\PostLoad instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_METHOD)]
20 | final class PostLoad extends PostLoadAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/PreFlush.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\PreFlush as PreFlushAttribute;
10 | 
11 | /**
12 |  * Marks a method as a preFlush lifecycle callback
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\PreFlush instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_METHOD)]
20 | final class PreFlush extends PreFlushAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/QueryResultDocument.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\QueryResultDocument as QueryResultDocumentAttribute;
10 | 
11 | /**
12 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\QueryResultDocument instead
13 |  *
14 |  * @Annotation
15 |  * @NamedArgumentConstructor
16 |  */
17 | #[Attribute(Attribute::TARGET_CLASS)]
18 | final class QueryResultDocument extends QueryResultDocumentAttribute implements Annotation
19 | {
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/File/Length.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations\File;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Annotations\Annotation;
10 | use Doctrine\ODM\MongoDB\Mapping\Attribute\File\Length as LengthAttribute;
11 | 
12 | /**
13 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\File\Length instead
14 |  *
15 |  * @Annotation
16 |  * @NamedArgumentConstructor
17 |  */
18 | #[Attribute(Attribute::TARGET_PROPERTY)]
19 | final class Length extends LengthAttribute implements Annotation
20 | {
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/PreRemove.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\PreRemove as PreRemoveAttribute;
10 | 
11 | /**
12 |  * Marks a method as a preRemove lifecycle callback
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\PreRemove instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_METHOD)]
20 | final class PreRemove extends PreRemoveAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/PreUpdate.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\PreUpdate as PreUpdateAttribute;
10 | 
11 | /**
12 |  * Marks a method as a preUpdate lifecycle callback
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\PreUpdate instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_METHOD)]
20 | final class PreUpdate extends PreUpdateAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Set.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Expr;
 8 | 
 9 | /**
10 |  * Fluent interface for adding a $set stage to an aggregation pipeline.
11 |  *
12 |  * @phpstan-import-type OperatorExpression from Expr
13 |  * @phpstan-type SetStageExpression array{"$set": array<string, OperatorExpression|mixed>}
14 |  * @final
15 |  */
16 | class Set extends Operator
17 | {
18 |     /** @phpstan-return SetStageExpression */
19 |     public function getExpression(): array
20 |     {
21 |         return ['$set' => $this->expr->getExpression()];
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/PostRemove.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\PostRemove as PostRemoveAttribute;
10 | 
11 | /**
12 |  * Marks a method as a postRemove lifecycle callback
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\PostRemove instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_METHOD)]
20 | final class PostRemove extends PostRemoveAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/PostUpdate.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\PostUpdate as PostUpdateAttribute;
10 | 
11 | /**
12 |  * Marks a method as a postUpdate lifecycle callback
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\PostUpdate instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_METHOD)]
20 | final class PostUpdate extends PostUpdateAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/PrePersist.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\PrePersist as PrePersistAttribute;
10 | 
11 | /**
12 |  * Marks a method as a prePersist lifecycle callback
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\PrePersist instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_METHOD)]
20 | final class PrePersist extends PrePersistAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/Document.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\Document as DocumentAttribute;
10 | 
11 | /**
12 |  * Identifies a class as a document that can be stored in the database
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\Document instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_CLASS)]
20 | final class Document extends DocumentAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/Index.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\Index as IndexAttribute;
10 | 
11 | /**
12 |  * Defines an index on a field
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\Index instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
20 | final class Index extends IndexAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/File/Filename.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations\File;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Annotations\Annotation;
10 | use Doctrine\ODM\MongoDB\Mapping\Attribute\File\Filename as FilenameAttribute;
11 | 
12 | /**
13 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\File\Filename instead
14 |  *
15 |  * @Annotation
16 |  * @NamedArgumentConstructor
17 |  */
18 | #[Attribute(Attribute::TARGET_PROPERTY)]
19 | final class Filename extends FilenameAttribute implements Annotation
20 | {
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/File/Metadata.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations\File;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Annotations\Annotation;
10 | use Doctrine\ODM\MongoDB\Mapping\Attribute\File\Metadata as MetadataAttribute;
11 | 
12 | /**
13 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\File\Metadata instead
14 |  *
15 |  * @Annotation
16 |  * @NamedArgumentConstructor
17 |  */
18 | #[Attribute(Attribute::TARGET_PROPERTY)]
19 | final class Metadata extends MetadataAttribute implements Annotation
20 | {
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/PostPersist.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\PostPersist as PostPersistAttribute;
10 | 
11 | /**
12 |  * Marks a method as a postPersist lifecycle callback
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\PostPersist instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_METHOD)]
20 | final class PostPersist extends PostPersistAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/TimeSeries.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\TimeSeries as TimeSeriesAttribute;
10 | 
11 | /**
12 |  * Marks a document or superclass as a time series document
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\TimeSeries instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_CLASS)]
20 | final class TimeSeries extends TimeSeriesAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Types/Int64Type.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | use MongoDB\BSON\Int64;
 8 | 
 9 | /**
10 |  * The Int64 type (long)
11 |  */
12 | class Int64Type extends IntType implements Incrementable, Versionable
13 | {
14 |     /** @return Int64|null */
15 |     public function convertToDatabaseValue($value)
16 |     {
17 |         if ($value instanceof Int64 || $value === null) {
18 |             return $value;
19 |         }
20 | 
21 |         return new Int64($value);
22 |     }
23 | 
24 |     public function closureToMongo(): string
25 |     {
26 |         return '$return = new \MongoDB\BSON\Int64($value);';
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/File/ChunkSize.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations\File;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Annotations\Annotation;
10 | use Doctrine\ODM\MongoDB\Mapping\Attribute\File\ChunkSize as ChunkSizeAttribute;
11 | 
12 | /**
13 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\File\ChunkSize instead
14 |  *
15 |  * @Annotation
16 |  * @NamedArgumentConstructor
17 |  */
18 | #[Attribute(Attribute::TARGET_PROPERTY)]
19 | final class ChunkSize extends ChunkSizeAttribute implements Annotation
20 | {
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/Indexes.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation as BaseAnnotation;
 9 | 
10 | /**
11 |  * Specifies a list of indexes for a document
12 |  *
13 |  * @deprecated class was deprecated in doctrine/mongodb-odm 2.2 and will be removed in 3.0. Specify all Index and UniqueIndex annotations on a class level.
14 |  *
15 |  * @Annotation
16 |  */
17 | #[Attribute(Attribute::TARGET_CLASS)]
18 | final class Indexes extends BaseAnnotation implements Annotation
19 | {
20 |     /** @var AbstractIndex[]|AbstractIndex */
21 |     public $value = [];
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Repository/RepositoryFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Repository;
 6 | 
 7 | use Doctrine\ODM\MongoDB\DocumentManager;
 8 | use Doctrine\Persistence\ObjectRepository;
 9 | 
10 | /**
11 |  * Interface for document repository factory.
12 |  */
13 | interface RepositoryFactory
14 | {
15 |     /**
16 |      * Gets the repository for a document class.
17 |      *
18 |      * @param class-string<T> $documentName
19 |      *
20 |      * @return ObjectRepository<T>
21 |      *
22 |      * @template T of object
23 |      */
24 |     public function getRepository(DocumentManager $documentManager, string $documentName): ObjectRepository;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/File/UploadDate.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations\File;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Annotations\Annotation;
10 | use Doctrine\ODM\MongoDB\Mapping\Attribute\File\UploadDate as UploadDateAttribute;
11 | 
12 | /**
13 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\File\UploadDate instead
14 |  *
15 |  * @Annotation
16 |  * @NamedArgumentConstructor
17 |  */
18 | #[Attribute(Attribute::TARGET_PROPERTY)]
19 | final class UploadDate extends UploadDateAttribute implements Annotation
20 | {
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/ReferenceOne.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\ReferenceOne as ReferenceOneAttribute;
10 | 
11 | /**
12 |  * Specifies a one-to-one relationship to a different document
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\ReferenceOne instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_PROPERTY)]
20 | final class ReferenceOne extends ReferenceOneAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/AddFields.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Expr;
 8 | 
 9 | /**
10 |  * Fluent interface for adding a $addFields stage to an aggregation pipeline.
11 |  *
12 |  * @phpstan-import-type OperatorExpression from Expr
13 |  * @phpstan-type AddFieldsStageExpression array{"$addFields": array<string, OperatorExpression|mixed>}
14 |  * @final
15 |  */
16 | class AddFields extends Operator
17 | {
18 |     /** @return AddFieldsStageExpression */
19 |     public function getExpression(): array
20 |     {
21 |         return ['$addFields' => $this->expr->getExpression()];
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/Compound/CompoundedNear.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search\Compound;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundedSearchOperatorTrait;
 8 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundSearchOperatorInterface;
 9 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\Near;
10 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\SupportsCompoundableOperatorsTrait;
11 | 
12 | /** @internal */
13 | class CompoundedNear extends Near implements CompoundSearchOperatorInterface
14 | {
15 |     use CompoundedSearchOperatorTrait;
16 |     use SupportsCompoundableOperatorsTrait;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/Compound/CompoundedText.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search\Compound;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundedSearchOperatorTrait;
 8 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundSearchOperatorInterface;
 9 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\SupportsCompoundableOperatorsTrait;
10 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\Text;
11 | 
12 | /** @internal */
13 | class CompoundedText extends Text implements CompoundSearchOperatorInterface
14 | {
15 |     use CompoundedSearchOperatorTrait;
16 |     use SupportsCompoundableOperatorsTrait;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/Compound/CompoundedEquals.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search\Compound;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundedSearchOperatorTrait;
 8 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundSearchOperatorInterface;
 9 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\Equals;
10 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\SupportsCompoundableOperatorsTrait;
11 | 
12 | /** @internal */
13 | class CompoundedEquals extends Equals implements CompoundSearchOperatorInterface
14 | {
15 |     use CompoundedSearchOperatorTrait;
16 |     use SupportsCompoundableOperatorsTrait;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/Compound/CompoundedExists.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search\Compound;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundedSearchOperatorTrait;
 8 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundSearchOperatorInterface;
 9 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\Exists;
10 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\SupportsCompoundableOperatorsTrait;
11 | 
12 | /** @internal */
13 | class CompoundedExists extends Exists implements CompoundSearchOperatorInterface
14 | {
15 |     use CompoundedSearchOperatorTrait;
16 |     use SupportsCompoundableOperatorsTrait;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/Compound/CompoundedPhrase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search\Compound;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundedSearchOperatorTrait;
 8 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundSearchOperatorInterface;
 9 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\Phrase;
10 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\SupportsCompoundableOperatorsTrait;
11 | 
12 | /** @internal */
13 | class CompoundedPhrase extends Phrase implements CompoundSearchOperatorInterface
14 | {
15 |     use CompoundedSearchOperatorTrait;
16 |     use SupportsCompoundableOperatorsTrait;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/Compound/CompoundedRange.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search\Compound;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundedSearchOperatorTrait;
 8 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundSearchOperatorInterface;
 9 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\Range;
10 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\SupportsCompoundableOperatorsTrait;
11 | 
12 | /** @internal */
13 | class CompoundedRange extends Range implements CompoundSearchOperatorInterface
14 | {
15 |     use CompoundedSearchOperatorTrait;
16 |     use SupportsCompoundableOperatorsTrait;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/Compound/CompoundedRegex.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search\Compound;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundedSearchOperatorTrait;
 8 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundSearchOperatorInterface;
 9 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\Regex;
10 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\SupportsCompoundableOperatorsTrait;
11 | 
12 | /** @internal */
13 | class CompoundedRegex extends Regex implements CompoundSearchOperatorInterface
14 | {
15 |     use CompoundedSearchOperatorTrait;
16 |     use SupportsCompoundableOperatorsTrait;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/AlsoLoad.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\AlsoLoad as AlsoLoadAttribute;
10 | 
11 | /**
12 |  * Loads data from a different field if the original field is not set
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\AlsoLoad instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_PROPERTY | Attribute::TARGET_METHOD)]
20 | final class AlsoLoad extends AlsoLoadAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/HasLifecycleCallbacks.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\ODM\MongoDB\Mapping\Attribute\HasLifecycleCallbacks as HasLifecycleCallbacksAttribute;
 9 | 
10 | /**
11 |  * Must be set on a document class to instruct Doctrine to check for lifecycle
12 |  * callback annotations on public methods.
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\HasLifecycleCallbacks instead
15 |  *
16 |  * @Annotation
17 |  */
18 | #[Attribute(Attribute::TARGET_CLASS)]
19 | final class HasLifecycleCallbacks extends HasLifecycleCallbacksAttribute implements Annotation
20 | {
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/InheritanceType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\InheritanceType as InheritanceTypeAttribute;
10 | 
11 | /**
12 |  * Specifies which inheritance type to use for a document
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\InheritanceType instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_CLASS)]
20 | final class InheritanceType extends InheritanceTypeAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/ReferenceMany.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\ReferenceMany as ReferenceManyAttribute;
10 | 
11 | /**
12 |  * Specifies a one-to-many relationship to a different document
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\ReferenceMany instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_PROPERTY)]
20 | final class ReferenceMany extends ReferenceManyAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Hydrator/HydratorInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Hydrator;
 6 | 
 7 | use Doctrine\ODM\MongoDB\UnitOfWork;
 8 | 
 9 | /**
10 |  * The HydratorInterface defines methods all hydrator need to implement
11 |  *
12 |  * @phpstan-import-type Hints from UnitOfWork
13 |  */
14 | interface HydratorInterface
15 | {
16 |     /**
17 |      * Hydrate array of MongoDB document data into the given document object.
18 |      *
19 |      * @param array<string, mixed> $data
20 |      * @phpstan-param Hints $hints
21 |      *
22 |      * @return array<string, mixed>
23 |      */
24 |     public function hydrate(object $document, array $data, array $hints = []): array;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/Compound/CompoundedGeoShape.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search\Compound;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundedSearchOperatorTrait;
 8 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundSearchOperatorInterface;
 9 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\GeoShape;
10 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\SupportsCompoundableOperatorsTrait;
11 | 
12 | /** @internal */
13 | class CompoundedGeoShape extends GeoShape implements CompoundSearchOperatorInterface
14 | {
15 |     use CompoundedSearchOperatorTrait;
16 |     use SupportsCompoundableOperatorsTrait;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/Compound/CompoundedWildcard.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search\Compound;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundedSearchOperatorTrait;
 8 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundSearchOperatorInterface;
 9 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\SupportsCompoundableOperatorsTrait;
10 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\Wildcard;
11 | 
12 | /** @internal */
13 | class CompoundedWildcard extends Wildcard implements CompoundSearchOperatorInterface
14 | {
15 |     use CompoundedSearchOperatorTrait;
16 |     use SupportsCompoundableOperatorsTrait;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/DiscriminatorValue.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\DiscriminatorValue as DiscriminatorValueAttribute;
10 | 
11 | /**
12 |  * Use the specified discriminator for this class
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\DiscriminatorValue instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_CLASS)]
20 | final class DiscriminatorValue extends DiscriminatorValueAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/Compound/CompoundedGeoWithin.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search\Compound;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundedSearchOperatorTrait;
 8 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundSearchOperatorInterface;
 9 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\GeoWithin;
10 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\SupportsCompoundableOperatorsTrait;
11 | 
12 | /** @internal */
13 | class CompoundedGeoWithin extends GeoWithin implements CompoundSearchOperatorInterface
14 | {
15 |     use CompoundedSearchOperatorTrait;
16 |     use SupportsCompoundableOperatorsTrait;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/DiscriminatorField.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\DiscriminatorField as DiscriminatorFieldAttribute;
10 | 
11 | /**
12 |  * Specify a field name to store a discriminator value
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\DiscriminatorField instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_CLASS)]
20 | final class DiscriminatorField extends DiscriminatorFieldAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/UniqueIndex.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\UniqueIndex as UniqueIndexAttribute;
10 | 
11 | /**
12 |  * Specifies a unique index on a field
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\UniqueIndex instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
20 | final class UniqueIndex extends UniqueIndexAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/Compound/CompoundedQueryString.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search\Compound;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundedSearchOperatorTrait;
 8 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundSearchOperatorInterface;
 9 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\QueryString;
10 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\SupportsCompoundableOperatorsTrait;
11 | 
12 | /** @internal */
13 | class CompoundedQueryString extends QueryString implements CompoundSearchOperatorInterface
14 | {
15 |     use CompoundedSearchOperatorTrait;
16 |     use SupportsCompoundableOperatorsTrait;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/Compound/CompoundedAutocomplete.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search\Compound;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\Autocomplete;
 8 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundedSearchOperatorTrait;
 9 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundSearchOperatorInterface;
10 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\SupportsCompoundableOperatorsTrait;
11 | 
12 | /** @internal */
13 | class CompoundedAutocomplete extends Autocomplete implements CompoundSearchOperatorInterface
14 | {
15 |     use CompoundedSearchOperatorTrait;
16 |     use SupportsCompoundableOperatorsTrait;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/Compound/CompoundedMoreLikeThis.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search\Compound;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundedSearchOperatorTrait;
 8 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundSearchOperatorInterface;
 9 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\MoreLikeThis;
10 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\SupportsCompoundableOperatorsTrait;
11 | 
12 | /** @internal */
13 | class CompoundedMoreLikeThis extends MoreLikeThis implements CompoundSearchOperatorInterface
14 | {
15 |     use CompoundedSearchOperatorTrait;
16 |     use SupportsCompoundableOperatorsTrait;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Event/LoadClassMetadataEventArgs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Event;
 6 | 
 7 | use Doctrine\ODM\MongoDB\DocumentManager;
 8 | use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
 9 | use Doctrine\Persistence\Event\LoadClassMetadataEventArgs as BaseLoadClassMetadataEventArgs;
10 | 
11 | /**
12 |  * Class that holds event arguments for a loadMetadata event.
13 |  *
14 |  * @template-extends BaseLoadClassMetadataEventArgs<ClassMetadata<object>, DocumentManager>
15 |  */
16 | final class LoadClassMetadataEventArgs extends BaseLoadClassMetadataEventArgs
17 | {
18 |     public function getDocumentManager(): DocumentManager
19 |     {
20 |         return $this->getObjectManager();
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/ChangeTrackingPolicy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\ChangeTrackingPolicy as ChangeTrackingPolicyAttribute;
10 | 
11 | /**
12 |  * Specifies the change tracking policy for a document
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\ChangeTrackingPolicy instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_CLASS)]
20 | final class ChangeTrackingPolicy extends ChangeTrackingPolicyAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/DiscriminatorMap.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\DiscriminatorMap as DiscriminatorMapAttribute;
10 | 
11 | /**
12 |  * Specify a map of discriminator values and classes
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\DiscriminatorMap instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_PROPERTY)]
20 | final class DiscriminatorMap extends DiscriminatorMapAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/EmbeddedDocument.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\EmbeddedDocument as EmbeddedDocumentAttribute;
10 | 
11 | /**
12 |  * Identifies a class as a document that can be embedded but not stored by itself
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\EmbeddedDocument instead
15 |  *
16 |  * @Annotation
17 |  * @NamedArgumentConstructor
18 |  */
19 | #[Attribute(Attribute::TARGET_CLASS)]
20 | final class EmbeddedDocument extends EmbeddedDocumentAttribute implements Annotation
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Mapping/Driver/SimplifiedXmlDriver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Driver;
 6 | 
 7 | use Doctrine\Persistence\Mapping\Driver\SymfonyFileLocator;
 8 | 
 9 | /**
10 |  * XmlDriver that additionally looks for mapping information in a global file.
11 |  */
12 | class SimplifiedXmlDriver extends XmlDriver
13 | {
14 |     public const DEFAULT_FILE_EXTENSION = '.mongodb-odm.xml';
15 | 
16 |     /** @param string[] $prefixes */
17 |     public function __construct($prefixes, $fileExtension = self::DEFAULT_FILE_EXTENSION)
18 |     {
19 |         $locator = new SymfonyFileLocator((array) $prefixes, $fileExtension);
20 | 
21 |         parent::__construct($locator, $fileExtension);
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/PersistentCollection/PersistentCollectionGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\PersistentCollection;
 6 | 
 7 | /**
 8 |  * Interface for PersistentCollection classes generator.
 9 |  */
10 | interface PersistentCollectionGenerator
11 | {
12 |     /**
13 |      * Loads persistent collection class.
14 |      *
15 |      * @param string $collectionClass FQCN of base collection class
16 |      *
17 |      * @return string FQCN of generated class
18 |      */
19 |     public function loadClass(string $collectionClass, int $autoGenerate): string;
20 | 
21 |     /**
22 |      * Generates persistent collection class.
23 |      */
24 |     public function generateClass(string $class, string $dir): void;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/MappedSuperclass.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\MappedSuperclass as MappedSuperclassAttribute;
10 | 
11 | /**
12 |  * Specifies a parent class that other documents may extend to inherit mapping
13 |  * information
14 |  *
15 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\MappedSuperclass instead
16 |  *
17 |  * @Annotation
18 |  * @NamedArgumentConstructor
19 |  */
20 | #[Attribute(Attribute::TARGET_CLASS)]
21 | final class MappedSuperclass extends MappedSuperclassAttribute implements Annotation
22 | {
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/ReplaceRoot.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Expr;
 8 | 
 9 | /**
10 |  * @phpstan-import-type OperatorExpression from Expr
11 |  * @phpstan-type ReplaceRootStageExpression array{
12 |  *     "$replaceRoot": array{
13 |  *         newRoot: OperatorExpression|string,
14 |  *     }
15 |  * }
16 |  */
17 | class ReplaceRoot extends AbstractReplace
18 | {
19 |     /** @return ReplaceRootStageExpression */
20 |     public function getExpression(): array
21 |     {
22 |         return [
23 |             '$replaceRoot' => [
24 |                 'newRoot' => $this->getReplaceExpression(),
25 |             ],
26 |         ];
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Repository/DefaultRepositoryFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Repository;
 6 | 
 7 | use Doctrine\ODM\MongoDB\DocumentManager;
 8 | use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
 9 | use Doctrine\Persistence\ObjectRepository;
10 | 
11 | /**
12 |  * This factory is used to create default repository objects for documents at runtime.
13 |  */
14 | final class DefaultRepositoryFactory extends AbstractRepositoryFactory
15 | {
16 |     protected function instantiateRepository(string $repositoryClassName, DocumentManager $documentManager, ClassMetadata $metadata): ObjectRepository
17 |     {
18 |         return new $repositoryClassName($documentManager, $documentManager->getUnitOfWork(), $metadata);
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Proxy/Factory/ProxyFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Proxy\Factory;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
 8 | 
 9 | interface ProxyFactory
10 | {
11 |     /** @param ClassMetadata<object>[] $classes */
12 |     public function generateProxyClasses(array $classes): int;
13 | 
14 |     /**
15 |      * Gets a reference proxy instance for the entity of the given type and identified by
16 |      * the given identifier.
17 |      *
18 |      * @param mixed $identifier
19 |      * @phpstan-param ClassMetadata<T> $metadata
20 |      *
21 |      * @return T
22 |      *
23 |      * @template T of object
24 |      */
25 |     public function getProxy(ClassMetadata $metadata, $identifier): object;
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Skip.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Builder;
 8 | use Doctrine\ODM\MongoDB\Aggregation\Stage;
 9 | 
10 | /**
11 |  * Fluent interface for adding a $skip stage to an aggregation pipeline.
12 |  *
13 |  * @phpstan-type SkipStageExpression array{"$skip": int}
14 |  */
15 | class Skip extends Stage
16 | {
17 |     public function __construct(Builder $builder, private int $skip)
18 |     {
19 |         parent::__construct($builder);
20 |     }
21 | 
22 |     /** @return SkipStageExpression */
23 |     public function getExpression(): array
24 |     {
25 |         return [
26 |             '$skip' => $this->skip,
27 |         ];
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/MappedSuperclass.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Specifies a parent class that other documents may extend to inherit mapping
11 |  * information
12 |  *
13 |  * @final
14 |  */
15 | #[Attribute(Attribute::TARGET_CLASS)]
16 | class MappedSuperclass extends AbstractDocument
17 | {
18 |     /** @var string|null */
19 |     public $repositoryClass;
20 | 
21 |     /** @var string|null */
22 |     public $collection;
23 | 
24 |     public function __construct(?string $repositoryClass = null, ?string $collection = null)
25 |     {
26 |         $this->repositoryClass = $repositoryClass;
27 |         $this->collection      = $collection;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/ShardKey.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /** @final */
10 | #[Attribute(Attribute::TARGET_CLASS)]
11 | class ShardKey implements MappingAttribute
12 | {
13 |     /** @var string[] */
14 |     public $keys;
15 | 
16 |     /** @var bool|null */
17 |     public $unique;
18 | 
19 |     /** @var int|null */
20 |     public $numInitialChunks;
21 | 
22 |     /** @param string[] $keys */
23 |     public function __construct(array $keys = [], ?bool $unique = null, ?int $numInitialChunks = null)
24 |     {
25 |         $this->keys             = $keys;
26 |         $this->unique           = $unique;
27 |         $this->numInitialChunks = $numInitialChunks;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Limit.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Builder;
 8 | use Doctrine\ODM\MongoDB\Aggregation\Stage;
 9 | 
10 | /**
11 |  * Fluent interface for adding a $limit stage to an aggregation pipeline.
12 |  *
13 |  * @phpstan-type LimitStageExpression array{"$limit": int}
14 |  */
15 | class Limit extends Stage
16 | {
17 |     public function __construct(Builder $builder, private int $limit)
18 |     {
19 |         parent::__construct($builder);
20 |     }
21 | 
22 |     /** @phpstan-return LimitStageExpression */
23 |     public function getExpression(): array
24 |     {
25 |         return [
26 |             '$limit' => $this->limit,
27 |         ];
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Types/BooleanType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | /**
 8 |  * The Boolean type.
 9 |  */
10 | class BooleanType extends Type
11 | {
12 |     /** @return bool|null */
13 |     public function convertToDatabaseValue($value)
14 |     {
15 |         return $value !== null ? (bool) $value : null;
16 |     }
17 | 
18 |     /** @return bool|null */
19 |     public function convertToPHPValue($value)
20 |     {
21 |         return $value !== null ? (bool) $value : null;
22 |     }
23 | 
24 |     public function closureToMongo(): string
25 |     {
26 |         return '$return = (bool) $value;';
27 |     }
28 | 
29 |     public function closureToPHP(): string
30 |     {
31 |         return '$return = (bool) $value;';
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/VectorSearchIndex.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
 9 | 
10 | /**
11 |  * Defines a vector search index on a class.
12 |  *
13 |  * @see https://www.mongodb.com/docs/atlas/atlas-vector-search/vector-search-type/
14 |  *
15 |  * @phpstan-import-type VectorSearchIndexField from ClassMetadata
16 |  */
17 | #[Attribute(Attribute::TARGET_CLASS | Attribute::IS_REPEATABLE)]
18 | class VectorSearchIndex implements MappingAttribute
19 | {
20 |     /** @param list<VectorSearchIndexField> $fields */
21 |     public function __construct(
22 |         public array $fields,
23 |         public ?string $name = null,
24 |     ) {
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/Id.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Special field mapping to map document identifiers
11 |  *
12 |  * @final
13 |  */
14 | #[Attribute(Attribute::TARGET_PROPERTY)]
15 | class Id extends AbstractField implements MappingAttribute
16 | {
17 |     /** @var bool */
18 |     public $id = true;
19 | 
20 |     public function __construct(
21 |         ?string $name = null,
22 |         ?string $type = null,
23 |         bool $nullable = false,
24 |         array $options = [],
25 |         ?string $strategy = 'auto',
26 |         bool $notSaved = false,
27 |     ) {
28 |         parent::__construct($name, $type, $nullable, $options, $strategy, $notSaved);
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Types/KeyType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | use MongoDB\BSON\MaxKey;
 8 | use MongoDB\BSON\MinKey;
 9 | 
10 | /**
11 |  * The Key type.
12 |  */
13 | class KeyType extends Type
14 | {
15 |     use ClosureToPHP;
16 | 
17 |     /** @return MinKey|MaxKey|null */
18 |     public function convertToDatabaseValue($value)
19 |     {
20 |         if ($value === null) {
21 |             return null;
22 |         }
23 | 
24 |         return $value ? new MaxKey() : new MinKey();
25 |     }
26 | 
27 |     /** @return int|null */
28 |     public function convertToPHPValue($value)
29 |     {
30 |         if ($value === null) {
31 |             return null;
32 |         }
33 | 
34 |         return $value instanceof MaxKey ? 1 : 0;
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Count.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Builder;
 8 | use Doctrine\ODM\MongoDB\Aggregation\Stage;
 9 | 
10 | /**
11 |  * Fluent interface for adding a $count stage to an aggregation pipeline.
12 |  *
13 |  * @phpstan-type CountStageExpression array{"$count": string}
14 |  */
15 | class Count extends Stage
16 | {
17 |     public function __construct(Builder $builder, private string $fieldName)
18 |     {
19 |         parent::__construct($builder);
20 |     }
21 | 
22 |     /** @phpstan-return CountStageExpression */
23 |     public function getExpression(): array
24 |     {
25 |         return [
26 |             '$count' => $this->fieldName,
27 |         ];
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Sample.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Builder;
 8 | use Doctrine\ODM\MongoDB\Aggregation\Stage;
 9 | 
10 | /**
11 |  * Fluent interface for adding a $sample stage to an aggregation pipeline.
12 |  *
13 |  * @phpstan-type SampleStageExpression array{"$sample": array{size: int}}
14 |  */
15 | class Sample extends Stage
16 | {
17 |     public function __construct(Builder $builder, private int $size)
18 |     {
19 |         parent::__construct($builder);
20 |     }
21 | 
22 |     /** @phpstan-return SampleStageExpression */
23 |     public function getExpression(): array
24 |     {
25 |         return [
26 |             '$sample' => ['size' => $this->size],
27 |         ];
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Tools/Console/Command/Schema/AbstractCommandCompatibility.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Tools\Console\Command\Schema;
 6 | 
 7 | use ReflectionMethod;
 8 | use Symfony\Component\Console\Command\Command;
 9 | 
10 | // Symfony 8
11 | if ((new ReflectionMethod(Command::class, 'configure'))->hasReturnType()) {
12 |     /** @internal */
13 |     trait AbstractCommandCompatibility
14 |     {
15 |         protected function configure(): void
16 |         {
17 |             $this->configureCommonOptions();
18 |         }
19 |     }
20 | } else {
21 |     /** @internal */
22 |     trait AbstractCommandCompatibility
23 |     {
24 |         /** @return void */
25 |         protected function configure()
26 |         {
27 |             $this->configureCommonOptions();
28 |         }
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/Encrypt.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\Encrypt as EncryptAttribute;
10 | 
11 | /**
12 |  * Defines an encrypted field mapping.
13 |  *
14 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\Encrypt instead
15 |  *
16 |  * @see https://www.mongodb.com/docs/manual/core/queryable-encryption/fundamentals/encrypt-and-query/#configure-encrypted-fields-for-optimal-search-and-storage
17 |  *
18 |  * @Annotation
19 |  * @NamedArgumentConstructor
20 |  */
21 | #[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_PROPERTY)]
22 | final class Encrypt extends EncryptAttribute implements Annotation
23 | {
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/TimeSeries.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\ODM\MongoDB\Mapping\TimeSeries\Granularity;
 9 | 
10 | /**
11 |  * Marks a document or superclass as a time series document
12 |  *
13 |  * @final
14 |  */
15 | #[Attribute(Attribute::TARGET_CLASS)]
16 | class TimeSeries implements MappingAttribute
17 | {
18 |     public function __construct(
19 |         public readonly string $timeField,
20 |         public readonly ?string $metaField = null,
21 |         public readonly ?Granularity $granularity = null,
22 |         public readonly ?int $expireAfterSeconds = null,
23 |         public readonly ?int $bucketMaxSpanSeconds = null,
24 |         public readonly ?int $bucketRoundingSeconds = null,
25 |     ) {
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/DefaultDiscriminatorValue.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\DefaultDiscriminatorValue as DefaultDiscriminatorValueAttribute;
10 | 
11 | /**
12 |  * Specifies a default discriminator value to be used when the discriminator
13 |  * field is not set in a document
14 |  *
15 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\DefaultDiscriminatorValue instead
16 |  *
17 |  * @Annotation
18 |  * @NamedArgumentConstructor
19 |  */
20 | #[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_PROPERTY)]
21 | final class DefaultDiscriminatorValue extends DefaultDiscriminatorValueAttribute implements Annotation
22 | {
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Types/StringType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | use MongoDB\BSON\Regex;
 8 | 
 9 | /**
10 |  * The String type.
11 |  */
12 | class StringType extends Type
13 | {
14 |     /** @return Regex|string|null */
15 |     public function convertToDatabaseValue($value)
16 |     {
17 |         return $value === null || $value instanceof Regex ? $value : (string) $value;
18 |     }
19 | 
20 |     /** @return string|null */
21 |     public function convertToPHPValue($value)
22 |     {
23 |         return $value !== null ? (string) $value : null;
24 |     }
25 | 
26 |     public function closureToMongo(): string
27 |     {
28 |         return '$return = (string) $value;';
29 |     }
30 | 
31 |     public function closureToPHP(): string
32 |     {
33 |         return '$return = (string) $value;';
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/Exists.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 8 | use Doctrine\ODM\MongoDB\Persisters\DocumentPersister;
 9 | 
10 | /**
11 |  * @internal
12 |  *
13 |  * @see https://www.mongodb.com/docs/atlas/atlas-search/exists/
14 |  */
15 | class Exists extends AbstractSearchOperator
16 | {
17 |     public function __construct(Search $search, DocumentPersister $persister, private string $path = '')
18 |     {
19 |         parent::__construct($search, $persister);
20 |     }
21 | 
22 |     public function getOperatorName(): string
23 |     {
24 |         return 'exists';
25 |     }
26 | 
27 |     public function getOperatorParams(): object
28 |     {
29 |         return (object) ['path' => $this->prepareFieldPath($this->path)];
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Event/PreLoadEventArgs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Event;
 6 | 
 7 | use Doctrine\ODM\MongoDB\DocumentManager;
 8 | use MongoDB\Driver\Session;
 9 | 
10 | /**
11 |  * Class that holds event arguments for a preLoad event.
12 |  */
13 | final class PreLoadEventArgs extends LifecycleEventArgs
14 | {
15 |     /** @param array<string, mixed> $data */
16 |     public function __construct(
17 |         object $document,
18 |         DocumentManager $dm,
19 |         private array &$data,
20 |         ?Session $session = null,
21 |     ) {
22 |         parent::__construct($document, $dm, $session);
23 |     }
24 | 
25 |     /**
26 |      * Get the array of data to be loaded and hydrated.
27 |      *
28 |      * @return array<string, mixed>
29 |      */
30 |     public function &getData(): array
31 |     {
32 |         return $this->data;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Proxy/Resolver/LazyGhostProxyClassNameResolver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Proxy\Resolver;
 6 | 
 7 | use Doctrine\Persistence\Mapping\ProxyClassNameResolver;
 8 | use Doctrine\Persistence\Proxy;
 9 | 
10 | use function strrpos;
11 | use function substr;
12 | 
13 | /** @internal */
14 | class LazyGhostProxyClassNameResolver implements ClassNameResolver, ProxyClassNameResolver
15 | {
16 |     public function getRealClass(string $class): string
17 |     {
18 |         return $this->resolveClassName($class);
19 |     }
20 | 
21 |     public function resolveClassName(string $className): string
22 |     {
23 |         $pos = strrpos($className, '\\' . Proxy::MARKER . '\\');
24 | 
25 |         if ($pos === false) {
26 |             return $className;
27 |         }
28 | 
29 |         return substr($className, $pos + Proxy::MARKER_LENGTH + 2);
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/View.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /** @final */
10 | #[Attribute(Attribute::TARGET_CLASS)]
11 | class View extends AbstractDocument
12 | {
13 |     /** @var string|null */
14 |     public $db;
15 | 
16 |     /** @var string|null */
17 |     public $view;
18 | 
19 |     /** @var string|null */
20 |     public $rootClass;
21 | 
22 |     /** @var string|null */
23 |     public $repositoryClass;
24 | 
25 |     public function __construct(
26 |         ?string $db = null,
27 |         ?string $view = null,
28 |         ?string $rootClass = null,
29 |         ?string $repositoryClass = null,
30 |     ) {
31 |         $this->db              = $db;
32 |         $this->view            = $view;
33 |         $this->rootClass       = $rootClass;
34 |         $this->repositoryClass = $repositoryClass;
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Types/HashType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | use Doctrine\ODM\MongoDB\MongoDBException;
 8 | 
 9 | use function is_array;
10 | 
11 | /**
12 |  * The Hash type.
13 |  */
14 | class HashType extends Type
15 | {
16 |     /** @return object|null */
17 |     public function convertToDatabaseValue($value)
18 |     {
19 |         if ($value !== null && ! is_array($value)) {
20 |             throw MongoDBException::invalidValueForType('Hash', ['array', 'null'], $value);
21 |         }
22 | 
23 |         return $value !== null ? (object) $value : null;
24 |     }
25 | 
26 |     /** @return array<string, mixed>|null */
27 |     public function convertToPHPValue($value)
28 |     {
29 |         return $value !== null ? (array) $value : null;
30 |     }
31 | 
32 |     public function closureToPHP(): string
33 |     {
34 |         return '$return = (array) $value;';
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/VectorSearchIndex.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\VectorSearchIndex as VectorSearchIndexAttribute;
10 | use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
11 | 
12 | /**
13 |  * Defines a vector search index on a class.
14 |  *
15 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\VectorSearchIndex instead
16 |  *
17 |  * @see https://www.mongodb.com/docs/atlas/atlas-vector-search/vector-search-type/
18 |  *
19 |  * @Annotation
20 |  * @NamedArgumentConstructor
21 |  * @phpstan-import-type VectorSearchIndexField from ClassMetadata
22 |  */
23 | #[Attribute(Attribute::TARGET_CLASS | Attribute::IS_REPEATABLE)]
24 | final class VectorSearchIndex extends VectorSearchIndexAttribute implements Annotation
25 | {
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Types/FloatType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | /**
 8 |  * The Float type.
 9 |  */
10 | class FloatType extends Type implements Incrementable
11 | {
12 |     /** @return float|null */
13 |     public function convertToDatabaseValue($value)
14 |     {
15 |         return $value !== null ? (float) $value : null;
16 |     }
17 | 
18 |     /** @return float|null */
19 |     public function convertToPHPValue($value)
20 |     {
21 |         return $value !== null ? (float) $value : null;
22 |     }
23 | 
24 |     public function closureToMongo(): string
25 |     {
26 |         return '$return = (float) $value;';
27 |     }
28 | 
29 |     public function closureToPHP(): string
30 |     {
31 |         return '$return = (float) $value;';
32 |     }
33 | 
34 |     /** @return float|null */
35 |     public function diff($old, $new)
36 |     {
37 |         return (float) ($new - $old);
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/DocumentNotFoundException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB;
 6 | 
 7 | use JsonException;
 8 | 
 9 | use function json_encode;
10 | use function sprintf;
11 | 
12 | use const JSON_THROW_ON_ERROR;
13 | 
14 | /**
15 |  * Class for exception when encountering a lazy object that has
16 |  * an identifier that does not exist in the database.
17 |  */
18 | final class DocumentNotFoundException extends MongoDBException
19 | {
20 |     /** @param mixed $identifier */
21 |     public static function documentNotFound(string $className, $identifier): self
22 |     {
23 |         try {
24 |             $id = json_encode($identifier, JSON_THROW_ON_ERROR);
25 |         } catch (JsonException $e) {
26 |         }
27 | 
28 |         return new self(sprintf(
29 |             'The "%s" document with identifier %s could not be found.',
30 |             $className,
31 |             $id ?? false,
32 |         ), 0, $e ?? null);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Mapping/Annotations/SearchIndex.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\SearchIndex as SearchIndexAttribute;
10 | use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
11 | 
12 | /**
13 |  * Defines a search index on a class.
14 |  *
15 |  * @deprecated Use \Doctrine\ODM\MongoDB\Mapping\Attribute\SearchIndex instead
16 |  *
17 |  * @see https://www.mongodb.com/docs/atlas/atlas-search/index-definitions/
18 |  *
19 |  * @Annotation
20 |  * @NamedArgumentConstructor
21 |  * @phpstan-import-type SearchIndexStoredSource from ClassMetadata
22 |  * @phpstan-import-type SearchIndexSynonym from ClassMetadata
23 |  */
24 | #[Attribute(Attribute::TARGET_CLASS | Attribute::IS_REPEATABLE)]
25 | final class SearchIndex extends SearchIndexAttribute implements Annotation
26 | {
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Proxy/Resolver/CachingClassNameResolver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Proxy\Resolver;
 6 | 
 7 | use Doctrine\Persistence\Mapping\ProxyClassNameResolver;
 8 | 
 9 | /** @internal */
10 | final class CachingClassNameResolver implements ClassNameResolver, ProxyClassNameResolver
11 | {
12 |     /** @var array<class-string, string> */
13 |     private array $resolvedNames = [];
14 | 
15 |     public function __construct(private ProxyClassNameResolver $resolver)
16 |     {
17 |     }
18 | 
19 |     /**
20 |      * Gets the real class name of a class name that could be a proxy.
21 |      */
22 |     public function getRealClass(string $class): string
23 |     {
24 |         return $this->resolveClassName($class);
25 |     }
26 | 
27 |     public function resolveClassName(string $className): string
28 |     {
29 |         return $this->resolvedNames[$className] ??= $this->resolver->resolveClassName($className);
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/PersistentCollection/PersistentCollectionFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\PersistentCollection;
 6 | 
 7 | use Doctrine\Common\Collections\Collection as BaseCollection;
 8 | use Doctrine\ODM\MongoDB\DocumentManager;
 9 | use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
10 | 
11 | /**
12 |  * Interface for persistent collection classes factory.
13 |  *
14 |  * @phpstan-import-type FieldMapping from ClassMetadata
15 |  */
16 | interface PersistentCollectionFactory
17 | {
18 |     /**
19 |      * Creates specified persistent collection to work with given collection class.
20 |      *
21 |      * @param BaseCollection<array-key, object>|null $coll
22 |      * @phpstan-param FieldMapping $mapping
23 |      *
24 |      * @return PersistentCollectionInterface<array-key, object>
25 |      */
26 |     public function create(DocumentManager $dm, array $mapping, ?BaseCollection $coll = null): PersistentCollectionInterface;
27 | }
28 | 


--------------------------------------------------------------------------------
/README.markdown:
--------------------------------------------------------------------------------
 1 | # Doctrine MongoDB Object Document Mapper
 2 | 
 3 | [![Build Status](https://github.com/doctrine/mongodb-odm/workflows/Continuous%20Integration/badge.svg)](https://github.com/doctrine/mongodb-odm/actions?query=workflow%3A%22Continuous+Integration%22)
 4 | [![Code Coverage](https://codecov.io/gh/doctrine/mongodb-odm/branch/2.2.x/graph/badge.svg)](https://codecov.io/gh/doctrine/mongodb-odm/branch/2.2.x)
 5 | [![Gitter](https://badges.gitter.im/doctrine/mongodb-odm.svg)](https://gitter.im/doctrine/mongodb-odm)
 6 | 
 7 | 
 8 | The Doctrine MongoDB ODM project is a library that provides a PHP object mapping functionality for MongoDB.
 9 | 
10 | ## More resources:
11 | 
12 | * [Website](https://www.doctrine-project.org/projects/mongodb-odm.html)
13 | * [Documentation](https://www.doctrine-project.org/projects/doctrine-mongodb-odm/en/stable/)
14 | * [Issue Tracker](https://github.com/doctrine/mongodb-odm/issues)
15 | * [Releases](https://github.com/doctrine/mongodb-odm/releases)
16 | 


--------------------------------------------------------------------------------
/src/SchemaException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | use function implode;
10 | use function sprintf;
11 | 
12 | /**
13 |  * Exception for schema-related issues.
14 |  */
15 | final class SchemaException extends RuntimeException
16 | {
17 |     /**
18 |      * @internal
19 |      *
20 |      * @param string[] $missingIndexes
21 |      */
22 |     public static function missingSearchIndex(string $documentClass, array $missingIndexes): self
23 |     {
24 |         return new self(sprintf('The document class "%s" is missing the following search index(es): "%s"', $documentClass, implode('", "', $missingIndexes)));
25 |     }
26 | 
27 |     /** @internal */
28 |     public static function searchIndexNotFound(string $namespace, string $indexName): self
29 |     {
30 |         return new self(sprintf('The search index "%s" of the collection "%s" is not found.', $indexName, $namespace));
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Types/CollectionType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | use Doctrine\ODM\MongoDB\MongoDBException;
 8 | 
 9 | use function array_values;
10 | use function is_array;
11 | 
12 | /**
13 |  * The Collection type.
14 |  */
15 | class CollectionType extends Type
16 | {
17 |     /** @return list<mixed>|null */
18 |     public function convertToDatabaseValue($value)
19 |     {
20 |         if ($value !== null && ! is_array($value)) {
21 |             throw MongoDBException::invalidValueForType('Collection', ['array', 'null'], $value);
22 |         }
23 | 
24 |         return $value !== null ? array_values($value) : null;
25 |     }
26 | 
27 |     /** @return list<mixed>|null */
28 |     public function convertToPHPValue($value)
29 |     {
30 |         return $value !== null ? array_values($value) : null;
31 |     }
32 | 
33 |     public function closureToPHP(): string
34 |     {
35 |         return '$return = array_values($value);';
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Iterator/IterableResult.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Iterator;
 6 | 
 7 | use BadMethodCallException;
 8 | use IteratorAggregate;
 9 | 
10 | interface IterableResult extends IteratorAggregate
11 | {
12 |     /**
13 |      * Executes the operation and returns a result if available; null otherwise
14 |      */
15 |     public function execute(): mixed;
16 | 
17 |     /**
18 |      * Executes the operation and returns a result iterator. If the operation
19 |      * did not yield an iterator, this method will throw
20 |      *
21 |      * @throws BadMethodCallException if the operation did not yield an iterator.
22 |      */
23 |     public function getIterator(): Iterator;
24 | 
25 |     /**
26 |      * Returns the first result only from the operation
27 |      *
28 |      * Note that the behaviour of fetching the first result is dependent on the
29 |      * implementation. A separate operation might be involved.
30 |      */
31 |     public function getSingleResult(): mixed;
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Event/PostCollectionLoadEventArgs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Event;
 6 | 
 7 | use Doctrine\ODM\MongoDB\DocumentManager;
 8 | use Doctrine\ODM\MongoDB\PersistentCollection\PersistentCollectionInterface;
 9 | 
10 | /**
11 |  * Class that holds arguments for postCollectionLoad event.
12 |  *
13 |  * @template TKey of array-key
14 |  * @template T of object
15 |  */
16 | final class PostCollectionLoadEventArgs extends ManagerEventArgs
17 | {
18 |     /** @param PersistentCollectionInterface<TKey, T> $collection */
19 |     public function __construct(private PersistentCollectionInterface $collection, DocumentManager $dm)
20 |     {
21 |         parent::__construct($dm);
22 |     }
23 | 
24 |     /**
25 |      * Gets collection that was just initialized (loaded).
26 |      *
27 |      * @return PersistentCollectionInterface<TKey, T>
28 |      */
29 |     public function getCollection(): PersistentCollectionInterface
30 |     {
31 |         return $this->collection;
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/PersistentCollection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB;
 6 | 
 7 | use Doctrine\Common\Collections\Collection as BaseCollection;
 8 | use Doctrine\ODM\MongoDB\PersistentCollection\PersistentCollectionInterface;
 9 | use Doctrine\ODM\MongoDB\PersistentCollection\PersistentCollectionTrait;
10 | 
11 | /**
12 |  * A PersistentCollection represents a collection of elements that have persistent state.
13 |  *
14 |  * @template TKey of array-key
15 |  * @template T of object
16 |  * @template-implements PersistentCollectionInterface<TKey,T>
17 |  */
18 | final class PersistentCollection implements PersistentCollectionInterface
19 | {
20 |     /** @use PersistentCollectionTrait<TKey, T> */
21 |     use PersistentCollectionTrait;
22 | 
23 |     /** @param BaseCollection<TKey, T> $coll */
24 |     public function __construct(BaseCollection $coll, DocumentManager $dm, UnitOfWork $uow)
25 |     {
26 |         $this->coll = $coll;
27 |         $this->dm   = $dm;
28 |         $this->uow  = $uow;
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/Field.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | use BackedEnum;
 9 | 
10 | /**
11 |  * Specifies a generic field mapping
12 |  *
13 |  * @final
14 |  */
15 | #[Attribute(Attribute::TARGET_PROPERTY)]
16 | class Field extends AbstractField implements MappingAttribute
17 | {
18 |     /** @var class-string<BackedEnum>|null */
19 |     public $enumType;
20 | 
21 |     /**
22 |      * @param mixed[]                       $options
23 |      * @param class-string<BackedEnum>|null $enumType
24 |      */
25 |     public function __construct(
26 |         ?string $name = null,
27 |         ?string $type = null,
28 |         bool $nullable = false,
29 |         array $options = [],
30 |         ?string $strategy = null,
31 |         bool $notSaved = false,
32 |         ?string $enumType = null,
33 |     ) {
34 |         parent::__construct($name, $type, $nullable, $options, $strategy, $notSaved);
35 | 
36 |         $this->enumType = $enumType;
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Mapping/PropertyAccessors/PropertyAccessor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\PropertyAccessors;
 6 | 
 7 | use ReflectionProperty;
 8 | 
 9 | /**
10 |  * A property accessor is a class that allows to read and write properties on objects regardless of visibility.
11 |  *
12 |  * We use them while creating objects from database rows in {@see UnitOfWork::getOrCreateDocument()} or when
13 |  * computing changesets from objects that are about to be written back to the database in {@see UnitOfWork::computeChangeSet()}.
14 |  *
15 |  * This abstraction over ReflectionProperty is necessary, because for several features of either Doctrine or PHP, we
16 |  * need to handle edge cases in reflection at a central location in the code.
17 |  *
18 |  * @internal
19 |  */
20 | interface PropertyAccessor
21 | {
22 |     public function setValue(object $object, mixed $value): void;
23 | 
24 |     public function getValue(object $object): mixed;
25 | 
26 |     public function getUnderlyingReflector(): ReflectionProperty;
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Types/TimestampType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | use MongoDB\BSON\Timestamp;
 8 | 
 9 | use function explode;
10 | use function substr;
11 | 
12 | /**
13 |  * The Timestamp type.
14 |  */
15 | class TimestampType extends Type
16 | {
17 |     use ClosureToPHP;
18 | 
19 |     /** @return Timestamp|null */
20 |     public function convertToDatabaseValue($value)
21 |     {
22 |         if ($value instanceof Timestamp) {
23 |             return $value;
24 |         }
25 | 
26 |         return $value !== null ? new Timestamp(0, $value) : null;
27 |     }
28 | 
29 |     /** @return int|string|null */
30 |     public function convertToPHPValue($value)
31 |     {
32 |         return $value instanceof Timestamp ? $this->extractSeconds($value) : ($value !== null ? (string) $value : null);
33 |     }
34 | 
35 |     private function extractSeconds(Timestamp $timestamp): int
36 |     {
37 |             $parts = explode(':', substr((string) $timestamp, 1, -1));
38 | 
39 |             return (int) $parts[1];
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/UniqueIndex.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Specifies a unique index on a field
11 |  *
12 |  * @final
13 |  */
14 | #[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
15 | class UniqueIndex extends AbstractIndex implements MappingAttribute
16 | {
17 |     public function __construct(
18 |         array $keys = [],
19 |         ?string $name = null,
20 |         ?bool $background = null,
21 |         ?int $expireAfterSeconds = null,
22 |         $order = null,
23 |         bool $sparse = false,
24 |         array $options = [],
25 |         array $partialFilterExpression = [],
26 |     ) {
27 |         parent::__construct(
28 |             $keys,
29 |             $name,
30 |             $background,
31 |             $expireAfterSeconds,
32 |             $order,
33 |             true,
34 |             $sparse,
35 |             $options,
36 |             $partialFilterExpression,
37 |         );
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Types/IntType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | use function max;
 8 | 
 9 | /**
10 |  * The Int type.
11 |  */
12 | class IntType extends Type implements Incrementable, Versionable
13 | {
14 |     /** @return int|null */
15 |     public function convertToDatabaseValue($value)
16 |     {
17 |         return $value !== null ? (int) $value : null;
18 |     }
19 | 
20 |     /** @return int|null */
21 |     public function convertToPHPValue($value)
22 |     {
23 |         return $value !== null ? (int) $value : null;
24 |     }
25 | 
26 |     public function closureToMongo(): string
27 |     {
28 |         return '$return = (int) $value;';
29 |     }
30 | 
31 |     public function closureToPHP(): string
32 |     {
33 |         return '$return = (int) $value;';
34 |     }
35 | 
36 |     /** @return int */
37 |     public function diff($old, $new)
38 |     {
39 |         return $new - $old;
40 |     }
41 | 
42 |     /** @return int */
43 |     public function getNextVersion($current)
44 |     {
45 |         return max(1, (int) $current + 1);
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2006-2016 Doctrine Project
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 4 | this software and associated documentation files (the "Software"), to deal in
 5 | the Software without restriction, including without limitation the rights to
 6 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
 7 | of the Software, and to permit persons to whom the Software is furnished to do
 8 | so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in all
11 | copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
19 | SOFTWARE.
20 | 


--------------------------------------------------------------------------------
/src/Aggregation/Operator/TimestampOperators.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Operator;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Expr;
 8 | 
 9 | /**
10 |  * Interface containing timestamp aggregation pipeline operators.
11 |  *
12 |  * This interface can be used for type hinting, but must not be implemented by
13 |  * users. Methods WILL be added to the public API in future minor versions.
14 |  *
15 |  * @internal
16 |  */
17 | interface TimestampOperators
18 | {
19 |     /**
20 |      * Returns the incrementing ordinal from a timestamp as a long.
21 |      *
22 |      * @see https://docs.mongodb.com/manual/reference/operator/aggregation/tsIncrement/
23 |      *
24 |      * @param mixed|Expr $expression
25 |      */
26 |     public function tsIncrement($expression): static;
27 | 
28 |     /**
29 |      * Returns the seconds from a timestamp as a long.
30 |      *
31 |      * @see https://docs.mongodb.com/manual/reference/operator/aggregation/tsSecond/
32 |      *
33 |      * @param mixed|Expr $expression
34 |      */
35 |     public function tsSecond($expression): static;
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/UnsetStage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Builder;
 8 | use Doctrine\ODM\MongoDB\Aggregation\Stage;
 9 | use Doctrine\ODM\MongoDB\Persisters\DocumentPersister;
10 | 
11 | use function array_map;
12 | use function array_values;
13 | 
14 | /**
15 |  * Fluent interface for adding an $unset stage to an aggregation pipeline.
16 |  *
17 |  * @phpstan-type UnsetStageExpression array{"$unset": list<string>}
18 |  */
19 | class UnsetStage extends Stage
20 | {
21 |     /** @var list<string> */
22 |     private array $fields;
23 | 
24 |     public function __construct(Builder $builder, private DocumentPersister $documentPersister, string ...$fields)
25 |     {
26 |         parent::__construct($builder);
27 | 
28 |         $this->fields = array_values($fields);
29 |     }
30 | 
31 |     /** @return UnsetStageExpression */
32 |     public function getExpression(): array
33 |     {
34 |         return [
35 |             '$unset' => array_map([$this->documentPersister, 'prepareFieldName'], $this->fields),
36 |         ];
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Types/ObjectIdType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | use MongoDB\BSON\ObjectId;
 8 | 
 9 | /**
10 |  * The ObjectId type.
11 |  */
12 | class ObjectIdType extends Type implements Versionable
13 | {
14 |     /** @return ObjectId|null */
15 |     public function convertToDatabaseValue($value)
16 |     {
17 |         if ($value === null) {
18 |             return null;
19 |         }
20 | 
21 |         if (! $value instanceof ObjectId) {
22 |             $value = new ObjectId($value);
23 |         }
24 | 
25 |         return $value;
26 |     }
27 | 
28 |     /** @return string|null */
29 |     public function convertToPHPValue($value)
30 |     {
31 |         return $value !== null ? (string) $value : null;
32 |     }
33 | 
34 |     public function closureToMongo(): string
35 |     {
36 |         return '$return = new MongoDB\BSON\ObjectId($value);';
37 |     }
38 | 
39 |     public function closureToPHP(): string
40 |     {
41 |         return '$return = (string) $value;';
42 |     }
43 | 
44 |     public function getNextVersion($current): ObjectId
45 |     {
46 |         return new ObjectId();
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/MoreLikeThis.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 8 | use Doctrine\ODM\MongoDB\Persisters\DocumentPersister;
 9 | 
10 | use function array_values;
11 | 
12 | /**
13 |  * @internal
14 |  *
15 |  * @see https://www.mongodb.com/docs/atlas/atlas-search/moreLikeThis/
16 |  */
17 | class MoreLikeThis extends AbstractSearchOperator
18 | {
19 |     /** @var list<array<string, mixed>|object> */
20 |     private array $like = [];
21 | 
22 |     /** @param array<string, mixed>|object $documents */
23 |     public function __construct(Search $search, DocumentPersister $persister, ...$documents)
24 |     {
25 |         parent::__construct($search, $persister);
26 | 
27 |         $this->like = array_values($documents);
28 |     }
29 | 
30 |     public function getOperatorName(): string
31 |     {
32 |         return 'moreLikeThis';
33 |     }
34 | 
35 |     public function getOperatorParams(): object
36 |     {
37 |         return (object) [
38 |             'like' => $this->prepareDocuments($this->like),
39 |         ];
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Aggregation/Operator/DataSizeOperators.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Operator;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Expr;
 8 | 
 9 | /**
10 |  * Interface containing all data size aggregation pipeline operators.
11 |  *
12 |  * This interface can be used for type hinting, but must not be implemented by
13 |  * users. Methods WILL be added to the public API in future minor versions.
14 |  *
15 |  * @internal
16 |  */
17 | interface DataSizeOperators
18 | {
19 |     /**
20 |      * Returns the size of a given string or binary data value's content in bytes.
21 |      *
22 |      * @see https://docs.mongodb.com/manual/reference/operator/aggregation/binarySize/
23 |      *
24 |      * @param mixed|Expr $expression
25 |      */
26 |     public function binarySize($expression): static;
27 | 
28 |     /**
29 |      * Returns the size in bytes of a given document (i.e. bsontype Object) when encoded as BSON.
30 |      *
31 |      * @see https://docs.mongodb.com/manual/reference/operator/aggregation/bsonSize/
32 |      *
33 |      * @param mixed|Expr $expression
34 |      */
35 |     public function bsonSize($expression): static;
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Mapping/PropertyAccessors/PropertyAccessorFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\PropertyAccessors;
 6 | 
 7 | use ReflectionProperty;
 8 | 
 9 | use const PHP_VERSION_ID;
10 | 
11 | /** @internal */
12 | class PropertyAccessorFactory
13 | {
14 |     /** @phpstan-param class-string $className */
15 |     public static function createPropertyAccessor(string $className, string $propertyName): PropertyAccessor
16 |     {
17 |         $reflectionProperty = new ReflectionProperty($className, $propertyName);
18 | 
19 |         $accessor = PHP_VERSION_ID >= 80400
20 |             ? RawValuePropertyAccessor::fromReflectionProperty($reflectionProperty)
21 |             : ObjectCastPropertyAccessor::fromReflectionProperty($reflectionProperty);
22 | 
23 |         if ($reflectionProperty->hasType() && ! $reflectionProperty->getType()->allowsNull()) {
24 |             $accessor = new TypedNoDefaultPropertyAccessor($accessor, $reflectionProperty);
25 |         }
26 | 
27 |         if ($reflectionProperty->isReadOnly()) {
28 |             $accessor = new ReadonlyAccessor($accessor, $reflectionProperty);
29 |         }
30 | 
31 |         return $accessor;
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Id/SymfonyUuidGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Id;
 6 | 
 7 | use Doctrine\ODM\MongoDB\DocumentManager;
 8 | use InvalidArgumentException;
 9 | use Symfony\Component\Uid\Uuid;
10 | use Symfony\Component\Uid\UuidV1;
11 | use Symfony\Component\Uid\UuidV4;
12 | use Symfony\Component\Uid\UuidV7;
13 | 
14 | use function array_values;
15 | use function implode;
16 | use function in_array;
17 | use function sprintf;
18 | 
19 | /** @internal */
20 | final class SymfonyUuidGenerator extends AbstractIdGenerator
21 | {
22 |     private const SUPPORTED_TYPES = [
23 |         1 => UuidV1::class,
24 |         4 => UuidV4::class,
25 |         7 => UuidV7::class,
26 |     ];
27 | 
28 |     public function __construct(private readonly string $class)
29 |     {
30 |         if (! in_array($this->class, self::SUPPORTED_TYPES, true)) {
31 |             throw new InvalidArgumentException(sprintf('Invalid UUID type "%s". Expected one of: %s.', $this->class, implode(', ', array_values(self::SUPPORTED_TYPES))));
32 |         }
33 |     }
34 | 
35 |     public function generate(DocumentManager $dm, object $document): Uuid
36 |     {
37 |         return new $this->class();
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/Validation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
 9 | 
10 | /** @Target({"CLASS"}) */
11 | #[Attribute(Attribute::TARGET_CLASS)]
12 | class Validation implements MappingAttribute
13 | {
14 |     /** @var string|null */
15 |     public $validator;
16 | 
17 |     /**
18 |      * @var string|null
19 |      * @Enum({
20 |      *     ClassMetadata::SCHEMA_VALIDATION_ACTION_ERROR,
21 |      *     ClassMetadata::SCHEMA_VALIDATION_ACTION_WARN,
22 |      *     })
23 |      */
24 |     public $action;
25 | 
26 |     /**
27 |      * @var string|null
28 |      * @Enum({
29 |      *     ClassMetadata::SCHEMA_VALIDATION_LEVEL_OFF,
30 |      *     ClassMetadata::SCHEMA_VALIDATION_LEVEL_STRICT,
31 |      *     ClassMetadata::SCHEMA_VALIDATION_LEVEL_MODERATE,
32 |      *     })
33 |      */
34 |     public $level;
35 | 
36 |     public function __construct(?string $validator = null, ?string $action = null, ?string $level = null)
37 |     {
38 |         $this->validator = $validator;
39 |         $this->action    = $action;
40 |         $this->level     = $level;
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Types/DateImmutableType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | use DateTime;
 8 | use DateTimeImmutable;
 9 | use DateTimeInterface;
10 | use RuntimeException;
11 | 
12 | use function sprintf;
13 | 
14 | class DateImmutableType extends DateType
15 | {
16 |     /** @return DateTimeImmutable */
17 |     public static function getDateTime($value): DateTimeInterface
18 |     {
19 |         $datetime = parent::getDateTime($value);
20 | 
21 |         if ($datetime instanceof DateTimeImmutable) {
22 |             return $datetime;
23 |         }
24 | 
25 |         if ($datetime instanceof DateTime) {
26 |             return DateTimeImmutable::createFromMutable($datetime);
27 |         }
28 | 
29 |         throw new RuntimeException(sprintf(
30 |             '%s::getDateTime has returned an unsupported implementation of DateTimeInterface: %s',
31 |             parent::class,
32 |             $datetime::class,
33 |         ));
34 |     }
35 | 
36 |     /**
37 |      * @param mixed $current
38 |      *
39 |      * @return DateTimeInterface
40 |      */
41 |     public function getNextVersion($current)
42 |     {
43 |         return new DateTimeImmutable();
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Event/LifecycleEventArgs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Event;
 6 | 
 7 | use Doctrine\ODM\MongoDB\DocumentManager;
 8 | use Doctrine\Persistence\Event\LifecycleEventArgs as BaseLifecycleEventArgs;
 9 | use Doctrine\Persistence\ObjectManager;
10 | use MongoDB\Driver\Session;
11 | 
12 | /**
13 |  * Lifecycle Events are triggered by the UnitOfWork during lifecycle transitions
14 |  * of documents.
15 |  *
16 |  * @template-extends BaseLifecycleEventArgs<DocumentManager>
17 |  */
18 | class LifecycleEventArgs extends BaseLifecycleEventArgs
19 | {
20 |     public function __construct(
21 |         object $object,
22 |         ObjectManager $objectManager,
23 |         public readonly ?Session $session = null,
24 |     ) {
25 |         parent::__construct($object, $objectManager);
26 |     }
27 | 
28 |     public function getDocument(): object
29 |     {
30 |         return $this->getObject();
31 |     }
32 | 
33 |     public function getDocumentManager(): DocumentManager
34 |     {
35 |         return $this->getObjectManager();
36 |     }
37 | 
38 |     public function isInTransaction(): bool
39 |     {
40 |         return $this->session?->isInTransaction() ?? false;
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Types/IdType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | use MongoDB\BSON\ObjectId;
 8 | use MongoDB\Driver\Exception\InvalidArgumentException;
 9 | 
10 | /**
11 |  * The Id type.
12 |  */
13 | class IdType extends Type
14 | {
15 |     /** @return ObjectId|null */
16 |     public function convertToDatabaseValue($value)
17 |     {
18 |         if ($value === null) {
19 |             return null;
20 |         }
21 | 
22 |         if (! $value instanceof ObjectId) {
23 |             try {
24 |                 $value = new ObjectId((string) $value);
25 |             } catch (InvalidArgumentException) {
26 |                 $value = new ObjectId();
27 |             }
28 |         }
29 | 
30 |         return $value;
31 |     }
32 | 
33 |     public function convertToPHPValue($value)
34 |     {
35 |         return $value instanceof ObjectId ? (string) $value : $value;
36 |     }
37 | 
38 |     public function closureToMongo(): string
39 |     {
40 |         return '$return = new MongoDB\BSON\ObjectId($value);';
41 |     }
42 | 
43 |     public function closureToPHP(): string
44 |     {
45 |         return '$return = $value instanceof \MongoDB\BSON\ObjectId ? (string) $value : $value;';
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Group.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Builder;
 8 | use Doctrine\ODM\MongoDB\Aggregation\Expr;
 9 | use Doctrine\ODM\MongoDB\Aggregation\Operator\GroupAccumulatorOperators;
10 | use Doctrine\ODM\MongoDB\Aggregation\Operator\ProvidesGroupAccumulatorOperators;
11 | 
12 | /**
13 |  * Fluent interface for adding a $group stage to an aggregation pipeline.
14 |  *
15 |  * @phpstan-type GroupStageExpression array{"$group": array<string, mixed>}
16 |  */
17 | class Group extends Operator implements GroupAccumulatorOperators
18 | {
19 |     use ProvidesGroupAccumulatorOperators;
20 | 
21 |     /** @var Expr */
22 |     protected $expr;
23 | 
24 |     public function __construct(Builder $builder)
25 |     {
26 |         parent::__construct($builder);
27 | 
28 |         $this->expr = $builder->expr();
29 |     }
30 | 
31 |     /** @phpstan-return GroupStageExpression */
32 |     public function getExpression(): array
33 |     {
34 |         return [
35 |             '$group' => $this->expr->getExpression(),
36 |         ];
37 |     }
38 | 
39 |     protected function getExpr(): Expr
40 |     {
41 |         return $this->expr;
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/Compound/CompoundedEmbeddedDocument.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search\Compound;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundedSearchOperatorTrait;
 8 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\CompoundSearchOperatorInterface;
 9 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\EmbeddedDocument;
10 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\SearchOperator;
11 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search\SupportsCompoundableOperatorsTrait;
12 | 
13 | /** @internal */
14 | class CompoundedEmbeddedDocument extends EmbeddedDocument implements CompoundSearchOperatorInterface
15 | {
16 |     use CompoundedSearchOperatorTrait;
17 |     use SupportsCompoundableOperatorsTrait;
18 | 
19 |     /**
20 |      * @param T $operator
21 |      *
22 |      * @return T
23 |      *
24 |      * @template T of SearchOperator
25 |      */
26 |     protected function addOperator(SearchOperator $operator): SearchOperator
27 |     {
28 |         // Any operator we add should be added to the EmbeddedDocument operator,
29 |         // not the Compound operator we're nested in.
30 |         return EmbeddedDocument::addOperator($operator);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Types/Decimal128Type.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | use MongoDB\BSON\Decimal128;
 8 | 
 9 | use function bcadd;
10 | use function bcsub;
11 | 
12 | class Decimal128Type extends Type implements Incrementable, Versionable
13 | {
14 |     use ClosureToPHP;
15 | 
16 |     /** @return Decimal128|null */
17 |     public function convertToDatabaseValue($value)
18 |     {
19 |         if ($value === null) {
20 |             return null;
21 |         }
22 | 
23 |         if (! $value instanceof Decimal128) {
24 |             $value = new Decimal128($value);
25 |         }
26 | 
27 |         return $value;
28 |     }
29 | 
30 |     /** @return string|null */
31 |     public function convertToPHPValue($value)
32 |     {
33 |         return $value !== null ? (string) $value : null;
34 |     }
35 | 
36 |     /** @return string */
37 |     public function diff($old, $new)
38 |     {
39 |         return bcsub($new, $old);
40 |     }
41 | 
42 |     /**
43 |      * @param mixed $current
44 |      *
45 |      * @return string
46 |      */
47 |     public function getNextVersion($current)
48 |     {
49 |         if ($current === null) {
50 |             return '1';
51 |         }
52 | 
53 |         return bcadd($current, '1');
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/AbstractField.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use function class_alias;
 8 | 
 9 | /** @internal */
10 | abstract class AbstractField
11 | {
12 |     /** @var string|null */
13 |     public $name;
14 | 
15 |     /** @var string|null */
16 |     public $type;
17 | 
18 |     /** @var bool */
19 |     public $nullable;
20 | 
21 |     /** @var mixed[] */
22 |     public $options;
23 | 
24 |     /** @var string|null */
25 |     public $strategy;
26 | 
27 |     /** @var bool */
28 |     public $notSaved;
29 | 
30 |     /** @param mixed[] $options */
31 |     public function __construct(
32 |         ?string $name = null,
33 |         ?string $type = null,
34 |         bool $nullable = false,
35 |         array $options = [],
36 |         ?string $strategy = null,
37 |         bool $notSaved = false,
38 |     ) {
39 |         $this->name     = $name;
40 |         $this->type     = $type;
41 |         $this->nullable = $nullable;
42 |         $this->options  = $options;
43 |         $this->strategy = $strategy;
44 |         $this->notSaved = $notSaved;
45 |     }
46 | }
47 | 
48 | // @phpstan-ignore class.notFound
49 | class_alias(AbstractField::class, \Doctrine\ODM\MongoDB\Mapping\Annotations\AbstractField::class);
50 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/SearchIndex.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
 9 | 
10 | /**
11 |  * Defines a search index on a class.
12 |  *
13 |  * @see https://www.mongodb.com/docs/atlas/atlas-search/index-definitions/
14 |  *
15 |  * @phpstan-import-type SearchIndexStoredSource from ClassMetadata
16 |  * @phpstan-import-type SearchIndexSynonym from ClassMetadata
17 |  */
18 | #[Attribute(Attribute::TARGET_CLASS | Attribute::IS_REPEATABLE)]
19 | class SearchIndex implements MappingAttribute
20 | {
21 |     /**
22 |      * @param array<string, array>|null     $fields
23 |      * @param list<array>|null              $analyzers
24 |      * @param SearchIndexStoredSource|null  $storedSource
25 |      * @param list<SearchIndexSynonym>|null $synonyms
26 |      */
27 |     public function __construct(
28 |         public ?string $name = null,
29 |         public ?bool $dynamic = null,
30 |         public ?array $fields = null,
31 |         public ?string $analyzer = null,
32 |         public ?string $searchAnalyzer = null,
33 |         public ?array $analyzers = null,
34 |         public $storedSource = null,
35 |         public ?array $synonyms = null,
36 |     ) {
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/ScoredSearchOperatorTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | /** @internal */
 8 | trait ScoredSearchOperatorTrait
 9 | {
10 |     private ?object $score = null;
11 | 
12 |     private function appendScore(object $params): object
13 |     {
14 |         if (! $this->score) {
15 |             return $params;
16 |         }
17 | 
18 |         $params->score = $this->score;
19 | 
20 |         return $params;
21 |     }
22 | 
23 |     public function boostScore(?float $value = null, ?string $path = null, ?float $undefined = null): static
24 |     {
25 |         $boost = (object) [];
26 |         if ($value !== null) {
27 |             $boost->value = $value;
28 |         }
29 | 
30 |         if ($path !== null) {
31 |             $boost->path = $path;
32 |         }
33 | 
34 |         if ($undefined !== null) {
35 |             $boost->undefined = $undefined;
36 |         }
37 | 
38 |         $this->score = (object) ['boost' => $boost];
39 | 
40 |         return $this;
41 |     }
42 | 
43 |     public function constantScore(float $value): static
44 |     {
45 |         $this->score = (object) [
46 |             'constant' => (object) ['value' => $value],
47 |         ];
48 | 
49 |         return $this;
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/Query/CriteriaMerger.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Query;
 6 | 
 7 | use function array_filter;
 8 | use function array_values;
 9 | use function count;
10 | 
11 | /**
12 |  * Utility class for merging query criteria.
13 |  *
14 |  * This is mainly used to incorporate filter and ReferenceMany mapping criteria
15 |  * into a query. Each criteria array will be joined with "$and" to avoid cases
16 |  * where criteria might be inadvertently overridden with array_merge().
17 |  */
18 | final class CriteriaMerger
19 | {
20 |     /**
21 |      * Combines any number of criteria arrays as clauses of an "$and" query.
22 |      *
23 |      * @param array<string, mixed> ...$criterias Any number of query criteria arrays
24 |      *
25 |      * @return array<string, mixed>
26 |      */
27 |     public function merge(...$criterias): array
28 |     {
29 |         $nonEmptyCriterias = array_values(array_filter($criterias, static fn (array $criteria) => ! empty($criteria)));
30 | 
31 |         switch (count($nonEmptyCriterias)) {
32 |             case 0:
33 |                 return [];
34 | 
35 |             case 1:
36 |                 return $nonEmptyCriterias[0];
37 | 
38 |             default:
39 |                 return ['$and' => $nonEmptyCriterias];
40 |         }
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Proxy/Resolver/ProxyManagerClassNameResolver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Proxy\Resolver;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Configuration;
 8 | use Doctrine\Persistence\Mapping\ProxyClassNameResolver;
 9 | use ProxyManager\Inflector\ClassNameInflectorInterface;
10 | use ProxyManager\Proxy\ProxyInterface;
11 | 
12 | /** @internal */
13 | final class ProxyManagerClassNameResolver implements ClassNameResolver, ProxyClassNameResolver
14 | {
15 |     public function __construct(private Configuration $configuration)
16 |     {
17 |     }
18 | 
19 |     public function getRealClass(string $class): string
20 |     {
21 |         return $this->resolveClassName($class);
22 |     }
23 | 
24 |     /**
25 |      * @param class-string<RealClassName>|class-string<ProxyInterface<RealClassName>> $className
26 |      *
27 |      * @return class-string<RealClassName>
28 |      *
29 |      * @phpstan-template RealClassName of object
30 |      */
31 |     public function resolveClassName(string $className): string
32 |     {
33 |         return $this->getClassNameInflector()->getUserClassName($className);
34 |     }
35 | 
36 |     private function getClassNameInflector(): ClassNameInflectorInterface
37 |     {
38 |         return $this->configuration->getProxyManagerConfiguration()->getClassNameInflector();
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/SortByCount.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Builder;
 8 | use Doctrine\ODM\MongoDB\Aggregation\Stage;
 9 | use Doctrine\ODM\MongoDB\DocumentManager;
10 | use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
11 | 
12 | use function substr;
13 | 
14 | /** @phpstan-type SortByCountStageExpression array{"$sortByCount": string} */
15 | class SortByCount extends Stage
16 | {
17 |     private string $fieldName;
18 | 
19 |     /**
20 |      * @param string $fieldName Expression to group by. To specify a field path,
21 |      * prefix the field name with a dollar sign $ and enclose it in quotes.
22 |      * The expression can not evaluate to an object.
23 |      */
24 |     public function __construct(Builder $builder, string $fieldName, DocumentManager $dm, ClassMetadata $class)
25 |     {
26 |         parent::__construct($builder);
27 | 
28 |         $documentPersister = $dm->getUnitOfWork()->getDocumentPersister($class->name);
29 |         $this->fieldName   = '$' . $documentPersister->prepareFieldName(substr($fieldName, 1));
30 |     }
31 | 
32 |     /** @phpstan-return SortByCountStageExpression */
33 |     public function getExpression(): array
34 |     {
35 |         return [
36 |             '$sortByCount' => $this->fieldName,
37 |         ];
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Tools/Console/Helper/DocumentManagerHelper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Tools\Console\Helper;
 6 | 
 7 | use Doctrine\ODM\MongoDB\DocumentManager;
 8 | use ReflectionMethod;
 9 | use Symfony\Component\Console\Helper\Helper;
10 | use Symfony\Component\Console\Helper\HelperInterface;
11 | 
12 | if ((new ReflectionMethod(HelperInterface::class, 'getName'))->hasReturnType()) {
13 |     /** @internal */
14 |     trait DocumentManagerHelperCompatibility
15 |     {
16 |         public function getName(): string
17 |         {
18 |             return 'documentManager';
19 |         }
20 |     }
21 | } else {
22 |     /** @internal */
23 |     trait DocumentManagerHelperCompatibility
24 |     {
25 |         /** @return string */
26 |         public function getName()
27 |         {
28 |             return 'documentManager';
29 |         }
30 |     }
31 | }
32 | 
33 | /**
34 |  * Symfony console component helper for accessing a DocumentManager instance.
35 |  */
36 | class DocumentManagerHelper extends Helper
37 | {
38 |     use DocumentManagerHelperCompatibility;
39 | 
40 |     /** @var DocumentManager */
41 |     protected $dm;
42 | 
43 |     public function __construct(DocumentManager $dm)
44 |     {
45 |         $this->dm = $dm;
46 |     }
47 | 
48 |     public function getDocumentManager(): DocumentManager
49 |     {
50 |         return $this->dm;
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/src/Event/OnClassMetadataNotFoundEventArgs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Event;
 6 | 
 7 | use Doctrine\ODM\MongoDB\DocumentManager;
 8 | use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
 9 | 
10 | /**
11 |  * Class that holds event arguments for a `onClassMetadataNotFound` event.
12 |  *
13 |  * This object is mutable by design, allowing callbacks having access to it to set the
14 |  * found metadata in it, and therefore "cancelling" a `onClassMetadataNotFound` event
15 |  */
16 | final class OnClassMetadataNotFoundEventArgs extends ManagerEventArgs
17 | {
18 |     private ?ClassMetadata $foundMetadata = null;
19 | 
20 |     /** @param class-string $className */
21 |     public function __construct(private string $className, DocumentManager $dm)
22 |     {
23 |         parent::__construct($dm);
24 |     }
25 | 
26 |     public function setFoundMetadata(?ClassMetadata $classMetadata = null): void
27 |     {
28 |         $this->foundMetadata = $classMetadata;
29 |     }
30 | 
31 |     public function getFoundMetadata(): ?ClassMetadata
32 |     {
33 |         return $this->foundMetadata;
34 |     }
35 | 
36 |     /**
37 |      * Retrieve class name for which a failed metadata fetch attempt was executed
38 |      *
39 |      * @return class-string
40 |      */
41 |     public function getClassName(): string
42 |     {
43 |         return $this->className;
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Event/DocumentNotFoundEventArgs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Event;
 6 | 
 7 | use Doctrine\ODM\MongoDB\DocumentManager;
 8 | 
 9 | /**
10 |  * Provides event arguments for the documentNotFound event.
11 |  */
12 | final class DocumentNotFoundEventArgs extends LifecycleEventArgs
13 | {
14 |     private bool $disableException = false;
15 | 
16 |     public function __construct(object $document, DocumentManager $dm, private mixed $identifier)
17 |     {
18 |         parent::__construct($document, $dm);
19 |     }
20 | 
21 |     /**
22 |      * Retrieve associated identifier.
23 |      *
24 |      * @return mixed
25 |      */
26 |     public function getIdentifier()
27 |     {
28 |         return $this->identifier;
29 |     }
30 | 
31 |     /**
32 |      * Indicates whether the proxy initialization exception is disabled.
33 |      */
34 |     public function isExceptionDisabled(): bool
35 |     {
36 |         return $this->disableException;
37 |     }
38 | 
39 |     /**
40 |      * Disable the throwing of an exception
41 |      *
42 |      * This method indicates to the proxy initializer that the missing document
43 |      * has been handled and no exception should be thrown. This can't be reset.
44 |      */
45 |     public function disableException(bool $disableException = true): void
46 |     {
47 |         $this->disableException = $disableException;
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/Mapping/ClassMetadataFactoryInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Configuration;
 8 | use Doctrine\ODM\MongoDB\DocumentManager;
 9 | use Doctrine\Persistence\Mapping\ClassMetadataFactory;
10 | use Doctrine\Persistence\Mapping\ProxyClassNameResolver;
11 | use Psr\Cache\CacheItemPoolInterface;
12 | 
13 | /**
14 |  * @template-extends ClassMetadataFactory<ClassMetadata>
15 |  * @method list<ClassMetadata> getAllMetadata()
16 |  * @method ClassMetadata[] getLoadedMetadata()
17 |  * @method ClassMetadata getMetadataFor($className)
18 |  */
19 | interface ClassMetadataFactoryInterface extends ClassMetadataFactory
20 | {
21 |     /**
22 |      * Sets the cache for created metadata.
23 |      */
24 |     public function setCache(CacheItemPoolInterface $cache): void;
25 | 
26 |     /**
27 |      * Sets the configuration for the factory.
28 |      */
29 |     public function setConfiguration(Configuration $config): void;
30 | 
31 |     /**
32 |      * Sets the document manager owning the factory.
33 |      */
34 |     public function setDocumentManager(DocumentManager $dm): void;
35 | 
36 |     /**
37 |      * Sets a resolver for real class names of a proxy.
38 |      *
39 |      * @deprecated This method is deprecated and will be removed in Doctrine ODM 3.0.
40 |      */
41 |     public function setProxyClassNameResolver(ProxyClassNameResolver $resolver): void;
42 | }
43 | 


--------------------------------------------------------------------------------
/UPGRADE-2.3.md:
--------------------------------------------------------------------------------
 1 | # UPGRADE FROM 2.2 to 2.3
 2 | 
 3 | ## Proxy Class Name Resolution
 4 | 
 5 | The `Doctrine\ODM\MongoDB\Proxy\Resolver\ClassNameResolver` interface has been
 6 | deprecated in favor of the `Doctrine\Persistence\Mapping\ProxyClassNameResolver`
 7 | interface.
 8 | 
 9 | The `getClassNameResolver` method in `DocumentManager` is deprecated and should
10 | not be used. To retrieve the mapped class name for any object or class string,
11 | fetch metadata for the class and read the class using `$metadata->getName()`.
12 | The metadata layer is aware of these proxy namespace changes and how to resolve
13 | them, so users should always go through the metadata layer to retrieve mapped
14 | class names.
15 | 
16 | ## Annotation Mapping
17 | 
18 | In order to make annotations usable as PHP 8 attributes, their classes no 
19 | longer extend `Doctrine\Common\Annotations\Annotation` class and are now using 
20 | `@NamedArgumentConstructor` which provides more type safety. 
21 | This does not apply to `@Indexes` which is deprecated and can't be used as 
22 | Attribute. Use `@Index` and `@UniqueIndex` instead.
23 | 
24 | `@Inheritance` annotation has been removed as it was never used.
25 | 
26 | ## Deprecated: Document Namespace Aliases
27 | 
28 | Document namespace aliases are deprecated, use the magic ::class constant to abbreviate full class names
29 | in DocumentManager and DocumentRepository.
30 | 
31 | ```diff
32 | -  $documentManager->find('MyBundle:User', $id);
33 | +  $documentManager->find(User::class, $id);
34 | ```
35 | 


--------------------------------------------------------------------------------
/src/LockException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB;
 6 | 
 7 | final class LockException extends MongoDBException
 8 | {
 9 |     public function __construct(string $msg, private ?object $document = null)
10 |     {
11 |         parent::__construct($msg);
12 |     }
13 | 
14 |     /**
15 |      * Gets the document that caused the exception.
16 |      */
17 |     public function getDocument(): ?object
18 |     {
19 |         return $this->document;
20 |     }
21 | 
22 |     public static function lockFailed(?object $document): self
23 |     {
24 |         return new self('A lock failed on a document.', $document);
25 |     }
26 | 
27 |     public static function lockFailedVersionMissmatch(object $document, int $expectedLockVersion, int $actualLockVersion): self
28 |     {
29 |         return new self('The optimistic lock failed, version ' . $expectedLockVersion . ' was expected, but is actually ' . $actualLockVersion, $document);
30 |     }
31 | 
32 |     public static function notVersioned(string $documentName): self
33 |     {
34 |         return new self('Document ' . $documentName . ' is not versioned.');
35 |     }
36 | 
37 |     public static function invalidLockFieldType(string $type): self
38 |     {
39 |         return new self('Invalid lock field type ' . $type . '. Lock field must be int.');
40 |     }
41 | 
42 |     public static function invalidVersionFieldType(string $type): self
43 |     {
44 |         return new self('Type ' . $type . ' does not implement Versionable interface.');
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/Phrase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | use function array_values;
 8 | 
 9 | /**
10 |  * @internal
11 |  *
12 |  * @see https://www.mongodb.com/docs/atlas/atlas-search/phrase/
13 |  */
14 | class Phrase extends AbstractSearchOperator implements ScoredSearchOperator
15 | {
16 |     use ScoredSearchOperatorTrait;
17 | 
18 |     /** @var list<string> */
19 |     private array $query = [];
20 | 
21 |     /** @var list<string> */
22 |     private array $path = [];
23 |     private ?int $slop  = null;
24 | 
25 |     public function query(string ...$query): static
26 |     {
27 |         $this->query = array_values($query);
28 | 
29 |         return $this;
30 |     }
31 | 
32 |     public function path(string ...$path): static
33 |     {
34 |         $this->path = $path;
35 | 
36 |         return $this;
37 |     }
38 | 
39 |     public function slop(int $slop): static
40 |     {
41 |         $this->slop = $slop;
42 | 
43 |         return $this;
44 |     }
45 | 
46 |     public function getOperatorName(): string
47 |     {
48 |         return 'phrase';
49 |     }
50 | 
51 |     public function getOperatorParams(): object
52 |     {
53 |         $params = (object) [
54 |             'query' => $this->query,
55 |             'path' => $this->prepareFieldPath($this->path),
56 |         ];
57 | 
58 |         if ($this->slop !== null) {
59 |             $params->slop = $this->slop;
60 |         }
61 | 
62 |         return $this->appendScore($params);
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/Document.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Identifies a class as a document that can be stored in the database
11 |  *
12 |  * @final
13 |  */
14 | #[Attribute(Attribute::TARGET_CLASS)]
15 | class Document extends AbstractDocument
16 | {
17 |     /** @var string|null */
18 |     public $db;
19 | 
20 |     /** @var string|null */
21 |     public $repositoryClass;
22 | 
23 |     /** @var Index[] */
24 |     public $indexes;
25 | 
26 |     /** @var bool */
27 |     public $readOnly;
28 | 
29 |     /** @var string|null */
30 |     public $shardKey;
31 | 
32 |     /**
33 |      * @param string|array{name: string, capped?: bool, size?: int, max?: int}|null $collection
34 |      * @param Index[]                                                               $indexes
35 |      * @param int|string|null                                                       $writeConcern
36 |      */
37 |     public function __construct(
38 |         ?string $db = null,
39 |         public $collection = null,
40 |         ?string $repositoryClass = null,
41 |         array $indexes = [],
42 |         bool $readOnly = false,
43 |         ?string $shardKey = null,
44 |         public $writeConcern = null,
45 |     ) {
46 |         $this->db              = $db;
47 |         $this->repositoryClass = $repositoryClass;
48 |         $this->indexes         = $indexes;
49 |         $this->readOnly        = $readOnly;
50 |         $this->shardKey        = $shardKey;
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/src/Aggregation/Operator/BooleanOperators.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Operator;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Expr;
 8 | 
 9 | /**
10 |  * Interface containing all boolean aggregation pipeline operators.
11 |  *
12 |  * This interface can be used for type hinting, but must not be implemented by
13 |  * users. Methods WILL be added to the public API in future minor versions.
14 |  *
15 |  * @internal
16 |  */
17 | interface BooleanOperators
18 | {
19 |     /**
20 |      * Adds one or more $and clauses to the current expression.
21 |      *
22 |      * @see https://docs.mongodb.com/manual/reference/operator/aggregation/and/
23 |      *
24 |      * @param array<string, mixed>|Expr $expression
25 |      * @param array<string, mixed>|Expr ...$expressions
26 |      */
27 |     public function and($expression, ...$expressions): static;
28 | 
29 |     /**
30 |      * Evaluates a boolean and returns the opposite boolean value.
31 |      *
32 |      * @see https://docs.mongodb.com/manual/reference/operator/aggregation/not/
33 |      *
34 |      * @param mixed|Expr $expression
35 |      */
36 |     public function not($expression): static;
37 | 
38 |     /**
39 |      * Adds one or more $or clause to the current expression.
40 |      *
41 |      * @see https://docs.mongodb.com/manual/reference/operator/aggregation/or/
42 |      *
43 |      * @param array<string, mixed>|Expr $expression
44 |      * @param array<string, mixed>|Expr ...$expressions
45 |      */
46 |     public function or($expression, ...$expressions): static;
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Mapping/Driver/AnnotationDriver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Driver;
 6 | 
 7 | use Doctrine\Common\Annotations\AnnotationReader;
 8 | use Doctrine\Common\Annotations\Reader;
 9 | use Doctrine\Persistence\Mapping\Driver\ClassLocator;
10 | 
11 | /**
12 |  * The AnnotationDriver reads the mapping metadata from docblock annotations.
13 |  */
14 | class AnnotationDriver extends AttributeDriver
15 | {
16 |     /**
17 |      * The annotation reader.
18 |      *
19 |      * @internal this property will be private in 3.0
20 |      *
21 |      * @var Reader
22 |      */
23 |     protected $reader;
24 | 
25 |     /**
26 |      * Initializes a new AnnotationDriver that uses the given AnnotationReader for reading
27 |      * docblock annotations.
28 |      *
29 |      * @param Reader                            $reader The AnnotationReader to use, duck-typed.
30 |      * @param string|string[]|ClassLocator|null $paths  One or multiple paths where mapping classes can be found.
31 |      */
32 |     public function __construct($reader, $paths = null)
33 |     {
34 |         parent::__construct($paths);
35 | 
36 |         // Setting the reader in the parent constructor is deprecated.
37 |         $this->reader = $reader;
38 |     }
39 | 
40 |     /**
41 |      * Factory method for the Annotation Driver
42 |      *
43 |      * @param string|string[]|ClassLocator $paths
44 |      */
45 |     public static function create($paths = [], ?Reader $reader = null): AnnotationDriver
46 |     {
47 |         return new self($reader ?? new AnnotationReader(), $paths);
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/UPGRADE-2.2.md:
--------------------------------------------------------------------------------
 1 | # UPGRADE FROM 2.1 to 2.2
 2 | 
 3 | ## Aggregation
 4 | 
 5 | The new `Doctrine\ODM\MongoDB\Aggregation\Builder::getAggregation()` method
 6 | returns an `Doctrine\ODM\MongoDB\Aggregation\Aggregation` instance, comparable
 7 | to the `Query` class.
 8 | 
 9 | The `Doctrine\ODM\MongoDB\Aggregation\Builder::execute()` method was deprecated
10 | and will be removed in ODM 3.0.
11 | 
12 | The `Doctrine\ODM\MongoDB\Aggregation\Stage\Match` and 
13 | `Doctrine\ODM\MongoDB\Aggregation\Stage\GraphLookup\Match` classes were
14 | deprecated and replaced by `Doctrine\ODM\MongoDB\Aggregation\Stage\MatchStage`
15 | and `Doctrine\ODM\MongoDB\Aggregation\Stage\GraphLookup\MatchStage`
16 | respectively. This change was necessary due to `match` being a reserved keyword
17 | in PHP 8. You must replace any usage of this class before you migrate to PHP 8.
18 | 
19 | ## Document indexes (annotations)
20 | 
21 | Using `@Index` annotation(s) on a class level is a preferred way for defining
22 | indexes for documents. Using `@Index` in the `@Indexes` annotation or an `indexes`
23 | property of other annotations was deprecated and will be removed in ODM 3.0.
24 | 
25 | ## DocumentManager configuration
26 | 
27 | Using doctrine/cache to cache metadata is deprecated in favor of using PSR-6.
28 | The `getMetadataCacheImpl` and `setMetadataCacheImpl` methods in
29 | `Doctrine\ODM\MongoDB\Configuration` have been deprecated. Please use
30 | `getMetadataCache`and `setMetadataCache` with a PSR-6 implementation instead.
31 | Note that even after switching to PSR-6, `getMetadataCacheImpl` will return a
32 | cache instance that wraps the PSR-6 cache.
33 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Project.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Expr;
 8 | 
 9 | /**
10 |  * Fluent interface for adding a $project stage to an aggregation pipeline.
11 |  *
12 |  * @phpstan-import-type OperatorExpression from Expr
13 |  * @phpstan-type ProjectStageExpression array{"$project": array<string, OperatorExpression|mixed>}
14 |  */
15 | class Project extends Operator
16 | {
17 |     /** @phpstan-return ProjectStageExpression */
18 |     public function getExpression(): array
19 |     {
20 |         return [
21 |             '$project' => $this->expr->getExpression(),
22 |         ];
23 |     }
24 | 
25 |     /**
26 |      * Shorthand method to define which fields to be included.
27 |      *
28 |      * @param string[] $fields
29 |      */
30 |     public function includeFields(array $fields): static
31 |     {
32 |         foreach ($fields as $fieldName) {
33 |             $this->field($fieldName)->expression(true);
34 |         }
35 | 
36 |         return $this;
37 |     }
38 | 
39 |     /**
40 |      * Shorthand method to define which fields to be excluded.
41 |      *
42 |      * If you specify the exclusion of a field other than _id, you cannot employ
43 |      * any other $project specification forms.
44 |      *
45 |      * @param string[] $fields
46 |      */
47 |     public function excludeFields(array $fields): static
48 |     {
49 |         foreach ($fields as $fieldName) {
50 |             $this->field($fieldName)->expression(false);
51 |         }
52 | 
53 |         return $this;
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/Types/BinDataType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Types;
 6 | 
 7 | use MongoDB\BSON\Binary;
 8 | 
 9 | use function sprintf;
10 | 
11 | /**
12 |  * The BinData type for generic data.
13 |  */
14 | class BinDataType extends Type
15 | {
16 |     /**
17 |      * Data type for binary data
18 |      *
19 |      * @see http://bsonspec.org/#/specification
20 |      *
21 |      * @var int
22 |      */
23 |     protected $binDataType = Binary::TYPE_GENERIC;
24 | 
25 |     /** @return Binary|null */
26 |     public function convertToDatabaseValue($value)
27 |     {
28 |         if ($value === null) {
29 |             return null;
30 |         }
31 | 
32 |         if (! $value instanceof Binary) {
33 |             return new Binary($value, $this->binDataType);
34 |         }
35 | 
36 |         if ($value->getType() !== $this->binDataType) {
37 |             return new Binary($value->getData(), $this->binDataType);
38 |         }
39 | 
40 |         return $value;
41 |     }
42 | 
43 |     /** @return mixed|string|null */
44 |     public function convertToPHPValue($value)
45 |     {
46 |         return $value !== null ? ($value instanceof Binary ? $value->getData() : $value) : null;
47 |     }
48 | 
49 |     public function closureToMongo(): string
50 |     {
51 |         return sprintf('$return = $value !== null ? new \MongoDB\BSON\Binary($value, %d) : null;', $this->binDataType);
52 |     }
53 | 
54 |     public function closureToPHP(): string
55 |     {
56 |         return '$return = $value !== null ? ($value instanceof \MongoDB\BSON\Binary ? $value->getData() : $value) : null;';
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/QueryString.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 8 | use Doctrine\ODM\MongoDB\Persisters\DocumentPersister;
 9 | 
10 | /**
11 |  * @internal
12 |  *
13 |  * @see https://www.mongodb.com/docs/atlas/atlas-search/queryString/
14 |  */
15 | class QueryString extends AbstractSearchOperator implements ScoredSearchOperator
16 | {
17 |     use ScoredSearchOperatorTrait;
18 | 
19 |     private string $query;
20 |     private string $defaultPath;
21 | 
22 |     public function __construct(Search $search, DocumentPersister $persister, string $query = '', string $defaultPath = '')
23 |     {
24 |         parent::__construct($search, $persister);
25 | 
26 |         $this
27 |             ->query($query)
28 |             ->defaultPath($defaultPath);
29 |     }
30 | 
31 |     public function query(string $query): static
32 |     {
33 |         $this->query = $query;
34 | 
35 |         return $this;
36 |     }
37 | 
38 |     public function defaultPath(string $defaultPath): static
39 |     {
40 |         $this->defaultPath = $defaultPath;
41 | 
42 |         return $this;
43 |     }
44 | 
45 |     public function getOperatorName(): string
46 |     {
47 |         return 'queryString';
48 |     }
49 | 
50 |     public function getOperatorParams(): object
51 |     {
52 |         $params = (object) [
53 |             'query' => $this->query,
54 |             'defaultPath' => $this->prepareFieldPath($this->defaultPath),
55 |         ];
56 | 
57 |         return $this->appendScore($params);
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/Regex.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  *
10 |  * @see https://www.mongodb.com/docs/atlas/atlas-search/regex/
11 |  */
12 | class Regex extends AbstractSearchOperator implements ScoredSearchOperator
13 | {
14 |     use ScoredSearchOperatorTrait;
15 | 
16 |     /** @var list<string> */
17 |     private array $query = [];
18 | 
19 |     /** @var list<string> */
20 |     private array $path               = [];
21 |     private ?bool $allowAnalyzedField = null;
22 | 
23 |     public function query(string ...$query): static
24 |     {
25 |         $this->query = $query;
26 | 
27 |         return $this;
28 |     }
29 | 
30 |     public function path(string ...$path): static
31 |     {
32 |         $this->path = $path;
33 | 
34 |         return $this;
35 |     }
36 | 
37 |     public function allowAnalyzedField(bool $allowAnalyzedField = true): static
38 |     {
39 |         $this->allowAnalyzedField = $allowAnalyzedField;
40 | 
41 |         return $this;
42 |     }
43 | 
44 |     public function getOperatorName(): string
45 |     {
46 |         return 'regex';
47 |     }
48 | 
49 |     public function getOperatorParams(): object
50 |     {
51 |         $params = (object) [
52 |             'query' => $this->query,
53 |             'path' => $this->prepareFieldPath($this->path),
54 |         ];
55 | 
56 |         if ($this->allowAnalyzedField !== null) {
57 |             $params->allowAnalyzedField = $this->allowAnalyzedField;
58 |         }
59 | 
60 |         return $this->appendScore($params);
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/Mapping/PropertyAccessors/ReflectionReadonlyProperty.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\PropertyAccessors;
 6 | 
 7 | use InvalidArgumentException;
 8 | use LogicException;
 9 | use ReflectionProperty;
10 | 
11 | use function assert;
12 | use function func_get_args;
13 | use function func_num_args;
14 | use function is_object;
15 | use function sprintf;
16 | 
17 | /** @internal */
18 | final class ReflectionReadonlyProperty extends ReflectionProperty
19 | {
20 |     public function __construct(
21 |         private readonly ReflectionProperty $wrappedProperty,
22 |     ) {
23 |         if (! $wrappedProperty->isReadOnly()) {
24 |             throw new InvalidArgumentException('Given property is not readonly.');
25 |         }
26 | 
27 |         parent::__construct($wrappedProperty->class, $wrappedProperty->name);
28 |     }
29 | 
30 |     public function getValue(object|null $object = null): mixed
31 |     {
32 |         return $this->wrappedProperty->getValue(...func_get_args());
33 |     }
34 | 
35 |     public function setValue(mixed $objectOrValue, mixed $value = null): void
36 |     {
37 |         if (func_num_args() < 2 || $objectOrValue === null || ! $this->isInitialized($objectOrValue)) {
38 |             $this->wrappedProperty->setValue(...func_get_args());
39 | 
40 |             return;
41 |         }
42 | 
43 |         assert(is_object($objectOrValue));
44 | 
45 |         if (parent::getValue($objectOrValue) !== $value) {
46 |             throw new LogicException(sprintf('Attempting to change readonly property %s::$%s.', $this->class, $this->name));
47 |         }
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/Wildcard.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  *
10 |  * @see https://www.mongodb.com/docs/atlas/atlas-search/wildcard/
11 |  */
12 | class Wildcard extends AbstractSearchOperator implements ScoredSearchOperator
13 | {
14 |     use ScoredSearchOperatorTrait;
15 | 
16 |     /** @var list<string> */
17 |     private array $query = [];
18 | 
19 |     /** @var list<string> */
20 |     private array $path               = [];
21 |     private ?bool $allowAnalyzedField = null;
22 | 
23 |     public function query(string ...$query): static
24 |     {
25 |         $this->query = $query;
26 | 
27 |         return $this;
28 |     }
29 | 
30 |     public function path(string ...$path): static
31 |     {
32 |         $this->path = $path;
33 | 
34 |         return $this;
35 |     }
36 | 
37 |     public function allowAnalyzedField(bool $allowAnalyzedField = true): static
38 |     {
39 |         $this->allowAnalyzedField = $allowAnalyzedField;
40 | 
41 |         return $this;
42 |     }
43 | 
44 |     public function getOperatorName(): string
45 |     {
46 |         return 'wildcard';
47 |     }
48 | 
49 |     public function getOperatorParams(): object
50 |     {
51 |         $params = (object) [
52 |             'query' => $this->query,
53 |             'path' => $this->prepareFieldPath($this->path),
54 |         ];
55 | 
56 |         if ($this->allowAnalyzedField !== null) {
57 |             $params->allowAnalyzedField = $this->allowAnalyzedField;
58 |         }
59 | 
60 |         return $this->appendScore($params);
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/File.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * Identifies a class as a GridFS file that can be stored in the database
11 |  *
12 |  * @final
13 |  */
14 | #[Attribute(Attribute::TARGET_CLASS)]
15 | class File extends AbstractDocument
16 | {
17 |     /** @var string|null */
18 |     public $db;
19 | 
20 |     /** @var string|null */
21 |     public $bucketName;
22 | 
23 |     /** @var string|null */
24 |     public $repositoryClass;
25 | 
26 |     /** @var Index[] */
27 |     public $indexes;
28 | 
29 |     /** @var bool bool */
30 |     public $readOnly;
31 | 
32 |     /** @var string|null */
33 |     public $shardKey;
34 | 
35 |     /** @var int|null */
36 |     public $chunkSizeBytes;
37 | 
38 |     /**
39 |      * @param Index[]         $indexes
40 |      * @param string|int|null $writeConcern
41 |      */
42 |     public function __construct(
43 |         ?string $db = null,
44 |         ?string $bucketName = null,
45 |         ?string $repositoryClass = null,
46 |         array $indexes = [],
47 |         bool $readOnly = false,
48 |         ?string $shardKey = null,
49 |         public $writeConcern = null,
50 |         ?int $chunkSizeBytes = null,
51 |     ) {
52 |         $this->db              = $db;
53 |         $this->bucketName      = $bucketName;
54 |         $this->repositoryClass = $repositoryClass;
55 |         $this->indexes         = $indexes;
56 |         $this->readOnly        = $readOnly;
57 |         $this->shardKey        = $shardKey;
58 |         $this->chunkSizeBytes  = $chunkSizeBytes;
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/EmbedOne.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
 9 | 
10 | /**
11 |  * Embeds a single document
12 |  *
13 |  * @final
14 |  */
15 | #[Attribute(Attribute::TARGET_PROPERTY)]
16 | class EmbedOne extends AbstractField implements MappingAttribute
17 | {
18 |     /** @var bool */
19 |     public $embedded = true;
20 | 
21 |     /** @var string|null */
22 |     public $targetDocument;
23 | 
24 |     /** @var string|null */
25 |     public $discriminatorField;
26 | 
27 |     /** @var array<string, class-string>|null */
28 |     public $discriminatorMap;
29 | 
30 |     /** @var string|null */
31 |     public $defaultDiscriminatorValue;
32 | 
33 |     /** @param array<string, class-string>|null $discriminatorMap */
34 |     public function __construct(
35 |         ?string $name = null,
36 |         bool $nullable = false,
37 |         array $options = [],
38 |         ?string $strategy = null,
39 |         bool $notSaved = false,
40 |         ?string $targetDocument = null,
41 |         ?string $discriminatorField = null,
42 |         ?array $discriminatorMap = null,
43 |         ?string $defaultDiscriminatorValue = null,
44 |     ) {
45 |         parent::__construct($name, ClassMetadata::ONE, $nullable, $options, $strategy, $notSaved);
46 | 
47 |         $this->targetDocument            = $targetDocument;
48 |         $this->discriminatorField        = $discriminatorField;
49 |         $this->discriminatorMap          = $discriminatorMap;
50 |         $this->defaultDiscriminatorValue = $defaultDiscriminatorValue;
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/File/Metadata.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute\File;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\ODM\MongoDB\Mapping\Attribute\AbstractField;
 9 | use Doctrine\ODM\MongoDB\Mapping\Attribute\MappingAttribute;
10 | use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
11 | 
12 | /** @final */
13 | #[Attribute(Attribute::TARGET_PROPERTY)]
14 | class Metadata extends AbstractField implements MappingAttribute
15 | {
16 |     /** @var bool */
17 |     public $embedded = true;
18 | 
19 |     /** @var string|null */
20 |     public $targetDocument;
21 | 
22 |     /** @var string|null */
23 |     public $discriminatorField;
24 | 
25 |     /** @var array<string, class-string>|null */
26 |     public $discriminatorMap;
27 | 
28 |     /** @var string|null */
29 |     public $defaultDiscriminatorValue;
30 | 
31 |     /** @param array<string, class-string>|null $discriminatorMap */
32 |     public function __construct(
33 |         bool $nullable = false,
34 |         array $options = [],
35 |         ?string $strategy = null,
36 |         bool $notSaved = false,
37 |         ?string $targetDocument = null,
38 |         ?string $discriminatorField = null,
39 |         ?array $discriminatorMap = null,
40 |         ?string $defaultDiscriminatorValue = null,
41 |     ) {
42 |         parent::__construct('metadata', ClassMetadata::ONE, $nullable, $options, $strategy, $notSaved);
43 | 
44 |         $this->targetDocument            = $targetDocument;
45 |         $this->discriminatorField        = $discriminatorField;
46 |         $this->discriminatorMap          = $discriminatorMap;
47 |         $this->defaultDiscriminatorValue = $defaultDiscriminatorValue;
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/Equals.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 8 | use Doctrine\ODM\MongoDB\Persisters\DocumentPersister;
 9 | use MongoDB\BSON\ObjectId;
10 | use MongoDB\BSON\UTCDateTime;
11 | 
12 | /**
13 |  * @internal
14 |  *
15 |  * @see https://www.mongodb.com/docs/atlas/atlas-search/equals/
16 |  */
17 | class Equals extends AbstractSearchOperator implements ScoredSearchOperator
18 | {
19 |     use ScoredSearchOperatorTrait;
20 | 
21 |     private string $path = '';
22 | 
23 |     private mixed $value;
24 | 
25 |     /** @param string|int|float|ObjectId|UTCDateTime|null $value */
26 |     public function __construct(Search $search, DocumentPersister $persister, string $path = '', $value = null)
27 |     {
28 |         parent::__construct($search, $persister);
29 | 
30 |         $this
31 |             ->path($path)
32 |             ->value($value);
33 |     }
34 | 
35 |     public function path(string $path): static
36 |     {
37 |         $this->path = $path;
38 | 
39 |         return $this;
40 |     }
41 | 
42 |     /** @param string|int|float|ObjectId|UTCDateTime|null $value */
43 |     public function value($value): static
44 |     {
45 |         $this->value = $value;
46 | 
47 |         return $this;
48 |     }
49 | 
50 |     public function getOperatorName(): string
51 |     {
52 |         return 'equals';
53 |     }
54 | 
55 |     public function getOperatorParams(): object
56 |     {
57 |         $params = (object) [
58 |             'path' => $this->prepareFieldPath($this->path),
59 |             'value' => $this->value,
60 |         ];
61 | 
62 |         return $this->appendScore($params);
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/src/PersistentCollection/AbstractPersistentCollectionFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\PersistentCollection;
 6 | 
 7 | use Doctrine\Common\Collections\ArrayCollection;
 8 | use Doctrine\Common\Collections\Collection as BaseCollection;
 9 | use Doctrine\ODM\MongoDB\DocumentManager;
10 | use Doctrine\ODM\MongoDB\PersistentCollection;
11 | 
12 | /**
13 |  * Abstract factory for creating persistent collection classes.
14 |  */
15 | abstract class AbstractPersistentCollectionFactory implements PersistentCollectionFactory
16 | {
17 |     public function create(DocumentManager $dm, array $mapping, ?BaseCollection $coll = null): PersistentCollectionInterface
18 |     {
19 |         if ($coll === null) {
20 |             $coll = ! empty($mapping['collectionClass'])
21 |                 ? $this->createCollectionClass($mapping['collectionClass'])
22 |                 : new ArrayCollection();
23 |         }
24 | 
25 |         if (empty($mapping['collectionClass'])) {
26 |             return new PersistentCollection($coll, $dm, $dm->getUnitOfWork());
27 |         }
28 | 
29 |         $className = $dm->getConfiguration()->getPersistentCollectionGenerator()
30 |             ->loadClass($mapping['collectionClass'], $dm->getConfiguration()->getAutoGeneratePersistentCollectionClasses());
31 | 
32 |         return new $className($coll, $dm, $dm->getUnitOfWork());
33 |     }
34 | 
35 |     /**
36 |      * Creates instance of collection class to be wrapped by PersistentCollection.
37 |      *
38 |      * @param string $collectionClass FQCN of class to instantiate
39 |      *
40 |      * @return BaseCollection
41 |      */
42 |     abstract protected function createCollectionClass(string $collectionClass): BaseCollection;
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Mapping/PropertyAccessors/ReadonlyAccessor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\PropertyAccessors;
 6 | 
 7 | use InvalidArgumentException;
 8 | use LogicException;
 9 | use ReflectionProperty;
10 | 
11 | use function sprintf;
12 | 
13 | /** @internal */
14 | class ReadonlyAccessor implements PropertyAccessor
15 | {
16 |     public function __construct(private PropertyAccessor $parent, private ReflectionProperty $reflectionProperty)
17 |     {
18 |         if (! $this->reflectionProperty->isReadOnly()) {
19 |             throw new InvalidArgumentException(sprintf(
20 |                 '%s::$%s must be readonly property',
21 |                 $this->reflectionProperty->getDeclaringClass()->getName(),
22 |                 $this->reflectionProperty->getName(),
23 |             ));
24 |         }
25 |     }
26 | 
27 |     public function setValue(object $object, mixed $value): void
28 |     {
29 |         if (! $this->reflectionProperty->isInitialized($object)) {
30 |             $this->parent->setValue($object, $value);
31 | 
32 |             return;
33 |         }
34 | 
35 |         if ($this->parent->getValue($object) !== $value) {
36 |             throw new LogicException(sprintf(
37 |                 'Attempting to change readonly property %s::$%s.',
38 |                 $this->reflectionProperty->getDeclaringClass()->getName(),
39 |                 $this->reflectionProperty->getName(),
40 |             ));
41 |         }
42 |     }
43 | 
44 |     public function getValue(object $object): mixed
45 |     {
46 |         return $this->parent->getValue($object);
47 |     }
48 | 
49 |     public function getUnderlyingReflector(): ReflectionProperty
50 |     {
51 |         return $this->reflectionProperty;
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/CompoundedSearchOperatorTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | use Closure;
 8 | use LogicException;
 9 | 
10 | use function sprintf;
11 | 
12 | /** @internal */
13 | trait CompoundedSearchOperatorTrait
14 | {
15 |     public function __construct(private Compound $compound, private Closure $addOperator, ...$args)
16 |     {
17 |         if (! $this instanceof CompoundSearchOperatorInterface) {
18 |             throw new LogicException(sprintf('Can only use %s on classes extending %s.', self::class, CompoundSearchOperatorInterface::class));
19 |         }
20 | 
21 |         parent::__construct(...$args);
22 |     }
23 | 
24 |     public function must(): Compound
25 |     {
26 |         return $this->compound->must();
27 |     }
28 | 
29 |     public function mustNot(): Compound
30 |     {
31 |         return $this->compound->mustNot();
32 |     }
33 | 
34 |     public function should(?int $minimumShouldMatch = null): Compound
35 |     {
36 |         return $this->compound->should($minimumShouldMatch);
37 |     }
38 | 
39 |     public function filter(): Compound
40 |     {
41 |         return $this->compound->filter();
42 |     }
43 | 
44 |     /**
45 |      * @param T $operator
46 |      *
47 |      * @return T
48 |      *
49 |      * @template T of SearchOperator
50 |      */
51 |     protected function addOperator(SearchOperator $operator): SearchOperator
52 |     {
53 |         return $this->getAddOperatorClosure()($operator);
54 |     }
55 | 
56 |     protected function getAddOperatorClosure(): Closure
57 |     {
58 |         return $this->addOperator;
59 |     }
60 | 
61 |     protected function getCompoundStage(): Compound
62 |     {
63 |         return $this->compound;
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/src/Mapping/Attribute/Encrypt.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Mapping\Attribute;
 6 | 
 7 | use Attribute;
 8 | use DateTimeInterface;
 9 | use Doctrine\ODM\MongoDB\Mapping\EncryptQuery;
10 | use MongoDB\BSON\Decimal128;
11 | use MongoDB\BSON\Int64;
12 | use MongoDB\BSON\UTCDateTime;
13 | 
14 | /**
15 |  * Defines an encrypted field mapping.
16 |  *
17 |  * @see https://www.mongodb.com/docs/manual/core/queryable-encryption/fundamentals/encrypt-and-query/#configure-encrypted-fields-for-optimal-search-and-storage
18 |  *
19 |  * @final
20 |  */
21 | #[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_PROPERTY)]
22 | class Encrypt implements MappingAttribute
23 | {
24 |     public int|float|Int64|Decimal128|UTCDateTime|null $min;
25 |     public int|float|Int64|Decimal128|UTCDateTime|null $max;
26 | 
27 |     /**
28 |      * @param EncryptQuery|null $queryType  Set the query type for the field, null if not queryable.
29 |      * @param int<1, 4>|null    $sparsity
30 |      * @param positive-int|null $precision
31 |      * @param positive-int|null $trimFactor
32 |      * @param positive-int|null $contention
33 |      */
34 |     public function __construct(
35 |         public ?EncryptQuery $queryType = null,
36 |         int|float|Int64|Decimal128|UTCDateTime|DateTimeInterface|null $min = null,
37 |         int|float|Int64|Decimal128|UTCDateTime|DateTimeInterface|null $max = null,
38 |         public ?int $sparsity = null,
39 |         public ?int $precision = null,
40 |         public ?int $trimFactor = null,
41 |         public ?int $contention = null,
42 |     ) {
43 |         $this->min = $min instanceof DateTimeInterface ? new UTCDateTime($min) : $min;
44 |         $this->max = $max instanceof DateTimeInterface ? new UTCDateTime($max) : $max;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Search/EmbeddedDocument.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Stage\Search;
 8 | use Doctrine\ODM\MongoDB\Persisters\DocumentPersister;
 9 | 
10 | /**
11 |  * @internal
12 |  *
13 |  * @see https://www.mongodb.com/docs/atlas/atlas-search/embeddedDocument/
14 |  */
15 | class EmbeddedDocument extends AbstractSearchOperator implements SupportsEmbeddableSearchOperators, ScoredSearchOperator
16 | {
17 |     use SupportsAllSearchOperatorsTrait;
18 |     use ScoredSearchOperatorTrait;
19 | 
20 |     private string $path;
21 |     private ?SearchOperator $operator = null;
22 | 
23 |     public function __construct(Search $search, DocumentPersister $persister, string $path)
24 |     {
25 |         parent::__construct($search, $persister);
26 | 
27 |         $this->path($path);
28 |     }
29 | 
30 |     public function path(string $path): static
31 |     {
32 |         $this->path = $path;
33 | 
34 |         return $this;
35 |     }
36 | 
37 |     /**
38 |      * @param T $operator
39 |      *
40 |      * @return T
41 |      *
42 |      * @template T of SearchOperator
43 |      */
44 |     protected function addOperator(SearchOperator $operator): SearchOperator
45 |     {
46 |         return $this->operator = $operator;
47 |     }
48 | 
49 |     public function getOperatorName(): string
50 |     {
51 |         return 'embeddedDocument';
52 |     }
53 | 
54 |     public function getOperatorParams(): object
55 |     {
56 |         $params = (object) ['path' => $this->prepareFieldPath($this->path)];
57 | 
58 |         if ($this->operator) {
59 |             $params->operator = (object) $this->operator->getExpression();
60 |         }
61 | 
62 |         return $this->appendScore($params);
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/src/Repository/GridFSRepository.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Repository;
 6 | 
 7 | use Doctrine\Persistence\ObjectRepository;
 8 | 
 9 | /**
10 |  * @template T of object
11 |  * @template-extends ObjectRepository<T>
12 |  */
13 | interface GridFSRepository extends ObjectRepository
14 | {
15 |     /**
16 |      * Opens a readable stream for reading a GridFS file.
17 |      *
18 |      * @param mixed $id File ID
19 |      *
20 |      * @return resource
21 |      */
22 |     public function openDownloadStream($id);
23 | 
24 |     /**
25 |      * Writes the contents of a GridFS file to a writable stream.
26 |      *
27 |      * @param mixed    $id          File ID
28 |      * @param resource $destination Writable Stream
29 |      */
30 |     public function downloadToStream($id, $destination): void;
31 | 
32 |     /**
33 |      * Opens a writable stream for writing a GridFS file.
34 |      *
35 |      * @return resource
36 |      */
37 |     public function openUploadStream(string $filename, ?UploadOptions $uploadOptions = null);
38 | 
39 |     /**
40 |      * Writes the contents of a readable stream to a GridFS file.
41 |      *
42 |      * @param resource $source Readable stream
43 |      *
44 |      * @return object The newly created GridFS file
45 |      */
46 |     public function uploadFromStream(string $filename, $source, ?UploadOptions $uploadOptions = null);
47 | 
48 |     /**
49 |      * Writes the contents of a file to a GridFS file.
50 |      *
51 |      * @param string|null $filename The filename to upload the file with. If no filename is provided, the name of the source file will be used.
52 |      *
53 |      * @return object The newly created GridFS file
54 |      */
55 |     public function uploadFromFile(string $source, ?string $filename = null, ?UploadOptions $uploadOptions = null);
56 | }
57 | 


--------------------------------------------------------------------------------
/src/Hydrator/HydratorException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Hydrator;
 6 | 
 7 | use Doctrine\ODM\MongoDB\MongoDBException;
 8 | 
 9 | use function sprintf;
10 | 
11 | /**
12 |  * MongoDB ODM Hydrator Exception
13 |  */
14 | final class HydratorException extends MongoDBException
15 | {
16 |     public static function hydratorDirectoryNotWritable(): self
17 |     {
18 |         return new self('Your hydrator directory must be writable.');
19 |     }
20 | 
21 |     public static function hydratorDirectoryRequired(): self
22 |     {
23 |         return new self('You must configure a hydrator directory. See docs for details.');
24 |     }
25 | 
26 |     public static function hydratorNamespaceRequired(): self
27 |     {
28 |         return new self('You must configure a hydrator namespace. See docs for details');
29 |     }
30 | 
31 |     public static function associationTypeMismatch(string $className, string $fieldName, string $expectedType, string $actualType): self
32 |     {
33 |         return new self(sprintf(
34 |             'Expected association for field "%s" in document of type "%s" to be of type "%s", "%s" received.',
35 |             $fieldName,
36 |             $className,
37 |             $expectedType,
38 |             $actualType,
39 |         ));
40 |     }
41 | 
42 |     /** @param int|string $key */
43 |     public static function associationItemTypeMismatch(string $className, string $fieldName, $key, string $expectedType, string $actualType): self
44 |     {
45 |         return new self(sprintf(
46 |             'Expected association item with key "%s" for field "%s" in document of type "%s" to be of type "%s", "%s" received.',
47 |             $key,
48 |             $fieldName,
49 |             $className,
50 |             $expectedType,
51 |             $actualType,
52 |         ));
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/Tools/Console/Command/CommandCompatibility.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Tools\Console\Command;
 6 | 
 7 | use ReflectionMethod;
 8 | use Symfony\Component\Console\Command\Command;
 9 | use Symfony\Component\Console\Input\InputInterface;
10 | use Symfony\Component\Console\Output\OutputInterface;
11 | 
12 | // Symfony 8
13 | if ((new ReflectionMethod(Command::class, 'configure'))->hasReturnType()) {
14 |     /** @internal */
15 |     trait CommandCompatibility
16 |     {
17 |         protected function configure(): void
18 |         {
19 |             $this->doConfigure();
20 |         }
21 | 
22 |         protected function execute(InputInterface $input, OutputInterface $output): int
23 |         {
24 |             return $this->doExecute($input, $output);
25 |         }
26 |     }
27 | // Symfony 7
28 | } elseif ((new ReflectionMethod(Command::class, 'execute'))->hasReturnType()) {
29 |     /** @internal */
30 |     trait CommandCompatibility
31 |     {
32 |         /** @return void */
33 |         protected function configure()
34 |         {
35 |             $this->doConfigure();
36 |         }
37 | 
38 |         protected function execute(InputInterface $input, OutputInterface $output): int
39 |         {
40 |             return $this->doExecute($input, $output);
41 |         }
42 |     }
43 | } else {
44 |     /** @internal */
45 |     trait CommandCompatibility
46 |     {
47 |         /** @return void */
48 |         protected function configure()
49 |         {
50 |             $this->doConfigure();
51 |         }
52 | 
53 |         /**
54 |          * {@inheritDoc}
55 |          *
56 |          * @return int
57 |          */
58 |         protected function execute(InputInterface $input, OutputInterface $output)
59 |         {
60 |             return $this->doExecute($input, $output);
61 |         }
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/Aggregation/Stage/Bucket/BucketAutoOutput.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ODM\MongoDB\Aggregation\Stage\Bucket;
 6 | 
 7 | use Doctrine\ODM\MongoDB\Aggregation\Builder;
 8 | use Doctrine\ODM\MongoDB\Aggregation\Expr;
 9 | use Doctrine\ODM\MongoDB\Aggregation\Stage;
10 | 
11 | use function assert;
12 | 
13 | /**
14 |  * Fluent interface for adding an output specification to a bucket stage.
15 |  */
16 | class BucketAutoOutput extends AbstractOutput
17 | {
18 |     public function __construct(Builder $builder, Stage\BucketAuto $bucket)
19 |     {
20 |         parent::__construct($builder, $bucket);
21 |     }
22 | 
23 |     /**
24 |      * An expression to group documents by. To specify a field path, prefix the
25 |      * field name with a dollar sign $ and enclose it in quotes.
26 |      *
27 |      * @param array<string, mixed>|Expr|string $expression
28 |      */
29 |     public function groupBy($expression): Stage\BucketAuto
30 |     {
31 |         assert($this->bucket instanceof Stage\BucketAuto);
32 | 
33 |         return $this->bucket->groupBy($expression);
34 |     }
35 | 
36 |     /**
37 |      * A positive 32-bit integer that specifies the number of buckets into which input documents are grouped.
38 |      */
39 |     public function buckets(int $buckets): Stage\BucketAuto
40 |     {
41 |         assert($this->bucket instanceof Stage\BucketAuto);
42 | 
43 |         return $this->bucket->buckets($buckets);
44 |     }
45 | 
46 |     /**
47 |      * A string that specifies the preferred number series to use to ensure that
48 |      * the calculated boundary edges end on preferred round numbers or their
49 |      * powers of 10.
50 |      */
51 |     public function granularity(string $granularity): Stage\BucketAuto
52 |     {
53 |         assert($this->bucket instanceof Stage\BucketAuto);
54 | 
55 |         return $this->bucket->granularity($granularity);
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------