DocumentManager.php

<?php

declare(strict_types=1);

namespace Doctrine\ODM\MongoDB;

use Doctrine\Common\EventManager;
use Doctrine\ODM\MongoDB\Hydrator\HydratorFactory;
use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
use Doctrine\ODM\MongoDB\Mapping\ClassMetadataFactory;
use Doctrine\ODM\MongoDB\Mapping\MappingException;
use Doctrine\ODM\MongoDB\Proxy\Factory\ProxyFactory;
use Doctrine\ODM\MongoDB\Proxy\Factory\StaticProxyFactory;
use Doctrine\ODM\MongoDB\Proxy\Resolver\CachingClassNameResolver;
use Doctrine\ODM\MongoDB\Proxy\Resolver\ClassNameResolver;
use Doctrine\ODM\MongoDB\Proxy\Resolver\ProxyManagerClassNameResolver;
use Doctrine\ODM\MongoDB\Query\FilterCollection;
use Doctrine\ODM\MongoDB\Repository\DocumentRepository;
use Doctrine\ODM\MongoDB\Repository\GridFSRepository;
use Doctrine\ODM\MongoDB\Repository\RepositoryFactory;
use Doctrine\ODM\MongoDB\Repository\ViewRepository;
use Doctrine\Persistence\ObjectManager;
use InvalidArgumentException;
use Jean85\PrettyVersions;
use MongoDB\Client;
use MongoDB\Collection;
use MongoDB\Database;
use MongoDB\Driver\ReadPreference;
use MongoDB\GridFS\Bucket;
use ProxyManager\Proxy\GhostObjectInterface;
use RuntimeException;
use Throwable;

use function array_search;
use function assert;
use function get_class;
use function gettype;
use function is_object;
use function ltrim;
use function sprintf;

/**
 * The DocumentManager class is the central access point for managing the
 * persistence of documents.
 *
 *     <?php
 *
 *     $config = new Configuration();
 *     $dm = DocumentManager::create(new Connection(), $config);
 *
 * @psalm-import-type CommitOptions from UnitOfWork
 */
class DocumentManager implements ObjectManager
{
    public const CLIENT_TYPEMAP = ['root' => 'array', 'document' => 'array'];

    /**
     * The Doctrine MongoDB connection instance.
     *
     * @var Client
     */
    private $client;

    /**
     * The used Configuration.
     *
     * @var Configuration
     */
    private $config;

    /**
     * The metadata factory, used to retrieve the ODM metadata of document classes.
     *
     * @var ClassMetadataFactory
     */
    private $metadataFactory;

    /**
     * The UnitOfWork used to coordinate object-level transactions.
     *
     * @var UnitOfWork
     */
    private $unitOfWork;

    /**
     * The event manager that is the central point of the event system.
     *
     * @var EventManager
     */
    private $eventManager;

    /**
     * The Hydrator factory instance.
     *
     * @var HydratorFactory
     */
    private $hydratorFactory;

    /**
     * The Proxy factory instance.
     *
     * @var ProxyFactory
     */
    private $proxyFactory;

    /**
     * The repository factory used to create dynamic repositories.
     *
     * @var RepositoryFactory
     */
    private $repositoryFactory;

    /**
     * SchemaManager instance
     *
     * @var SchemaManager
     */
    private $schemaManager;

    /**
     * Array of cached document database instances that are lazily loaded.
     *
     * @var Database[]
     */
    private $documentDatabases = [];

    /**
     * Array of cached document collection instances that are lazily loaded.
     *
     * @var Collection[]
     */
    private $documentCollections = [];

    /**
     * Array of cached document bucket instances that are lazily loaded.
     *
     * @var Bucket[]
     */
    private $documentBuckets = [];

    /**
     * Whether the DocumentManager is closed or not.
     *
     * @var bool
     */
    private $closed = false;

    /**
     * Collection of query filters.
     *
     * @var FilterCollection
     */
    private $filterCollection;

    /** @var ClassNameResolver */
    private $classNameResolver;

    /** @var string|null */
    private static $version;

    /**
     * Creates a new Document that operates on the given Mongo connection
     * and uses the given Configuration.
     */
    protected function __construct(?Client $client = null, ?Configuration $config = null, ?EventManager $eventManager = null)
    {
        $this->config       = $config ?: new Configuration();
        $this->eventManager = $eventManager ?: new EventManager();
        $this->client       = $client ?: new Client(
            'mongodb://127.0.0.1',
            [],
            [
                'driver' => [
                    'name' => 'doctrine-odm',
                    'version' => self::getVersion(),
                ],
            ]
        );

        $metadataFactoryClassName = $this->config->getClassMetadataFactoryName();
        $this->metadataFactory    = new $metadataFactoryClassName();
        $this->metadataFactory->setDocumentManager($this);
        $this->metadataFactory->setConfiguration($this->config);

        $cacheDriver = $this->config->getMetadataCache();
        if ($cacheDriver) {
            $this->metadataFactory->setCache($cacheDriver);
        }

        $hydratorDir           = $this->config->getHydratorDir();
        $hydratorNs            = $this->config->getHydratorNamespace();
        $this->hydratorFactory = new HydratorFactory(
            $this,
            $this->eventManager,
            $hydratorDir,
            $hydratorNs,
            $this->config->getAutoGenerateHydratorClasses()
        );

        $this->unitOfWork = new UnitOfWork($this, $this->eventManager, $this->hydratorFactory);
        $this->hydratorFactory->setUnitOfWork($this->unitOfWork);
        $this->schemaManager     = new SchemaManager($this, $this->metadataFactory);
        $this->proxyFactory      = new StaticProxyFactory($this);
        $this->repositoryFactory = $this->config->getRepositoryFactory();
        $this->classNameResolver = new CachingClassNameResolver(new ProxyManagerClassNameResolver($this->config));

        $this->metadataFactory->setProxyClassNameResolver($this->classNameResolver);
    }

    /**
     * Gets the proxy factory used by the DocumentManager to create document proxies.
     */
    public function getProxyFactory(): ProxyFactory
    {
        return $this->proxyFactory;
    }

    /**
     * Creates a new Document that operates on the given Mongo connection
     * and uses the given Configuration.
     */
    public static function create(?Client $client = null, ?Configuration $config = null, ?EventManager $eventManager = null): DocumentManager
    {
        return new static($client, $config, $eventManager);
    }

    /**
     * Gets the EventManager used by the DocumentManager.
     */
    public function getEventManager(): EventManager
    {
        return $this->eventManager;
    }

    /**
     * Gets the MongoDB client instance that this DocumentManager wraps.
     */
    public function getClient(): Client
    {
        return $this->client;
    }

    /**
     * Gets the metadata factory used to gather the metadata of classes.
     *
     * @return ClassMetadataFactory
     */
    public function getMetadataFactory()
    {
        return $this->metadataFactory;
    }

    /**
     * Helper method to initialize a lazy loading proxy or persistent collection.
     *
     * This method is a no-op for other objects.
     *
     * @param object $obj
     */
    public function initializeObject($obj)
    {
        $this->unitOfWork->initializeObject($obj);
    }

    /**
     * Gets the UnitOfWork used by the DocumentManager to coordinate operations.
     */
    public function getUnitOfWork(): UnitOfWork
    {
        return $this->unitOfWork;
    }

    /**
     * Gets the Hydrator factory used by the DocumentManager to generate and get hydrators
     * for each type of document.
     */
    public function getHydratorFactory(): HydratorFactory
    {
        return $this->hydratorFactory;
    }

    /**
     * Returns SchemaManager, used to create/drop indexes/collections/databases.
     */
    public function getSchemaManager(): SchemaManager
    {
        return $this->schemaManager;
    }

    /**
     * Returns the class name resolver which is used to resolve real class names for proxy objects.
     *
     * @deprecated Fetch metadata for any class string (e.g. proxy object class) and read the class name from the metadata object
     */
    public function getClassNameResolver(): ClassNameResolver
    {
        return $this->classNameResolver;
    }

    /**
     * Returns the metadata for a class.
     *
     * @param string $className The class name.
     * @psalm-param class-string<T> $className
     *
     * @psalm-return ClassMetadata<T>
     *
     * @template T of object
     *
     * @psalm-suppress InvalidReturnType, InvalidReturnStatement see https://github.com/vimeo/psalm/issues/5788
     */
    public function getClassMetadata($className): ClassMetadata
    {
        return $this->metadataFactory->getMetadataFor($className);
    }

    /**
     * Returns the MongoDB instance for a class.
     *
     * @psalm-param class-string $className
     */
    public function getDocumentDatabase(string $className): Database
    {
        $metadata = $this->metadataFactory->getMetadataFor($className);
        assert($metadata instanceof ClassMetadata);

        $className = $metadata->getName();

        if (isset($this->documentDatabases[$className])) {
            return $this->documentDatabases[$className];
        }

        $db                                  = $metadata->getDatabase();
        $db                                  = $db ?: $this->config->getDefaultDB();
        $db                                  = $db ?: 'doctrine';
        $this->documentDatabases[$className] = $this->client->selectDatabase($db);

        return $this->documentDatabases[$className];
    }

    /**
     * Gets the array of instantiated document database instances.
     *
     * @return Database[]
     */
    public function getDocumentDatabases(): array
    {
        return $this->documentDatabases;
    }

    /**
     * Returns the collection instance for a class.
     *
     * @throws MongoDBException When the $className param is not mapped to a collection.
     */
    public function getDocumentCollection(string $className): Collection
    {
        $metadata = $this->metadataFactory->getMetadataFor($className);
        assert($metadata instanceof ClassMetadata);

        if ($metadata->isFile) {
            return $this->getDocumentBucket($className)->getFilesCollection();
        }

        $collectionName = $metadata->getCollection();

        if (! $collectionName) {
            throw MongoDBException::documentNotMappedToCollection($className);
        }

        if (! isset($this->documentCollections[$className])) {
            $db = $this->getDocumentDatabase($className);

            $options = ['typeMap' => self::CLIENT_TYPEMAP];
            if ($metadata->readPreference !== null) {
                $options['readPreference'] = new ReadPreference($metadata->readPreference, $metadata->readPreferenceTags);
            }

            $this->documentCollections[$className] = $db->selectCollection($collectionName, $options);
        }

        return $this->documentCollections[$className];
    }

    /**
     * Returns the bucket instance for a class.
     *
     * @throws MongoDBException When the $className param is not mapped to a collection.
     */
    public function getDocumentBucket(string $className): Bucket
    {
        $metadata = $this->metadataFactory->getMetadataFor($className);
        assert($metadata instanceof ClassMetadata);

        if (! $metadata->isFile) {
            throw MongoDBException::documentBucketOnlyAvailableForGridFSFiles($className);
        }

        $bucketName = $metadata->getBucketName();

        if (! $bucketName) {
            throw MongoDBException::documentNotMappedToCollection($className);
        }

        if (! isset($this->documentBuckets[$className])) {
            $db = $this->getDocumentDatabase($className);

            $options = ['bucketName' => $bucketName];
            if ($metadata->readPreference !== null) {
                $options['readPreference'] = new ReadPreference($metadata->readPreference, $metadata->readPreferenceTags);
            }

            $this->documentBuckets[$className] = $db->selectGridFSBucket($options);
        }

        return $this->documentBuckets[$className];
    }

    /**
     * Gets the array of instantiated document collection instances.
     *
     * @return Collection[]
     */
    public function getDocumentCollections(): array
    {
        return $this->documentCollections;
    }

    /**
     * Create a new Query instance for a class.
     *
     * @param string[]|string|null $documentName (optional) an array of document names, the document name, or none
     */
    public function createQueryBuilder($documentName = null): Query\Builder
    {
        return new Query\Builder($this, $documentName);
    }

    /**
     * Creates a new aggregation builder instance for a class.
     */
    public function createAggregationBuilder(string $documentName): Aggregation\Builder
    {
        return new Aggregation\Builder($this, $documentName);
    }

    /**
     * Tells the DocumentManager to make an instance managed and persistent.
     *
     * The document will be entered into the database at or before transaction
     * commit or as a result of the flush operation.
     *
     * NOTE: The persist operation always considers documents that are not yet known to
     * this DocumentManager as NEW. Do not pass detached documents to the persist operation.
     *
     * @param object $object The instance to make managed and persistent.
     *
     * @throws InvalidArgumentException When the given $object param is not an object.
     */
    public function persist($object)
    {
        if (! is_object($object)) {
            throw new InvalidArgumentException(gettype($object));
        }

        $this->errorIfClosed();
        $this->unitOfWork->persist($object);
    }

    /**
     * Removes a document instance.
     *
     * A removed document will be removed from the database at or before transaction commit
     * or as a result of the flush operation.
     *
     * @param object $object The document instance to remove.
     *
     * @throws InvalidArgumentException When the $object param is not an object.
     */
    public function remove($object)
    {
        if (! is_object($object)) {
            throw new InvalidArgumentException(gettype($object));
        }

        $this->errorIfClosed();
        $this->unitOfWork->remove($object);
    }

    /**
     * Refreshes the persistent state of a document from the database,
     * overriding any local changes that have not yet been persisted.
     *
     * @param object $object The document to refresh.
     *
     * @throws InvalidArgumentException When the given $object param is not an object.
     */
    public function refresh($object)
    {
        if (! is_object($object)) {
            throw new InvalidArgumentException(gettype($object));
        }

        $this->errorIfClosed();
        $this->unitOfWork->refresh($object);
    }

    /**
     * Detaches a document from the DocumentManager, causing a managed document to
     * become detached.  Unflushed changes made to the document if any
     * (including removal of the document), will not be synchronized to the database.
     * Documents which previously referenced the detached document will continue to
     * reference it.
     *
     * @param object $object The document to detach.
     *
     * @throws InvalidArgumentException When the $object param is not an object.
     */
    public function detach($object)
    {
        if (! is_object($object)) {
            throw new InvalidArgumentException(gettype($object));
        }

        $this->unitOfWork->detach($object);
    }

    /**
     * Merges the state of a detached document into the persistence context
     * of this DocumentManager and returns the managed copy of the document.
     * The document passed to merge will not become associated/managed with this DocumentManager.
     *
     * @param object $object The detached document to merge into the persistence context.
     *
     * @return object The managed copy of the document.
     *
     * @throws LockException
     * @throws InvalidArgumentException If the $object param is not an object.
     */
    public function merge($object)
    {
        if (! is_object($object)) {
            throw new InvalidArgumentException(gettype($object));
        }

        $this->errorIfClosed();

        return $this->unitOfWork->merge($object);
    }

    /**
     * Acquire a lock on the given document.
     *
     * @throws InvalidArgumentException
     * @throws LockException
     */
    public function lock(object $document, int $lockMode, ?int $lockVersion = null): void
    {
        $this->unitOfWork->lock($document, $lockMode, $lockVersion);
    }

    /**
     * Releases a lock on the given document.
     */
    public function unlock(object $document): void
    {
        $this->unitOfWork->unlock($document);
    }

    /**
     * Gets the repository for a document class.
     *
     * @param string $className The name of the Document.
     * @psalm-param class-string<T> $className
     *
     * @return DocumentRepository|GridFSRepository|ViewRepository  The repository.
     * @psalm-return DocumentRepository<T>|GridFSRepository<T>|ViewRepository<T>
     *
     * @template T of object
     */
    public function getRepository($className)
    {
        return $this->repositoryFactory->getRepository($this, $className);
    }

    /**
     * Flushes all changes to objects that have been queued up to now to the database.
     * This effectively synchronizes the in-memory state of managed objects with the
     * database.
     *
     * @param array $options Array of options to be used with batchInsert(), update() and remove()
     * @psalm-param CommitOptions $options
     *
     * @throws MongoDBException
     */
    public function flush(array $options = [])
    {
        $this->errorIfClosed();
        $this->unitOfWork->commit($options);
    }

    /**
     * Gets a reference to the document identified by the given type and identifier
     * without actually loading it.
     *
     * If partial objects are allowed, this method will return a partial object that only
     * has its identifier populated. Otherwise a proxy is returned that automatically
     * loads itself on first access.
     *
     * @param mixed $identifier
     * @psalm-param class-string<T> $documentName
     *
     * @psalm-return T|(T&GhostObjectInterface<T>)
     *
     * @template T of object
     */
    public function getReference(string $documentName, $identifier): object
    {
        /** @psalm-var ClassMetadata<T> $class */
        $class = $this->metadataFactory->getMetadataFor(ltrim($documentName, '\\'));
        assert($class instanceof ClassMetadata);
        $document = $this->unitOfWork->tryGetById($identifier, $class);

        // Check identity map first, if its already in there just return it.
        if ($document) {
            return $document;
        }

        $document = $this->proxyFactory->getProxy($class, $identifier);
        $this->unitOfWork->registerManaged($document, $identifier, []);

        return $document;
    }

    /**
     * Gets a partial reference to the document identified by the given type and identifier
     * without actually loading it, if the document is not yet loaded.
     *
     * The returned reference may be a partial object if the document is not yet loaded/managed.
     * If it is a partial object it will not initialize the rest of the document state on access.
     * Thus you can only ever safely access the identifier of a document obtained through
     * this method.
     *
     * The use-cases for partial references involve maintaining bidirectional associations
     * without loading one side of the association or to update a document without loading it.
     * Note, however, that in the latter case the original (persistent) document data will
     * never be visible to the application (especially not event listeners) as it will
     * never be loaded in the first place.
     *
     * @param mixed $identifier The document identifier.
     */
    public function getPartialReference(string $documentName, $identifier): object
    {
        $class = $this->metadataFactory->getMetadataFor(ltrim($documentName, '\\'));
        assert($class instanceof ClassMetadata);

        $document = $this->unitOfWork->tryGetById($identifier, $class);

        // Check identity map first, if its already in there just return it.
        if ($document) {
            return $document;
        }

        $document = $class->newInstance();
        $class->setIdentifierValue($document, $identifier);
        $this->unitOfWork->registerManaged($document, $identifier, []);

        return $document;
    }

    /**
     * Finds a Document by its identifier.
     *
     * This is just a convenient shortcut for getRepository($documentName)->find($id).
     *
     * @param string $className
     * @param mixed  $id
     * @param int    $lockMode
     * @param int    $lockVersion
     * @psalm-param class-string<T> $className
     *
     * @psalm-return T|null
     *
     * @template T of object
     */
    public function find($className, $id, $lockMode = LockMode::NONE, $lockVersion = null): ?object
    {
        $repository = $this->getRepository($className);
        if ($repository instanceof DocumentRepository) {
            return $repository->find($id, $lockMode, $lockVersion);
        }

        return $repository->find($id);
    }

    /**
     * Clears the DocumentManager.
     *
     * All documents that are currently managed by this DocumentManager become
     * detached.
     *
     * @param string|null $objectName if given, only documents of this type will get detached
     */
    public function clear($objectName = null)
    {
        $this->unitOfWork->clear($objectName);
    }

    /**
     * Closes the DocumentManager. All documents that are currently managed
     * by this DocumentManager become detached. The DocumentManager may no longer
     * be used after it is closed.
     *
     * @return void
     */
    public function close()
    {
        $this->clear();
        $this->closed = true;
    }

    /**
     * Determines whether a document instance is managed in this DocumentManager.
     *
     * @param object $object
     *
     * @return bool TRUE if this DocumentManager currently manages the given document, FALSE otherwise.
     *
     * @throws InvalidArgumentException When the $object param is not an object.
     */
    public function contains($object)
    {
        if (! is_object($object)) {
            throw new InvalidArgumentException(gettype($object));
        }

        return $this->unitOfWork->isScheduledForInsert($object) ||
            $this->unitOfWork->isInIdentityMap($object) &&
            ! $this->unitOfWork->isScheduledForDelete($object);
    }

    /**
     * Gets the Configuration used by the DocumentManager.
     */
    public function getConfiguration(): Configuration
    {
        return $this->config;
    }

    /**
     * Returns a reference to the supplied document.
     *
     * @return mixed The reference for the document in question, according to the desired mapping
     *
     * @throws MappingException
     * @throws RuntimeException
     */
    public function createReference(object $document, array $referenceMapping)
    {
        $class = $this->getClassMetadata(get_class($document));
        $id    = $this->unitOfWork->getDocumentIdentifier($document);

        if ($id === null) {
            throw new RuntimeException(
                sprintf('Cannot create a DBRef for class %s without an identifier. Have you forgotten to persist/merge the document first?', $class->name)
            );
        }

        $storeAs = $referenceMapping['storeAs'] ?? null;
        switch ($storeAs) {
            case ClassMetadata::REFERENCE_STORE_AS_ID:
                if ($class->inheritanceType === ClassMetadata::INHERITANCE_TYPE_SINGLE_COLLECTION) {
                    throw MappingException::simpleReferenceMustNotTargetDiscriminatedDocument($referenceMapping['targetDocument']);
                }

                return $class->getDatabaseIdentifierValue($id);

            case ClassMetadata::REFERENCE_STORE_AS_REF:
                $reference = ['id' => $class->getDatabaseIdentifierValue($id)];
                break;

            case ClassMetadata::REFERENCE_STORE_AS_DB_REF:
                $reference = [
                    '$ref' => $class->getCollection(),
                    '$id'  => $class->getDatabaseIdentifierValue($id),
                ];
                break;

            case ClassMetadata::REFERENCE_STORE_AS_DB_REF_WITH_DB:
                $reference = [
                    '$ref' => $class->getCollection(),
                    '$id'  => $class->getDatabaseIdentifierValue($id),
                    '$db'  => $this->getDocumentDatabase($class->name)->getDatabaseName(),
                ];
                break;

            default:
                throw new InvalidArgumentException(sprintf('Reference type %s is invalid.', $storeAs));
        }

        return $reference + $this->getDiscriminatorData($referenceMapping, $class);
    }

    /**
     * Build discriminator portion of reference for specified reference mapping and class metadata.
     *
     * @param array         $referenceMapping Mappings of reference for which discriminator data is created.
     * @param ClassMetadata $class            Metadata of reference document class.
     *
     * @return array with next structure [{discriminator field} => {discriminator value}]
     *
     * @throws MappingException When discriminator map is present and reference class in not registered in it.
     */
    private function getDiscriminatorData(array $referenceMapping, ClassMetadata $class): array
    {
        $discriminatorField = null;
        $discriminatorValue = null;
        $discriminatorMap   = null;

        if (isset($referenceMapping['discriminatorField'])) {
            $discriminatorField = $referenceMapping['discriminatorField'];

            if (isset($referenceMapping['discriminatorMap'])) {
                $discriminatorMap = $referenceMapping['discriminatorMap'];
            }
        } else {
            $discriminatorField = $class->discriminatorField;
            $discriminatorValue = $class->discriminatorValue;
            $discriminatorMap   = $class->discriminatorMap;
        }

        if ($discriminatorField === null) {
            return [];
        }

        if ($discriminatorValue === null) {
            if (! empty($discriminatorMap)) {
                $pos = array_search($class->name, $discriminatorMap);

                if ($pos !== false) {
                    $discriminatorValue = $pos;
                }
            } else {
                $discriminatorValue = $class->name;
            }
        }

        if ($discriminatorValue === null) {
            throw MappingException::unlistedClassInDiscriminatorMap($class->name);
        }

        return [$discriminatorField => $discriminatorValue];
    }

    /**
     * Throws an exception if the DocumentManager is closed or currently not active.
     *
     * @throws MongoDBException If the DocumentManager is closed.
     */
    private function errorIfClosed(): void
    {
        if ($this->closed) {
            throw MongoDBException::documentManagerClosed();
        }
    }

    /**
     * Check if the Document manager is open or closed.
     */
    public function isOpen(): bool
    {
        return ! $this->closed;
    }

    /**
     * Gets the filter collection.
     */
    public function getFilterCollection(): FilterCollection
    {
        if ($this->filterCollection === null) {
            $this->filterCollection = new FilterCollection($this);
        }

        return $this->filterCollection;
    }

    private static function getVersion(): string
    {
        if (self::$version === null) {
            try {
                self::$version = PrettyVersions::getVersion('doctrine/mongodb-odm')->getPrettyVersion();
            } catch (Throwable $t) {
                return 'unknown';
            }
        }

        return self::$version;
    }
}