Is there a way to list all relationships of a model?

$user = User::find(1);

$user->posts()->orderBy("id","desc")->get(); // it will order it by id and get new collection of all items for this user

@pisio FAR from the original question.

No,@rsferreira11, there are no way as of now.

I'm not getting the question. Are you trying to get all the relationships of a specific model, all relationships of all models, or something else?

@Francismori7, I've thought that there were a easy way to do it =/

@thomaskim I wanted a generic way to show all parents and children model from a model

@mikemand thanks, gonna try to think about something

@mikemand's solution cannot be used as the ReflectionClass cannot see what's inside the method - it will not detect "hasOne" or similar callbacks, you're better of using a regular expression on the file's content and filter it all out (complex IMHO).

You would have to list all the methods yourself in another method, not so bad if you ask me, because you always know what's in the code, nothing is "assumed", it's all there.

    public function getRelationships() {
        return [
            'belongsTo' => [
                'User',
            ],
            'hasMany' => [
                'Post',
            ],
        ];
    }

https://laracasts.com/discuss/channels/eloquent/get-all-model-relationships

I'm a little late, but if you're using PHP 7, and leveraging return types, you could do this:

$user = \App\User::class;
    $reflector = new ReflectionClass($user);
    $relations = [];
    foreach ($reflector->getMethods() as $reflectionMethod) {
        $returnType = $reflectionMethod->getReturnType();
        if ($returnType) {
            if (in_array(class_basename($returnType->getName()), ['HasOne', 'HasMany', 'BelongsTo', 'BelongsToMany', 'MorphToMany', 'MorphTo'])) {
                $relations[] = $reflectionMethod;
            }
        }
    }

    dd($relations);

@sonoma Why are you responding to posts that have been inactive for years...

@MTHOMAS - My web search throw up this thread as the first result, I figured I'd provide a solution. Got a problem with that?

@derp - I came to the same conclusion. Including a return type on relationships seems to be the only conceivable way of doing this.

I've seen other solutions which involve actually invoking every method on a class and checking the return type - which is a truly terrible idea!

Thanks Derp for saving me time :)

Thanks @derp, thats actually quite a smart solution. I was using doc annotations for this so far, but realized this is a much nicer approach.

Here is my method. It depends on the models properly including an Illuminate return type for the relationship method:

protected function hasRelationships($model): array
    {
        $reflectionClass = new ReflectionClass($model);
        $reflectionMethods = $reflectionClass->getMethods(ReflectionMethod::IS_PUBLIC);
        $relationshipMethods = [];

        foreach ($reflectionMethods as $reflectionMethod) {
            $methodName = $reflectionMethod->getName();
            $methodReturnType = $reflectionMethod->getReturnType();

            if ($methodReturnType !== null) {
                $methodReturnTypeString = $methodReturnType->getName();
                
                $shortname = explode("\", $methodReturnTypeString);
                $relationshipClass=strtolower(end($shortname));
                $relationshipHelpers = [
                    'belongsto', 'hasone', 'hasmany', 'belongstomany',
                    'hasmanythrough', 'morphone', 'morphone', 'morphmany',
                    'morphto', 'morphtomany', 'through', 'embedsone',
                    'embedsmany', 'embedsmany', 'embedsmany'
                ];
    
                    if(in_array($relationshipClass, $relationshipHelpers))
                        $relationshipMethods[] = $methodName;

                 
            }
        }

        return $relationshipMethods;
    }