doctrine-extensions/DoctrineExtensions

This system is a library of behavioral extensions for Doctrine ORM and MongoDB ODM that adds common data management features to entities and documents. It provides capabilities for automatic timestamping, user attribution, IP tracking, and soft deletion, alongside complex data handling for hierarchical trees, sortable lists, and file uploads. The library also supports multi-language content through a translation system and maintains audit trails via a logging extension that allows for versioning and reversion of entity states.

57 changes.

This period focused on modernizing the codebase by migrating behavioral extensions from PHPDoc annotations to PHP 8 attributes, alongside standardizing development tooling and repository configuration. A massive expansion of test coverage was conducted, adding comprehensive fixtures and unit tests for all major extensions across both Doctrine ORM and MongoDB ODM to ensure compatibility with newer PHP and Doctrine versions.

113 changes.

This period focused on modernizing the codebase by introducing PHP 8 attribute support for metadata mapping across all extensions, while deprecating legacy annotation and YAML drivers. It also introduced several new behavioral extensions, including IpTraceable, ReferenceIntegrity, and Uploadable, alongside significant enhancements to existing features like Translatable, Tree, and SoftDeleteable.

14 changes.

This period focused on ensuring backward compatibility with Doctrine ORM 3.x by introducing internal compatibility layers for hydration, repository methods, and SQL walkers. Concurrently, extensive test coverage was added for the Translatable, Sluggable, and Tree extensions, including new fixtures for PHP 8 attributes, edge cases, and embedded objects.

The example application now includes \Category\ and \CategoryTranslation\ entity classes that demonstrate the use of Doctrine Behavioral Extensions features such as Tree (nested set), Translatable, Sluggable, Timestampable, and Blameable behaviors. These entities utilize PHP 8 attributes for mapping configuration alongside legacy docblock annotations, providing a concrete example of how to implement hierarchical categories with translations and audit fields in an application.

example/app/Entity · high confidence

This change introduces the \src/Translatable/Mapping/Event/Adapter/ODM.php\ and \ORM.php\ files, which implement the \TranslatableAdapter\ interface for Doctrine MongoDB ODM and Doctrine ORM respectively. These adapters provide the specific logic required to load, find, insert, and remove translation records for both document and entity managers, enabling the Translatable behavior to function with both Doctrine persistence layers.

src/Translatable/Mapping/Event/Adapter · high confidence

Introduces a new MaterializedPath strategy for MongoDB ODM documents, enabling tree structures to be managed using the materialized path pattern. This implementation handles node removal (including cascading deletion of children), retrieval of child nodes with path-based sorting, and tree locking mechanisms using UTCDateTime for concurrency control.

src/Tree/Strategy/ODM · high confidence

A new Translation document class has been added to the Translatable module for Doctrine MongoDB ODM. This class extends the AbstractTranslation superclass and is configured with a unique index on foreign\_key, locale, object\_class, and field to ensure lookup efficiency. The implementation supports both legacy Doctrine annotations and modern PHP 8 attributes, allowing users to utilize the translatable feature with current PHP versions while maintaining backward compatibility.

src/Translatable/Document, src/Translator/Document · high confidence

Introduces the AbstractLogEntry mapped superclass for Doctrine MongoDB ODM, providing the foundational document structure for storing audit log entries. This class implements LogEntryInterface and defines fields for tracking actions (create, update, remove), timestamps, object identifiers, class names, versions, associated data, and usernames, enabling the loggable extension to persist history records in MongoDB.

src/Loggable/Document/MappedSuperclass · high confidence

This change introduces support for Doctrine MongoDB ODM in the Translatable extension by adding \AbstractTranslation\ and refactoring \AbstractPersonalTranslation\ (renamed from the previous Entity-based \Translation\). The new classes use PHP 8 attributes for mapping fields like locale, object class, field, foreign key, and content, replacing the previous Doctrine ORM annotations and table definitions. This allows users to translate MongoDB document properties using the same translatable behavior previously available only for relational databases.

src/Translatable/Document/MappedSuperclass · high confidence

The LogEntry document class now supports Doctrine MongoDB ODM PHP 8 attributes alongside the existing annotations. This allows users to leverage native PHP 8 attribute syntax for mapping the document and its indexes, ensuring compatibility with modern Doctrine versions while maintaining backward compatibility.

src/Loggable/Document · high confidence

The Timestampable traits for Doctrine ORM (TimestampableEntity) and MongoDB ODM (TimestampableDocument) now include PHP 8 attributes alongside existing docblock annotations. This allows users to configure timestampable behavior using native PHP 8 syntax (e.g., \#\[Gedmo\\Timestampable\]) in addition to the traditional @Gedmo annotations, providing a modern alternative for mapping configuration while maintaining backward compatibility.

src/Timestampable/Traits · high confidence

The IpTraceable traits for Doctrine ORM (IpTraceableEntity) and MongoDB ODM (IpTraceableDocument) now include PHP 8 attributes (\#\[ORM\\Column\] and \#\[Gedmo\\IpTraceable\]) alongside the existing docblock annotations. This allows users to configure IP tracking using native PHP 8 syntax, providing a modern alternative to annotation-based mapping while maintaining backward compatibility.

src/IpTraceable/Traits · high confidence

The Tree traits (MaterializedPath, NestedSet, NestedSetEntity, NestedSetEntityUuid) now support PHP 8 attributes alongside existing Doctrine annotations. NestedSetEntity and NestedSetEntityUuid include both annotation and attribute mappings for tree columns (root, level, left, right), allowing users to choose their preferred mapping syntax. MaterializedPath and NestedSet traits remain annotation-free as they do not provide mapping configurations.

src/Tree/Traits · high confidence

The AbstractPersonalTranslation and AbstractTranslation mapped superclasses now include Doctrine ORM PHP 8 attributes alongside existing annotations. This allows users who prefer or require attribute-based configuration to define translatable entity mappings without relying on docblock annotations, while maintaining backward compatibility with the annotation style.

src/Translatable/Entity/MappedSuperclass · high confidence

The example application now includes a new console command, \app:print-category-translation-tree\, which seeds a sample category hierarchy (Food, Fruits, Apple, Milk) with translations and displays the tree structure in both English and Lithuanian. This command demonstrates how to use the Doctrine Translatable extension's \TranslationWalker\ to query and render localized content within a nested set structure.

example/app/Command · high confidence

This change introduces the event adapter infrastructure for the Blameable and IpTraceable behaviors. It adds the \BlameableAdapter\ and \IpTraceableAdapter\ interfaces, along with their concrete implementations for both Doctrine ORM and ODM (\Adapter/ORM.php\ and \Adapter/ODM.php\). These adapters allow the respective behaviors to hook into Doctrine's event lifecycle, enabling tracking of who made changes (Blameable) and the IP address of the requester (IpTraceable).

src/Blameable/Mapping/Event, src/IpTraceable/Mapping/Event · high confidence

The example application now includes a CategoryRepository class that extends NestedTreeRepository. This addition demonstrates how to initialize and use the Tree extension's repository functionality within the example app, providing a concrete implementation for the Category entity.

example/app/Entity/Repository · high confidence

The LogEntry entity now includes native PHP 8 attributes (e.g., \#\[ORM\\Entity\], \#\[ORM\\Table\]) alongside the existing Doctrine annotations. This addition enables the entity to work with Doctrine ORM versions that support PHP 8 attributes, providing a modern alternative to annotation-based configuration without removing legacy support.

src/Loggable/Entity · high confidence

Introduced a new LogEntryRepository class for Doctrine MongoDB ODM that provides methods to retrieve and revert document versions. Users can now call getLogEntries() to fetch the history of a specific document and revert() to restore a document to a previous state by applying stored field data, with the internal fillDocument() method handling the population of versioned fields including embedded documents and associations.

src/Loggable/Document/Repository · high confidence

The example application now includes a console entry point (\example/bin/console\) that bootstraps a Symfony Console application using the Doctrine ORM Console Runner. This setup registers default DBAL and ORM commands and includes a custom command (\PrintCategoryTranslationTreeCommand\) to demonstrate the Doctrine Extensions functionality.

example/bin · high confidence

The Blameable traits for Doctrine ORM (BlameableEntity) and MongoDB ODM (BlameableDocument) have been updated to include PHP 8 attribute mappings (e.g., \#\[ORM\\Column\], \#\[Gedmo\\Blameable\]) alongside the existing docblock annotations. This allows users to configure the Blameable behavior using native PHP 8 attributes, providing a modern alternative to annotation-based configuration while maintaining backward compatibility.

src/Blameable/Traits · high confidence

Added \ObjectHydrator\ and \SimpleObjectHydrator\ classes in the \src/Translatable/Hydrator/ORM\ directory to extend Doctrine's default hydrators. These custom hydrators integrate with the \TranslationQueryWalker\ to temporarily disable the \onLoad\ event during hydration, ensuring that translatable fields are not unnecessarily retranslated when loading existing objects from the database.

src/Translatable/Hydrator · high confidence

Added new \ODM.php\ and \ORM.php\ adapter classes in the \src/Loggable/Mapping/Event/Adapter\ directory to handle loggable behavior for Doctrine MongoDB ODM and ORM respectively. These adapters implement the \LoggableAdapter\ interface and provide specific logic for determining the default log entry class, checking post-insert generators, and calculating the next version number for log entries by querying existing logs.

src/Loggable/Mapping/Event/Adapter · high confidence

A new SluggableAdapter interface has been added to the Sluggable extension's mapping event layer. This interface defines the contract for handling slug-related operations, specifically methods to retrieve similar slugs for a managed object and to replace parts of slugs on matching records (both relative and inverse relative). This change establishes a dedicated adapter mechanism for the Sluggable extension to interact with Doctrine's event system.

src/Sluggable/Mapping/Event · high confidence

Added a new \SoftDeleteableWalker\ class that intercepts DQL DELETE statements and transforms them into UPDATE statements, setting the \deletedAt\ field to the current timestamp instead of removing the record. This walker supports both single-table and joined-inheritance entity strategies by delegating to appropriate SQL executors, enabling soft-delete behavior directly through DQL queries.

src/SoftDeleteable/Query/TreeWalker · high confidence

Adds the Uploadable extension, enabling entities to automatically handle file uploads, validation, and storage. This includes a new \Events\ class for pre- and post-processing hooks, an \Uploadable\ marker interface to identify uploadable entities, and an \UploadableListener\ that manages file movement, MIME type guessing, and size validation during Doctrine lifecycle events.

src/Uploadable · high confidence

This change adds the core repository classes for the Tree extension (AbstractTreeRepository, ClosureTreeRepository, MaterializedPathRepository, and NestedTreeRepository). These repositories provide specialized methods for managing tree structures, including new capabilities to sort children by multiple fields (including ManyToOne relations) and specify sort directions per field. Additionally, path-related methods (getPath, getPathQuery, getPathQueryBuilder) now support an 'includeNode' option to control whether the starting node is included in the results, and the NestedTreeRepository's verify and recover methods have gained options for handling forests and sibling ordering.

src/Tree/Entity/Repository · high confidence

The Loggable extension now defines a formal \LogEntryInterface\ that standardizes the contract for log entry models, including methods for action, username, object class, ID, data, and versioning, alongside a \Loggable\ marker interface to identify loggable entities. This provides a clear, type-safe foundation for implementing custom log entry classes and ensures consistent structure for audit trails.

src/Loggable · high confidence

The IpTraceable extension is now available, allowing developers to automatically track IP addresses on Doctrine entities. This feature introduces the IpTraceable marker interface and the IpTraceableListener, which supports configuring IP fields to update on entity creation, updates, or specific field changes via annotations. The listener allows IP values to be set directly or provided via a custom IpAddressProviderInterface, enabling accurate attribution of who or what created or modified records.

src/IpTraceable · high confidence

The src/Translator directory now contains the core model classes for the translation system: TranslationInterface, Translation, and TranslationProxy. TranslationInterface defines the contract for translation objects, while the abstract Translation class provides a base implementation with properties for translatable entity, locale, property name, and value. TranslationProxy acts as a dynamic proxy that intercepts property access on translatable entities to retrieve or store localized values in a separate translation collection, enabling transparent multi-language support for entity properties.

src/Translator · high confidence

The Uploadable component now introduces a dedicated \FileInfoInterface\ and a concrete \FileInfoArray\ implementation to standardize how uploaded file metadata (such as name, size, type, and error codes) is accessed. This change provides a structured, interface-based approach to file info retrieval, ensuring consistent data shapes across the extension and improving type safety for developers relying on upload functionality.

src/Uploadable/FileInfo · high confidence

A new LogEntryRepository class has been added to the Loggable extension, providing dedicated methods to interact with log entries. Users can now retrieve all log entries for a specific entity via getLogEntries() or obtain the underlying query with getLogEntriesQuery(). The repository also supports reverting an entity to a previous state using the revert() method, which restores field values from a specified revision version. This repository extends Doctrine's EntityRepository and is typed with generics to ensure type safety for loggable entities.

src/Loggable/Entity/Repository · high confidence

The Uploadable extension now includes a dedicated MimeType component that provides a \MimeTypeGuesser\ class and a \MimeTypesExtensionsMap\ to handle file type detection. The guesser uses PHP's \finfo\ extension to determine MIME types, while the map provides a comprehensive lookup table of standard MIME types and their corresponding file extensions, enabling more robust validation of uploaded files.

src/Uploadable/MimeType · high confidence

A new SoftDeleteableFilter class has been added for Doctrine MongoDB ODM, allowing users to automatically filter out soft-deleted documents in queries. The filter supports both standard soft-delete (checking for null values) and time-aware soft-delete (checking for timestamps greater than the current date), and provides methods to enable or disable the filter for specific document classes.

src/SoftDeleteable/Filter/ODM · high confidence

Added new \ODM.php\ and \ORM.php\ files in \src/Sortable/Mapping/Event/Adapter\ that implement the \SortableAdapter\ interface for Doctrine MongoDB ODM and Doctrine ORM respectively. These adapters provide the concrete logic for \getMaxPosition\ and \updatePositions\, enabling the Sortable behavior to correctly calculate and update document/entity positions within groups using the respective query builders and DQL/ODM query mechanisms.

src/Sortable/Mapping/Event/Adapter · high confidence

This release introduces a new ReferenceIntegrity extension that allows you to define how related objects are handled when a parent object is removed. By applying the @Gedmo\\ReferenceIntegrity annotation to associations, you can choose between three actions: 'nullify' to automatically set the reference to null, 'pull' to remove the reference from the parent's collection, or 'restrict' to prevent deletion if the reference is still active. This provides fine-grained control over referential integrity in Doctrine ODM mappings.

src/ReferenceIntegrity · high confidence

A new \ReferencesAdapter\ interface has been introduced in the \Gedmo\\References\\Mapping\\Event\ namespace to serve as the event adapter for the References extension. This interface extends \AdapterInterface\ and defines three methods—\getIdentifier\, \getSingleReference\, and \extractIdentifier\—which allow the extension to retrieve object identifiers and references from the Doctrine ObjectManager. This change provides the necessary contract for mapping events specific to the References feature.

src/References/Mapping/Event · high confidence

A new SortableRepository class is introduced, extending Doctrine's EntityRepository to provide specialized methods for retrieving entities sorted by position within specific groups. Users can now query entities using getBySortableGroups, which accepts an array of group values to filter and order results, ensuring that items are returned in the correct sequence defined by the sortable listener configuration.

src/Sortable/Entity · high confidence

A new \TranslatableAdapter\ interface has been introduced in the \src/Translatable/Mapping/Event\ namespace to define the contract for Doctrine event adapters specific to the Translatable extension. This interface extends the base \AdapterInterface\ and specifies methods for managing personal translations, loading and searching for translation records, and handling translation value transformations, providing a standardized way for implementations to interact with the translation mapping system.

src/Translatable/Mapping/Event · high confidence

Added a new TranslationRepository class for the Doctrine MongoDB ODM translatable extension. This repository provides methods to manage translations for document fields, including translating a specific field into a locale, finding all translations for a document, and locating documents by their translated field values.

src/Translatable/Document/Repository · high confidence

Added a new TranslationRepository class in the Translatable extension that provides methods to interact with translation entities. This includes the translate() method for creating or updating translations for specific fields and locales, findTranslations() to retrieve all translations for an entity grouped by locale, and findObjectByTranslatedField() to locate entities based on their translated content. The repository handles the underlying persistence logic for translation records, including managing foreign keys, object classes, and locale-specific content storage.

src/Translatable/Entity/Repository · high confidence

A new TreeObjectHydrator class has been added to the ORM hydrator layer to automatically map parent and children properties of tree nodes during hydration. This component hooks into the hydration process to build a children hashmap and populate entity collections in memory, which allows users to retrieve complete tree structures with fewer database queries and ensures that nested child collections are properly initialized without triggering additional SELECT statements.

src/Tree/Hydrator · high confidence

A new Validator class has been added to the ReferenceIntegrity/Mapping namespace to validate mapping information. This class defines constants for reference integrity actions (NULLIFY, PULL, RESTRICT) and provides a method to retrieve the list of available integrity actions, helping users ensure their mapping configurations are valid.

src/ReferenceIntegrity/Mapping · high confidence

The library introduces two new interfaces in the event mapping layer: \AdapterInterface\, which standardizes the contract for Doctrine event adapters (including deprecating the magic \\_\_call\ method), and \ClockAwareAdapterInterface\, which allows adapters to accept a PSR-20 \ClockInterface\ for deterministic time handling in event adapters that create new \DateTimeInterface\ objects.

src/Mapping/Event · high confidence

Added new \ODM\ and \ORM\ classes in the \src/References/Mapping/Event/Adapter\ directory that implement the \ReferencesAdapter\ interface. These adapters provide specific logic for extracting identifiers and retrieving single references for Doctrine MongoDB ODM, PHPCR ODM, and ORM entities, including support for proxy objects via \Doctrine\\Persistence\\Proxy\ and \GhostObjectInterface\.

src/References/Mapping/Event/Adapter · high confidence

Added a new \example/em.php\ script that shows how to configure and initialize the Doctrine ORM Entity Manager with Gedmo Behavioral Extensions. The example supports both PHP 8+ attributes and PHP 7 annotations, registers listeners for Sluggable, Tree, Timestampable, Blameable, and Translatable extensions, and uses a shared \ArrayAdapter\ cache for metadata and query caching.

example · high confidence

The Sluggable extension now includes three new handler classes—RelativeSlugHandler, InversedRelativeSlugHandler, and TreeSlugHandler—along with their supporting interfaces (SlugHandlerInterface, SlugHandlerWithUniqueCallbackInterface) and a deprecated Urlizer utility. RelativeSlugHandler allows slugs to be prefixed by a related object's slug (e.g., 'company/user'), InversedRelativeSlugHandler updates back-related slugs when an inversed relation changes, and TreeSlugHandler recursively builds hierarchical slugs from parent nodes (e.g., 'category/subcategory/item'). These handlers enable more complex, relationship-aware slug generation patterns previously unavailable in the extension.

src/Sluggable/Handler · high confidence

The SoftDeleteable trait implementations for Doctrine ORM (SoftDeleteableEntity) and MongoDB ODM (SoftDeleteableDocument) have been updated to include PHP 8 attribute mapping configurations alongside the existing docblock annotations. This allows users to utilize native PHP 8 attributes for defining the \deletedAt\ field mapping, providing a modern alternative to annotation-based configuration while maintaining backward compatibility.

src/SoftDeleteable/Traits · high confidence

The repository now includes standardized configuration files for code quality and development workflows, including \.php-cs-fixer.dist.php\ for coding standards, \phpstan.neon.dist\ for static analysis, \phpunit.xml.dist\ for the test suite, and \compose.yaml\ for Docker-based local environments. A new \.gitattributes\ file ensures that non-essential files (such as tests, docs, and CI configs) are excluded from distribution archives, while the \Makefile\ provides convenient commands for linting and fixing code. Additionally, the legacy \README.markdown\ has been removed in favor of the updated \README.md\.

(repo-wide) · high confidence

The ORM SQL walkers now support Doctrine ORM 3.x alongside the existing 2.x versions. This change introduces a compatibility layer that automatically selects the correct implementation based on the installed ORM version, ensuring that query translation and pagination continue to work correctly without breaking changes for users upgrading their ORM dependency.

src/Tool/ORM/Walker · high confidence

The TranslationRepository class, which previously provided helper methods for querying translation records (such as findTranslation and findFieldTranslation), has been removed from the codebase. Users relying on this specific repository for direct translation queries will need to adjust their data access patterns.

lib/DoctrineExtensions/Translatable/Repository · high confidence

The Translation entity now includes native PHP 8 attributes (\#\[ORM\\Entity\], \#\[ORM\\Table\], \#\[ORM\\UniqueConstraint\]) alongside the existing Doctrine annotations. This dual-mapping approach ensures compatibility with Doctrine ORM versions that support PHP 8 attributes while maintaining backward compatibility with older versions, allowing users to migrate their mapping style without breaking existing functionality.

src/Translatable/Entity · high confidence

Introduces new \AbstractTreeRepository\ and \MaterializedPathRepository\ classes for the Doctrine MongoDB ODM driver, replacing the previous implementation to ensure compatibility with ODM 2.0. These repositories provide the core tree-strategy logic (such as materialized path queries and hierarchy building) specifically for MongoDB document storage, utilizing the updated \MongoDB\\BSON\\Regex\ for path matching and adhering to the new ODM repository interfaces.

src/Tree/Document · high confidence

The AbstractClosure entity in the Tree extension now supports PHP 8 attributes alongside existing PHPDoc annotations. This change allows users who prefer or require native PHP 8 attribute syntax for Doctrine ORM mappings to utilize the new \#\[ORM\\...\] attributes for defining the mapped superclass, ID, and column types, ensuring compatibility with modern PHP versions while maintaining backward compatibility with annotation-based configurations.

src/Tree/Entity/MappedSuperclass · high confidence

The AbstractLogEntry mapped superclass now includes native PHP 8 ORM attributes alongside existing Doctrine annotations. This dual-annotation approach ensures compatibility with both older and newer Doctrine ORM versions while supporting the transition to attribute-based configuration for logging entity metadata.

src/Loggable/Entity/MappedSuperclass · high confidence

A new \EntityRepositoryCompat\ trait has been introduced to ensure backward compatibility between Doctrine ORM 2.x and 3.x. This trait adapts the return type of the \\_\_call\ magic method—omitting the \mixed\ return type for ORM 2.x environments where it is not supported, while including it for ORM 3.x—allowing the library to function correctly across both major versions without breaking changes.

src/Tool/ORM/Repository · high confidence

New internal traits (EntityManagerRetriever and HydratorCompat) have been added to the ORM hydration tooling to bridge differences between Doctrine ORM 2.x and 3.x. This ensures that custom hydrators can correctly access the entity manager and override lifecycle methods like prepare, cleanup, and hydrateAllData regardless of the underlying ORM version, maintaining backward compatibility without requiring changes to user code.

src/Tool/ORM/Hydration · high confidence

A new Validator class has been introduced in the SoftDeleteable mapping layer to ensure that fields designated for soft-delete timestamps use only supported data types. This validation checks the field mapping against a strict list of valid types (such as date, datetime, and timestamp variants) and throws an exception if an unsupported type is detected, preventing configuration errors at runtime.

src/SoftDeleteable/Mapping · high confidence

All mapping annotation classes in src/Mapping/Annotation (such as Blameable, Timestampable, Sluggable, and Tree) now include PHP 8 attribute syntax (\#\[Attribute\]) alongside their existing docblock annotations, allowing you to use them as native PHP attributes. Additionally, constructors have been standardized to use named arguments, with deprecation warnings triggered if the legacy array-based first argument is passed.

src/Mapping/Annotation · high confidence

The Blameable extension now allows tracking changes by an actor via a new \ActorProviderInterface\, which takes precedence over a static user value. When resolving the user identity for blameable fields, the listener automatically extracts the identifier by checking for \getUserIdentifier()\, \getUsername()\, or \\_\_toString()\ methods on the actor object, ensuring compatibility with modern user objects that may not expose a simple string username.

src/Blameable · high confidence

The ORM closure table strategy now triggers a deprecation warning if the 'ancestor' and 'descendant' associations are not explicitly mapped in the entity metadata. Users must now manually define these mappings in their entity configuration to ensure compatibility with version 4.0, as the library will no longer auto-generate them. This change also includes updates to the nested set and materialized path strategies to align with modern Doctrine ORM APIs and improve type safety.

src/Tree/Strategy/ORM · high confidence

The \AbstractWrapper::clear()\ and \WrapperInterface::populate()\ methods are now deprecated and will be removed in version 4.0. Calling these methods will trigger a deprecation notice via the \doctrine/deprecations\ library, guiding users to migrate away from these APIs before the next major release.

src/Tool/Wrapper · high confidence

The Annotation and Yaml mapping drivers in the Blameable extension are now deprecated and will be removed in version 4.0. Users relying on PHP annotations or YAML files to configure Blameable fields should migrate to PHP attributes, which are now the supported standard. The Attribute driver remains fully functional and is the recommended approach for defining blameable metadata going forward.

src/Blameable/Mapping/Driver, src/IpTraceable/Mapping/Driver · high confidence

The \UploadableBaseEventArgs\ class now triggers deprecation warnings when \getEntityManager()\ and \getEntity()\ are called, indicating these methods are deprecated since version 3.14 and will be removed in version 4.0. Users should migrate to using \getObjectManager()\ and \getObject()\ respectively, which provide the same functionality without triggering deprecations.

src/Uploadable/Event · high confidence

The ORM and ODM event adapters now trigger deprecation warnings when using legacy methods like \getEntityManager()\/\getEntity()\ (ORM) or \createLifecycleEventArgsInstance()\ (ODM). These methods are deprecated in favor of the standard \Doctrine\\Common\\EventArgs\ interface methods (\getObjectManager()\, \getObject()\) and custom lifecycle event classes, ensuring compatibility with newer Doctrine versions and preparing for removal in version 4.0.

src/Mapping/Event/Adapter · high confidence

The Annotation and Yaml mapping drivers for the Loggable extension have been deprecated and are scheduled for removal in version 4.0. Users relying on PHP annotations or YAML files to configure loggable classes and versioned fields will now see deprecation warnings. The codebase has shifted towards using PHP attributes (via the new Attribute driver) and XML mapping (Xml driver remains supported) as the primary configuration methods. Existing configurations using annotations or YAML will continue to work for now but should be migrated to attributes or XML to ensure future compatibility.

src/Loggable/Mapping/Driver, src/Sortable/Mapping/Driver, src/Tree/Mapping/Driver · high confidence

The QueryAnalyzer class in the logging tooling is now deprecated as of version 3.5 and marked as final since version 3.11. Users relying on this class for SQL logging and query performance analysis should be aware that it is scheduled for removal in a future release and should plan to migrate to alternative logging or profiling solutions.

src/Tool/Logging · high confidence

The mapping drivers for the Reference Integrity extension that rely on PHP annotations (Annotation.php) and YAML configuration files (Yaml.php) are now deprecated and will be removed in version 4.0. Users must migrate to the new PHP 8+ attribute-based mapping driver (Attribute.php) to continue using this feature. The annotation driver now extends the attribute driver, and the YAML driver remains available but marked for removal.

src/ReferenceIntegrity/Mapping/Driver · high confidence

The annotation and YAML mapping drivers for the SoftDeleteable extension are now deprecated and will be removed in version 4.0. Users relying on PHP annotations or YAML files to configure soft-deleteable entities will receive deprecation warnings, encouraging a migration to the new attribute-based mapping or XML/YAML drivers that remain supported. The underlying logic for reading metadata from these deprecated formats remains functional in this version but is marked for future removal.

(repo-wide) · high confidence

The mapping drivers in src/Mapping/Driver now officially deprecate support for PHP annotations, requiring users to migrate to PHP attributes for version 4.0. The AbstractAnnotationDriver now triggers deprecation warnings when an annotation reader is used, and the AnnotationDriverInterface is marked as deprecated. A new AttributeReader class has been introduced to handle PHP attribute-based metadata, and an AttributeAnnotationReader provides a fallback mechanism to support both styles during the transition. Existing annotation-based configurations will continue to work but will emit deprecation notices.

src/Mapping, src/Mapping/Driver · high confidence

The exception classes in the \Gedmo\\Exception\ namespace (such as \BadMethodCallException\, \InvalidMappingException\, and the various \Uploadable\*\ exceptions) are now marked as \final\. This change prevents these classes from being extended, effectively closing the API for inheritance and ensuring that users cannot create custom subclasses of these specific exception types.

src/Exception · high confidence

The \FilenameGeneratorAlphanumeric\ and \FilenameGeneratorSha1\ classes in the \src/Uploadable/FilenameGenerator\ directory are now marked as \@final\ since version 3.11. This change prevents these specific filename generation implementations from being extended by subclasses, effectively closing the API for inheritance in this area while keeping the \FilenameGeneratorInterface\ open for new implementations.

src/Uploadable/FilenameGenerator · high confidence

The References extension now uses a new LazyCollection class to handle 'reference many' associations. This change defers the loading of related entities until they are actually accessed, which can improve performance by avoiding unnecessary database queries during object hydration. The ReferencesListener has been updated to instantiate this lazy collection when loading mapped 'referenceMany' fields.

src/References · high confidence

A new SoftDeleteableAdapter interface has been added to the SoftDeleteable mapping event system. This interface extends the standard Doctrine AdapterInterface and defines a getDateValue method that can return either an integer or a DateTimeInterface object. This change enables the SoftDeleteable extension to support non-DateTime fields, allowing date values to be stored as integers (e.g., Unix timestamps) in addition to standard DateTime objects.

src/SoftDeleteable/Mapping/Event · high confidence

The library now supports PHP 8 attributes for metadata mapping in the ORM and MongoDB ODM extensions, automatically using \AttributeDriver\ when running on PHP 8.0+ while falling back to annotations on older versions. The \DoctrineExtensions::registerAnnotations()\ method is now deprecated and performs no action, as modern annotation libraries support autoloading; users should rely on the new attribute-based configuration or ensure their annotation reader is properly configured for PHP 7 environments.

src · high confidence

The Sortable and Tree extensions now define their own event adapter contracts (\SortableAdapter\ and \TreeAdapter\) and provide concrete implementations for Doctrine ORM and ODM. These new adapter classes extend the base Doctrine adapter classes and implement the respective extension-specific interfaces, establishing a dedicated event handling layer for these behaviors.

src/Sortable/Mapping/Event, src/Tree/Mapping/Event · high confidence

The Materialized Path tree strategy now explicitly casts the value of the path source property to a string type before using it to build the path. This ensures consistent path generation regardless of the underlying data type of the source field, preventing potential issues with non-string identifiers in tree structures.

src/Tree/Strategy · high confidence

Added new Sluggable event adapters for both Doctrine ORM and ODM. The ORM adapter now uses the TranslationWalker for Translatable objects to ensure slug uniqueness across translations, and replaces relative/inverse slugs via DQL update queries. The ODM adapter implements similar logic using MongoDB queries, including support for unique\_base constraints and regex-based slug matching, while fixing return values for replaceRelative and replaceInverseRelative methods to correctly return the count of updated documents.

src/Sluggable/Mapping/Event/Adapter · high confidence

A new Validator class has been introduced in the mapping layer to enforce strict validation rules for uploadable field configurations. This component ensures that fields designated for file name, MIME type, path, and size adhere to their required data types (e.g., string for names/paths, decimal/float for sizes) and validates that the target storage directory exists and is writable, throwing specific exceptions if these constraints are not met.

src/Uploadable/Mapping · high confidence

This release introduces new extension points for tracking actor and IP address references via the newly added ActorProviderInterface and IpAddressProviderInterface, allowing extensions to support user and IP references. It also deprecates the populate() method on WrapperInterface (and AbstractWrapper::clear()) for removal in version 4.0, and adds a ClassUtils utility that gracefully falls back to get\_class() if doctrine/common is not installed.

src/Tool · high confidence

A new Validator class has been introduced in the Tree mapping layer to enforce strict type constraints for tree-related fields. This change ensures that parent, path, path source, path hash, lock time, and root fields are mapped to specific, valid database types (e.g., integers for parents, strings for paths, UUIDs for path sources), preventing configuration errors at the mapping level.

src/Tree/Mapping · high confidence

The Sluggable extension has replaced the behat/transliterator library with Symfony String components for generating slugs. This change updates the default transliteration and urlization callbacks in SluggableListener to use Symfony's AsciiSlugger and string utilities, ensuring consistent slug generation behavior and reducing external dependencies.

src/Sluggable · high confidence

The soft-deleteable extension now handles DELETE queries involving inheritance hierarchies by intercepting multi-table delete operations. When a delete query targets the root entity of an inheritance tree, the executor transforms the SQL to perform an UPDATE on the root table (setting the soft-delete field to the current timestamp) instead of a hard delete, while preventing the deletion of child entity records. This ensures that soft-deleted entities and their related inheritance data remain intact rather than being permanently removed from the database.

src/SoftDeleteable/Query/TreeWalker/Exec · high confidence

The SoftDeleteable event adapters for both ORM and ODM now accept a PSR-20 ClockInterface, allowing users to inject a custom clock for deterministic date handling instead of relying on the system time. Additionally, the adapters have been updated to support Doctrine 3+ field mapping objects (FieldMapping) and correctly handle non-DateTime field types such as integer timestamps and immutable date/time types, ensuring compatibility with newer Doctrine versions and more flexible schema definitions.

src/SoftDeleteable/Mapping/Event/Adapter · high confidence

The SoftDeleteable behavior now allows users to control whether soft-deleted entities are automatically detached from the ObjectManager after a flush operation. By passing a boolean flag to the SoftDeleteableListener constructor (defaulting to false), users can enable this feature to prevent soft-deleted objects from remaining in the unit of work, which can help manage memory and avoid unintended access to deleted records. This change introduces new event argument classes (PreSoftDeleteEventArgs and PostSoftDeleteEventArgs) and updates the listener to conditionally detach objects based on this new configuration.

src/SoftDeleteable · high confidence

The SoftDeleteableFilter implementation now ensures that calling disableForEntity or enableForEntity changes the filter's internal hash by setting a parameter, which forces Doctrine to invalidate the query cache. This prevents stale SQL results when soft-delete filtering is dynamically enabled or disabled for specific entities during runtime.

src/SoftDeleteable/Filter · high confidence

The Sortable and Timestampable behaviors have been updated to standardize runtime deprecation handling by integrating the \doctrine/deprecations\ library, ensuring consistent warnings for deprecated usage patterns. Additionally, the \SortableListener\ and \TimestampableListener\ classes now leverage methods from the \Doctrine\\Persistence\\Mapping\\ClassMetadata\ interface for field access, replacing direct property access or older adapter calls. The codebase has also been modernized with strict PHP types, generics for configuration arrays, and the \SortableListener\ is now marked as \@final\, signaling that it should not be extended in future versions.

src/Sortable · high confidence

The Timestampable event adapters for both ORM and ODM now implement ClockAwareAdapterInterface, allowing users to inject a PSR-20 ClockInterface to control time generation instead of relying on the system clock. Additionally, the ORM adapter has been updated to handle Doctrine ORM 3's new FieldMapping object structure returned by ClassMetadata::getFieldMapping(), ensuring correct PHP value conversion for timestamp and immutable date/time fields.

src/Timestampable/Mapping/Event/Adapter · high confidence

The TranslatableListener is now marked as final, preventing further inheritance and stabilizing the API contract for users relying on this core component. Additionally, the implementation has been updated with strict PHP type declarations and generics, improving type safety and reducing runtime errors when handling translation events and configurations.

src/Translatable · high confidence

The Translatable extension has removed the requirement for entities to implement the \Translatable\ interface and the \TranslatableException\ class. Instead, translation behavior is now configured via annotations, simplifying entity definitions by removing the need for explicit interface methods like \getTranslatableFields()\ and \getTranslatableLocale()\.

lib/DoctrineExtensions/Translatable · high confidence

The Translation entity in the Translator module has been updated to use PHP 8 attributes (e.g., \#\[ORM\\MappedSuperclass\], \#\[ORM\\Column\]) alongside the existing DocBlock annotations for mapping metadata. This change modernizes the entity's definition to support the newer attribute-based configuration style while maintaining backward compatibility with annotation-based readers, ensuring the entity continues to function correctly within the Doctrine ORM context.

src/Translator/Entity · high confidence

The TranslationWalker in the Translatable query component has been updated to extend the new SqlOutputWalker class from Doctrine ORM. This change aligns the extension with recent ORM internal API shifts, ensuring that SQL generation for translatable entities continues to function correctly without breaking changes for users relying on the existing translation features.

src/Translatable/Query · high confidence

The Tree extension has been reorganized under the \Gedmo\\Tree\ namespace, introducing new marker and utility interfaces (\Node\, \RepositoryInterface\, \RepositoryUtilsInterface\) and a dedicated \Strategy\ interface to manage tree algorithms. The \TreeListener\ now uses PHPStan generics and specific configuration types to improve type safety, while \RepositoryUtils\ provides updated methods for building tree hierarchies and HTML output. This change aligns the Tree component with modern PHP standards and prepares it for stricter static analysis.

src/Tree · high confidence

The XML mapping schemas for Doctrine Extensions have been updated to support new features and extensions. The 2.2 schema adds definitions for SoftDeleteable, Uploadable (including file size and MIME type validation), Reference, and Tree PathHash, while also introducing locking options for Tree mappings. The 2.1 schema adds support for IpTraceable and Blameable extensions, and both schemas now include the fallback option for Translatable mappings.

schemas · high confidence

Added ArticleTemplate fixture for translatable tests; Added Blameable test fixtures for Doctrine ORM entities; Added Doctrine ODM test fixtures for Loggable embedded documents and references; Added Doctrine ODM test fixtures for ReferenceIntegrity; Added MongoDB ODM fixture documents for translatable tests; Added MongoDB ODM fixture for Sluggable tests; Added MongoDB ODM test fixtures for Sortable behavior; Added ODM document fixtures for Timestampable tests; Added PHP 8 attribute-based mapping fixtures for tests; Added PHP 8 attribute-based test fixtures for MongoDB Tree documents; Added PHP 8 attribute-based test fixtures for Tree extensions; Added PHP 8 attribute-based test fixtures for the genealogy tree hierarchy; Added PHP 8 attribute-based test fixtures for tree mapping; Added SoftDeleteable test fixtures; Added Sortable test fixtures with Doctrine 8 attribute mapping; Added XML mapping fixture classes for behavioral extensions; Added XML mapping tests for Tree, Translatable, and References extensions; Added Yaml mapping fixture classes for Gedmo extensions; Added closure table tree fixture models with PHP 8 attributes; Added mapping tests for Gedmo extensions; Added mock classes for testing MaterializedPath concurrency; Added mock event subscriber classes for mapping tests; Added test coverage for Sluggable handlers; Added test coverage for Sortable behavior in Doctrine MongoDB ODM; Added test fixture files for uploadable tests; Added test fixture for BehavioralCategory repository; Added test fixture for Document mapping with annotations and attributes; Added test fixture for MongoDB ODM Article document; Added test fixture for MongoDB ODM translatable entity; Added test fixture for ODM Sluggable upserts; Added test fixture for Sluggable SQL filtering; Added test fixture for Sluggable slug generation with attributes; Added test fixture for Sluggable unique\_base attribute; Added test fixture for Sluggable with PHP 8 attributes; Added test fixture for Tree Issue 2408; Added test fixture for Tree NestedSet Issue 2517; Added test fixture for custom DBAL type compatibility; Added test fixture for nullable slug behavior; Added test fixture for sluggable translatable articles; Added test fixture for translatable boolean handling; Added test fixture for translatable entity with nullable title; Added test fixture for unmapped Timestampable entity; Added test fixtures for Blameable with Doctrine ODM MongoDB attributes; Added test fixtures for IpTraceable with Doctrine ODM 2.0 attribute support; Added test fixtures for Issue 2616; Added test fixtures for Issue 75 (ManyToMany translatable relations); Added test fixtures for Loggable entity scenarios; Added test fixtures for Loggable with attribute mapping support; Added test fixtures for Sluggable Document handlers; Added test fixtures for Sluggable behavior on mapped superclasses; Added test fixtures for Sluggable behavior with JOINED inheritance; Added test fixtures for Sluggable handlers with PHP 8 attributes; Added test fixtures for Sluggable unique\_base behavior with relations; Added test fixtures for Sluggable unique\_base with foreign keys; Added test fixtures for Sluggable with embedded address objects; Added test fixtures for Sluggable with various DateTime types; Added test fixtures for SoftDeleteable ODM document mappings; Added test fixtures for Sortable inheritance and multiple groups; Added test fixtures for Timestampable behavior; Added test fixtures for Translatable attribute mapping; Added test fixtures for Translatable attribute support; Added test fixtures for combined slug handlers; Added test fixtures for cross-OM reference scenarios; Added test fixtures for personal translation entities; Added test fixtures for personal translations in MongoDB ODM; Added test fixtures for the Translatable extension; Added test fixtures for translatable inheritance issue \#1123; Added test fixtures for wrapper entity mapping; Added test for Timestampable mapping with SimplifiedXmlDriver; Added test infrastructure for ORM event adapter and deprecation handling; Added test mock for the Encoder mapping extension; Added test stubs for Uploadable component; Added tests for Blameable behavior across ORM and ODM; Added tests for Entity and MongoDocument wrappers; Added tests for FileInfoArray validation; Added tests for FilenameGeneratorAlphanumeric; Added tests for Loggable behavior with annotations, attributes, and ODM; Added tests for ReferenceIntegrity extension behavior; Added tests for References extension lazy loading and cross-ORM persistence; Added tests for Tree listener edge cases; Added tests for Uploadable Mapping Validator; Added tests for Uploadable behavior with typed properties; Added tests for annotation argument handling and attribute/annotation parity; Added tests for custom and forced metadata mapping scenarios; Added tests for mapping driver registration, actor provider, and IP address provider; Added tests for the IpTraceable behavior; Added tests for the Translatable behavior; Added tests for translatable behavior edge cases; Expanded test coverage for Gedmo Tree strategies; Expanded test coverage for the Translatable behavior; Expanded test fixtures for Uploadable entity scenarios; New test infrastructure for Doctrine ODM and ORM.

This change introduces the composer.json manifest for the gedmo/doctrine-extensions library, defining its dependencies and development requirements. The package requires PHP 7.4 or 8.0 and relies on core Doctrine components (collections, event-manager, persistence) alongside Symfony utilities (cache, string). It supports Doctrine ORM versions 2.20+ and 3.3+, as well as Doctrine MongoDB ODM 2.3+. Development dependencies include PHPUnit 9.6, PHPStan 2.x, and various Symfony components for testing and coding standards.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 70.

• Code Health 79
• Architecture 89
• Maturity 60
• Readiness 86
• Security 74

• 300 commits — 254 feature/other, 46 fixes

• (root) — 87 commits
• tests/Gedmo — 59 commits
• .github/workflows — 45 commits
• src/Mapping — 20 commits
• src/Tree — 16 commits
• src/Translatable — 11 commits
• src/SoftDeleteable — 7 commits
• src/Sluggable — 6 commits
• src/Tool — 6 commits
• src/Loggable — 4 commits
• src/Blameable — 3 commits
• doc/annotations.md — 2 commits
• doc/blameable.md — 2 commits
• doc/frameworks — 2 commits
• doc/ip_traceable.md — 2 commits
• doc/loggable.md — 2 commits
• doc/sluggable.md — 2 commits
• doc/symfony.md — 2 commits
• doc/translatable.md — 2 commits
• src/Exception — 2 commits

• fix: Bump ORM requirements, fix translation walker handling of paginated queries
• fix: Expand compat fixes for the translation walker
• fix: Fix @note annotation error
• fix: Fix CS
• fix: Fix CS
• fix: Fix CS errors
• fix: Fix CS issues
• fix: Fix CS on composer.json
• fix: Fix PHPStan definition for "path_append_id" option at TreeListener
• fix: Fix PHPStan findings
• fix: Fix PHPStan findings about iterable parameters
• fix: Fix PHPUnit config to restore Codecov support
• fix: Fix SA issue with AbstractAnnotationDriver::getMetaReflectionClass()
• fix: Fix compat with doctrine/mongodb-odm 2.11
• fix: Fix constraint for "behat/transliterator" by using semver operator
• fix: Fix entity manager acquisition in the example app
• fix: Fix findings from PHP CS Fixer
• fix: Fix generic type implementations
• fix: Fix materialized path tests
• fix: Fix phpstan build
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

doctrine-extensions/DoctrineExtensions was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.