[10.x] Add Support for SaveQuietly and Upsert with UUID/ULID Primary Keys (#46161)

* Improve how UUID/ULID is set when perform an Insert

* Add UUID/ULID support when Upsert

* formatting

---------

Co-authored-by: Taylor Otwell <[email protected]>

Author: TFSThiagoBR98

src/Illuminate/Database/Eloquent/Builder.php

@@ -1034,7 +1034,7 @@ public function upsert(array $values, $uniqueBy, $update = null)
         }
 
         return $this->toBase()->upsert(
-            $this->addTimestampsToUpsertValues($values),
+            $this->addTimestampsToUpsertValues($this->addUniqueIdsToUpsertValues($values)),
             $uniqueBy,
             $this->addUpdatedAtToUpsertColumns($update)
         );
@@ -1124,6 +1124,29 @@ protected function addUpdatedAtColumn(array $values)
         return $values;
     }
 
+    /**
+     * Add unique IDs to the inserted values.
+     *
+     * @param  array  $values
+     * @return array
+     */
+    protected function addUniqueIdsToUpsertValues(array $values)
+    {
+        if (! $this->model->usesUniqueIds()) {
+            return $values;
+        }
+
+        foreach ($this->model->uniqueIds() as $uniqueIdAttribute) {
+            foreach ($values as &$row) {
+                if (! array_key_exists($uniqueIdAttribute, $row)) {
+                    $row = array_merge([$uniqueIdAttribute => $this->model->newUniqueId()], $row);
+                }
+            }
+        }
+
+        return $values;
+    }
+
     /**
      * Add timestamps to the inserted values.
      *

src/Illuminate/Database/Eloquent/Concerns/HasUlids.php

@@ -8,19 +8,23 @@
 trait HasUlids
 {
     /**
-     * Boot the trait.
+     * Initialize the trait.
      *
      * @return void
      */
-    public static function bootHasUlids()
+    public function initializeHasUlids()
     {
-        static::creating(function (self $model) {
-            foreach ($model->uniqueIds() as $column) {
-                if (empty($model->{$column})) {
-                    $model->{$column} = $model->newUniqueId();
-                }
-            }
-        });
+        $this->uniqueIds = true;
+    }
+
+    /**
+     * Get the columns that should receive a unique identifier.
+     *
+     * @return array
+     */
+    public function uniqueIds()
+    {
+        return [$this->getKeyName()];
     }
 
     /**
@@ -56,16 +60,6 @@ public function resolveRouteBindingQuery($query, $value, $field = null)
         return parent::resolveRouteBindingQuery($query, $value, $field);
     }
 
-    /**
-     * Get the columns that should receive a unique identifier.
-     *
-     * @return array
-     */
-    public function uniqueIds()
-    {
-        return [$this->getKeyName()];
-    }
-
     /**
      * Get the auto-incrementing key type.
      *

src/Illuminate/Database/Eloquent/Concerns/HasUniqueIds.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace Illuminate\Database\Eloquent\Concerns;
+
+trait HasUniqueIds
+{
+    /**
+     * Indicates if the model uses unique ids.
+     *
+     * @var bool
+     */
+    public $uniqueIds = false;
+
+    /**
+     * Determine if the model uses unique ids.
+     *
+     * @return bool
+     */
+    public function usesUniqueIds()
+    {
+        return $this->uniqueIds;
+    }
+
+    /**
+     * Generate a unique keys for model.
+     *
+     * @return void
+     */
+    public function setUniqueIds()
+    {
+        foreach ($this->uniqueIds() as $column) {
+            if (empty($this->{$column})) {
+                $this->{$column} = $this->newUniqueId();
+            }
+        }
+    }
+
+    /**
+     * Generate a new key for the model.
+     *
+     * @return string
+     */
+    public function newUniqueId()
+    {
+        return null;
+    }
+
+    /**
+     * Get the columns that should receive a unique identifier.
+     *
+     * @return array
+     */
+    public function uniqueIds()
+    {
+        return [];
+    }
+}

src/Illuminate/Database/Eloquent/Concerns/HasUuids.php

@@ -8,39 +8,33 @@
 trait HasUuids
 {
     /**
-     * Generate a primary UUID for the model.
+     * Initialize the trait.
      *
      * @return void
      */
-    public static function bootHasUuids()
+    public function initializeHasUuids()
     {
-        static::creating(function (self $model) {
-            foreach ($model->uniqueIds() as $column) {
-                if (empty($model->{$column})) {
-                    $model->{$column} = $model->newUniqueId();
-                }
-            }
-        });
+        $this->uniqueIds = true;
     }
 
     /**
-     * Generate a new UUID for the model.
+     * Get the columns that should receive a unique identifier.
      *
-     * @return string
+     * @return array
      */
-    public function newUniqueId()
+    public function uniqueIds()
     {
-        return (string) Str::orderedUuid();
+        return [$this->getKeyName()];
     }
 
     /**
-     * Get the columns that should receive a unique identifier.
+     * Generate a new UUID for the model.
      *
-     * @return array
+     * @return string
      */
-    public function uniqueIds()
+    public function newUniqueId()
     {
-        return [$this->getKeyName()];
+        return (string) Str::orderedUuid();
     }
 
     /**

src/Illuminate/Database/Eloquent/Model.php

@@ -30,6 +30,7 @@ abstract class Model implements Arrayable, ArrayAccess, CanBeEscapedWhenCastToSt
         Concerns\HasGlobalScopes,
         Concerns\HasRelationships,
         Concerns\HasTimestamps,
+        Concerns\HasUniqueIds,
         Concerns\HidesAttributes,
         Concerns\GuardsAttributes,
         ForwardsCalls;
@@ -1286,6 +1287,10 @@ protected function performInsert(Builder $query)
             $this->updateTimestamps();
         }
 
+        if ($this->usesUniqueIds()) {
+            $this->setUniqueIds();
+        }
+
         // If the model has an incrementing key, we can use the "insertGetId" method on
         // the query builder, which will give us back the final inserted ID for this
         // table from the database. Not all tables have to be incrementing though.

tests/Integration/Database/EloquentUniqueStringPrimaryKeysTest.php

@@ -20,6 +20,13 @@ protected function defineDatabaseMigrationsAfterDatabaseRefreshed()
             $table->timestamps();
         });
 
+        Schema::create('foo', function (Blueprint $table) {
+            $table->uuid('id')->primary();
+            $table->string('email')->unique();
+            $table->string('name');
+            $table->timestamps();
+        });
+
         Schema::create('posts', function (Blueprint $table) {
             $table->ulid('id')->primary();
             $table->ulid('foo');
@@ -73,6 +80,58 @@ public function testModelWithCustomUuidPrimaryKeyNameCanBeCreated()
 
         $this->assertTrue(Str::isUuid($user->uuid));
     }
+
+    public function testModelWithUuidPrimaryKeyCanBeCreatedQuietly()
+    {
+        $user = new ModelWithUuidPrimaryKey();
+
+        $user->saveQuietly();
+
+        $this->assertTrue(Str::isUuid($user->id));
+        $this->assertTrue(Str::isUuid($user->foo));
+        $this->assertTrue(Str::isUuid($user->bar));
+    }
+
+    public function testModelWithUlidPrimaryKeyCanBeCreatedQuietly()
+    {
+        $user = new ModelWithUlidPrimaryKey();
+
+        $user->saveQuietly();
+
+        $this->assertTrue(Str::isUlid($user->id));
+        $this->assertTrue(Str::isUlid($user->foo));
+        $this->assertTrue(Str::isUlid($user->bar));
+    }
+
+    public function testModelWithoutUuidPrimaryKeyCanBeCreatedQuietly()
+    {
+        $user = new ModelWithoutUuidPrimaryKey();
+
+        $user->saveQuietly();
+
+        $this->assertTrue(is_int($user->id));
+        $this->assertTrue(Str::isUuid($user->foo));
+        $this->assertTrue(Str::isUuid($user->bar));
+    }
+
+    public function testModelWithCustomUuidPrimaryKeyNameCanBeCreatedQuietly()
+    {
+        $user = new ModelWithCustomUuidPrimaryKeyName();
+
+        $user->saveQuietly();
+
+        $this->assertTrue(Str::isUuid($user->uuid));
+    }
+
+    public function testUpsertWithUuidPrimaryKey()
+    {
+        ModelUpsertWithUuidPrimaryKey::create(['email' => 'foo', 'name' => 'bar']);
+        ModelUpsertWithUuidPrimaryKey::create(['name' => 'bar1', 'email' => 'foo2']);
+
+        ModelUpsertWithUuidPrimaryKey::upsert([['email' => 'foo3', 'name' => 'bar'], ['name' => 'bar2', 'email' => 'foo2']], ['email']);
+
+        $this->assertEquals(3, ModelUpsertWithUuidPrimaryKey::count());
+    }
 }
 
 class ModelWithUuidPrimaryKey extends Eloquent
@@ -89,6 +148,20 @@ public function uniqueIds()
     }
 }
 
+class ModelUpsertWithUuidPrimaryKey extends Eloquent
+{
+    use HasUuids;
+
+    protected $table = 'foo';
+
+    protected $guarded = [];
+
+    public function uniqueIds()
+    {
+        return [$this->getKeyName()];
+    }
+}
+
 class ModelWithUlidPrimaryKey extends Eloquent
 {
     use HasUlids;