Can't use boot() nor mount() to make Dependency Injection of service class

[Aeropixel]

I'm trying to make Dependency Injection of a serviceclass to use its methods to do something in the bulk actions.
Since this is livewire I can't use __construct to do it, so I tried to use mount() or boot() instead and I get the following errors:

When using mount() it simply tells:
Typed property App\Http\Livewire\UserTable::$userService must not be accessed before initialization

When using boot() to resolve the previous error I get the following:
Declaration of App\Http\Livewire\UserTable::boot(App\Services\UserService $userService) must be compatible with Rappasoft\LaravelLivewireTables\DataTableComponent::boot(): void

Using boot is what I usually use with Livewire to make DI to work.
Now how can I make use of my services when using rappasoft's tables?

[lrljoe]

So you're trying to make use of your userService somewhere in the Bulk Actions?

There's a couple of options here, if you let me know where exactly you're making a call to it, and I can give you a steer as to where to add it in!

Drop what you're doing with your boot method to help me out a bit.

The best method in my opinion? Create a trait for your UserService, and then use the Livewire Lifecycle bindings to load it properly.

You can of course just call the parent method at the end of your customised boot method within the component itself, but note that this approach isn't entirely recommended, and you may have some oddities, so it's best practice to use Traits, especially where you're going to end up re-using the code!

If you wanted to just proceed with a custom boot method, then this would work:

    public function boot(): void
    {
        // Your Code Goes Here

        parent::boot();
    }

Otherwise, you could have a trait (e.g. UserServiceTrait), and call the following in your trait:

public function bootUserServiceTrait
{
 // Your Code Here
}

mountUserServiceTrait will also work there.

[Aeropixel]

Editor's note: Sorry about the confusion, the answer deleted was to another issue. Below comes the real answer to @lrljoe

The original code giving the "(...) must be compatible with Rappasoft (...)" is as follows.
I simply can't make Dependency Injection with this library.

class userTable extends DataTableComponent
{
    public UserService $userService;

    public function boot(UserService $userService) {
        $this->userService = $userService;
    }

    public array $bulkActions = [
        'deleteUser' => 'Delete User'
    ];

    public function deleteUser()
    {
        $this->userService->deleteUser($this->getSelected());
    }
}

The solution I found to make it work was simply giving up on using the service, eliminating bool() at all and repeat the query using Eloquent directly on the bulk action's methods.

    public function deleteUser()
    {
        User::destroy($this->getSelected());
    }

P.S. - I tried calling parent::bool() in the end and the error keeps there.

[Aeropixel]

Thanks for the speedy response.

• I wont solve the problem today but there are a couple of things I can say now.

• The configuration and columns methods exist but were removed to keep the question as clean as possible.

• You are totally right, the UserService property should not be "public", it should be "private" for obvious reasons. My bad.

• The intention of making the Dependency Injection of the whole UserService to access all the methods there that are needed in this table's actions. There is more than just delete stuff.

• I'm still not aware (at this moment, friday night) how can I solve the boot or mount problem as they blow up in my face right in VS Code's inteliphense (at least the boot()).

And finally:

• Even though it wasn't the intention at all when I showed the deleteUser method, your suggestion on how to deal with a user's deletion is really good and much appreciated.

Monday I'll attack this again and will tell you the outcome.

[lrljoe]

Did you manage to get your head around this in the end, if you're stuck then shout!

[Aeropixel]

Lemme have one last try on this.

I have this simple table with the following code:

<?php

namespace App\Http\Livewire\Roles;

use App\Models\Role;
use App\Models\User;
use App\Services\UserService;
use Illuminate\Database\Eloquent\Builder;
use Rappasoft\LaravelLivewireTables\DataTableComponent;
use Rappasoft\LaravelLivewireTables\Views\Column;

class UsersTable extends DataTableComponent
{
    // protected $model = Role::class;

    public int $roleid;
    public bool $withRole;
    private UserService $userService;

    public function mount(int $roleid, bool $withRole, UserService $userService): void
    {
        $this->roleid = $roleid;
        $this->withRole = $withRole;
        $this->userService = $userService;
    }

    public function builder(): Builder
    {
        return $this->userService->getUsersWithRole($this->roleid, $this->withRole);
    }

    public function configure(): void
    {
        $this->setPrimaryKey('id');
        $this->setDefaultSort('id', 'asc');
        $this->setEagerLoadAllRelationsStatus(true);
        $this->setEmptyMessage('No results found');
    }

    public function columns(): array
    {
        return [
            Column::make("Id", "id")
                ->sortable()
                ->searchable(),
            Column::make("Nome", "name")
                ->sortable()
                ->searchable(),
        ];
    }
}

It's a simple table with 3 columns.
The page loads perfectly without errors and the service's method works, but if e.g. I select a different number of rows per page, it trows the error:

Typed property App\Http\Livewire\Roles\UsersTable::$userService must not be accessed before initialization

The service method code is:

    public function getUsersWithRole(int $roleId, bool $withRole): Builder
    {
        $role = Role::find($roleId);

        if (!$withRole)
        {
            return User::whereDoesntHave('roles', function ($query) use ($role) {
                $query->where('id', $role->id);
            });
        }
        else
        {
            return User::whereHas('roles', function ($query) use ($role) {
                $query->where('id', $role->id);
            });
        }
    }

To make this table work perfectly I must not use the UserService and have to repeat the code in the builder, which is like as follows:

// builder method repeating the code from the service
    public function builder(): Builder
    {
        // return $this->userService->getUsersWithRole($this->roleid, $this->withRole);
        $role = Role::find($this->roleid);

        if (!$this->withRole)
        {
            return User::whereDoesntHave('roles', function ($query) use ($role) {
                $query->where('id', $role->id);
            });
        }
        else
        {
            return User::whereHas('roles', function ($query) use ($role) {
                $query->where('id', $role->id);
            });
        }
        // The code below returns every user that doesn't have the given role
        return User::whereDoesntHave('roles', function ($query) use ($role) {
            $query->where('id', $role->id);
        });
    }

This makes me very very confused because supposedly the service class has already been initialized in the Service Container prior to the page being loaded, so... I'm stuck and don't know how to do this without repeating the code that already exists in the services.
Not being able to fully use classes doesn't make sense to me, for repeating code that exists and is tested.
This library is really awesome for creating tables with lots of functionality, but this problem I'm facing is about to make me give up on it.

Thanks once again for your help!

[Aeropixel]

Alright, finally I've found a solution to my problem!

To finally solve the "xxxService must not be accessed before initialization" and rightfully use my services I did this:

    private function initialize(): void
    {
        if (!isset($this->userService)) {
            $this->userService = app(UserService::class);
        }
    }

then I call it on builder():

    public function builder(): Builder
    {
        $this->initialize(); // Initialize the $userService method

        return (!$this->withRole) ?
            $this->userService->getUsersNotWithRole($this->role->id) :
            $this->userService->getUsersWithRole($this->role->id);
    }

Now I can use the services I injected on mount() everywhere.