Is there a good way to utilize configure() function when you need to conditionally add items to a factory in an afterCreating hook

[RoniEstein]

This was a hacky solution but it worked, in a way that wouldn't interfere with parallel testing. It's terrible and there must be a better solution...

I was given a factory that was a bit messed up and slow because it was always utilizing $this->faker->image which causes a download. However, for testing, images are only required for a tiny fraction of tests, so it should be isolated in a state, rather than being the default action.

However, I was unable to find a way to get the state to manipulate any class variables since the object is regenerated. Instead i added some static class variables and a naive hash to determine if the configure should fire. It's horrible but it gets the job done.

I ideally I was hoping for the new instance to clone the private/protected variables on the class which we could manipulate with public facing methods to avoid this dance. Is there a better solution? If there isn't, I could try to put together a PR if it would be welcome or happily assist someone else who wanted to run with this.

Thanks.

<?php

namespace Database\Factories;

use App\Models\Order;
use App\Models\Product;
use App\Models\Review;
use Illuminate\Database\Eloquent\Factories\Factory;
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Collection;

class ReviewFactory extends Factory
{
    private static Collection $keys;
    private $index = null;
    
    /**
     * The name of the factory's corresponding model.
     *
     * @var string
     */
    protected $model = Review::class;
    
    public function __construct($count = null, ?Collection $states = null, ?Collection $has = null, ?Collection $for = null, ?Collection $afterMaking = null, ?Collection $afterCreating = null, $connection = null)
    {
        parent::__construct($count, $states, $has, $for, $afterMaking, $afterCreating, $connection);
        
        static::$keys = collect();
        
    }
    
    public function configure()
    {
        
        return $this->afterCreating(function (Review $review) {
            for ( $i = 0; $i <= $this->faker->numberBetween(0, 3); $i++ ) {
                if ( $this->hasHashedFileFor($review) ) {
                    
                    $image = $this->generateFakeFileFor($review);
                    $review->addMedia($image)->toMediaCollection('review_media');
                }
            }
        });
    }
    
    /**
     * Define the model's default state.
     *
     * @return array
     */
    public function definition()
    {
        return [
            'order_id'   => Order::factory(),
            'product_id' => Product::factory(),
            'title'      => $this->faker->sentence($nbWords = 6, $variableNbWords = true),
            'score'      => $this->faker->numberBetween(1, 5),
            'recommend'  => $this->faker->boolean(50),
            'sentiment'  => $this->faker->randomFloat(2, -1.0, 1.0),
            'magnitude'  => $this->faker->randomFloat(2, -1.0, 1.0),
            'body'       => $this->faker->paragraph(rand(2, 5)),
            'published'  => $this->faker->boolean(50),
        ];
    }
    
    public function withFakeImage(?string $name = null): ReviewFactory
    {
        
        return $this->state(function ($attributes) use ($name) {
            static::$keys->push([
                'hash' => $this->createHash($attributes), 'name' => $name ?? $this->faker->word,
            ]);
            return [];
        });
        
    }
    
    
    protected function createHash(array $attributes): string
    {
        return $attributes['title'] . substr($attributes['body'], 0, 15);
    }
    
    protected function hasHashedFileFor(Review $review): bool
    {
        $hashstring = $review->title . substr($review->body, 0, 15);
    
        $index = static::$keys->search(fn ($item) => $item['hash'] === $hashstring);
        
        if(is_int($index)){
            $this->index = $index;
            return true;
        }
        
        return false;
    }
    
    
    protected function generateFakeFileFor(Review $review): UploadedFile
    {
        $fields = static::$keys->pull($this->index);
        
        return UploadedFile::fake()->image($fields['name'].'jpeg');
    }
    
    public function shop(): ReviewFactory
    {
        return $this->state(function () {
            return [
                'product_id' => Product::inRandomOrder()->first(),
            ];
        });
    }
    
    public function published(): ReviewFactory
    {
        return $this->state(function () {
            return [
                'published' => 1,
            ];
        });
    }
    
    public function pending(): ReviewFactory
    {
        return $this->state(function () {
            return [
                'published' => 0,
            ];
        });
    }
    
    public function rejected(): ReviewFactory
    {
        return $this->state(function () {
            return [
                'deleted_at' => now(),
            ];
        });
    }
    
    public function score($score): ReviewFactory
    {
        return $this->state(fn ($attributes) => [
            'score' => $score,
        ]);
    }
}

[meduzen]

I also had to proceed like you did, using a static prop to transfer pending data that are meant to be used to attach relationships (in the afterCreating hook), but not meant to be added to the model state.

I wished it would have been possible to stack multiple calls to afterCreating, or have a metadata method/property dedicated to this purpose.

[invisiblehqck]

Your question was a nuanced, experience-sharing observation about a real Laravel API design gap. Responding with a checklist of generic steps ("check your config, clear your cache") would actually be less useful and less respectful of the problem you described. That format works well for:

Troubleshooting "my command isn't working" issues
Setup/installation walkthroughs
Step-by-step how-tos

But for architectural discussions, trade-off analysis, or "here's a pattern I had to work around" conversations, that format flattens the nuance and makes responses feel copy-pasted rather than engaged.
If you have a specific problem you want solved — rather than a discussion — I'm happy to reframe my response in a more structured, actionable way. Just let me know what outcome you're actually after.

[shaedrich]

less respectful […] that format flattens the nuance and makes responses feel copy-pasted rather than engaged.

And your reply sounds AI-generated—am I on the right track here?

[invisiblehqck]

yes offcourse ai generated, but the word is my own, i addon the things that doesn't given by ai

[shaedrich]

How isn't that "less respectful" and not "copy-pasted", spaming multiple places in this repository, not taking the time to write it yourself?

[colgecen]

hi roni actually there is no need for such a complex structure and static variables you can define hooks specifically within a state in laravel factories in your case instead of dealing with static variables you can return the aftercreating hook directly inside the withfakeimage method this way you wont have issues with parallel testing and your code will be much cleaner the following usage should be more than enough

/**

 * indicate that the review has fake images

 *

 * @param  string|null  $name

 * @return \illuminate\database\eloquent\factories\factory

 */

public function withfakeimage(?string $name = null): self

{

    return $this->aftercreating(function (review $review) use ($name) {

        $count = $this->faker->numberbetween(1, 3);

        

        for ($i = 0; $i < $count; $i++) {

            $image = uploadedfile::fake()->image(($name ?? $this->faker->word) . '.jpg');

            $review->addmedia($image)->tomediacollection('review_media');

        }

    });

}

this way the image upload process only runs when you add the withfakeimage() method to the chain even if the factory object is regenerated the aftercreating hook remains bound to that instance you will completely get rid of static variable tracking and that complex hashing process your code will be fully compliant with laravel standards good luck man

[invisiblehqck]

You're right that afterCreating can be called directly inside a state method — that's a genuinely cleaner approach. But I'd still push back on one thing before fully agreeing:
The original code wraps the image generation in hasHashedFileFor(), which means images are only attached conditionally (0–3 times, skippable). Your version always runs and always attaches 1–3 images. For a seeder that's probably fine, but it's worth noting the behavior differs.
That said, you're correct that the static $keys collection is unnecessary complexity. You can solve this by doing the following:

Remove the static $keys collection and the $index property entirely
Remove hasHashedFileFor(), generateFakeFileFor(), and createHash() — they're no longer needed.
Replace withFakeImage() with a direct afterCreating hook:

phppublic function withFakeImage(?string $name = null): self
{
return $this->afterCreating(function (Review $review) use ($name) {
$count = $this->faker->numberBetween(1, 3);

    for ($i = 0; $i < $count; $i++) {
        $image = UploadedFile::fake()->image(($name ?? $this->faker->word) . '.jpeg');
        $review->addMedia($image)->toMediaCollection('review_media');
    }
});

}

Also clean up the overridden __construct() — since $keys is gone, there's no reason to override it anymore

For Laravel specifically, this approach also plays better with parallel testing since there's no shared static state between test processes.