ixmanuel/nexus

It manages object's dependencies for internal builders collaborators.

, _(*1)

Mapping dependencies at construction time

This registers collaborators (dependencies) in the constructors in order to decouple the object creation in methods., _(*2)

Keywords

inversion control, dependency injection, builder, _(*3)

Goal

Testable, reusable and maintainable code by avoiding hard-coded references in methods., _(*4)

Benefits

• Creating collaborators (a.k.a. dependencies) only in constructors.
• Avoiding a global dependency injection container.
• Switching default implementations with alternatives and test's objects.

Advantages of the language

• Referencing of classes and interfaces with its namespace.

Alternatives

• Usage of mapping.
• Anonymous classes.
• Passing empty objects that create those which are fully identifiable.
• Defining and implementing an interface for each collaboration.

Here is an example that reconstitutes an entity from a data store.

You just need to pass the interface and its implementation.

    // It reconstitutes a person from a data store: PersonID is a kind 
    // of Identity as much as an AboutMe is a kind of About and both
    // of them are collaborators. Take note that the creation is
    // delayed until need it, but it is not a Singleton.

    // Testing purposes.
    $person = new PersonFromStore(
        new FetchedPerson($id), TestPersonID::class, AboutMe::class
    );   

    // Application.
    $person = new PersonFromStore(
        new FetchedPerson($id), PersonID::class, AboutMe::class
    );  

    // Description
    final class PersonFromStore implements Party
    {
        private $record;
        private $identity;
        private $about;

        public function __construct(IdentityRecord $record, string $identity, string $about)
        {
            $this->record = $record;        

            $this->identity = new Assignment(Identity::class, $identity);

            $this->about = new Assignment(About::class, $about);
        }

        // Please, your ID?
        public function identity() : Identity
        {
            // It calls the main constructor or the operator "new" in the ID class.
            // Same as: new PersonID(...)
            return $this->identity->new($this->record->key());
        }

        // Tell me something about you.
        public function about() : About
        {
            // It calls a convenience constructor in the AboutMe class.
            // Same as: AboutMe::withID(...)
            return $this->about->withID($this->identity());
        }
    }  

A proposal for the php community.

    // Definition
    final class PersonFromStore implements Party 
    {
        // It can use another word, such as join, to avoid conflicts with traits.
        use (Identity, About);

        public function identity() : Identity
        {
            return new Identity($record->key());
        }

        ...               
    }

    // Client
    $person = new PersonFromStore($fetchedPerson) use (PersonID, AboutMe);
    // Test
    $person = new PersonFromStore($fetchedPerson) use (TestPersonID, AboutMe);

Now, we can create objects from their interfaces and thus, we have no more hard-coded dependencies in the methods., _(*5)