Tutorial on using UUID gracefully in Laravel 7

Recently I had to implement Universal Unique Identifiers (UUIDs) in Laravel 7 and ran into some issues. I hope this post helps others who are doing the same thing.

Advanced Reasons to Use UUIDs

A) They remove the numbered identifier from your Uniform Resource Locator, so users cannot See how many specific objects your app has created. Example:

https://myapp.com/api/users/5

Contrast:

https://myapp.com/api/users/0892b118-856e-4a15-af0c-66a3a4a28eed

B) They make identification numbers much harder to guess. This is good for security, but we should probably implement other techniques to guard against it.

Implementing UUIDs as primary keys

How to change the database migration

First, in the database migration , you want to replace the current auto-incrementing ID fields with UUIDs. You could also follow this approach: keep the auto-increment ID and use the UUID as an additional field in the table to be used when the user is presented with the URL (in this case you hide the ID into the model), but that's not what we can do here made. Let's see what a hypothetical employees table looks like.

public function up()
    {
        Schema::create('employees', function (Blueprint $table) {
            $table->uuid('id')->primary;
            $table->string('name');
            $table->string('email')->unique();
            $table->string('work_location')->nullable();
            $table->timestamps();
        });
    }

Here, notice that we replaced normal id() with uuid(); and make it the primary key.

Let's make this a trait

Next, we can implement the Laravel lifecycle hook to ensure that when a new instance of this model is created, it is allocated UUID. We can write the code directly in the model, but if you are going to use UUIDs in multiple models, I recommend using Traits (I learned this in this Dev article, thank you very much Dev). Traits basically allow you to create functionality and call it via the use keyword for use in multiple models.

To create a new Trait, create a \App\Http\Traits\ folder (this is just my hobby, you can put it elsewhere) and create a new file for the Trait . We will call the file UsesUuid.php.

This is the specific code for the trait:

<?php
namespace App\Http\Traits;
use Illuminate\Support\Str;
trait UsesUuid
{
  protected static function bootUsesUuid() {
    static::creating(function ($model) {
      if (! $model->getKey()) {
        $model->{$model->getKeyName()} = (string) Str::uuid();
      }
    });
  }
  public function getIncrementing()
  {
      return false;
  }
  public function getKeyType()
  {
      return &#39;string&#39;;
  }
}

Use \Illuminate\Support\Str to easily generate UUID. The getIncrementing () method tells Laravel that the model's primary key will not increment (because we set it to false), and the getKeyType () method tells Laravel that the model's primary key is a string type. The bootUsesUuid () method allows us to use Laravel's powerful lifecycle hooks. You can come here for more details on Ouyang Festival. Basically our code already tells Laravel that when a new instance of this model is created, set the UUID primary key for it!

Now we can easily implement this feature on our model using the use keyword.

<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
...
class Employee extends Model
{
    ...
    use \App\Http\Traits\UsesUuid;
    ...
}

Referencing a UUID as a foreign key

To reference a UUID on a table as a foreign key, simply change the type of the foreign key field on the table. As follows...

 Schema::create('another_table', function(Blueprint $table) {
        $table->id();
        $table->unsignedBigInteger('employee_id');
        $table->string('some_field');
        $table->foreign('employee_id')
            ->references('id')
            ->on('shifts')
            ->onDelete('cascade');
    });

... We created an unsigned large integer data type when referencing the employee_id foreign key, and modified it as follows:

 Schema::create('another_table', function(Blueprint $table) {
        $table->id();
        $table->uuid('employee_id');
        $table->string('some_field');
        $table->foreign('employee_id')
            ->references('id')
            ->on('shifts')
            ->onDelete('cascade');
    });

That's as simple as that! One more thing...

UUIDs and Polymorphic Relationships

You may find yourself referencing in a polymorphic relationship either through your own operations or through a package you are importing the model. In the migration, the table might look like this:

    public function up()
    {
        Schema::create('some_package_table', function (Blueprint $table) 
        {
            $table->bigIncrements('id');
            $table->morphs('model');
            ...
        }
    }

Here, the morphs () method will create two fields in the database, model_id of unsigned big integer type and model_type of string type . The problem is that our model is now using a UUID instead of an incrementing integer ID, so this will give you an error saying something like: :

Data truncated for column 'model_id' at row 1

We now need the model_id field to support our new UUID, its type is CHAR (36). don’t worry! Laravel makes this super easy and you don’t need to do it manually. Just change the migration to:

    public function up()
    {
        Schema::create('some_package_table', function (Blueprint $table) 
        {
            $table->bigIncrements('id');
            $table->uuidMorphs('model');
            ...
        }
    }

Another reason to love Laravel! Happy coding!

Recommended tutorial: "Laravel Tutorial"

The above is the detailed content of Tutorial on using UUID gracefully in Laravel 7. For more information, please follow other related articles on the PHP Chinese website!