Route binding and lazy load don't throw error in some cases

[abdel-aouby]

Hello, I have a question about a strange case regarding route binding and eager load

I have two routes

1. Route::get('/cars'), [CarController::class, 'index'])->name('cars.index');
2. Route::get('/cars/{car}', [CarController::class, 'show']) ->name('cars.show');

and a controller with 2 methods

public function index(Request $request): View
    {
        $cars = Car::query()
            ->with('translation')
            ->search($request)
            ->applyFilters($request)
            ->applySort($request)
            ->paginate(100)
            ->withQueryString();

        return view('cars.index', compact('cars'));
    }

    /**
     * Display the specified car.
     */
    public function show(Car $car): View
    {
        return view('cars.show', compact('car'));
    }

the car model relationship methods looks like that

public function translations(): HasMany
    {
        return $this->hasMany(CarTranslation::class);
    }

public function translation(): HasOne
    {
        return $this->hasOne(CarTranslation::class)
            ->where('locale', app()->getLocale())
            ->withDefault();
    }

I have prevented lazy load in the appServiceProvider

public function boot(): void
    {
        Model::preventLazyLoading(!$this->app->isProduction());
    }

like that everything works fine

1. If I comment ->with('translation') in the index method of the controller it will throw me error

Attempted to lazy load [translation] on model [App\Models\Car] but lazy loading is disabled.

which is understandable and is the desired result.

however, the strange thing for me is

2. in the show method of the controller or in the blade template cars.show
   if I do $car->translation or $car->translations it still works and does not throw an error even if I did not use
   ->with('translation) or ->with('translations) anywhere

can someone please explain to me why?

is the exception for preventing lazy loading works only with multiple objects (e.g Car::all or/and Car::query) and does not work when you have a single object like I have in the show method, because in the case of a single object the $car->translations still perform only one query all the time and there is no N + 1 issue?

is my understanding right or I'm missing something?

---

EDIT 1:

as suggested in the comment by @bulletproof-coding I added protected static $modelsShouldPreventLazyLoading = true; to my Car model class. the same results as above are still happening. the error is not thrown in the show method of the controller

so I did some more digging into this..

I created a multi-level relationship to test the N + 1 issue. starting with a single object as I have in the show method above

so I created

1. new route Route::get('/configurator/{car}', [ConfiguratorController::class, 'index'])->name('configurator.index');

2. ConfiguratorCar model

class ConfiguratorCar extends Model
{
    /** @use HasFactory<\Database\Factories\ConfiguratorCarFactory> */
    use HasFactory;

    public function carParts()
    {
        return $this->hasMany(ConfiguratorCarPart::class);
    }
}

3. ConfiguratorCarPart module

class ConfiguratorCarPart extends Model
{
    /** @use HasFactory<\Database\Factories\ConfiguratorCarPartFactory> */
    use HasFactory;

    public function car(): BelongsTo
    {
        return $this->belongsTo(ConfiguratorCar::class);
    }

    public function partValues()
    {
        return $this->hasMany(ConfiguratorCarPartValue::class);
    }
}

4. ConfiguratorCarPartValue model

class ConfiguratorCarPartValue extends Model
{
    /** @use HasFactory<\Database\Factories\ConfiguratorCarPartValueFactory> */
    use HasFactory;

    public function carPart(): BelongsTo
    {
        return $this->belongsTo(ConfiguratorCarPart::class);
    }

so a car has multiple parts and each part has multiple values

5. AppServiceProvide class

public function boot(): void
    {
        Model::preventLazyLoading(!$this->app->isProduction());
    }

6. The controller

public function show(ConfiguratorCar $car)
    {
        $partOptions = [];
        $carParts = $car->carParts;  // this does not trigger the exception
        foreach ($carParts as $carPart) {
            $partOptions[] = $carPart->partValues; // this trigger the exception
        }

        return view('configurator.show', compact('car'));
    }

so accessing the $car->carParts does not throw the exception (I guess because it is never N + 1 operation. it will all the time generate one query)

select * from configurator_car_part where configurator_car_part.car_id = 2 and configurator_car_part.car_id is not null

bu accessing $carPart->partValues in a loop of carParts will throw the exception because it is obviously an N + 1 issue

If I set the preventLazyLoading to false and take a look at the laravel debugger queries, we can see the N + 1 the is generated by $carPart->partValues; inside the loop

So I think that this is not some error or missing/not caught case. rather than a desired result.
when accessing the relationship with lazy loading and it does not cause N + 1 issue, it does not throw the exception.

[ghost]

Try setting this in your model to true
protected static $modelsShouldPreventLazyLoading = true;

If it works then it is an uncovered case/not implemented feature.

[abdel-aouby]

@bulletproof-coding I tried that, and did some more testing to proof the case. please take a look at my edit of the original post.

[dlisek-wt]

Hi, is this the same problem here?
I also want to prevent all(!) lazy loading.

lazy loading exception:

$users = User::all();
foreach ($users as $user) {
    dd($user->roles);
}

no exception:

$user = User::find(11);
dd($user->roles);

this is an unexpected behavior and should also throw the lazy loading exeption.
Otherwise the function preventLazyLoading should be renamed to preventNplus1loading.