Martin Joo

🔥Level up your Eloquent game

In this thread, you can read about 5 pretty useful but not so well-known Eloquent features such as:

- whereBelongsTo
- whereRelation
- Default relationship values

🧵Keep Reading 

1/6 whereRelation

You can use the whereRelation helper to filter records based on Eloquent relationships.

It uses EXISTS in the background so it’s an excellent choice if you don’t need data from the related record: 

2/6 whereBelongsTo

With the whereBelongsTo helper, your code reads like an English sentence.

Just take a look at this: 

3/6 oldestOfMany

If you often need the oldest record from a related table, you can use the oldestOfMany relationship type.

It feels a bit more “native” than writing a regular query. This will return the oldest paycheck (based on the smallest auto-increment ID) for an employee: 

4/6 Default attribute values

Did you know that you can give default values for model attributes?

Check this out: 

5/6 Default relationships

Not only for attributes, but you can also give default values for relationships.

Easy as usual: 

6/6 Thank you, if you're still here!

Just released a new book - Building a database engine

Check it out here: https://thedatabasebook.com/

Here are my favorite 22 Laravel packages📦

I would immediately DIE without them!

🧵Keep Reading

1/ laravel-excel

The single best package to handle Excel exports and imports:

- Exporting collections
- Storing files
- Exporting from a query
- Queue jobs
- And more 

2/ laravel-health

This amazing Spatie package can monitor the health of your application and server. It sends you notifications if something's wrong. For example:
- CPU load
- Used disk space
- Database connections
- Redis
- and more 

3/ blueprint

With this package, you can define your models in a YAML file and it will generate:

- Migrations
- Models with relationships
- Factories
- CRUD Controllers
- Routes
- Form requests
- Even Jobs, Mails, Events, or basic HTTP tests 

4/ laravel-backup

You should regularly back up your databases and filesystem. With laravel-backup it takes only two lines of code: 

5/ laravel-data

If you’re using DTOs to handle data in your application, this is a must-have:
- DTO as request, response
- Nested DTOs
- Lazy loading properties
- Validation rules
- Easy mapping from requests or models 

6/ phpinsights

This is my favorite static analysis tool. It scores your codebase and gives you this beautiful page in the terminal: 

7/ laravel-query-builder

With this package, you can build Eloquent queries based on the Request. It can handle things like:
- Filtering
- Sorting
- Including relationships
- Sparse fieldsets 

8/ larastan

It’s a very great static analysis tool on top of phpstan that integrates well with Laravel: 

9/ has-many-deep

With this package, you can query deep relationships with a single SQL query.

Consider these relations:
Country → has many → User → has many → Post → has many → Comment

With this relationship, you can query every comment to a country in just one query: 

10/ deptrac

You can keep your architecture clean with this static analysis tool. You can define what layer can use what other layers and it will force you to obey these rules.

It can be especially useful in legacy projects if want to refactor: 

11/ pest

The most amazing PHP testing framework built top on phpunit: 

12/ clockwork

Debugbar on steroids. You can monitor:
- Requests
- Performance metrics
- Log entries
- DB queries
- Cache queries
- Redis commands
- Events, jobs
- ...and more 

13/ json-api

A package that implements the JSON API standard and makes your life easy.

This is what a JsonApiResource looks like: 

14/ ziggy

This package makes it possible to use your Laravel named routes from your Javascript. It can be a Blade, an Inertia, or an SPA application.

Very useful! 

15/ laravel-activitylog

A very convenient audit log package. It will log every activity in your application: 

16/ laravel-ide-helper

The good old IDE helper! This package makes your IDE understand your models and Laravel classes. It gives you very nice autocompletion. 

https://buff.ly/2nzR073

17/ laravel-transporter by @JustSteveKing

If you’re working with 3rd party APIs and services, you ABSOLUTELY need this package! 

@JustSteveKing 18/ request-factories

If you’re writing a lot of API or feature tests (which you should do, by the way) this package will save you hours when constructing request data: 

@JustSteveKing 19/ laravel-backup by Spatie

Another package from Spatie. With this one, your whole backup process should look like this:

php artisan backup:run

@JustSteveKing 20/ terminal by TitasGailius

If you’re working with terminal commands you can use Symfony Process which is a pretty good component. Terminal takes it to another level: 

@JustSteveKing 21/ laravel-nestedset by lazychaser

Let’s be honest… We all hate hierarchical data structures and trees. Fortunately, this package saves us: 

@JustSteveKing 22/ accountant by Altek

Another pretty impressive auditing and accountability package: 

@JustSteveKing 23/ Thanks for reading! 

I just released a new book - Building a database engine

Check it out here: https://buff.ly/4kcvgcv

Ever seen a SQL query with 3 nested subqueries and cried? 

🧵 Let's clean them with CTEs. 

2/ Original query: employees in departments where avg salary &gt; $75k. 

Subquery-in-subquery chaos: 

4/ CTEs act as temporary tables that can be used in one query.

Break complex logic into named blocks.

For example, this CTE: 

6/ Why use CTEs?
✅ Readable
✅ Reusable in same query
✅ Debuggable (test each CTE separately)

7/ CTEs can reference earlier CTEs. Chain them like functions! 

`dept_avg_salary` is a CTE from the earlier query.

It can be used like a table: 

8/ Thanks for reading!

I'll release a book soon.

It's called Building a database engine.

Yes. We're going to build a DB engine.

From scratch.

Check it out here: https://buff.ly/4kcvgcv

🧵 Understand how database locks work through a seat reservation example.

1/ Let's model a seat reservation process in a movie theatre. When a user selects a seat they have 5 minutes to complete the payment. Until then, the seat is reserved for them and cannot be selected by other users.

2/ In this app, I'm not going to handle dates, so the Seat model has a status column. It can have the following values:
- Available
- Reserving represents the 5-minute period until it's not available for other users
- Reserved means the user completed the payment

3/ When a seat is reserved a new Reservation model is created.

This simple process looks like this: 

4/ It works as expected but it has a flaw.

Conflicts are possible. If two users select the same seat at the same time this condition returns false for both of them and then two reservations are created for the same seat: 

5/ The easiest way to avoid conflicts like this is to use locks at the database level.

A database lock is a technique that helps us concurrent requests to the database. For example, you can lock a specific row and say “no one can change this row until I’m done.”

6/ In this example this is the desired behavior:

When the request comes in it needs to lock the specific seat

The lock prevents other requests from changing the seat data (status) until the original request is handled

7/ In MySQL, there are two types of locks:

A *shared lock* prevents the selected rows from being modified until your transaction is committed.

An *exclusive lock* prevents the selected records from being modified or from being selected with another lock.

8/ We need an exclusive lock in this case. The current request should own the seat record entirely.

The way exclusive locks are implemented in MySQL is the following: 

9/ After executing this query seat #112 cannot be modified by other transactions until the current one commits.

This is what the new method looks like: 

10/ First, everything is wrapped in a transaction, and then the seat query acquires an exclusive lock.

Until this transaction is done, other transactions (requests) cannot modify or acquire locks on seat #112. This means that the other request has to wait even to select the seat

11/ But until then it is updated by the first request. So this if statement results true and the second request is rejected: 

12/ Thanks for reading! 

On the 8th of April, I'm releasing a new book - Building a database engine

Check it out here: https://buff.ly/4kcvgcv

🔥 Here are some of the most basic monitoring techniques you can start using immediately:
- Spatie laravel-health
- Error tracking
- Syntethic checks

It takes ~30 minutes to set up these.

🧵 Keep Reading 

Health checks with laravel-health

The package can check:
- CPU load
- Disk space utilization
- Database connectivity
- Redis
- And even query speed 

The example contains pre-built checks. For instance, it notifies you if the average CPU load is higher than 2.5 in the last 5 minutes or 2 in the previous 15 minutes.

It also notifies you if the used disk space is more than 70% 

You can also write custom checks for your own need. For example, QuerySpeedCheck is one I wrote. It notifies you if a particular query takes too long to execute.

This is what it looks like: 

Syntethic checks

For this, you can use something like Uptime Robot or Better Uptime. They send a request every minute to your site and notify you if it's unavailable or slow.

Your server provider might also offer something like that. DigitalOcean looks like this: 

You can (and should) also set resource and latency alerts. For example, this notifies me if the memory usage is higher than 70% on given servers: 

Error tracking

Instead of relying only on log files, you can install Rollbar or Sentry to track your errors in a more organized way.

You only need to add a new log channel: 

And then your provider collects your logs/errors in a more organized way than laravel.log does: 

Thank you if you're still here!

Just released a new book called Building a database engine.

Check out the details here if you want to build your own database: https://thedatabasebook.com/

⚡You can do some pretty cool stuff with enums in PHP and Laravel. In this thread, I’ve collected some of the useful stuff, such as:

- Backed enums
- Using enums as factories
- Validation
- Enum route binding
- Model attribute casts

🧵Keep Reading 

1/7 Backed Enums

This is a very basic backed enum with string values: 

2/7 Enums As Factories

You probably already know that. but did you know that you can use it as a factory?

You can combine enums with the match operator. For example, if you’re using the strategy pattern: 

3/7 Enum Validation

Since backed enums have a string value, you can easily validate these values in a request: 

4/7 Route Binding

Once again, since backed enums have string values you can use them in route bindings!

This is very useful if you have endpoints that filter based on some status: 

5/7 Model Casts

To be able to use enums in where expression (like the example above) you can cast attributes to enums: 

6/7 Default Attribute Values

You can even specify default attribute values with enums.

In this example, if you instantiate a new Post, the status will always be ‘draft’ by default: 

🔥 Most applications need to export and import large amounts of data.

It is very easy to:
- Waste lots of memory
- Perform hundreds or thousands of unnecessary DB queries

You can avoid them by learning some pretty simple techniques.

🧵 Keep Reading 

1/

When it comes to working with larger datasets one of the best you can apply to any problem is chunking. Divide the dataset into smaller chunks and process them. It comes in many different forms.

2/ Let's start with a simple CSV or XLS export since it's a common feature in many applications. laravel-excel is a pretty good package that you can use.

Here's a basic export: 

3/ I've seen dozens of exports like this one over the years. It creates a CSV from a collection. In the collection method, you can define your collection which is 99% of the time the result of a query. 

Nice and simple, right?

4/ However, an export such as this one, has two potential problems:

- The collection method runs a single query and loads each and every transaction into memory
- The `map` function will run for each transaction. If you execute only one query here, it'll run N times

5/ Be aware of these things because it's pretty easy to kill your server with a poor export.

The above job has failed with only 2,000 transactions: 

6/ Fortunately, there's a much better export type than FromCollection, it is called FromQuery. This export does not define a Collection but a DB query instead that will be executed in chunks by laravel-excel.

This is how we can rewrite the export class: 

7/ Instead of returning a Collection the query method returns a builder.

- Queued exports (using the Exportable trait and the queue method) are processed in chunks
- If the export implements FromQuery the number of jobs is calculated by query()-&gt;count() / chunkSize()

8/ In the chunkSize we can control how many jobs we want. If we have 5,000 transactions for and chunkSize() returns 250 then 20 jobs will be dispatched each processing 250 transactions.

Using the techniques above, exporting 10k transactions is a walk in the park: 

9/ So there's a huge difference between the two export classes.

The first one failed exporting only 2,000 transactions.
The second one processed 10,000 of them.

That's the power of chunking larger data sets.

10/ Thank you if you're still here!

Next week I'm gonna release a book called Building a database engine.

Don’t miss out https://thedatabasebook.com/