Laravel Eloquent is without doubt one of the strongest and wonderful options in a contemporary framework immediately. From casting information to worth objects and courses, protected the database utilizing fillable fields, transactions, scopes, world scopes, and relationships. Eloquent allows you to achieve no matter you should do with the database.
Getting began with Eloquent can typically really feel intimidating, as it might achieve this a lot you’re by no means actually certain the place to start out. On this tutorial, I’ll deal with what I take into account to be one of many important facets of any software – writing to the database.
You’ll be able to write to the database in any software space: a controller, a Job, middleware, artisan command. What’s the easiest way to deal with database writes although?
Let’s begin with a easy Eloquent mannequin with no relationships.
1last class Submit extends Mannequin
2{
3 protected $fillable = [
4 'title',
5 'slug',
6 'content',
7 'published',
8 ];
9
10 protected $casts = [
11 'published' => 'boolean',
12 ];
13}
We’ve got a Submit mannequin that represents a weblog publish; it has a title, slug, content material, and a boolean flag to say whether it is revealed. On this instance, we could say that the revealed property defaults to true within the database. Now, to start with, we have now advised Eloquent that we wish to have the ability to fill within the title, slug, content material, and revealed properties or columns. So if we cross something not registered within the fillable array, an exception will probably be thrown – defending our software from potential points.
Now that we all know what fields will be crammed, we are able to take a look at writing information to the database, whether or not creating, updating, or deleting. In case your mannequin inherits the SoftDeletes trait, then deleting a report is a write motion – however for this instance, I’ll preserve it easy; a delete is a delete.
What you will have more than likely seen, particularly within the documentation, is one thing like the next:
1Submit::create($request->solely('title', 'slug', 'content material'));
That is what I can commonplace Eloquent, you will have a mannequin, and also you name the static technique to create a brand new occasion – passing in a selected array from the request. There are advantages to this method; it’s clear and easy, and everybody understands it. I could also be a really opinionated developer at instances. Nonetheless, nonetheless, I’ll use this method, particularly if I’m in prototyping mode, the place it’s extra about testing an concept over constructing one thing long-term.
We will take this one step additional by beginning a brand new Eloquent question builder occasion on the mannequin earlier than asking for a brand new occasion to be created. This is able to appear to be the next:
1Submit::question()->create($request->solely('title', 'slug', 'content material'));
As you’ll be able to see, it’s nonetheless quite simple and is changing into a extra standardized solution to begin queries in Laravel. Probably the most vital advantages of this method is that every thing after question follows the Question Builder Contract, which was lately launched. Due to how Laravel works underneath the hood, your IDE won’t perceive the static calls very properly – as it’s a static proxy to a technique utilizing __callStatic over an precise static technique. Fortunately this isn’t the case with the question technique, which is a static technique on the Eloquent Mannequin you’re extending.
There’s the “older” technique of constructing your mannequin to avoid wasting to the database. Nonetheless, I hardly ever see it used fairly often anymore. I’ll point out it, although, for readability:
1$publish = new Submit();
2$publish->title = $request->get('title');
3$publish->slug = $request->get('slug');
4$publish->content material = $request->get('content material');
5$publish->save();
That is the place we’d construct up the mannequin programmatically, assigning values to properties after which saving it to the database. This was a little bit long-winded to do and at all times felt prefer it was an excessive amount of effort to attain. Nonetheless, that is nonetheless an appropriate solution to create a brand new mannequin if that is how you like to do it.
To this point, we have now checked out three completely different approaches to creating new information within the database. We will use the same method to updating information within the database, a static name to replace or utilizing the question constructing contract question()->the place('column', 'worth')->replace() or lastly programmatically setting the property after which save. I will not repeat myself right here, as it’s a lot the identical as above.
What will we do if we aren’t certain if the report already exists? For instance, we need to create or replace an present publish. We can have a column that’s what we need to verify towards when it comes to uniqueness – then we cross by means of an array of values that we need to create or replace relying on if it exists.
1Submit::question()->updateOrCreate(
2 attributes: ['slug' => $request->get('slug'),
3 values: [
4 'title' => $request->get('title'),
5 'content' => $request->get('content'),
6 ],
7);
This has some large advantages when you aren’t certain if the report will exist, and I lately applied this myself once I wished to “guarantee” a report was within the database it doesn’t matter what. For instance, for an OAuth 2.0 social login, you’ll be able to settle for the data from the supplier and replace or create a brand new report earlier than authenticating the consumer.
Might we take this a step additional? What can be the advantages? You can use a sample just like the Repository Sample to mainly “proxy” the calls you’d ship to eloquent by means of a special class. There are just a few advantages to this, or at the very least there was once earlier than Eloquent grew to become what it’s immediately. Let us take a look at an instance:
1class PostRepository
2{
3 personal Mannequin $mannequin;
4
5 public operate __construct()
6 {
7 $this->mannequin = Submit::question();
8 }
9
10 public operate create(array $attributes): Mannequin
11 {
12 return $this->mannequin->create(
13 attributes: $attributes,
14 );
15 }
16}
If we have been utilizing the DB Facade or plain PDO, then maybe the Repository Sample would give us various advantages in preserving consistency. Let’s transfer on.
Sooner or later, individuals determined that transferring from a Repository class to a Service class can be a good suggestion. Nonetheless, this is similar factor … Let’s not go into that one.
So, we wish a solution to deal with interacting with Eloquent that is not so “inline” or procedural. Just a few years in the past, I adopted an method that’s now labeled as “actions”. It’s just like the Repository Sample. Nonetheless, every interplay with Eloquent is its personal class as a substitute of a technique inside one class.
Let us take a look at this instance, the place we have now a devoted class for every interplay referred to as an “motion”:
1last class CreateNewPostAction implements CreateNewPostContract
2{
3 public operate deal with(array $attributes): Mannequin|Submit
4 {
5 return Submit::question()
6 ->create(
7 attributes: $attributes,
8 );
9 }
10}
Our class implements a contract to bind it to the container properly, permitting us to inject this right into a constructor and name the deal with technique with our information when wanted. That is getting more and more common, and many individuals (in addition to packages) have began adopting this method, as you create utility courses that do one factor properly – and may simply have check doubles created for them. The opposite profit is that we use an interface; if we ever resolve to maneuver away from Eloquent (unsure why you’d need to), we are able to shortly change our code to replicate this with out having to hunt something down.
Once more, an method that’s fairly good – and has no actual downsides, in precept. I discussed that I’m a fairly choosy developer, proper? Properly …
My largest downside with “actions” after utilizing them for therefore lengthy is that we put all of our write, replace, and delete integrations underneath one hood. Actions do not cut up issues up sufficient for me. If I give it some thought, we have now two various things we wish to have the ability to obtain – we need to write, and we need to learn. This displays partially onto one other design sample referred to as CQRS (Command Question Duty Segregation), which is one thing I’ve borrowed from a little bit. In CQRS, usually, you’d use a command bus and a question bus to learn and write information, usually emitting occasions to be saved utilizing occasion sourcing. Nonetheless, typically that’s much more work than you want. Do not get me flawed, there’s positively a time and place for that method, however you need to solely attain for it when you should – in any other case, you’ll over-engineer your resolution from the smallest half.
So I cut up my write actions into “Instructions” and my learn actions into “Queries” in order that my interactions are separated and centered. Let’s take a look at a Command:
1last class CreateNewPost implements CreateNewPostContract
2{
3 public operate deal with(array $attributes): Mannequin|Submit
4 {
5 return Submit::question()
6 ->create(
7 attributes: $attributes,
8 );
9 }
10}
Would you take a look at that, aside from the category naming, it’s the similar factor as an motion. That is by design. Actions are a superb solution to write to the database. I discover they have a tendency to get crowded too shortly.
What different methods might we enhance on this? Introducing a Area Switch Object can be a great place to start, because it gives sort security, context and consistency.
1last class CreateNewPost implements CreateNewPostContract
2{
3 public operate deal with(CreatePostRequest $publish): Mannequin|Submit
4 {
5 return Submit::question()
6 ->create(
7 attributes: $publish->toArray(),
8 );
9 }
10}
So we at the moment are introducing sort security in an array the place we beforehand relied on arrays and hoped issues went the appropriate method. Sure, we are able to validate to our hearts’ content material – however objects have a greater consistency.
Is there any method we might enhance upon this? There’s at all times room for enchancment, however do we have to? This present method is dependable, type-safe, and simple to recollect. However, what will we do if the database desk locks earlier than we are able to write, or if we have now a blip in community connectivity, possibly Cloudflare goes down at simply the flawed time.
Database Transactions will save our butts right here. They don’t seem to be used as a lot as they in all probability must be, however they’re a robust device that you need to take into account adopting quickly.
1last class CreateNewPost implements CreateNewPostContract
2{
3 public operate deal with(CreatePostRequest $publish): Mannequin|Submit
4 {
5 return DB::tranaction(
6 fn() => Submit::question()->create(
7 attributes: $publish->toArray(),
8 )
9 );
10 }
11}
We acquired there ultimately! I’d be leaping for pleasure if I noticed code like this in a PR or a code assessment I needed to do. Nonetheless, don’t really feel like it’s important to write code this manner. Keep in mind, it’s completely okay to simply inline static create if it does the job for you! You will need to do what you’re comfy with, what’s going to make you efficient – not what others say you need to be doing locally.
Taking the method we simply checked out, we might method studying from the database in the identical method. Break down the issue, determine the steps and the place enhancements may very well be made, however at all times query if possibly you’re taking it a step too far. If it feels pure, it’s in all probability a great signal.
How do you method writing to the database? How far alongside the journey would you go, and when is simply too far? Tell us your ideas on Twitter!
