HasMany-Relation with a static field (model_type)

[Cluster2a]

Hey there!

I’ve set up a Model and a GlobalFields table. The GlobalFields table includes a model_type field, which contains the morph class name—but without the actual model id, since these fields are intended to be shared across different model types.

What I’d like to do is load all related GlobalFields records by calling $model->globalFields, with support for eager loading as well.

Is there a way to achieve this using a relation, maybe with a workaround?

I’ve tried something along these lines, but it didn’t work:

/**
 * @return HasMany<GlobalField>
 */
public function globalFields(): HasMany
{
    $hasMany = new HasMany(GlobalField::query(), $this, null, null);

    return $hasMany->where('model_type', $this->getMorphClass());
}

Best - Alex

[soheylfarzane]

Hi Alex 👋 interesting use case!

You're basically trying to emulate a partial morph relation, where only model_type exists, and there's no model_id to bind individual records.

---

✅ What you're trying to do is technically not a HasMany

(because it needs foreign_key and local_key), but you can mimic it with a custom query() accessor or hasMany + manual conditions.

Here’s a clean solution:

---

🛠 Option 1: Use custom accessor (no eager loading)

public function getGlobalFieldsAttribute()
{
    return GlobalField::query()
        ->where('model_type', $this->getMorphClass())
        ->get();
}

Usage:

$model->global_fields;

⚠️ This doesn't support eager loading.

---

🛠 Option 2: Use custom query method and eager load manually

In your model:

public function globalFieldsCustom()
{
    return GlobalField::query()
        ->where('model_type', $this->getMorphClass());
}

Then eager load manually:

$models = YourModel::all();

$models->each(function ($model) {
    $model->setRelation('globalFields', $model->globalFieldsCustom()->get());
});

Now you can use:

$model->globalFields;

---

🧠 Bonus idea: use a trait for reuse

trait HasGlobalFields
{
    public function globalFields()
    {
        return GlobalField::query()
            ->where('model_type', $this->getMorphClass());
    }
}

Then in your model:

use HasGlobalFields;

---

Let me know if you want a custom HasMany relation class for this.
It’s totally possible, but for most use cases, this should be enough 🙌

[shaedrich]

Don't tell me, this isn't AI-generated. If @Cluster2a wanted an AI-generated solution, they could and would have done so themself.

🛠 Option 1: Use custom accessor (no eager loading)

This is wrong on so many levels. Whatever AI you used, it has not a sufficient understanding of Laravel. Accessors are not to build queries but to add dynamic properties to models. If you want to build queries, use scopes.

🛠 Option 2: Use custom query method and eager load manually

While this technically works, this is a lot of manual work, which should be avoided if possible

• Fetching the collection, then looping over it
• Making an extra query for each model in the collection

So, please don't.

This is while vibe coding doesn't return good code if the vibe coder isn't qualified to check the results …

Instead of copy-pasting code you don't understand, take your time and actually learn Laravel. This isn't helping anyone.

[soheylfarzane]

Hey,
I just wanted to sincerely apologize for my earlier response.
You’re right — I got caught up in the excitement of wanting to contribute and didn’t pay enough attention to the quality or correctness of the code I shared. That was a mistake, and I’m honestly a bit embarrassed about it.

I’ve been working with Laravel for years and genuinely love the framework, so it’s even more disappointing to me that I let something so basic slip through like that.
Thanks for pointing it out — I truly appreciate the honesty and the feedback.

This won’t happen again. I’ll make sure to be more thoughtful and responsible moving forward.
Again, I’m really sorry for the oversight. I’ll do my best to make up for it.

[soheylfarzane]

I used ai to answer the thread and translate my comment to avoid grammar mistakes.so thank you for your honesty response

[shaedrich]

Hey,
sorry for my harsh tone earlier :)

[Cluster2a]

I came to another solution, which might not be perfect in general but works for our use cases:

<?php

declare(strict_types=1);

namespace App\Freispace\CustomFields\Traits;

use App\Freispace\CustomFields\Models\GlobalField;
use App\Freispace\CustomFields\Models\GlobalFieldResponse;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Model;
use InvalidArgumentException;

/**
 * Trait LoadsGlobalFields
 *
 * This trait provides functionality to load global fields for models.
 * It supports loading fields for individual models and collections.
 *
 * @property-read Collection $global_fields
 */
trait LoadsGlobalFields
{
     /**
     * Load global fields for the given targets.
     *
     * @param  array  $targets
     *
     * @throws InvalidArgumentException
     *
     * @return void
     */
    public function loadGlobalFields(array $targets): void
    {
        if (empty($targets)) {
            return;
        }

        $modelsByType = [];

        foreach ($targets as $target) {
            if (!is_string($target)) {
                throw new InvalidArgumentException('Target must be a string');
            }

            if ($target === 'self') {
                $modelsByType[static::class][] = $this;
            } else {
                $relations = explode('.', $target);
                $this->traverseAndCollect($this, $relations, $modelsByType);
            }
        }

        if (empty($modelsByType)) {
            return;
        }

        $allFields = GlobalField::whereIn('model_type', array_keys($modelsByType))
            ->orderBy('order')
            ->get()
            ->groupBy('model_type');

        $allIds = collect($modelsByType)->flatten()->pluck('id');
        $allResponses = GlobalFieldResponse::whereIn('model_type', array_keys($modelsByType))
            ->whereIn('model_id', $allIds)
            ->with('field')
            ->get()
            ->groupBy(fn ($r) => $r->model_type . ':' . $r->model_id);

        foreach ($modelsByType as $modelType => $models) {
            $fields = $allFields->get($modelType, collect());

            foreach ($models as $model) {
                $key = $modelType . ':' . $model->id;
                $responses = $allResponses->get($key, collect());

                $fieldsWithResponses = $fields->map(function ($field) use ($responses) {
                    // Clone the field to ensure each model gets its own independent copy
                    $field = clone $field;

                    $fieldResponse = $responses->firstWhere('field_id', $field->id);

                    if ($fieldResponse) {
                        $fieldResponse->setRelation('field', $field);
                        $field->setRelation('responses', collect([$fieldResponse]));
                        $field->value = $fieldResponse->value;
                    } else {
                        $field->setRelation('responses', collect());
                        $field->value = null;
                    }

                    return $field;
                });

                $model->setRelation('global_fields', $fieldsWithResponses);
            }
        }
    }

    /**
     * Traverse the model and its relations to collect all models of a specific type.
     *
     * @param Model $model
     * @param array<string> $relations
     * @param array<string, array<Model>> $modelsByType
     *
     * @throws InvalidArgumentException
     *
     * @return void
     */
    protected function traverseAndCollect(Model $model, array $relations, array &$modelsByType): void
    {
        if (empty($relations)) {
            return;
        }

        $relation = array_shift($relations);

        if (!method_exists($model, $relation)) {
            throw new InvalidArgumentException("Relation '{$relation}' does not exist on model " . $model::class);
        }

        $related = $model->$relation;

        if ($related instanceof Collection) {
            foreach ($related as $item) {
                if (!$item instanceof Model) {
                    continue;
                }
                $modelsByType[$item::class][] = $item;
                $this->traverseAndCollect($item, $relations, $modelsByType);
            }
        } elseif ($related instanceof Model) {
            $modelsByType[$related::class][] = $related;
            $this->traverseAndCollect($related, $relations, $modelsByType);
        }
    }
}

Now I can laod all the global fields like this:

$client->loadGlobalFields([
    'self',
    'addresses',
    'contacts',
]);