Decompose entity inheritance hierarchy into traits and interfaces with composition

[Copilot]

Refactors the deep entity inheritance hierarchy into composable traits and explicit interfaces, replacing inheritance with trait composition in all concrete entities.

Changes

New Traits (5)

Extracted functionality from base classes into reusable traits:

• DBElementTrait - ID management (from AbstractDBElement)
• NamedElementTrait - Name property and methods (from AbstractNamedDBElement)
• AttachmentsTrait - Attachment collection management (from AttachmentContainingDBElement)
• StructuralElementTrait - Tree/hierarchy operations (from AbstractStructuralDBElement)
• CompanyTrait - Company-specific fields (from AbstractCompany)

New Interfaces (4)

Define explicit contracts for entity capabilities:

• DBElementInterface - Entities with database IDs
• StructuralElementInterface - Hierarchical entities
• CompanyInterface - Company entities
• HasParametersInterface - Parametrized entities

Refactored Base Classes

Replaced inline implementations with trait composition:

• AbstractDBElement: 80 → 20 lines
• AbstractNamedDBElement: 105 → 20 lines
• AttachmentContainingDBElement: 120 → 20 lines
• AbstractStructuralDBElement: 455 → 55 lines
• AbstractCompany: 260 → 20 lines

Refactored Concrete Entities (8)

Replaced inheritance with explicit trait composition:

• Category - Uses 7 traits directly instead of extending AbstractPartsContainingDBElement
• Footprint - Uses 7 traits directly instead of extending AbstractPartsContainingDBElement
• StorageLocation - Uses 7 traits directly instead of extending AbstractPartsContainingDBElement
• MeasurementUnit - Uses 7 traits directly instead of extending AbstractPartsContainingDBElement
• PartCustomState - Uses 7 traits directly instead of extending AbstractPartsContainingDBElement
• Manufacturer - Uses 8 traits (including CompanyTrait) instead of extending AbstractCompany
• Supplier - Uses 8 traits (including CompanyTrait) instead of extending AbstractCompany
• AttachmentType - Uses 7 traits directly instead of extending AbstractStructuralDBElement

Each entity now:

• Implements all required interfaces directly
• Explicitly declares which traits it uses
• Has custom __construct(), __clone(), and jsonSerialize() methods
• No longer relies on deep inheritance chains (previously 5-6 levels)

Example Usage

Entities now use explicit trait composition:

class Category implements DBElementInterface, NamedElementInterface, TimeStampableInterface, 
    HasAttachmentsInterface, HasMasterAttachmentInterface, StructuralElementInterface, 
    HasParametersInterface, \Stringable, \JsonSerializable
{
    use DBElementTrait;
    use NamedElementTrait;
    use TimestampTrait;
    use AttachmentsTrait;
    use MasterAttachmentTrait;
    use StructuralElementTrait;
    use ParametersTrait;
    
    // Entity-specific functionality
}

Impact

• ~1,000 lines moved from base classes to reusable traits
• All 8 concrete entities refactored to use composition instead of inheritance
• Explicit dependencies make trait usage visible and clear
• Trait dependencies documented in docblocks
• No database schema or API changes
• Backward compatible - all functionality preserved

Original prompt

Decompose the entity inheritance hierachy into traits and interfaces for better architecture.

---

✨ Let Copilot coding agent set things up for you — coding agent works faster and does higher quality work when set up for your repo.

[jbtronics]

@copilot Adopt the existing entities to the new trait structure.

[Copilot]

@copilot Adopt the existing entities to the new trait structure.

Could you clarify what you'd like me to do? The existing entities (Category, Manufacturer, Supplier, etc.) already benefit from the trait-based structure through inheritance. Would you like me to:

1. Add explicit trait use statements in concrete entities (though this would conflict with parent classes already using them)?
2. Update documentation/comments to clarify which traits are available through inheritance?
3. Refactor some entities to use traits directly instead of through inheritance?

The current implementation maintains backward compatibility - all entities work as before but the base classes now use traits internally.

[jbtronics]

@copilot Remove the inheritance and replace it by composition of traits

[Copilot]

@copilot Remove the inheritance and replace it by composition of traits

Done! All 8 concrete entities now use trait composition instead of inheritance:

Commits:

• 87d26e7: Refactored Category, Footprint, StorageLocation
• ad77dea: Refactored MeasurementUnit, PartCustomState, Manufacturer, Supplier, AttachmentType

Changes:
Each entity now:

• Implements all required interfaces directly (DBElementInterface, NamedElementInterface, TimeStampableInterface, HasAttachmentsInterface, HasMasterAttachmentInterface, StructuralElementInterface, HasParametersInterface, \Stringable, \JsonSerializable)
• Uses explicit traits (DBElementTrait, NamedElementTrait, TimestampTrait, AttachmentsTrait, MasterAttachmentTrait, StructuralElementTrait, ParametersTrait)
• Company entities (Manufacturer, Supplier) additionally use CompanyTrait and implement CompanyInterface
• Has custom __construct(), __clone(), and jsonSerialize() methods

All entities removed deep inheritance chains in favor of explicit trait composition.