Ability to make objects immutable? Or remove only/except on an instance?

[joelvh]

Hi!

I've been using laravel-data recently and it's been great. We're using data objects as value objects, but just discovered that objects are not immutable.

Specifically, except seems to remove properties that we can't get back. The use case is that we have a data object that we serialize to send to an external API, and we need to exclude the ID. Then we want to use the same instance to include the ID elsewhere, but it is no longer included in the array/JSON.

Also, it seems like only doesn't work after calling except? Are we missing something?

Thanks!

[rubenvanassche]

Specifically, except seems to remove properties that we can't get back. The use case is that we have a data object that we serialize to send to an external API, and we need to exclude the ID. Then we want to use the same instance to include the ID elsewhere, but it is no longer included in the array/JSON.

Yeah this is a shortcoming of the current implementation of our partial trees, with v4 this is solved which should release later this year!

Also, it seems like only doesn't work after calling except? Are we missing something?

Hmm wouldn't that always be the case? They are each others opposites:

• only -> remove everything and take only these keys
• except -> take everything except these keys

I don't think they can ever work together.

[joelvh]

@rubenvanassche the scenario would be if we have an object with a variety of properties and use except('id') and then on the same instance only('name'). I would expect that to work since it's a subset of properties that were not excluded via except. The net effect is that everything is excluded except name.

I think it would depend on how this is implemented, but if there were a "stack" of transformations applied to the underlying data, this ought to work. Or if only rules are evaluated after except.

[anuzpandey]

I came across the same case. How did you solve your issue?

My current implementation:

$user = DB::transaction(function () use ($password, $payload) {
    $createPayload = $payload->toArray();
    $user = User::create([
        ...collect($createPayload)->except('role_id', 'permission_ids')->toArray(),
        'password' => Hash::make($password),
        'password_change_required' => TRUE
    ]);

    $this->assignRolesAndPermissions($payload, $user);

    return $user;
});

[joelvh]

@anuzpandey we added a reset method to our base class that inherits from Data. We also overrode the except/only methods to clone the object to return a new instance, but don't use it because we aren't sure if this will create side-effects. (It's worth noting that other parts of the package do use clone and that's what made us think that these methods are also doing it, but aren't.

Here's an example of how to both use reset and override the other methods if you wish.

class BaseObject extends Data
{
    /**
     * Sometimes we need to remove the inclusion and exclusion rules.
     */
    public function reset(): static
    {
        $this->_includes = [];
        $this->_excludes = [];
        $this->_except = [];
        $this->_only = [];

        return $this;
    }

    /**
     * Includable
     */
    public function include(string ...$includes): static
    {
        $cloned = clone $this;

        foreach ($includes as $include) {
            $cloned->_includes[$include] = true;
        }

        return $cloned;
    }

    public function exclude(string ...$excludes): static
    {
        $cloned = clone $this;

        foreach ($excludes as $exclude) {
            $cloned->_excludes[$exclude] = true;
        }

        return $cloned;
    }

    public function only(string ...$only): static
    {
        $cloned = clone $this;

        foreach ($only as $onlyDefinition) {
            $cloned->_only[$onlyDefinition] = true;
        }

        return $cloned;
    }

    public function except(string ...$except): static
    {
        $cloned = clone $this;

        foreach ($except as $exceptDefinition) {
            $cloned->_except[$exceptDefinition] = true;
        }

        return $cloned;
    }

    public function includeWhen(string $include, bool|Closure $condition): static
    {
        $cloned = clone $this;

        $cloned->_includes[$include] = $condition;

        return $cloned;
    }

    public function excludeWhen(string $exclude, bool|Closure $condition): static
    {
        $cloned = clone $this;

        $cloned->_excludes[$exclude] = $condition;

        return $cloned;
    }

    public function onlyWhen(string $only, bool|Closure $condition): static
    {
        $cloned = clone $this;

        $cloned->_only[$only] = $condition;

        return $cloned;
    }

    public function exceptWhen(string $except, bool|Closure $condition): static
    {
        $cloned = clone $this;

        $cloned->_except[$except] = $condition;

        return $cloned;
    }
}

[anuzpandey]

@joelvh Thank you so much. For me reset method is enough for now. This did the trick.

class BaseData extends Data
{
    public function reset(): static
    {
        $this->_except = [];
        $this->_only = [];

        return $this;
    }
}