[11.x] Add pending attributes

src/Illuminate/Database/Eloquent/Builder.php

@@ -52,6 +52,13 @@ class Builder implements BuilderContract
      */
     protected $model;
 
+    /**
+     * The attributes that should be added to new models created by this builder.
+     *
+     * @var array
+     */
+    public $pendingAttributes = [];
+
     /**
      * The relationships that should be eager loaded.
      *
@@ -1601,6 +1608,8 @@ public function withOnly($relations)
      */
     public function newModelInstance($attributes = [])
     {
+        $attributes = array_merge($this->pendingAttributes, $attributes);
+
         return $this->model->newInstance($attributes)->setConnection(
             $this->query->getConnection()->getName()
         );
@@ -1765,6 +1774,30 @@ protected function addNestedWiths($name, $results)
         return $results;
     }
 
+    /**
+     * Specify attributes that should be added to any new models created by this builder.
+     *
+     * The given key / value pairs will also be added as where conditions to the query.
+     *
+     * @param  \Illuminate\Contracts\Database\Query\Expression|array|string  $attributes
+     * @param  mixed  $value
+     * @return $this
+     */
+    public function withAttributes(Expression|array|string $attributes, $value = null)
+    {
+        if (! is_array($attributes)) {
+            $attributes = [$attributes => $value];
+        }
+
+        foreach ($attributes as $column => $value) {
+            $this->where($this->qualifyColumn($column), $value);
+        }
+
+        $this->pendingAttributes = array_merge($this->pendingAttributes, $attributes);
+
+        return $this;
+    }
+
     /**
      * Apply query-time casts to the model instance.
      *

src/Illuminate/Database/Eloquent/Relations/BelongsToMany.php

@@ -1350,6 +1350,8 @@ public function saveManyQuietly($models, array $pivotAttributes = [])
      */
     public function create(array $attributes = [], array $joining = [], $touch = true)
     {
+        $attributes = array_merge($this->getQuery()->pendingAttributes, $attributes);
+
         $instance = $this->related->newInstance($attributes);
 
         // Once we save the related model, we need to attach it to the base model via

src/Illuminate/Database/Eloquent/Relations/HasOneOrMany.php

@@ -447,6 +447,12 @@ protected function setForeignAttributesForCreate(Model $model)
     {
         $model->setAttribute($this->getForeignKeyName(), $this->getParentKey());
 
+        foreach ($this->getQuery()->pendingAttributes as $key => $value) {
+            if (! $model->hasAttribute($key)) {
+                $model->setAttribute($key, $value);
+            }
+        }
+
         $this->applyInverseRelationToModel($model);
     }
 

src/Illuminate/Database/Eloquent/Relations/MorphOneOrMany.php

@@ -96,6 +96,12 @@ protected function setForeignAttributesForCreate(Model $model)
 
         $model->{$this->getMorphType()} = $this->morphClass;
 
+        foreach ($this->getQuery()->pendingAttributes as $key => $value) {
+            if (! $model->hasAttribute($key)) {
+                $model->setAttribute($key, $value);
+            }
+        }
+
         $this->applyInverseRelationToModel($model);
     }
 

tests/Database/DatabaseEloquentBelongsToManyWithAttributesTest.php

@@ -0,0 +1,263 @@
+<?php
+
+namespace Illuminate\Tests\Database;
+
+use Illuminate\Database\Capsule\Manager as DB;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsToMany;
+use Illuminate\Database\Eloquent\Relations\MorphToMany;
+use PHPUnit\Framework\TestCase;
+
+class DatabaseEloquentBelongsToManyWithAttributesTest extends TestCase
+{
+    protected function setUp(): void
+    {
+        $db = new DB;
+
+        $db->addConnection([
+            'driver' => 'sqlite',
+            'database' => ':memory:',
+        ]);
+        $db->bootEloquent();
+        $db->setAsGlobal();
+        $this->createSchema();
+    }
+
+    public function testCreatesWithAttributesAndPivotValues(): void
+    {
+        $post = ManyToManyWithAttributesPost::create();
+        $tag = $post->metaTags()->create(['name' => 'long article']);
+
+        $this->assertSame('long article', $tag->name);
+        $this->assertTrue($tag->visible);
+
+        $pivot = DB::table('with_attributes_pivot')->first();
+        $this->assertSame('meta', $pivot->type);
+        $this->assertSame($post->id, $pivot->post_id);
+        $this->assertSame($tag->id, $pivot->tag_id);
+    }
+
+    public function testQueriesWithAttributesAndPivotValues(): void
+    {
+        $post = new ManyToManyWithAttributesPost(['id' => 2]);
+        $wheres = $post->metaTags()->toBase()->wheres;
+
+        $this->assertContains([
+            'type' => 'Basic',
+            'column' => 'with_attributes_tags.visible',
+            'operator' => '=',
+            'value' => true,
+            'boolean' => 'and',
+        ], $wheres);
+
+        $this->assertContains([
+            'type' => 'Basic',
+            'column' => 'with_attributes_pivot.type',
+            'operator' => '=',
+            'value' => 'meta',
+            'boolean' => 'and',
+        ], $wheres);
+    }
+
+    public function testMorphToManyWithAttributes(): void
+    {
+        $post = new ManyToManyWithAttributesPost(['id' => 2]);
+        $wheres = $post->morphedTags()->toBase()->wheres;
+
+        $this->assertContains([
+            'type' => 'Basic',
+            'column' => 'with_attributes_tags.visible',
+            'operator' => '=',
+            'value' => true,
+            'boolean' => 'and',
+        ], $wheres);
+
+        $this->assertContains([
+            'type' => 'Basic',
+            'column' => 'with_attributes_taggables.type',
+            'operator' => '=',
+            'value' => 'meta',
+            'boolean' => 'and',
+        ], $wheres);
+
+        $this->assertContains([
+            'type' => 'Basic',
+            'column' => 'with_attributes_taggables.taggable_type',
+            'operator' => '=',
+            'value' => ManyToManyWithAttributesPost::class,
+            'boolean' => 'and',
+        ], $wheres);
+
+        $this->assertContains([
+            'type' => 'Basic',
+            'column' => 'with_attributes_taggables.taggable_id',
+            'operator' => '=',
+            'value' => 2,
+            'boolean' => 'and',
+        ], $wheres);
+
+        $tag = $post->morphedTags()->create(['name' => 'new tag']);
+
+        $this->assertTrue($tag->visible);
+        $this->assertSame('new tag', $tag->name);
+        $this->assertSame($tag->id, $post->morphedTags()->first()->id);
+    }
+
+    public function testMorphedByManyWithAttributes(): void
+    {
+        $tag = new ManyToManyWithAttributesTag(['id' => 4]);
+        $wheres = $tag->morphedPosts()->toBase()->wheres;
+
+        $this->assertContains([
+            'type' => 'Basic',
+            'column' => 'with_attributes_posts.title',
+            'operator' => '=',
+            'value' => 'Title!',
+            'boolean' => 'and',
+        ], $wheres);
+
+        $this->assertContains([
+            'type' => 'Basic',
+            'column' => 'with_attributes_taggables.type',
+            'operator' => '=',
+            'value' => 'meta',
+            'boolean' => 'and',
+        ], $wheres);
+
+        $this->assertContains([
+            'type' => 'Basic',
+            'column' => 'with_attributes_taggables.taggable_type',
+            'operator' => '=',
+            'value' => ManyToManyWithAttributesPost::class,
+            'boolean' => 'and',
+        ], $wheres);
+
+        $this->assertContains([
+            'type' => 'Basic',
+            'column' => 'with_attributes_taggables.tag_id',
+            'operator' => '=',
+            'value' => 4,
+            'boolean' => 'and',
+        ], $wheres);
+
+        $post = $tag->morphedPosts()->create();
+        $this->assertSame('Title!', $post->title);
+        $this->assertSame($post->id, $tag->morphedPosts()->first()->id);
+    }
+
+    protected function createSchema()
+    {
+        $this->schema()->create('with_attributes_posts', function ($table) {
+            $table->increments('id');
+            $table->string('title')->nullable();
+            $table->timestamps();
+        });
+
+        $this->schema()->create('with_attributes_tags', function ($table) {
+            $table->increments('id');
+            $table->string('name');
+            $table->boolean('visible')->nullable();
+            $table->timestamps();
+        });
+
+        $this->schema()->create('with_attributes_pivot', function ($table) {
+            $table->integer('post_id');
+            $table->integer('tag_id');
+            $table->string('type');
+        });
+
+        $this->schema()->create('with_attributes_taggables', function ($table) {
+            $table->integer('tag_id');
+            $table->integer('taggable_id');
+            $table->string('taggable_type');
+            $table->string('type');
+        });
+    }
+
+    /**
+     * Tear down the database schema.
+     *
+     * @return void
+     */
+    protected function tearDown(): void
+    {
+        $this->schema()->drop('with_attributes_posts');
+        $this->schema()->drop('with_attributes_tags');
+        $this->schema()->drop('with_attributes_pivot');
+    }
+
+    /**
+     * Get a database connection instance.
+     *
+     * @return \Illuminate\Database\Connection
+     */
+    protected function connection($connection = 'default')
+    {
+        return Model::getConnectionResolver()->connection($connection);
+    }
+
+    /**
+     * Get a schema builder instance.
+     *
+     * @return \Illuminate\Database\Schema\Builder
+     */
+    protected function schema($connection = 'default')
+    {
+        return $this->connection($connection)->getSchemaBuilder();
+    }
+}
+
+class ManyToManyWithAttributesPost extends Model
+{
+    protected $guarded = [];
+    protected $table = 'with_attributes_posts';
+
+    public function tags(): BelongsToMany
+    {
+        return $this->belongsToMany(
+            ManyToManyWithAttributesTag::class,
+            'with_attributes_pivot',
+            'tag_id',
+            'post_id',
+        );
+    }
+
+    public function metaTags(): BelongsToMany
+    {
+        return $this->tags()
+            ->withAttributes('visible', true)
+            ->withPivotValue('type', 'meta');
+    }
+
+    public function morphedTags(): MorphToMany
+    {
+        return $this
+            ->morphToMany(
+                ManyToManyWithAttributesTag::class,
+                'taggable',
+                'with_attributes_taggables',
+                relatedPivotKey: 'tag_id'
+            )
+            ->withAttributes('visible', true)
+            ->withPivotValue('type', 'meta');
+    }
+}
+
+class ManyToManyWithAttributesTag extends Model
+{
+    protected $guarded = [];
+    protected $table = 'with_attributes_tags';
+
+    public function morphedPosts(): MorphToMany
+    {
+        return $this
+            ->morphedByMany(
+                ManyToManyWithAttributesPost::class,
+                'taggable',
+                'with_attributes_taggables',
+                'tag_id',
+            )
+            ->withAttributes('title', 'Title!')
+            ->withPivotValue('type', 'meta');
+    }
+}