Php: Using Where Clause With Apiresource Route Parameter In Laravel: A Guide

I aim to provide a parameter for an apiResource route and constrain the allowed values using a where clause, but I encountered an issue with laravel throw .

Route::apiResource('/admin/{category}/attributes', 'AttributeController')
   ->where('category', 'industries|professions|studies|experiences|locations');

I got this error:

> BadMethodCallException Method
> Illuminate\Routing\PendingResourceRegistration::where does not exist.

Passing options as the third argument to the Route::apiResource method can be achieved with this syntax:

Route::apiResource('/admin/{category}/attributes', 'AttributeController', [
    'where' => ['category' => 'industries|professions|studies|experiences|locations']
]);

Essentially, I was on the lookout for an effective method to categorize these routes in Laravel 8. It is evident that the Route::apiResource() is replicated, implying that there should be an alternative approach to accomplish this.

Route::middleware('auth:api')->group(function () {
    Route::post('logout', [AuthController::class, 'logout'])->name('logout');
    Route::apiResource('stores', StoreController::class);
    Route::apiResource('books', BookController::class);
    Route::apiResource('companies', CompanyController::class);
    Route::apiResource('users', UserController::class);
    Route::apiResource('posts', PostController::class);
    Route::apiResource('projects', ProjectController::class);
    Route::apiResource('category_projects', CategoryProjectController::class);
    Route::apiResource('parent_category_projects', ParentCategoryProjectController::class);
    Route::apiResource('child_category_projects', ChildCategoryProjectController::class);
    Route::post('books/{book}/ratings', [RatingController::class, 'store']);
});

You can do it like this:

Route::apiResources([
    'stores' => StoreController::class,
    'books'=> BookController::class,
    'companies' => CompanyController::class,
    'users' => UserController::class,
    'posts' => PostController::class,
    'projects' => ProjectController::class,
    'category_projects'=> CategoryProjectController::class,
    'parent_category_projects' => ParentCategoryProjectController::class,
    'child_category_projects' => ChildCategoryProjectController::class
]);

This particular section of the documentation page provides readers with information to peruse.

As I develop an API using Laravel, I seek an easy lazy approach to enroll Api resources . My current practice involves defining the routes in the following manner:

Route::apiResource('categories', 'CategoryController')->only(['index', 'show']);

While reviewing some documentation, I came across apiResources , which offers a way for me to efficiently access multiple API resources with just one method call. I am particularly interested in checked Laravel's controller this functionality.

The aim is to utilize apiResources in conjunction with the only approach.

Route::apiResources(['categories' => 'CategoryController', 'products' => 'ProductController'])->only(['index', 'show']);

current result:

The function "only()" was called on a null member.

In summary, if you're not interested in reading the entire story, you can simply follow these steps.

Route::apiResources(['brands' => 'BrandController', 'categories' => 'CategoryController'], ['only' => ['index', 'show']]);

As I was composing the question, I remembered to verify the declaration for apiResources . Upon doing so, I discovered the following information:

   /**
     * Register an array of API resource controllers.
     *
     * @param  array  $resources
     * @param  array  $options
     * @return void
     */
    public function apiResources(array $resources, array $options = [])
    {
        foreach ($resources as $name => $controller) {
            $this->apiResource($name, $controller, $options);
        }
    }

By utilizing apiResource as the underlying framework, I am able to examine the available choices due to its passing options parameter nature.

/**
 * Route an API resource to a controller.
 *
 * @param  string  $name
 * @param  string  $controller
 * @param  array  $options
 * @return \Illuminate\Routing\PendingResourceRegistration
 */
public function apiResource($name, $controller, array $options = [])
{
    $only = ['index', 'show', 'store', 'update', 'destroy'];
    if (isset($options['except'])) {
        $only = array_diff($only, (array) $options['except']);
    }
    return $this->resource($name, $controller, array_merge([
        'only' => $only,
    ], $options));
}

As I work with API resources, I intend to incorporate additional logic. The resource I am currently dealing with is as follows:

return [
    'id' => $this->id,
    'name' => $this->name,
    'contacts' => $this->whenLoaded('contacts'),
    'phone' => $this->whenLoaded('contacts',
        $this->contacts->where('type', '=', 'phone')->first()
            ? $this->contacts->where('type', '=', 'phone')->first()->value
            : null),
];

The contacts connection involves a "one-to-many" relationship, which provides various options for contact (phone such as email, phone, and others.

I decided to include the 'phone' attribute, which will output phone contact .

The code functions properly but the issue is that the phone attribute is loaded consistently, even when the 'contacts' relation is not loaded. This negatively impacts performance since it leads to the N+1 problem when the phone attribute is not required.

Is my usage of the whenLoaded method flawed? Essentially, the logic states that if the contacts relation is loaded, obtain the phone attribute, otherwise refrain from doing so.

To avoid immediate execution of the second argument, you can pass a callable function to the method.

You have to structure it like this:

return [
    'id' => $this->id,
    'name' => $this->name,
    'contacts' => $this->whenLoaded('contacts'),
    'phone' => $this->whenLoaded('contacts', function() {
        return object_get($this->contacts->where('type', 'phone')->first(), 'value');
    })
];

In addition to object_get() , I have also implemented some simplification.