__call method not being executed when Service container resolves and try to run a non existent method.

[silver-co]

I'm not sure if this is a bug or something for take into account. I'm actually trying to create a hook behaviour for classes and methods using the __call magic method. When I declare a __call magic method on a class that is automatically injected by the service container, and then try to execute a non existent method, it throws a ReflectionException "Method (*) does not exist". If I declare a method protected/private inside that class, and then I try to execute that method outside of the class (e.g. injected by the service container automatically in a controller) It executes the __call magic method (as expected).

The PHP documentation says this about __call magic method:

__call() is triggered when invoking inaccessible methods in an object context.

As you may know, __call is executed also when a method doesn't exist (not only if the method is not accessible).

am I missing something? do you think it's a bug or not? Please let me know your thoughts, because I believe it is a bug taking into account the current way PHP handle __call magic method.

[mikeydevelops]

Magic methods are functionality of PHP itself not Laravel. So it doesn't matter what you try to resolve with the SOC if it is able to create it, it will give it to you. That means you implementation of the magic method is not set up properly.

Made you a little example of correctly set up class with magic method __call;

App\Services\ChuckNorrisJoke Source

<?php
namespace App\Services;

use GuzzleHttp\Client;
use Illuminate\Support\Str;
use Throwable;

/**
 * @method array categories() Retrieve a list of available categories.
 *
 * @see https://api.chucknorris.io
 */
class ChuckNorrisJoke
{
    /**
     * The http client.
     *
     * @var \GuzzleHttp\Client
     */
    protected Client $http;

    /**
     * List of endpoints that gave errors.
     *
     * @var array
     */
    protected array $failedEndpoints = [];

    /**
     * Create new instance of Chuck Norris Joke instance.
     *
     * @return void
     */
    public function __construct()
    {
        $this->http = new Client([
            'base_uri' => 'https://api.chucknorris.io',
            'headers' => [
                'Accept' => 'application/json',
            ],
        ]);
    }

    /**
     * Retrieve a random chuck norris joke from a given category.
     *
     * @param  string|null  $category
     * @return \stdObject|null
     */
    public function random(string $category = null)
    {
        return $this->request('random', array_filter(compact('category')));
    }

    /**
     * Search the Chuck Norris Jokes.
     *
     * @param  string  $query
     * @return \stdObject|null
     */
    public function search(string $query)
    {
        return $this->request('search', compact('query'));
    }

    /**
     * Make a request to the Chuck Norris API.
     *
     * @param  string  $endpoint
     * @param  array  $query
     * @return \stdObject|null
     */
    public function request(string $endpoint, array $query = [])
    {
        if (in_array ($endpoint, $this->failedEndpoints)) {
            return null;
        }

        try {
            $response = $this->http->get("/jokes/$endpoint", compact('query'));

            if (! Str::contains($response->getHeader('Content-Type')[0], 'application/json')) {
                return $response->getBody()->getContents();
            }

            return json_decode($response->getBody()->getContents());
        } catch (Throwable $e) {
            if (! method_exists($this, $endpoint)) {
                $this->failedEndpoints[] = $endpoint;
            }
        }

        return null;
    }

    /**
     * Magic method for calling endpoints based on requested methods.
     *
     * @param  string  $method
     * @param  array  $parameters
     * @return \stdObject|null
     */
    public function __call(string $method, array $parameters)
    {
        $endpoint = Str::slug($method);

        return $this->request($endpoint);
    }

}

and when you want to use it:

use Illuminate\Support\Arr;
use App\Services\ChuckNorrisJoke;
use Illuminate\Support\Arr;

$jokes = app(ChuckNorrisJoke::class);

$randomCategory = Arr::random($jokes->categories());
$joke = $jokes->random($randomCategory);

$missingEndpoint = $jokes->missing(); // Expecting null, because the we will call the API endpoint /jokes/missing and it will give us 404.

dump(compact('randomCategory', 'joke', 'missingEndpoint'));

The magic example here is $jokes->categories(), it is not defined in the service, but it is giving us an array, that is because its result is the response from the API.

And the response is:

If you want you can share where you define the magic method in your class to debug it :)

[silver-co]

Thank you for your reply. Well. I think I can give more context considering that I have more information about what is going on. I thought that it was an issue regarding the service provider (could be but we can discuss it later).

In my case I was trying to achieve a functionality to intercept the execution of a method (like a hook before some method) using __call and a provided structure, to create a cache register of the returned value of that method. For example, if I have a method on some class named doSomething() that will be executed by the service container (I don't know when), the idea is to rename that method using a defined structure (like cacheableDoSomething()) and when the service container call that method doSomething(), it will first execute __call, then build the cache for that execution, proxying the execution to cacheableDoSomething(). My idea is to have a defined way on how to manage the cache of certain parts of my application, just importing and using a trait.

I tried that with the method rules of a form request (because there are some extensive processing to dinamically generate the rules) and It didn't work using the method described before. But, if create the method rules as private (without any modification to the name or logic to check a certain format), it works as expected.

I checked some of the code that the service container use to execute some defined method on certain classes and it uses reflection to check the presence or absence of a method (that is why is failing).

HasCacheability trait source

<?php

namespace App\Services;

use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Config;

trait HasCacheability
{
    public function __call($method, $arguments)
    {
        $formatted_method = ucfirst($method);
        $cacheable_method = $this->getCacheablePrefix() . $formatted_method;

        if (method_exists($this, $cacheable_method)) {
            $cache_id = $this->getCacheId($method, $arguments);
            $tags = $this->getCacheTags();
            $expires_at = $this->getCacheExpiration();

            // create the cache register.
            return Cache::tags($tags)->remember(
                $cache_id,
                $expires_at,
                call_user_func([
                    $this,
                    'buildCacheContent',
                    $cacheable_method,
                    $arguments,
                ])
            );
        }

        parent::__call($method, $arguments);
    }

    private function buildCacheContent(string $cacheable_method, array $arguments)
    {
        // call the cacheable method instead.
        $cacheable_content = $this->$cacheable_method(...$arguments);
        return $cacheable_content;
    }

    protected function getCacheId(string $method, array $arguments): string
    {
        $serialized_arguments = serialize($arguments);

        return static::class . "-$method-$serialized_arguments";
    }

    protected function getCacheExpiration(): int
    {
        return Config::get('cache.defaults.expiration', 0);
    }

    protected function getCacheablePrefix(): string
    {
        return 'cacheable';
    }

    abstract protected function getCacheTags(): array;
}

I can guarantee the trait is used in the form request and the method rules is declared as cacheableRules in the form request and the execution is throwing this error.